[Deep Learning] Tensor / 스칼라, 벡터, 행렬, 텐서 사칙연산

텐서(Tensor)

데이터를 표현하는 단위

---

스칼라, 벡터, 행렬, 텐서 개념도

https://towardsdatascience.com/linear-algebra-for-deep-learning-506c19c0d6fa

---

스칼라(Scalar)

흔히 알고 있는 상숫값

즉, 하나의 값을 표현할 때 1개의 수치로 표현한 것

 

torch 내 텐서 메서드(tensor method)를 이용해 스칼라 값 정의

import torch

scalar1 = torch.tensor([1.])
# tenser([1.])

scalar2 = torch.tensor([3.])
# tenser([3.])

 

사칙연산 수행

• add : + , torch.add( )
• sub : - , torch.sub( )
• mul : * , torch.mul( )
• div : / , torch.div( )

# 스칼라 값간의 사칙연산 계산

# add +
add_scalar = scalar1 + scalar2
# tensor([4.])

# sub -
sub_scalar = scalar1 - scalar2
# tensor([-2.])

# mul *
mul_scalar = scalar1 * scalar2
# tensor([3.])

# div /
div_scalar = scalar1 / scalar2
# tensor([0.3333])

# torch 모듈에 내장된 메서드를 이용해 계산

torch.add(scalar1, scalar2)
# tensor([4.])

torch.sub(scalar1, scalar2)
# tensor([-2.])

torch.mul(scalar1, scalar2)
# tensor([3.])

torch.div(scalar1, scalar2)
# tensor([0.3333])

---

벡터(Vector)

벡터는 하나의 값을 표현할 때 2개 이상의 수치로 표현한 것

스칼라의 형태와 동일한 속성을 갖고 있지만, 여러 수치 값을 이용해 표현하는 방식

 

vector1 = torch.tensor([1., 2., 3.])
# tensor([1., 2., 3.])

vector2 =  torch.tensor([4., 5., 6.])
# tensor([4., 5., 6.])

 

벡터 값 간 사칙연산 (스칼라 사칙연산과 동일한 방식) → 곱셈과 나눗셈은 각 요소별로(element-wise) 연산됨

• add : + , torch.add( )
• sub : - , torch.sub( )
• mul : * , torch.mul( ) → element-wise 연산
• div : / , torch.div( ) → element-wise 연산
• 내적 연산 → torch.dot( )

# 곱셈과 나눗셈은 각 요소별로(element-wise) 연산

# add +
add_vector = vector1 + vector2
# tensor([5., 6., 7.])

# sub -
sub_vector = vector1 - vector2
# tensor([-3., -3., -3.])

# mul *
mul_vector = vector1 * vector2
# tensor([4., 10., 18.])

# div /
div_vector = vector1 / vector2
# tensor([0.2500, 04000, 0.5000])

# torch 모듈에 내장된 메서드를 이용해 벡터 값 계산
# 벡터 값 간 내적 연산도 torch모듈에 내장되어있어 사용 가능

torch.add(vector1, vector2)
# tensor([5., 6., 7.])

torch.sub(vector1, vector2)
# tensor([-3., -3., -3.])

torch.mul(vector1, vector2)
# tensor([4., 10., 18.])

torch.div(vector1, vector2)
# tensor([0.2500, 04000, 0.5000])

torch.dot(vector1, vector2)
# tensor(32.)
# 내적 값 (1*4)+(2*5)+(3*6)=4+10+18=32

---

행렬(Matrix)

2개 이상의 벡터 값을 통합해 구성된 값, 벡터 값 간 연산 속도를 빠르게 진행할 수 있는 선형 대수의 기본 단위

 

matrix1 = torch.tensor([[1., 2.], [3., 4.]])
# tensor([[1., 2.],
#        [3., 4.]])

matrix2 = torch.tensor([[5., 6.], [7., 8.]])
#tensor([[5., 6.],
#        [7., 8.]])

 

행렬 값 간의 사칙연산 → 스칼라, 벡터 사칙연산과 동일한 방식

• 행렬 곱 연산 → torch.matmul( )

sum_matrix = matrix1 + matrix2
# tensor([[ 6.,  8.],
#        [10., 12.]])

sub_matrix = matrix1 - matrix2
# tensor([[-4., -4.],
#        [-4., -4.]])

