Lab01-1

 

 

In [1]:

import numpy as np
import torch 

In [2]:

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

 

[0. 1. 2. 3. 4. 5. 6.]

In [3]:

print(f'텐서 t는 {t.ndim}차원')
print(f'텐서 t의 크기는 {t.shape[0]}')

 

텐서 t는 1차원
텐서 t의 크기는 7

In [4]:

print(f't[0] = {t[0]},  t[1] = {t[1]},  t[-1] = {t[-1]}')

 

t[0] = 0.0,  t[1] = 1.0,  t[-1] = 6.0

In [5]:

print(f't[2:5] = {t[2:5]}, t[4:-1] = {t[4:-1]}')

 

t[2:5] = [2. 3. 4.], t[4:-1] = [4. 5.]

In [6]:

print(f't[:2] = {t[:2]}, t[3:] = {t[3:]}')

 

t[:2] = [0. 1.], t[3:] = [3. 4. 5. 6.]

In [7]:

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

 

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

In [8]:

print(f'2차원 텐서 t는 {t.ndim}차원')
print(f'2차원 텐서 t의 크기는 {t.shape[0]}행 x {t.shape[1]}열 ') 

 

2차원 텐서 t는 2차원
2차원 텐서 t의 크기는 4행 x 3열 

In [9]:

t = np.array([0., 1., 2., 3., 4., 5., 6.])
ft = torch.FloatTensor(t)
print(f'파이토치 1차원 텐서: {ft}')
print(f'파이토치 1차원 텐서는 {ft.dim()}차원') 
print(f'파이토치 1차원 텐서의 모양: {ft.shape}')

 

파이토치 1차원 텐서: tensor([0., 1., 2., 3., 4., 5., 6.])
파이토치 1차원 텐서는 1차원
파이토치 1차원 텐서의 모양: torch.Size([7])

In [10]:

print(f'ft[0] = {ft[0]}, ft[1] = {ft[1]}, ft[-1] = {ft[-1]}')
print(f'ft[2:5] = {ft[2:5]}, ft[4:-1] = {ft[4:-1]}')
print(f'ft[:2] = {ft[:2]}, ft[3:] = {ft[3:]}')

 

ft[0] = 0.0, ft[1] = 1.0, ft[-1] = 6.0
ft[2:5] = tensor([2., 3., 4.]), ft[4:-1] = tensor([4., 5.])
ft[:2] = tensor([0., 1.]), ft[3:] = tensor([3., 4., 5., 6.])

In [11]:

t = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]])
ft = torch.FloatTensor(t)
print(ft)
print(f'파이토치 2차원 텐서는 {ft.dim()}차원') 
print(f'파이토치 2차원 텐서의 모양: {ft.shape}')
print(f'파이토치 2차원 텐서의 크기: {ft.size()}')

 

tensor([[ 1.,  2.,  3.],
        [ 4.,  5.,  6.],
        [ 7.,  8.,  9.],
        [10., 11., 12.]])
파이토치 2차원 텐서는 2차원
파이토치 2차원 텐서의 모양: torch.Size([4, 3])
파이토치 2차원 텐서의 크기: torch.Size([4, 3])

In [12]:

print(f't[:, 1] = {t[:, 1]}')
print(f't[:, 1]의 크기: {t[:, 1].size}')
print(f't[:, :-1] = \n{t[:, :-1]}')

 

t[:, 1] = [ 2.  5.  8. 11.]
t[:, 1]의 크기: 4
t[:, :-1] = 
[[ 1.  2.]
 [ 4.  5.]
 [ 7.  8.]
 [10. 11.]]

In [13]:

t = np.array([[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
               [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]])
ft = torch.FloatTensor(t)
print(ft)
print(f'파이토치 4차원 텐서는 {ft.dim()}차원') 
print(f'파이토치 4차원 텐서의 모양: {ft.shape}')
print(f'파이토치 4차원 텐서의 크기: {ft.size()}')

 

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

         [[13., 14., 15., 16.],
          [17., 18., 19., 20.],
          [21., 22., 23., 24.]]]])
파이토치 4차원 텐서는 4차원
파이토치 4차원 텐서의 모양: torch.Size([1, 2, 3, 4])
파이토치 4차원 텐서의 크기: torch.Size([1, 2, 3, 4])

In [14]:

m1 = torch.FloatTensor([[3, 2]])
m2 = torch.FloatTensor([[2, 2]])
print(f'm1 = {m1}')
print(f'm2 = {m2}')
print(f'm1 + m2 = {m1 + m2}')

 

m1 = tensor([[3., 2.]])
m2 = tensor([[2., 2.]])
m1 + m2 = tensor([[5., 4.]])

In [15]:

m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3]])
print(f'm1 = {m1}')
print(f'm2 = {m2}')
print(f'm1 + m2 = {m1 + m2}')

 

m1 = tensor([[1., 2.]])
m2 = tensor([[3.]])
m1 + m2 = tensor([[4., 5.]])

In [16]:

m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3], [2]])
print(f'm1 = {m1}')
print(f'm2 = \n{m2}')
print(f'm1 + m2 = \n{m1 + m2}')

 

m1 = tensor([[1., 2.]])
m2 = 
tensor([[3.],
        [2.]])
