[PyTorch] 파이토치 기본 조작 - Tensor 만들기, .matmul, .mul, 브로드캐스팅, mean(), sum(), max(), agrmax()

 

 

 

Numpy로 Tensor 만들기¶

In [1]:

import numpy as np

 

1차원 백터

In [2]:

t = np.array([0.,1.,2.,3.,4.,5.,6.])

In [3]:

t

Out[3]:

array([0., 1., 2., 3., 4., 5., 6.])

 

.ndim으로 몇 차원인지 확인¶

In [5]:

t.ndim

Out[5]:

1

 

.shape로 크기 및 형태 출력¶

In [6]:

t.shape

Out[6]:

(7,)

 

2차원 행렬(matrix) 만들기¶

In [7]:

t = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]])
t

Out[7]:

array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.],
       [ 7.,  8.,  9.],
       [10., 11., 12.]])

In [8]:

t.ndim

Out[8]:

2

In [9]:

t.shape

Out[9]:

(4, 3)

 

3차원 Tensor 만들기¶

In [11]:

t3 = np.array([[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]]
               ,[[4., 5., 6.], [7., 8., 9.], [10., 11., 12.], [13., 14., 15.]]]
                         
             )
t3

Out[11]:

array([[[ 1.,  2.,  3.],
        [ 4.,  5.,  6.],
        [ 7.,  8.,  9.],
        [10., 11., 12.]],

       [[ 4.,  5.,  6.],
        [ 7.,  8.,  9.],
        [10., 11., 12.],
        [13., 14., 15.]]])

In [12]:

t3.ndim

Out[12]:

3

In [13]:

t3.shape

Out[13]:

(2, 4, 3)

In [ ]:

 

Pytorch로 텐서 선언하기 (PyTorch Tensor Allocation)¶

In [14]:

import torch

 

1차원 백터¶

In [15]:

t= torch.FloatTensor([0., 1., 2., 3., 4., 5., 6.])
t

Out[15]:

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

In [16]:

# 1차원 백터
t.dim()

Out[16]:

1

In [17]:

# 1행 7열
t.shape

Out[17]:

torch.Size([7])

In [21]:

# 7개의 데이터
t.size()

Out[21]:

torch.Size([7])

In [20]:

# 데이터타입은 torch.float32
t.dtype

Out[20]:

torch.float32

 

2차원 행렬(Matrix)¶

In [23]:

t = torch.FloatTensor([[1., 2., 3.],
                       [4., 5., 6.],
                       [7., 8., 9.],
                       [10., 11., 12.]
                      ])
t

Out[23]:

tensor([[ 1.,  2.,  3.],
        [ 4.,  5.,  6.],
        [ 7.,  8.,  9.],
        [10., 11., 12.]])

In [25]:

# 2차원
t.dim()

Out[25]:

2

In [27]:

# 4행 3열
t.shape

Out[27]:

torch.Size([4, 3])

In [28]:

# 4, 3의 크기
t.size()

Out[28]:

torch.Size([4, 3])

In [29]:

t[:,1]

Out[29]:

tensor([ 2.,  5.,  8., 11.])

In [30]:

t[1,1]

Out[30]:

tensor(5.)

 

브로드캐스팅 (Broadcasting)¶

 

PyTorch도 Numpy처럼 행렬 계산에서 크기가 맞지 않아도 알아서 맞춰 계산해 주는 브로드캐스팅이 가능하다.¶

In [33]:

# 정상적으로 크기가 같은 (1,2)끼리의 계산
m1 = torch.FloatTensor([[3, 3]])
m2 = torch.FloatTensor([[2, 2]])
print(m1.size())
print(m2.size())
print(m1 + m2)

 

torch.Size([1, 2])
torch.Size([1, 2])
tensor([[5., 5.]])

In [34]:

# 크기가 같지 않은 계산 즉 Vector + scalar의 계산
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([3]) # [3] -> [3, 3]
print(m1.size())
print(m2.size())
print(m1 + m2)

 

torch.Size([1, 2])
torch.Size([1])
tensor([[4., 5.]])

 