mul_matrix = matrix1 * matrix2
# tensor([[ 5., 12.],
#        [21., 32.]])

div_matrix = matrix1 / matrix2
# tensor([[0.2000, 0.3333],
#        [0.4286, 0.5000]])

# torch 모듈에 내장된 메서드를 이용해 행렬 값 간 계산
# 행렬 값 간의 내적 연산을 torch 모듈에 내장되어 이것 이용
# 벡터 및 행렬 간 사칙연산 중 곱셈은 element-wise 계산
# 행렬 곱 연산은 torch.matmul을 이용해 실행 가능

torch.add(matrix1, matrix2)
# tensor([[ 6.,  8.],
#        [10., 12.]])

torch.sub(matrix1, matrix2)
# tensor([[-4., -4.],
#        [-4., -4.]])

torch.mul(matrix1, matrix2)
# tensor([[ 5., 12.],
#        [21., 32.]])

torch.div(matrix1, matrix2)
# tensor([[0.2000, 0.3333],
#        [0.4286, 0.5000]])

torch.matmul(matrix1, matrix2)
# tensor([[19., 22.],
#        [43., 50.]])
# [[(1*5)+(2*7)], [(1*6)+(2*8)], [(3*5)+(4*7)], [(3*6)+(4*8)]]

 

torch.matmul(matrix1, matrix2)

---

텐서 (Tensor)

행렬을 2차원의 배열이라 표현

텐서는 2차원 이상의 배열이라 표현

 

텐서의 파이토치 예제 역시 스칼라, 벡터, 행렬과 같은 논리로 적용

텐서 내 행렬 단위의 인덱스 간, 행렬 내 인덱스 간 원소끼리 계산되며 행렬 곱은 텐서 내 같은 행렬 단위의 인덱스 간에 계산됨

 

tensor1 = torch.tensor([[[1., 2.],[3., 4.]], [[5., 6.],[7., 8.]]])
# tensor([[[1., 2.],
#         [3., 4.]],

#        [[5., 6.],
#         [7., 8.]]])

tensor2 = torch.tensor([[[9., 10.],[11., 12.]], [[13., 14.],[15., 16.]]])
# tensor([[[ 9., 10.],
#         [11., 12.]],

#        [[13., 14.],
#         [15., 16.]]])

 

텐서 값 간의 사칙연산

sum_tensor = tensor1 + tensor2
# tensor([[[10., 12.],
#         [14., 16.]],

#        [[18., 20.],
#         [22., 24.]]])

sub_tensor = tensor1 - tensor2
# tensor([[[-8., -8.],
#         [-8., -8.]],

#        [[-8., -8.],
#         [-8., -8.]]])

mul_tensor = tensor1 * tensor2
# tensor([[[  9.,  20.],
#         [ 33.,  48.]],

#        [[ 65.,  84.],
#         [105., 128.]]])

div_tensor = tensor1 / tensor2
# tensor([[[0.1111, 0.2000],
#         [0.2727, 0.3333]],

#        [[0.3846, 0.4286],
#         [0.4667, 0.5000]]])

torch 모듈에 내장된 메서드를 이용해 계산

텐서 값 간 내적 연산 역시 torch 모듈에 내장되어있어 사용 가능

torch.add(tensor1, tensor2)
# tensor([[[10., 12.],
#         [14., 16.]],

#        [[18., 20.],
#         [22., 24.]]])

torch.sub(tensor1, tensor2)
# tensor([[[-8., -8.],
#         [-8., -8.]],

#        [[-8., -8.],
#         [-8., -8.]]])

torch.mul(tensor1, tensor2)
# tensor([[[  9.,  20.],
#         [ 33.,  48.]],

#        [[ 65.,  84.],
#         [105., 128.]]])

torch.div(tensor1, tensor2)
# tensor([[[0.1111, 0.2000],
#         [0.2727, 0.3333]],

#        [[0.3846, 0.4286],
#         [0.4667, 0.5000]]])

torch.matmul(tensor1, tensor2)
# tensor([[[ 31.,  34.],
#         [ 71.,  78.]],

#        [[155., 166.],
#         [211., 226.]]])

torch.matmul(tensor1, tensor2)

---

파이썬 딥러닝 파이토치 part01(p02~27)