
import numpy as np 
import torch


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

              [[6, 7, 8],
               [9, 10, 11]]])

ft = torch.FloatTensor(t)
print(ft)
print()
print(f'ft의 크기: {ft.shape} = {ft.shape[0]}축 x {ft.shape[1]}행 x {ft.shape[2]}열')
print()

print(f'ft.view([-1, 3]) = \n{ft.view([-1, 3])}')
print()

print(f'ft.view([-1, 3]) = \n{ft.view([-1, 3])}')
print()
print(f'ft.view([-1, 3])의 크기: {ft.view([-1, 3]).shape[0]}행 x {ft.view([-1, 3]).shape[1]}열')
print()
print(f'ft.view([-1, 1, 3]) = \n{ft.view([-1, 1, 3])}')
print()
print(f'ft.view([-1, 1, 3])의 크기: {ft.view([-1, 1, 3]).shape[0]}축 x {ft.view([-1, 1, 3]).shape[1]}행 x {ft.view([-1, 1, 3]).shape[2]}열')

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

        [[ 6.,  7.,  8.],
         [ 9., 10., 11.]]])

ft의 크기: torch.Size([2, 2, 3]) = 2축 x 2행 x 3열

ft.view([-1, 3]) = 
tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 6.,  7.,  8.],
        [ 9., 10., 11.]])

ft.view([-1, 3]) = 
tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 6.,  7.,  8.],
        [ 9., 10., 11.]])

ft.view([-1, 3])의 크기: 4행 x 3열

ft.view([-1, 1, 3]) = 
tensor([[[ 0.,  1.,  2.]],

        [[ 3.,  4.,  5.]],

        [[ 6.,  7.,  8.]],

        [[ 9., 10., 11.]]])

ft.view([-1, 1, 3])의 크기: 4축 x 1행 x 3열


ft = torch.FloatTensor([[0], [1], [2]])

print(f'ft = \n{ft}')
print()
print(f'ft의 크기: {ft.shape[0]}행 x {ft.shape[1]}열')

ft = 
tensor([[0.],
        [1.],
        [2.]])

ft의 크기: 3행 x 1열


print(f'ft.squeeze() = {ft.squeeze()}')
print()
print(f'ft.squeeze()의 크기: {ft.squeeze().shape[0]}')

ft.squeeze() = tensor([0., 1., 2.])

ft.squeeze()의 크기: 3


ft = torch.Tensor([0, 1, 2])
print(f'ft = {ft}')
print()
print(f'ft의 크기: {ft.shape[0]}')

ft = tensor([0., 1., 2.])

ft의 크기: 3


print(f'ft.unsqueeze(0) = {ft.unsqueeze(0)}')
print()
print(f'ft.unsqueeze(0)의 크기: {ft.unsqueeze(0).shape[0]}행 x {ft.unsqueeze(0).shape[1]}열')

ft.unsqueeze(0) = tensor([[0., 1., 2.]])

ft.unsqueeze(0)의 크기: 1행 x 3열


print(f'ft.view(1, -1) = {ft.view(1, -1)}')
print(f'ft.view(1, -1)의 크기: {ft.view(1, -1).shape[0]}행 x {ft.view(1, -1).shape[1]}열')

ft.view(1, -1) = tensor([[0., 1., 2.]])
ft.view(1, -1)의 크기: 1행 x 3열


print(f'ft.unsqueeze(0) = \n{ft.unsqueeze(1)}')
print()
print(f'ft.unsqueeze(0)의 크기: {ft.unsqueeze(1).shape[0]}행 x {ft.unsqueeze(1).shape[1]}열')

ft.unsqueeze(0) = 
tensor([[0.],
        [1.],
        [2.]])

ft.unsqueeze(0)의 크기: 3행 x 1열


print(f'ft.unsqueeze(0) = \n{ft.unsqueeze(-1)}')
print()
print(f'ft.unsqueeze(0)의 크기: {ft.unsqueeze(-1).shape[0]}행 x {ft.unsqueeze(-1).shape[1]}열')

ft.unsqueeze(0) = 
tensor([[0.],
        [1.],
        [2.]])

ft.unsqueeze(0)의 크기: 3행 x 1열


lt = torch.LongTensor([1, 2, 3, 4])
print(lt)
print(lt.float())

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


bt = torch.ByteTensor([True, False, False, True])
print(bt)

tensor([1, 0, 0, 1], dtype=torch.uint8)


print(bt.long())
print(bt.float())

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


x = torch.FloatTensor([[1, 2], [3, 4]])
y = torch.FloatTensor([[5, 6], [7, 8]])
print(f'x = \n{x}')
print(f'y = \n{y}')

x = 
tensor([[1., 2.],
        [3., 4.]])
y = 
tensor([[5., 6.],
        [7., 8.]])


print(torch.cat([x, y], dim=0))
print(torch.cat([x, y], dim=1))

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


x = torch.FloatTensor([1, 4])
y = torch.FloatTensor([2, 5])
z = torch.FloatTensor([3, 6])
print(f'x = {x}')
print(f'y = {y}')
print(f'z = {z}')

x = tensor([1., 4.])
y = tensor([2., 5.])
z = tensor([3., 6.])


print(torch.stack([x, y, z]))
print(torch.stack([x, y, z], dim=1))

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


print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0))

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


print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=1))

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


print(torch.cat([x.unsqueeze(1), y.unsqueeze(1), z.unsqueeze(1)], dim=0))

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


print(torch.cat([x.unsqueeze(1), y.unsqueeze(1), z.unsqueeze(1)], dim=1))

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


x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])
print(x)

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


print(torch.ones_like(x))
print(torch.zeros_like(x))

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


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

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


print(x.mul(2.))
print(x)

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


print(x.mul_(2.))
print(x)

tensor([[2., 4.],
        [6., 8.]])
tensor([[2., 4.],
        [6., 8.]])



import numpy as np
import torch



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

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



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

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



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



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.]



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

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



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.]]



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열



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])



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.])



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])



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.]]



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])



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.]])



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.]])



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.]])



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.]])



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.]])



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.]])



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

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



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.



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

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



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])



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.])



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]))

Machine Learning with Python

모두를 위한 PyTorch

Lab01-2

'모두를 위한 PyTorch' 카테고리의 다른 글

Lab01-1

'모두를 위한 PyTorch' 카테고리의 다른 글

+ Recent posts

티스토리툴바