원래는 수학적으로 계산이 안되는 것이 정상이지만 파이토치에서 알아서 m2의 스칼라 3을 m1의 백터 [1,2] 형태인 [3,3]으로 브로드캐스팅해서 [1,2]+[3,3]을 계산 값 [4,5]가 나옴

In [36]:

# 2 x 1 Vector + 1 x 2 Vector
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3], [4]])
print(m1.size())
print(m2.size())
print(m1 + m2)

 

torch.Size([1, 2])
torch.Size([2, 1])
tensor([[4., 5.],
        [5., 6.]])

 

m1 = [1, 2], m2 = [2,1]의 행렬로 원래 수학적 계산이 불가능 그러나 파이토치가

[1, 2] 를 ==> [[1, 2], [1, 2]]

[3] [4] 를 ==> [[3, 3], [4, 4]]

로 브로드캐스팅 변환해 자동으로 연산해 줌

In [ ]:

 

자주 사용되는 기능들¶

 

1) 행렬 곱셈(.matmul)과 원소 별 곱셈(.mul)¶

(Matrix Multiplication Vs. Multiplication)¶

 

행렬 곱셈(.matmul)¶

In [37]:

m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print('Shape of Matrix 1: ', m1.shape) # 2 x 2
print('Shape of Matrix 2: ', m2.shape) # 2 x 1
print(m1.matmul(m2)) # 2 x 1

 

Shape of Matrix 1:  torch.Size([2, 2])
Shape of Matrix 2:  torch.Size([2, 1])
tensor([[ 5.],
        [11.]])

 

원소 별 곱셈(.mul) m1*m2를 한 결과와 같음¶

In [38]:

m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print('Shape of Matrix 1: ', m1.shape) # 2 x 2
print('Shape of Matrix 2: ', m2.shape) # 2 x 1
print(m1 * m2) # 2 x 2
print(m1.mul(m2))

 

Shape of Matrix 1:  torch.Size([2, 2])
Shape of Matrix 2:  torch.Size([2, 1])
tensor([[1., 2.],
        [6., 8.]])
tensor([[1., 2.],
        [6., 8.]])

 

2) 평균 mean()¶

In [39]:

t = torch.FloatTensor([1,2])
t.mean()

Out[39]:

tensor(1.5000)

In [40]:

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

Out[40]:

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

In [41]:

t.mean()

Out[41]:

tensor(2.5000)

In [42]:

t.mean(dim=0)

Out[42]:

tensor([2., 3.])

In [43]:

t.mean(dim=1)

Out[43]:

tensor([1.5000, 3.5000])

In [44]:

t.mean(dim=-1)

Out[44]:

tensor([1.5000, 3.5000])

 

3) 덧셈 sum()¶

In [45]:

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

Out[45]:

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

In [46]:

t.sum()

Out[46]:

tensor(10.)

In [47]:

t.sum(dim=0)

Out[47]:

tensor([4., 6.])

In [48]:

t.sum(dim=1)

Out[48]:

tensor([3., 7.])

In [49]:

t.sum(dim=-1)

Out[49]:

tensor([3., 7.])

 

3) 최대값 max(), 최대값을 가진 인덱스 argmax()¶

In [57]:

t = torch.FloatTensor([[7, 2], [3, 4]])
t

Out[57]:

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

In [58]:

t.max()

Out[58]:

tensor(7.)

In [59]:

t.argmax()

Out[59]:

tensor(0)

 

max에 dim= 옵션을 주면 max 값과 agrmax 값이 같이 리턴 됨¶

max 값만 보고 싶으면 뒤에 [0], agrmax 값만 보고 싶을 땐 [1]로 인덱싱¶

In [60]:

t.max(dim=0)

Out[60]:

torch.return_types.max(
values=tensor([7., 4.]),
indices=tensor([0, 1]))

In [61]:

t.max(dim=1)

Out[61]:

torch.return_types.max(
values=tensor([7., 4.]),
indices=tensor([0, 1]))

In [64]:

# 값만 리턴 받고 싶을 때
t.max(dim=1)[0]

Out[64]:

tensor([7., 4.])

In [65]:

# 인덱스만 리턴 받고 싶을 때
t.max(dim=1)[1]

Out[65]:

tensor([0, 1])

In [ ]: