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

재표본 추출 (0)	2019.11.25
가설검정 (0)	2019.11.22
A/B 검정 (0)	2019.11.22
1. Data Science in a Big Data World (0)	2018.04.06

기술 통계량(Descriptive Statistics) (0)	2020.06.16
가설검정 (0)	2019.11.22
A/B 검정 (0)	2019.11.22
1. Data Science in a Big Data World (0)	2018.04.06

Data Science and Machine Learning

정의

기하학적 의미

대수적 의미

고유값 $\lambda$ 찾기

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

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

통계적 가설 검정

귀무가설

유의수준

신뢰구간

엑셀로 통계적 검증 해보기

'Data Science with Excel' 카테고리의 다른 글

측정값과 오차

대표값 추정

추정을 위한 통계량을 얻은 다음, 통계량이 기존의 확률분포를 따른다는 가정하에 추정한다.

추정에 필요한 정보

평균값의 신뢰구간 추정

모집단의 분산을 아는 경우 모평균의 신뢰구간 추정

모집단의 분산을 모르는 경우 모평균의 신뢰구간 추정

엑셀로 모평균의 구간을 추정을 해보자

모집단 분산의 신뢰구간 추정

엑셀로 모평균의 구간을 추정을 해보자

자유도

'Data Science with Excel' 카테고리의 다른 글

위치 모수(location parameter)

데이터 집합의 크기를 나타내는 대표값

척도 모수(scale parameter)

데이터 집합의 산포를 나타내는 대표값

기타 척도

'Data Science with Python' 카테고리의 다른 글

재표본추출 Resampling

순열검정

'Data Science with Python' 카테고리의 다른 글

티스토리툴바