๐ง๐ป scalar & vector fundamentals ํฌ์คํ ์์ scalar์ vector์ ๊ฐ๋ ์ ๋ํด ๊ฐ๋จํ ์ดํด๋ณด์๋ค.
๐ง๐ป ์ด์ ๋ ์ฌ๋ฌ ๊ฐ์ง vector similarity ๊ฐ๋ ์ ๋ํด์ ์์๋ณด์!
๐ง๐ป ๋ฐ์ดํฐ ๋ถ์์์์ vector๋ ๊ฐ ๊ด์ธก์น์ ๋ณ์(ํน์ฑ) ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ๊ด์ธก์น๋ฅผ ํ๋์ vector๋ก ํํํ๋ค.
ex)
๊ด์ธก์น | A | B |
1 | 50 | 1 |
2 | 60 | 2 |
3 | 100 | 50 |
→ ๋ ๋ฆฝ๋ณ์๊ฐ A,B ๋ ๊ฐ๋ก 2์ฐจ์ ๋ฒกํฐ๋ก ํํ ๊ฐ๋ฅํ๋ค. ๊ฐ๊ฐ์ ๊ด์ธก์น๋ (50,1) (60,2) (100,50)์ผ๋ก ๋ํ๋ผ ์ ์์
→ ํด๋น vector ๋ด์ element์ ์ํด์ vector์ ์์น๊ฐ ๊ฒฐ์ ๋๋ค.
→ vector๊ฐ์ ์ ์ฌ๋๋ vector๊ฐ์ ๊ฑฐ๋ฆฌ ๊ฐ๋ ๊ณผ ์ฐ๊ด๋จ - ์ ์ฌ๋ ๊ฐ๋ ์ ์ฌ์ฉํด ML์ ์ ์ฉ ๊ฐ๋ฅ
Euclidian Distance
๐ง๐ป ๋ 2์ฐจ์ ๋ฒกํฐ๊ฐ ์์ผ๋ฉด, ๋ฒกํฐ๋ 2์ฐจ์ ์์์ point๋ก ๋ํ๋ผ ์ ์์ผ๋ฏ๋ก, ๋ฒกํฐ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ ๊ณง point๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ปํ๋ค.
๐ง๐ป ์ ๊ทธ๋ฆผ์์ p1๊ณผ p2 ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ์์์ผ๋ก ๋ํ๋ด๋ฉด ($v_1 = x_2 - x_1, v_2 = y_2 - y_1$)
$$\overline{p_1p_2} = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2} = \sqrt{v_1^2 + v_2^2} = ||v_2 - v_1||$$
๐ง๐ป ๋ฐ๋ผ์, ๋ ๋ฒกํฐ ์ฌ์ด์ euclidian distance๋ L2 norm ํจ์์ธ np.linalg.norm()์ผ๋ก ์๋์ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.
a = np.array([1,2])
b = np.array([2,2])
c = np.array([-3, -3])
print(np.linalg.norm(b-a)) #1.0
print(np.linalg.norm(c-a)) #6.4031242374328485
Cosine Similarity / Cosine Distance
๐ง๐ป ์์์ ๋ฒกํฐ์ ํฌ๊ธฐ๋ฅผ ์ด์ฉํ ๊ฑฐ๋ฆฌ ์ ์ฌ๋๋ก ๋ํ์ ์ธ ์๋ฅผ euclidian distance๋ฅผ ๋ค์๋ค. ์ด์ ๋ฌ๋ฆฌ, ๋ฒกํฐ์ ๋ ๋ค๋ฅธ ์ฑ์ง์ธ ๋ฐฉํฅ์ ์ด์ฉํ ๋ฐฉํฅ ์ ์ฌ๋๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๐ง๐ป ๋ฒกํฐ์ ๋ฐฉํฅ์ ์์์ ๊ฐ์ ์ํด์ ๊ฒฐ์ - ์ฆ ๋ฒกํฐ๊ฐ์ ๋ฐฉํฅ์ด ์๋ก ์ ์ฌํ ์๋ก ์ ์ฌ๋๊ฐ ๋๋ค๋ ๋ป
๐ง๐ป ๋ ๋ฒกํฐ์ ๋ฐฉํฅ์ด ์ ์ฌํ ์ ๋๋ ๋ ๋ฒกํฐ ์ฌ์ด์ ๊ฐ(์ฌ์๊ฐ)์ ์ด์ฉํด์ ํํ
โป ์ฌ์๊ฐ์ด ์์์๋ก (0์ ๊ฐ๊น์ธ์๋ก) ๋ฐฉํฅ์ฑ์ด ๋ ์ ์ฌ
โป ์ฌ์๊ฐ์ด ํด์๋ก (180์ ๊ฐ๊น์ธ์๋ก) ๋ฐฉํฅ์ด ๋ฐ๋
๐ง๐ป ์ด๋ฅผ ์์น์ ์ผ๋ก ํํํ๊ธฐ ์ํด ์ฝ์ฌ์ธ ํจ์ ์ฌ์ฉ
๐ง๐ป ๋ฐฉํฅ์ฑ์ด ์ ์ฌํ ์๋ก → ์ฌ์๊ฐ์ด ์์์ง → cos๊ฐ์ด ์ปค์ง(cos๊ฐ์ $\cfrac{v_1 · v_2}{|v_1||v_2|}$๋ก ๊ตฌํจ)
(np.dot()์ผ๋ก ๋ฒกํฐ ๊ฐ์ ๋ด์ ์ฐ์ฐ / np.linalg.norm()์ผ๋ก ๊ฐ ๋ฒกํฐ์ L2-norm ๊ณ์ฐ)
๐ง๐ป n์ฐจ์์ ๋ vector๊ฐ์ cosine similarity ์์ ์ผ๋ฐํํ๋ฉด ์๋์ ๊ฐ๋ค.
๐ง๐ป ์ด๋ฅผ ๋ฐํ์ผ๋ก cosine distance๋ฅผ ๊ณ์ฐํ๋ฉด ์๋์ ๊ฐ๋ค
cosine distance = $1 - \cos\theta$
๐ง๐ป ๋ฐฉํฅ์ฑ์ด ์ ์ฌํ ์๋ก, cos๊ฐ์ด ์ปค์ง๋ฏ๋ก, ์ด๋ฅผ ๊ฑฐ๋ฆฌ ๊ฐ๋ ์ ์ ์ฉํ๊ธฐ ์ํด cosine distance ์์ ๋ง๋ค์๋ค.
๐ง๐ป ๋ฐฉํฅ์ฑ์ด ์ ์ฌํ ์๋ก → ์ฌ์๊ฐ์ด ์์์ง → cos๊ฐ์ด ์ปค์ง → cosine distance๊ฐ ์์์ง
(๋ฐ๋ผ์! ๋ฐฉํฅ์ฑ์ด ์ ์ฌํ ์๋ก cosine distance๊ฐ ์์์ง - ์ฆ ๊ฐ๊น์์ง์ ์์์ผ๋ก ํํํ ์ ์๋ค)
๐ง๐ป ์ฝ๋๋ก ๋ํ๋ด์๋ฉด, ์ง์ ์ 2์ฝ์ฌ์ธ๋ฒ์น์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ & scipy์์ ์ ๊ณตํ๋ ํจ์๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
a = np.array([1,2])
b = np.array([2,2])
print(1-np.dot(a,b)/(np.linalg.norm(a)*np.linalg.norm(b)))
#0.05131670194948623
import scipy.spatial.distance as dst
print(dst.cosine(a,b))
#0.05131670194948623
๐ง๐ป ex) euclidian distance์ cosine similarity ๋น๊ต
→ euclidian distance ๊ธฐ์ค์ผ๋ก๋ agriculture corpus์ history corpus๊ฐ ์ ์ฌ๋๊ฐ fodd corpus์ agriculture corpus๊ฐ ์ ์ฌ๋๋ณด๋ค ๋๋ค๊ณ ๋ณผ ์ ์์ง๋ง, cosine similarity ๊ธฐ์ค์ผ๋ก ๋ณด์์ ๋๋, food corpus์ agriculture corpus๊ฐ ์ ์ฌ๋๊ฐ ๋ ๋๋ค(์ฌ์๊ฐ์ด ๋ ์์ผ๋ฏ๋ก)
๐ง๐ป cosine similarity๋ euclidian distance์ธ ๋จ์ ๊ฑฐ๋ฆฌ ๊ฐ๋ ์ผ๋ก ๋น๊ต๊ฐ ๊ถ์ฅ๋์ง ์๋, ๋ spareํ data point๊ฐ ์์ ๊ฒฝ์ฐ ์ฌ์ฉ๋๋ค. ์ถํ ์ฌ๋ฌ ์ฌ๋ก๋ฅผ ๋ถ์ํ๋ฉด์ ๊ฒฝํํ๋๋ก ํ์!
Jaccard Distance / Jaccard Index
๐ง๐ป 0๊ณผ 1๋ก๋ง ์ด๋ฃจ์ด์ง binary array์๋ง ์ ์ฉ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
๐ง๐ป $\cfrac{C_{1,0} + C_{0,1}}{C_{1,1} + C_{1,0} + C_{0,1}}$
($C_{1,0}$์ ๊ฐ์ ์๋ฆฌ์ ์๋ ์์๋ค ์ค์์ ์ฒซ ๋ฒ์งธ vector์ ์์๊ฐ์ 1์ด๊ณ , ๋ ๋ฒ์งธ vector์ ์์๊ฐ์ 0์ธ ์์ ์๋ฆฌ์ ์)
(์ ์์ 0๊ณผ 1๋ก๋ง ์ด๋ฃจ์ด์ง binary array ํ์ )
๐ง๐ป Cosine Similarity๋ฅผ ๋ฐํ์ผ๋ก ์ ์ฌ์ฑ์ด ๋์์๋ก ๋ฐ๋๋ก Cosine Distance ๊ฑฐ๋ฆฌ๊ฐ ์งง๋ค๋ ๊ณต์์ ๋ง๋ค์๋ฏ์ด($1 - cos\theta$)
๐ง๐ป Jaccard Index๋ฅผ ๋ฐํ์ผ๋ก ๋ ์ ์ฌ์ฑ์ด ๋์ ๋ปํ๊ณ , ๋ฐ๋๋ก Jaccard Distance ๊ฑฐ๋ฆฌ๊ฐ ์งง๋ค๋ ๊ณต์์ ๋ง๋ฆ
→ ์๋ A์ B๊ฐ ์์ ๋, A์ B์ ํฉ์งํฉ์ $M_{10} + M_{01} + M_{11}$์ด๋ค.
→ ์ด ํฉ์งํฉ์์ A์ B์ ๊ต์งํฉ์ด ์ฐจ์งํ๋ ๋น์จ์ Jaccard Similarity Coefficient (J)๋ผ๊ณ ํ๋ค.
→ ๋ฐ๋๋ก Jaccard distance $d_j = 1 - J$๋ก ํํ (๋ฐ๋ผ์ ๋ชจ๋ ๋น์จ์ ๋ปํ๋ฏ๋ก 0๊ณผ 1์ฌ์ด์ ๊ฐ์ ๊ฐ์ง๋ค)
๐ง๐ป $J(A,B), d_j(A,B)$ ๊ณต์
ex) ์๋ฅผ ๋ค์ด A[1,0,0]๊ณผ B[0,1,0]์ธ ๋ column vector๊ฐ ์๋ค๊ณ ํ๋ฉด, ๋ column vector๊ฐ์ Jaccard Index๋ 0/2. ์ฆ (1,1)์ธ ๊ฒฝ์ฐ๊ฐ ์์ผ๋ฏ๋ก 0์ด๋ค. ๋ฐ๋๋ก Jaccard Distance๋ 1
import scipy.spatial.distance as dst
print(dst.jaccard([1, 0, 0],[1, 1, 0])) #0.5
print(distance.jaccard([1, 0, 0], [1, 2, 0])) #0.5
Hamming Distance
๐ง๐ป hamming ๊ฑฐ๋ฆฌ๋, ์ฝ๊ฒ ๋งํ๋ฉด ์ ์ฒด ๋ฐ์ดํฐ ๊ฐ์ ์ค์ ์๋ก ๊ฐ์ง ์์ ์์ ๊ฐ์๋ฅผ ๋ปํ๋ค. ๊ฐ์ง ์์ ์์ด ๋ง์์๋ก ์ ์ฌ๋๋ ๊ฐ์ํ๊ณ , ๊ฑฐ๋ฆฌ๋ ๊ณง ๋ฉ์ด์ง๋ ๊ฐ๋ ์ ์์์ผ๋ก ํํํ ๊ฒ
๐ง๐ป1-D arrays๊ฐ ์ ์ฉ๋๊ณ , ๋ array u์ v๊ฐ ์๋ค๋ฉด, u์ v๊ฐ ๋ชจ๋ boolean vector์ผ ๊ฒฝ์ฐ hamming distance๋ ์๋์ ๊ฐ์ด ๋ํ๋ ์ ์๋ค.
(n์ element ๊ฐ์)
$$\cfrac{C_{1,0} + C_{0,1}}{n}$$
print(dst.hamming([1, 0, 0], [0, 1, 0])) #0.6666666666666666
print(distance.hamming([1, 0, 0], [1, 1, 0])) #0.3333333333333333
print(distance.hamming([1, 0, 0], [3, 0, 0])) #0.3333333333333333
Cityblock Distance(Manhattan Distance)
๐ง๐ป L2-norm์ euclidian distance๋ก ๋ํ๋๋ค๋ฉด, L1-norm์ cityblock distance๋ก ๋ํ๋ผ ์ ์๋ค.
๐ง๐ป 1-D array๊ฐ ์ ์ฉ๋๊ณ ๋ array๊ฐ u์ v๋ผ๋ฉด, ์๋์ ๊ฐ์ด cityblock distance๋ฅผ ๋ํ๋ผ ์ ์๋ค.
$$\sum_{i}^{} |u_i - v_i|$$
๐ง๐ป ์ ๊ทธ๋ฆผ์์ ์ด๋ก์ ์ ์ ์ธ ๋๋จธ์ง ๋ชจ๋ ์๊น์ ์ ์ cityblock distance๋ฅผ ๋ํ๋ธ๋ค. ๋ ์ ์ฌ์ด์ ์ฌ๋ฌ block์ ๊ฐ๋ก์ ์ธ๋ก ๋ฐฉํฅ์ผ๋ก๋ง ๊ฐ ์ ์๋ค๋ ์ ์ ํ์ ๊ณ ์๋ ๊ฑฐ๋ฆฌ
๐ง๐ป vector๋ก ํํํ๋ฉด ์ฌ๋ฌ ์ถ์ผ๋ก ํํํ์ ๋ ๊ฐ ์ถ์ ๋์๋๋ ๊ฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ์ถ ๋ณ๋ก ๋์ ํด์ ๋ํ ๊ฒฐ๊ณผ์ด๋ค.
print(dst.cityblock([1, 0, 0], [0, 1, 0])) #2
print(dst.cityblock([1, 0, 0], [0, 2, 0])) #3
* ์ถ์ฒ1) https://en.wikipedia.org/wiki/Cosine_similarity
* ์ถ์ฒ2) Jaccard Index https://en.wikipedia.org/wiki/Jaccard_index
* ์ถ์ฒ3) ๋ํ์ ์ฌ์ ๊ต์ก - ์ํ ๊ธฐ์ด
'Math & Linear Algebra > Concepts' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
SVD(Singular Value Decomposition) (0) | 2023.02.20 |
---|---|
eigendecomposition (0) | 2023.02.19 |
Linear Equation & Linear System / Rank & det(A) (0) | 2023.02.01 |
Matrix (fundamentals) (0) | 2022.07.31 |
Odds Ratio & log(Odds Ratio) (0) | 2022.07.11 |
๋๊ธ