当前位置：网站首页>[deep learning] pytoch tensor

It's early morning 12 spot , Record your study , Review it again Pytorch...... ok , In fact, it's not review , I just had a brief understanding before , That's it . however ！ Now it's different , Need to study carefully ！
Let‘s do it ！！！
This is just a simple study note , That's it ！！！

One 、 Tensor overview ：

A special data structure , Used in deep learning neural networks , It's like an array （ multidimensional ） And matrices . Input and output of neural network 、 Mesh parameters are described by tensors ！

import torch
import numpy as np

Two 、 Initialization tensor ：

There are many ways to initialize tensors , Mainly choose different initialization methods according to the data source ：

Use it directly Python The list is transformed into a tensor ：

data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)

Use torch Functions in the library tensor Put a two-dimensional python The list is transformed into a two-dimensional tensor .

adopt Numpy Array （ndarray） Convert to tensor ：

ndarray And tensor （tensor） It supports mutual conversion

np_array = np.array(data)
x_np = torch.from_numpy(np_array)

Generate a new tensor from the existing tensor ：

The new tensor will inherit the data properties of the original tensor （ Structure and type ）, You can also reassign new data attributes .

x_ones = torch.ones_like(x_data)   #  Retain  x_data  Properties of 
print(f"Ones Tensor: \n {x_ones} \n")

x_rand = torch.rand_like(x_data, dtype=torch.float)   #  rewrite  x_data  Data type of int -> float
print(f"Random Tensor: \n {x_rand} \n")

Ones Tensor:
 tensor([[1, 1],
         [1, 1]])

Random Tensor:
 tensor([[0.0381, 0.5780],
         [0.3963, 0.0840]])

Generate tensors by specifying data dimensions ：

Use shape Tuples specify the generated tensor dimension , Pass tuples to torch Function to create different tensors ：

shape = (2,3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")

Random Tensor:
 tensor([[0.0266, 0.0553, 0.9843],
         [0.0398, 0.8964, 0.3457]])

Ones Tensor:
 tensor([[1., 1., 1.],
         [1., 1., 1.]])

Zeros Tensor:
 tensor([[0., 0., 0.],
         [0., 0., 0.]])

3、 ... and 、 Tensor properties ：

Through the different properties of tensor , We can know the dimension of tensor , The data type of the tensor 、 Tensor storage devices （ Physical devices ）

tensor = torch.rand(3,4)

print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

Shape of tensor: torch.Size([3, 4])   #  dimension 
Datatype of tensor: torch.float32     #  data type 
Device tensor is stored on: cpu       #  The storage device

Four 、 Tensor operations ：

Check whether the current operating environment supports Pytorch, Check code ：

#  Judge the current environment GPU Is it available ,  And then tensor Import GPU Internal operation 
if torch.cuda.is_available():
  tensor = tensor.to('cuda')

1. Tensor indexing and slicing ：

Python The section of , The first parameter is line operation , The second parameter is the column operation .

tensor = torch.ones(4, 4)
tensor[:,1] = 0            #  Will be the first 1 Column ( from 0 Start ) All the data of are assigned to 0
print(tensor)

All index positions are from 0 Start ：

tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

2. The splicing of tensors ：

You can go through torch.cat Method to splice a set of tensors according to the specified dimension , You can also refer to torch.stack Method .

t1 = torch.cat([tensor, tensor, tensor], dim=1)
print(t1)

Notice the dim Parameters , Here is the designation tensor Spliced dimensions , The dimension index is also from 0 Start ,0 Represents the first dimension ,1 Represents the second dimension , Therefore, in the case of two-dimensional splicing, it is spliced according to columns ：

tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])

Want to know how many dimension , Just count the number of brackets , There are several layers of brackets, and there are several dimensions . and , Follow the brackets from the outside to the inside , Dimensions increase in turn ： from 0 Turn into 1 Turn into 2.

3. Tensor multiplication and matrix multiplication ：

Simply distinguish the difference between multiplication and matrix multiplication ：
Multiplication ： On the matrix are two shape The same matrix （ That is, the shape of the matrix must be consistent ）, Multiply the elements in the corresponding position
Matrix multiplication ： The dimensions of the matrix inline are required to be consistent , namely （n,m）x （m,z）

Multiplication （ Point multiplication ）：

#  Multiply the result element by element 
print(f"tensor.mul(tensor): \n {tensor.mul(tensor)} \n")
#  Equivalent writing :
print(f"tensor * tensor: \n {tensor * tensor}")

tensor.mul(tensor):
 tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor * tensor:
 tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

Matrix multiplication （ Cross riding ）：

print(f"tensor.matmul(tensor.T): \n {tensor.matmul(tensor.T)} \n")
#  Equivalent writing :
print(f"tensor @ tensor.T: \n {tensor @ tensor.T}")

tensor.matmul(tensor.T):
 tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])

tensor @ tensor.T:
 tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])

4. Automatic assignment operation ：

The automatic assignment operation usually has... After the method _ As a suffix , for example : x.copy_(y), x.t_() The operation will change x The value of . Re assign the result of the method call execution to the variable of the calling method .

print(tensor, "\n")
tensor.add_(5)
print(tensor)

tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor([[6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.]])

Be careful ： Although automatic assignment operation can save memory , But in the derivation, some problems will be caused by the loss of the intermediate process , So we don't encourage it .

5、 ... and 、Tensor and Numpy Mutual conversion of ：

Tensor sum ndarray Array in CPU You can share a memory area on the , Change one of the values , The other will change .

1. from tensor Convert to ndarray：

tensor Call directly numpy Method ：

t = torch.ones(5)
print(f"t: {t}")
n = t.numpy()
print(f"n: {n}")

t: tensor([1., 1., 1., 1., 1.])
n: [1. 1. 1. 1. 1.]

here , If you modify the tensor tensor Value , So the corresponding ndarray The value in will also change , Here is only the change of variable type , But the memory address that the variable points to is the same memory space ：

t.add_(1)
print(f"t: {t}")
print(f"n: {n}")

t: tensor([2., 2., 2., 2., 2.])
n: [2. 2. 2. 2. 2.]

2. from Ndarray Convert to Tensor：

n = np.ones(5)
t = torch.from_numpy(n)

modify Numpy array The value of the array , Then the tensor value will change .

np.add(n, 1, out=n)
print(f"t: {t}")
print(f"n: {n}")

t: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
n: [2. 2. 2. 2. 2.]

        So that's it , Current pair tensor Tensor With a simple understanding , Learn how to create Tensor Variable ,Tensor Properties of , as well as Tensor Common operations of ！
        We will continue to learn related content later , Come on, ladies and gentlemen ！！！
        .
        By the way, my live learning room is at a station , Ha ha ha , You can come and visit when you are free , Then stop here , Encourage everyone ！！！
【 Deep learning 】（ The first 1 God ） - Classmate fan who loves sugar - Bili Bili live , Two dimensional bullet screen live broadcasting platform https://live.bilibili.com/22404070?broadcast_type=0&is_room_feed=1?spm_id_from=333.999.space_home.left_live.click