m1 + m2 = 
tensor([[4., 5.],
        [3., 4.]])

In [17]:

m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3], [4]])
print(f'm1 = {m1}')
print(f'm2 = \n{m2}')
print(f'm1 + m2 = \n{m1 + m2}')

 

m1 = tensor([[1., 2.]])
m2 = 
tensor([[3.],
        [4.]])
m1 + m2 = 
tensor([[4., 5.],
        [5., 6.]])

In [18]:

m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print(f'm1 = \n{m1}')
print(f'm2 = \n{m2}')
print(f'm1의 크기: {m1.shape} = {m1.shape[0]}행 x {m1.shape[1]}열') # 2 x 2
print(f'm2의 크기: {m2.shape} = {m2.shape[0]}행 x {m2.shape[1]}열') # 2 x 1
print(f'm1.matmul(m2) = m1 x m2 = \n{m1.matmul(m2)}') # 2 x 1

 

m1 = 
tensor([[1., 2.],
        [3., 4.]])
m2 = 
tensor([[1.],
        [2.]])
m1의 크기: torch.Size([2, 2]) = 2행 x 2열
m2의 크기: torch.Size([2, 1]) = 2행 x 1열
m1.matmul(m2) = m1 x m2 = 
tensor([[ 5.],
        [11.]])

In [19]:

m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print(f'm1 = \n{m1}')
print(f'm2 = \n{m2}')
print(f'm1의 크기: {m1.shape} = {m1.shape[0]}행 x {m1.shape[1]}열') # 2 x 2
print(f'm2의 크기: {m2.shape} = {m2.shape[0]}행 x {m2.shape[1]}열') # 2 x 1
print(f'm1.mul(m2) = m1 * m2 = \n{m1.mul(m2)}') # 2 x 1

 

m1 = 
tensor([[1., 2.],
        [3., 4.]])
m2 = 
tensor([[1.],
        [2.]])
m1의 크기: torch.Size([2, 2]) = 2행 x 2열
m2의 크기: torch.Size([2, 1]) = 2행 x 1열
m1.mul(m2) = m1 * m2 = 
tensor([[1., 2.],
        [6., 8.]])

In [20]:

# 평균
t = torch.FloatTensor([1, 2])
print(f't = {t}')
print(f'토치텐서 t의 평균 = {t.mean()}')

 

t = tensor([1., 2.])
토치텐서 t의 평균 = 1.5

In [21]:

t = torch.LongTensor([1, 2])
try:
    print(t.mean())
except Exception as exc:
    print(exc)

 

Can only calculate the mean of floating types. Got Long instead.

In [22]:

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

 

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

In [23]:

print(f'토치텐서 전체 평균: {t.mean()}')
print(f'토치텐서 행별(dim=0) 평균: {t.mean(dim=0)}')
print(f'토치텐서 열별(dim=1) 평균: {t.mean(dim=1)}')
print(f'토치텐서 dim=-1별 평균: {t.mean(dim=-1)}')

 

토치텐서 전체 평균: 2.5
토치텐서 행별(dim=0) 평균: tensor([2., 3.])
토치텐서 열별(dim=1) 평균: tensor([1.5000, 3.5000])
토치텐서 dim=-1별 평균: tensor([1.5000, 3.5000])

In [24]:

print(f'토치텐서 전체 합: {t.sum()}')
print(f'토치텐서 행별(dim=0) 합: {t.sum(dim=0)}')
print(f'토치텐서 열별(dim=1) 합: {t.sum(dim=1)}')
print(f'토치텐서 dim=-1별 합: {t.sum(dim=-1)}')

 

토치텐서 전체 합: 10.0
토치텐서 행별(dim=0) 합: tensor([4., 6.])
토치텐서 열별(dim=1) 합: tensor([3., 7.])
토치텐서 dim=-1별 합: tensor([3., 7.])

In [25]:

print(f'토치텐서 전체에 대한 최대값: {t.max()}')
print(f'토치텐서 행별(dim=0) 최대값 및 행에서의 인덱스: \n{t.max(dim=0)}')
print(f'토치텐서 행별 최대값: {t.max(dim=0)[0]}')
print(f'토치텐서 최대값의 인덱스: {t.max(dim=0)[1]}')
print(f'토치텐서 열별(dim=1) 최대값 및 열에서의 인덱스: \n{t.max(dim=1)}')
print(f'토치텐서 dim=-1별 최대값 및 dim=-1에서의 인덱스: \n{t.max(dim=-1)}')

 

토치텐서 전체에 대한 최대값: 4.0
토치텐서 행별(dim=0) 최대값 및 행에서의 인덱스: 
torch.return_types.max(
values=tensor([3., 4.]),
indices=tensor([1, 1]))
토치텐서 행별 최대값: tensor([3., 4.])
토치텐서 최대값의 인덱스: tensor([1, 1])
토치텐서 열별(dim=1) 최대값 및 열에서의 인덱스: 
torch.return_types.max(
values=tensor([2., 4.]),
indices=tensor([1, 1]))
토치텐서 dim=-1별 최대값 및 dim=-1에서의 인덱스: 
torch.return_types.max(
values=tensor([2., 4.]),
indices=tensor([1, 1]))