๐ป ์ฌ์ค ์ด๊ฑฐ ๋ค๋ฃฐ๋ ค๊ณ Scalar & Vector ๋ฐฐ์ด ๊ฑฐ๋ผ ํ ์ ๋๋ก ํ๋ ฌ์.. ์ ํ๋์ํ์ ๊ฝ! ๐ป
Scalar & Vector (fundamentals)
โถ Linear Algebra ํ๋ฉด? ๋น์ฐํ ์์์ผ ํ ๊ธฐ๋ณธ์ 'Scalar(์ค์นผ๋ผ)' & 'Vector(๋ฒกํฐ)' & 'Matrix(ํ๋ ฌ)' โ 1. Scalar * concepts = "๋จ์ํ ๋ณ์๋ก ์ ์ฅ๋์ด ์๋ ์ซ์" → vector ํน์ matrices์ ๊ณฑํด์ง๋..
sh-avid-learner.tistory.com
1. intro
"ํ๋ ฌ์ด๋ → ํ๊ณผ ์ด์ ํตํด ๋ฐฐ์น๋์ด ์๋ ์ซ์๋ค"
→ matrix๋ฅผ ํํํ๋ ๋ณ์๋ ์ผ๋ฐ์ ์ผ๋ก ๋๋ฌธ์
→ ํ๋ ฌ์ vector์ ๋ชจ์์ผ๋ก๋ ๋งํ ์ ์์ (์ฃผ๋ก default๋ก column vector๋ฅผ ๊ธฐ์ค์ผ๋ก ํจ)
→ ์ฆ, dataframe์ ์ ์ฉํ๋ฉด ํ column์ vector, ๊ทธ๋ฆฌ๊ณ ์ฌ๋ฌ column๋ค์ ๋ชจ์ ์ผ์ข ์ dataframe์ ํ๋ ฌ์ด๋ผ ๋งํ ์๋ ์์
→ $X_{ij}$๋ ํ๋ ฌ X์ i๋ฒ์งธ ์ด๊ณผ j๋ฒ์งธ ํ์ด ๋ง๋๋ ๊ณณ์ ์์๋ฅผ ๋ปํ๋ค
→ numpy๋ฅผ ์ฌ์ฉํด 2์ฐจ์ ๋ฐฐ์ด๋ก ํํ ๊ฐ๋ฅํ๋ค. ์๋ matrix A๋ 2๊ฐ์ ํ vector๋ฅผ ํ๋์ array์์ ๋ด์ ํ๋ ฌ๋ก ํํํ๋ค.
(ํ์ด์ฌ numpy์์๋ ์ฌ๋ฌ ํ vector๋ฅผ [] ์์ ๋ฃ์ด๋๊ณ ๋์ดํด์ ํ๋ ฌ๋ก ๋ง๋ฆ)
import numpy as np
A = np.array([[1, 2],
[3, 4]])
A
'''
array([[1, 2],
[3, 4]])
'''
A.shape #(2,2)
#1st column vector
A[:, 0]
#array([1, 3])
#2nd column vector
A[:, 1]
#array([2, 4])
#1st row vector
A[0, :]
#array([1, 2])
#2nd row vector
A[1, :]
#array([3, 4])
* ํ๋ ฌ์ ์ผ์น / ์ ์น
โ ํ๋ ฌ์ ์ผ์น
→ matrix dimensionality) matrix์ ํ๊ณผ ์ด์ ์ซ์(์ฐจ์) (vector dimensionality๋ vector element์ ๊ฐ์)
→ matrix dimensonality๋ (ํ-์ด)๋ก ํํ
→ ํ๋ ฌ์ ์ผ์น 2๊ฐ์ง ์กฐ๊ฑด
(1) ์กฐ๊ฑด1) ๋ matrix๊ฐ ์ฐจ์์ด ์๋ก ๋์ผ (ex (2,3) != (3,2))
(2) ์กฐ๊ฑด2) ๊ฐ matrix ๊ตฌ์ฑ component๊ฐ ๋์ผ
โก ํ๋ ฌ์ ์ ์น (transpose)
= "matrix์ ํ๊ณผ ์ด์ ๋ฐ๊พธ๋๊ฒ"
→ ์ผ๋ฐ์ ์ผ๋ก matrix ์ฐ์ธก ์๋จ์ T ๋๋ tick ๋งํฌ๋ฅผ ํ๊ธฐํ๋ค ($X^T = (x_{ji})$)
→ ์ฝ๋ ๋ฐฉ๋ฒ์ B transpose or B prime
→ ์ผ๋ฐ์ ์ผ๋ก n์ฐจ์์ vector๋ ์ฃผ๋ก ์ด๋ฒกํฐ(column vector)๋ฅผ ์ง์นญํ ๋ ๋ง์ด ์ฐ์ด๊ณ , ํ๋ฒกํฐ(row vector)๋ ์ด๋ฒกํฐ์ transpose ํํ๋ก ๋ง์ด ์ฐ์ธ๋ค. (์๋ ๊ทธ๋ฆผ ์ฐธ์กฐ)
* ์ฐ์ฐ
โ ํ๋ ฌ๊ณผ ์ค์นผ๋ผ์ ์ฐ์ฐ (broadcasting)
→ ๊ธฐ์กด ํ๋ ฌ์ A๋ผ๊ณ ํ๋ฉด A+1์ A์ ๋ชจ๋ ์์์ 1์ด ๋ํด์ง ๊ฒฐ๊ณผ์ ํ๋ ฌ์ด ๋์จ๋ค.
→ A*3์ A์ ๋ชจ๋ ์์์ 3์ด ๊ณฑํด์ง ๊ฒฐ๊ณผ์ ํ๋ ฌ์ด ๋์จ๋ค.
A+1
'''
array([[2, 3],
[4, 5]])
'''
A*3
'''
array([[ 3, 6],
[ 9, 12]])
'''
โก ํ๋ ฌ๊ณผ ํ๋ ฌ์ ๊ณฑ - matrix multiplication
→ ์ ๊ทธ๋ฆผ์์ ์ ์ ์๋ฏ์ด, A์ ์ด์ ๊ฐ์(column vector์ ๊ฐ์)์ B์ ํ์ ๊ฐ์(row vector์ ๊ฐ์)๊ฐ ๊ฐ์์ผ๋ง multiplication ์งํ ๊ฐ๋ฅ
→ not commutative - ๊ตํ๋ฒ์น์ด ์ฑ๋ฆฝํ์ง ์๋๋ค AB≠BA
→ distributive - ๋ถ๋ฐฐ๋ฒ์น ์ฑ๋ฆฝ A(B+C) = AB + AC (Distributive)
→ associative - ๊ฒฐํฉ๋ฒ์น ์ฑ๋ฆฝ A(BC) = (AB)C (Associative)
→ multiplication ๊ฒฐ๊ณผ ํ ์ค์นผ๋ผ ๊ฐ์ด ๋์จ๋ค๋ฉด ๋ด์ , ๋ ์ฌ์ด์ฆ๊ฐ ์ปค์ง matrix๊ฐ ๋์จ๋ค๋ฉด ์ธ์
B = np.array([[1,2,3],
[4,5,6]])
np.dot(A, B) # A X B
'''
array([[ 9, 12, 15],
[19, 26, 33]])
'''
np.dot(B,A) #ValueError: shapes (2,3) and (2,2) not aligned: 3 (dim 1) != 2 (dim 0)
โข ํ๋ ฌ๊ณผ ํ๋ ฌ์ ํฉ (element-wise)
→ ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ํ๋ ฌ๋ผ๋ฆฌ ๊ฐ์ shape์ ๊ฐ์ง๋ฉด, ํ๋ ฌ ๊ฐ์ ๋ง์ ๊ณผ ๋บ์ ์ฐ์ฐ ๊ฐ๋ฅ
C = np.array([[2, 2],
[4, 4]])
A+C
'''
array([[3, 4],
[7, 8]])
'''
A+B #ValueError: operands could not be broadcast together with shapes (2,2) (2,3)
โฃ ํ๋ ฌ๊ณผ ๋ฒกํฐ์ ๊ณฑ
→ ํ๋ ฌ๊ณผ ํ๋ ฌ์ ๊ณฑ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก element-wise ์งํ
# v - column vector
v = np.array([[1],
[2]])
np.dot(A,v)
'''
array([[ 5],
[11]])
'''
A
'''
array([[1, 2],
[3, 4]])
'''
โป ํ๋ ฌ๊ณผ ๋ฒกํฐ ๊ณฑ์ ๊ธฐํํ์ ์๋ฏธ โป
๐ column vector๋ ๊ณต๊ฐ์์ ํ ์ ์ผ๋ก ๋ณผ ์ ์๊ณ , ์ฌ๋ฌ column vector๊ฐ ๋ชจ์ธ matrix์ ์ํด column vector ํ ์ ์ด ๋ค๋ฅธ ์๋ก์ด column vector๋ก ๋ณํ
๐ ์ฆ, ํ๋ ฌ๊ณผ ๋ฒกํฐ ๊ณฑ์์์ matrix๋ ๊ณต๊ฐ์์ ํ ์ ์ ๋ค๋ฅธ ์ ์ผ๋ก ์ด๋์ํค๋ ์ญํ ์ ํ๋ค๊ณ ํ ์ ์์ผ๋ฉฐ, ์ด๋ฅผ 'linear transformation(์ ํ๋ณํ)'์ด๋ผ๊ณ ํ๋ค.
๐ Linear Transformation ๋ ๊ฐ์ง ์ฑ์ง
→ T(u+v) = T(u) + T(v)
→ T(av) = aT(v) (a๋ scalar)
ex1) ์๋ ํ๋ ฌ A์ ์ํด column vector [1, 2]๊ฐ [5, 11]์ด๋ผ๋ ๋ค๋ฅธ ์ ์ผ๋ก ์ด๋ํ๋ค.
ex2) m์ฐจ์์ column vector๋ฅผ linear transformation์ ํ์ฉํด ์ฐจ์์ด ๋ค๋ฅธ n์ฐจ์์ ๊ณต๊ฐ์ผ๋ก ์ด๋์ํฌ ์๋ ์๋ค.
v=np.array([[1],
[1],
[1]])
A=np.array([[1,0,1],
[0,1,0],
[0,1,1],
[1,1,0]])
print(np.dot(A,v))
'''
[[2]
[1]
[2]
[2]]
'''
→ ์ ์ฝ๋ ์์์์ column vector์ ์ฐจ์์ 3์ด์์ผ๋, A์ ์ํด linear transformation ๊ณผ์ ์ผ๋ก ๊ฑฐ์ณ 4์ฐจ์ ๊ณต๊ฐ์ผ๋ก ์ด๋ํ๋ค.
→ ์ฆ, matrix multiplication์ ํตํด m์ฐจ์ ๊ณต๊ฐ์ ์กด์ฌํ๋ ๊ธฐ์กด vector๋ฅผ ๋ค๋ฅธ ์ฐจ์์ธ n์ฐจ์ ๊ณต๊ฐ์ผ๋ก ๋ณด๋ผ ์ ์๋ค(mapping)
→ ๋ฐ๋ผ์, matrix multipllication์ ํตํด ํจํด์ ์ถ์ถํ ์๋ ์๊ณ , ๋ฐ์ดํฐ๋ฅผ ์์ถํ ์๋ ์๋ค. (๊ธฐ๊ณํ์ต์์ ํ๋ ฌ์ ๋ง์ด ์ฌ์ฉ)
โค ํ๋ ฌ๊ณผ ๋ฒกํฐ์ ํฉ (broadcasting)
A+v
'''
array([[2, 3],
[5, 6]])
'''
(โป ๊ทธ๋ฆผ ์ฐธ์กฐ โป)
2. ํ๋ ฌ์ ์ข ๋ฅ
* ๋๊ฐํ๋ ฌ(diagonal matrix)
๐ ์ ์ → '๋๊ฐ์ ์์ ์๋ ์์ ์ด์ธ์ ๋ค๋ฅธ ์์์ ๊ฐ์ด ๋ชจ๋ 0์ธ ํ๋ ฌ'
(์ฃผ๋ก ์ ์ฌ๊ฐํ๋ ฌ์์ ์ง์นญํ๋, ์ ์ฌ๊ฐํ๋ ฌ์ด ์๋ ๊ฒฝ์ฐ์๋ ์กด์ฌ - ์๋ ๊ทธ๋ฆผ ์ฐธ์กฐ)
๐ ๋๊ฐํ๋ ฌ์ ์ฑ์ง๋ก, ๋์ผ ๋๊ฐํ๋ ฌ์ ์ฌ๋ฌ ๋ฒ ๊ณฑํ๋ฉด, ๋๊ฐ์ฑ๋ถ์ ๊ฐ์ ๋์ผํ๊ฒ ์ฌ๋ฌ ๋ฒ ๊ณฑํ ๊ฒฐ๊ณผ๊ฐ ๋๊ฐ์ ์ฑ๋ถ์ผ๋ก ๋ํ๋๋ค.
๐ ๋๊ฐํ๋ ฌ๊ณผ ๋ฒกํฐ์ ๊ณฑ - ๋๊ฐํ๋ ฌ์ ๋๊ฐ์ฑ๋ถ์ด ์ผ์ข ์ scalar ํํ๋ก vector์ element์ ๊ณฑํด์ง๋ ํํ๋ก ๋ํ๋จ
D = np.array([[1,0],
[0,4]])
np.dot(D,D)
'''
array([[ 1, 0],
[ 0, 16]])
'''
* ์์ผ๊ฐํ๋ ฌ(upper triangular matrix)
๐ ์ ์ → '๋๊ฐ์ ์์ชฝ ๋ถ๋ถ(+๋๊ฐ์ ์ฑ๋ถ ํฌํจ)์๋ง ๊ฐ์ด ์๊ณ ๋๋จธ์ง๋ ์ ๋ถ 0์ธ ํ๋ ฌ'
* ํ์ผ๊ฐํ๋ ฌ(lower triangular matrix)
๐ ์ ์ → '๋๊ฐ์ ์๋์ชฝ ๋ถ๋ถ(+๋๊ฐ์ ์ฑ๋ถ ํฌํจ)์๋ง ๊ฐ์ด ์๊ณ ๋๋จธ์ง๋ ์ ๋ถ 0์ธ ํ๋ ฌ'
* ๋จ์ํ๋ ฌ(unit matrix; identity matrix)
๐ ์ ์ → '๋๊ฐ์ฑ๋ถ์ด ๋ชจ๋ 1์ธ ๋๊ฐํ๋ ฌ' (์ ๋๊ฐํ๋ ฌ์ ๋๊ฐ์ฑ๋ถ์ด ๋ชจ๋ 1์ด๋ฉด ๋๋ค)
๐ ๋จ์ํ๋ ฌ๊ณผ ๋ฒกํฐ์ ๊ณฑ - ์๋ ๊ทธ๋ฆผ์ ๋ณด๋ฉด ๊ธฐ์กด vector๊ฐ ๋ณํ์ง ์๊ฒ ๋๋ฏ๋ก, ๋จ์ํ๋ ฌ์ ์ํด ํํด์ง๋ ๋ณํ์ ๋ฒกํฐ๋ฅผ ์์ง์ด์ง ์๋ ๋ณํ์ด๋ผ ํ ์ ์๋ค.
I = np.eye(2)
I
'''
array([[1., 0.],
[0., 1.]])
'''
np.dot(I, A)
'''
array([[1., 2.],
[3., 4.]])
'''
* ์ ์นํ๋ ฌ(transposed matrix)
๐ ์ ์ → 'ํ๊ณผ ์ด์ด ๋ฐ๋ ํ๋ ฌ'
๐ ๊ธฐ์กด ํ๋ ฌ์ ํ์ด ์๋ก์ด ํ๋ ฌ์ ์ด์ด ๋๊ณ , ์ด์ด ํ์ด ๋๋ ๊ฒ์ผ๋ก Aํ๋ ฌ์ ์ ์นํ๋ ฌ์ $A^T$๋ก ํํ ๊ฐ๋ฅํ๋ค
๐ ์ ์นํ๋ ฌ ๊ด๋ จ ์ฑ์ง
โ $(A^T)^T = A$
โก $(A+B)^T = A^T + B^T$
โข $(kA)^T = kA^T$
โฃ $(AB)^T = B^TA^T$
ex) $(A+BC)^T = A^T + (BC)^T = A^T + A^T + C^TB^T$
A
'''
array([[1, 2],
[3, 4]])
'''
A.T
'''
array([[1, 3],
[2, 4]])
'''
* ๋์นญํ๋ ฌ(symmetric matrix)
๐ ์ ์ → '๋๊ฐ์ ์ ๊ธฐ์ค์ผ๋ก ์์ ์๋๊ฐ ๊ฐ์ ํ๋ ฌ'
๐ ๋์นญํ๋ ฌ ๊ด๋ จ ์ฑ์ง
$$A = A^T$$
* ์ญํ๋ ฌ(inverse matrix)
๐ $A$์ ์ญํ๋ ฌ์ $A^{-1}$๋ก ํํ
๐ $AA^{-1} = A^{-1}A = I_n$
ex) 2x2 ํ๋ ฌ์ ์ญํ๋ ฌ ๊ตฌํ๊ธฐ
โป ์ญํ๋ ฌ์ ๊ธฐํํ์ ์๋ฏธ โป
๐ A์ ์ญํ๋ ฌ์ 'A์ ์ํด์(linear transformation) ์ฎ๊ฒจ์ง ์ ์ ๋ค์ ์๋์ ์ ์ผ๋ก ์ฎ๊ธฐ๋ ์ผ์ข ์ ๋ณํ'์ ๋ปํ๋ค.
๐ ์ฐ๋ฆฝ๋ฐฉ์ ์์์๋ ์ญํ๋ ฌ์ด ์กด์ฌํ๋ค๋ ๊ฑด, ์ ์ผํ ํด๊ฐ ์กด์ฌํ๋ค๋ ๋ป (์ญํ๋ ฌ์ด ์๋์ ์ ์ผ๋ก ์ฎ๊ธฐ๋ ๋ณํ์ด๋ฏ๋ก, ๊ทธ ๋ณํ์ด ์กด์ฌํ๋ค๋ ๊ฑด ๋์ฐฉ์ ์ธ ํด๊ฐ ์กด์ฌํ๋ค๋ ๊ฒ์ ๋ปํ๋ฏ๋ก)
๐ ํ๋ ฌ A์ ์ญํ๋ ฌ์ np.linalg.inv()๋ฅผ ์ฌ์ฉํ๋ค.
A = np.array([[1, 2],
[2, 5]])
A_inv = np.linalg.inv(A)
A_inv
'''
array([[ 5., -2.],
[-2., 1.]])
'''
np.dot(A, A_inv)
'''
array([[1., 0.],
[0., 1.]])
'''
np.linalg.det(A) #1
๐ A์ ๋ณํ ํ์ vector y๊ฐ ์ฃผ์ด์ง๋ฉด ์ญํ๋ ฌ์ ์ฌ์ฉํด ๋ณํ ์ vector๋ฅผ ๊ตฌํ ์ ์๋ค.
y = np.array([1,2])
np.dot(A_inv,y) #array([1., 0.])
* ์ถ๊ฐ
๐ matrix๋ฅผ python์์ ํํํ๋ ค๋ฉด 2D numpy array๋ก ํํํด์ผ ํ๋ค. ๋ฐ๋ผ์, 1D numpy array๊ฐ ์ฃผ์ด์ง๋ฉด, reshape method๋ฅผ ์ฌ์ฉํด์ ์ค์ matrix๋ก ๋ณํํ ์ ์๋ค.
โ 1D numpy array๋ฅผ row vector๋ก ๋ณํํ๋ ค๋ฉด array_1D.reshape(1, -1)
โ โก 1D numpy array๋ฅผ column vector๋ก ๋ณํํ๋ ค๋ฉด array_1D.reshape(-1,1)
x = np.arange(10)
x.reshape(1,-1)
#array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
x.reshape(-1,1)
'''
array([[0],
[1],
[2],
[3],
[4],
[5],
[6],
[7],
[8],
[9]])
'''
* ์ถ์ฒ1) matrix multiplication> https://en.wikipedia.org/wiki/Matrix_multiplication
* ์ถ์ฒ2) 1d - 2d np array ๋ณํ https://roundhere.tistory.com/entry/Python-Numpy-%EB%8B%A8%ED%8E%B8-1D-array%EB%A5%BC-2D-array%EC%9D%98-vector%EB%A1%9C-%EB%B3%80%ED%99%98
* ์ถ์ฒ3) ๋ค์ด๋ฒ AI-Tech pre-course ๊ฐ์ข
* ์ถ์ฒ4) edtih boostcourse <์ธ๊ณต์ง๋ฅ์ ์ํ ์ ํ๋์> ๊ฐ์ข
* ์ถ์ฒ5) gilbert strang's MIT + khan academy ์ ํ๋์ํ
* ์ถ์ฒ6) ๋ํ์ DA ์ฌ์ ๊ต์ก <๋ฐ์ดํฐ๋ถ์์ ์ํ ๊ธฐ์ด์ํ>
'Math & Linear Algebra > Concepts' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
vector similarity (0) | 2023.02.09 |
---|---|
Linear Equation & Linear System / Rank & det(A) (0) | 2023.02.01 |
Odds Ratio & log(Odds Ratio) (0) | 2022.07.11 |
eigenvalue & eigenvector (0) | 2022.05.14 |
linear & non-linear โ span, basis, rank, projection (0) | 2022.05.13 |
๋๊ธ