[모각코] (Pytorch) Tensor 생성 과 연산

인공지능 개발에 가장많이 사용되는 프레임워크에는 Pytorch와 Tensorflow가있다. 우리는 그 중 Pytorch를 사용하기로 하였다.

 

먼저, 여러가지 방법으로 Tensor를 생성하는 법을 알아보자.

 

FloatTensor()

실수형 변수들로 텐서를 생성

float_tensor = torch.FloatTensor([1,2,3,4])
float_tensor

tensor([1., 2., 3., 4.])

 

LongTensor()

정수형 변수들로 텐서를 생성

여기서 Long은 정수자료형의 Long이 맞다

int_tensor = torch.LongTensor([1,2,3,4])
int_tensor

tensor([1, 2, 3, 4])

 

randn(텐서의크기)

무작위 정수형 변수들로 입력된 크기로 생성

random_tensor = torch.randn(10,10)
random_tensor

tensor([[-0.4425, -0.7106, -0.3880, -0.9679, -0.3600,  0.7215, -0.4596, -1.2455,
          0.4086,  0.3004],
        [ 0.1868,  0.8983,  0.8996, -1.1363,  0.3247,  2.0468, -0.3157,  0.9688,
          0.7453,  0.7590],
        [-0.0912, -0.9494, -0.0457,  0.1697,  0.0593,  1.4769, -0.9958,  0.4652,
          0.5478,  2.0339],
        [-1.2208, -0.2805,  0.4981, -1.0593, -0.6753, -0.5352,  1.2400, -0.5344,
         -0.9100,  0.3187],
        [ 0.8707,  0.7918, -0.7110,  0.6744,  1.3362, -1.3673,  0.9088, -0.1030,
         -0.2045,  0.8816],
        [ 0.1038, -0.3147, -1.0492, -1.4616,  0.3486,  0.0935,  1.0991,  0.6017,
          0.4244,  1.0089],
        [-1.0991, -0.8065, -0.4636, -2.2918, -0.6212,  0.0072, -0.0078, -1.6868,
          1.6626, -0.5034],
        [-0.2553, -0.7485, -0.0802,  0.2031, -0.4702, -0.5646,  0.6447, -0.5848,
          0.6888,  0.6894],
        [-1.2122, -1.8357,  0.0791, -1.2439,  1.4827, -0.6096, -0.4403, -0.4679,
          0.7568, -0.6869],
        [ 0.1302, -0.0033, -0.1498,  2.4830,  2.1556,  0.9569, -0.6370,  0.1353,
         -0.6154, -1.6343]])

 

zeros(텐서의크기), ones(텐서의크기)

0으로만 (zeros), 또는 1로만(ones) 이루어진 텐서를 입력된 크기로 생성

torch.ones(10,10)

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

 

shape

텐서의 크기를 알려준다

torch.ones(10,10).shape

torch.Size([10, 10])

 

fill_diagoanl_(값)

텐서의 대각성분을 입력된 값으로 바꿔준다

a= torch.zeros(10,10)
a.fill_diagonal_(1)

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

 

tensor[n:m]

파이썬에서 사용되는 인덱싱과 동일하다. 다차원일경우 " , "을 이용한다

a[0:2, 0:2]

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

 

repeat(), view()

텐서를 입력된 값만큼 반복한 텐서를 반환해준다 (repeat)

텐서를 입력된 사이즈로 재 정렬한다(view)

tensor = torch.Tensor([1,2,3,4,5]).repeat(4).view([4,5])
tensor

tensor([[1., 2., 3., 4., 5.],
        [1., 2., 3., 4., 5.],
        [1., 2., 3., 4., 5.],
        [1., 2., 3., 4., 5.]])

 

@ , *

행렬곱을 수행(@)

같은 자리에있는 요소끼리의 곱을 수행(*)

tensor*tensor

tensor([[ 1.,  4.,  9., 16., 25.],
        [ 1.,  4.,  9., 16., 25.],
        [ 1.,  4.,  9., 16., 25.],
        [ 1.,  4.,  9., 16., 25.]])

 

squeeze() , unsqueeze() 

텐서를 입력된 값만큼 차원을 늘렸다(unsqueeze) 줄인다(squeeze).

사이즈는 자동으로 맞춰진다

int_tensor.unsqueeze(-1)

tensor([[1],
        [2],
        [3],
        [4]])

 

 

torch.where(조건문, True일경우, False일경우)

torch.where(a.fill_diagonal_(1) == 1, -1, 3)

tensor([[-1,  3,  3,  3,  3,  3,  3,  3,  3,  3],
        [ 3, -1,  3,  3,  3,  3,  3,  3,  3,  3],
        [ 3,  3, -1,  3,  3,  3,  3,  3,  3,  3],
        [ 3,  3,  3, -1,  3,  3,  3,  3,  3,  3],
        [ 3,  3,  3,  3, -1,  3,  3,  3,  3,  3],
        [ 3,  3,  3,  3,  3, -1,  3,  3,  3,  3],
        [ 3,  3,  3,  3,  3,  3, -1,  3,  3,  3],
        [ 3,  3,  3,  3,  3,  3,  3, -1,  3,  3],
        [ 3,  3,  3,  3,  3,  3,  3,  3, -1,  3],
        [ 3,  3,  3,  3,  3,  3,  3,  3,  3, -1]])

 

tesonr.T

차원반전

b = torch.ones(4,1)
b.T

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