[Data Mining] Introduction to Numpy part.2

Broadcasting

Numpy의 Broadcasting은 서로 다른 크기의 배열 간의 연산을 가능하게 하는 강력한 기능입니다.

 

• Broadcasting을 통해 Numpy는 더 작은 배열을 더 큰 배열과 동일한 모양으로 확장하여 요소별(element-wise) 연산을 수행할 수 있습니다. 이는 반복문을 사용하지 않고도 효율적인 벡터화 연산을 가능하게 합니다.
• 브로드캐스트는 산술 연산 중에 numpy가 다양한 모양을 가진 배열을 어떻게 처리하는지 설명합니다.
• 특정 제약 조건에 따라 더 작은 배열은 더 큰 배열에 걸쳐 "브로드캐스트"되어 호환 가능한 모양을 갖습니다.

Examples

A      (2d array):  5 x 4
B      (1d array):      1
Result (2d array):  5 x 4

A      (2d array):  5 x 4
B      (1d array):      4
Result (2d array):  5 x 4

A      (3d array):  15 x 3 x 5
B      (3d array):  15 x 1 x 5
Result (3d array):  15 x 3 x 5

A      (3d array):  15 x 3 x 5
B      (2d array):       3 x 5
Result (3d array):  15 x 3 x 5

A      (3d array):  15 x 3 x 5
B      (2d array):       3 x 1
Result (3d array):  15 x 3 x 5

 

np.array([[1,2],[3,4]]) + np.array([[10]])

array([[11, 12],
       [13, 14]])

 

np.array([[1,2],[3,4]]) + np.array([[10,100]])

array([[ 11, 102],
       [ 13, 104]])

 

A = np.array([[1,2]])
B = np.array([[10],[100]])
print(A.shape, B.shape)
C = A + B
C

 

(1, 2) (2, 1)
array([[ 11,  12],
       [101, 102]])

 

X = np.array([[1]]*3) + np.array([[0]*10]) # 3 * 1, 1 * 10
X

X = np.array([[1]]*3) + np.array([[0]*10])
X
array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])

 

• np.array([[1]]*3)는 [[1]] 배열을 3번 반복하여 2차원 배열로 만드는 연산입니다.
• 이 경우, 형상은 (3, 1)이 되며 결과는 [[1], [1], [1]]입니다.
• np.array([[0]*10])는 [0]을 10번 반복하여 길이가 10인 2차원 배열을 만듭니다.
• 이 경우, 형상은 (1, 10)이 되며 결과는 [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]입니다.
• [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]가 3번 반복된 3 x 10 배열입니다. 

 

# 배열 a 생성 (3x1 크기)
a = np.array([[1], [2], [3]])

# 배열 a의 전치(행렬의 전치)를 계산하여 배열 b에 저장 (1x3 크기)
b = a.T

# a와 b를 더한 결과를 계산 (broadcasting 기능 사용)
result = a + b

# 결과 배열 출력
result

array([[2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])

---

Meshgrid

numpy.meshgrid는 다차원 격자 좌표를 생성하는 데 사용되는 함수입니다.

• 보통 2차원 평면이나 3차원 공간에서의 좌표계를 만들 때 유용합니다.
• 이 함수는 주로 함수의 그래프를 그리거나 다차원 데이터의 시각화를 위해 사용됩니다.

meshgrid의 사용법

• numpy.meshgrid는 1차원 좌표 배열 두 개를 받아서 두 개의 2차원 배열을 반환합니다.
• 각 반환된 배열은 좌표 그리드를 구성하는 데 사용됩니다.
• 벡터화된 평가를 위해 D x N 메쉬 그리드를 만들어 보겠습니다.

v = np.array([10,20,30])   # N
w = np.array([5,6])        # D
X, Y = np.meshgrid(v, w)
X + Y

array([[15, 25, 35],
       [16, 26, 36]])

---

Axis ordering

정의상 차원의 축 번호는 배열의 모양 안에서 해당 차원의 인덱스입니다.

• 인덱싱하는 동안 해당 차원에 액세스하는 데 사용되는 위치이기도 합니다.
• 예를 들어, 2D 배열 a의 모양이 (5,6)이면 a[4,5]까지 a[0,0]에 접근할 수 있습니다.
  • 따라서 축 0은 첫 번째 차원("행")이고, 축 1은 두 번째 차원("열")입니다.
  • "행"과 "열"이 의미가 없는 고차원에서는 축을 관련된 모양과 지수로 생각해 보십시오.
• 예를 들어 np.sum(axis=n)을 하면 차원 n이 축소되고 삭제되며 새 행렬의 각 값은 축소된 값의 합과 같습니다.
  • 예를 들어 b의 모양이 (5,6,7,8)이고 c = b.sum(axis=2)이면 축 2(크기 7의 dimension)가 축소되고 결과는 모양이 (5,6,8)됩니다.
  • 또한 c[x,y,z]는 모든 원소 b[x,y,:,z]의 합과 같습니다.

 

X = np.array([[0,0,0], [1,1,1]])
X.shape

# axis 0 is row; axis 1 is column

# Result: (2, 3)

X.sum(axis=0) # 차원 0이 축소 및 삭제되거나 차원 0에 대해 집계됩니다

# Result: array([1, 1, 1])

X.sum(axis=1) # 차원 1이 축소 및 삭제되거나 차원 0에 대해 집계됩니다

# Result: array([0, 3])

# 1부터 24까지의 정수로 구성된 1차원 배열을 생성합니다.
X = np.array(range(1, 24 + 1))

# 배열 X를 (2, 3, 4) 형상으로 재구조화하여 3차원 배열로 변환합니다.
# 이때, 배열은 2개의 3x4 행렬로 구성됩니다.
X = X.reshape(2, 3, 4)

# 재구조화된 3차원 배열 X를 출력합니다.
X

X.shape

# (2, 3, 4)

 

X.sum(axis=0)

array([[14, 16, 18, 20],
       [22, 24, 26, 28],
       [30, 32, 34, 36]])

 

X는 np.arange(24).reshape(2, 3, 4)을 통해 만들어진 3차원 배열 입니다.

 

• X[0]: 첫 번째 3x4 행렬

[[[ 1,  2,  3,  4],
  [ 5,  6,  7,  8],
  [ 9, 10, 11, 12]],

• X[1]: 두 번째 3x4 행렬

[[13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]]]

 

• axis=0을 따라 합계를 계산합니다.
• 첫 번째 열: [1+13, 5+17, 9+21] = [14, 22, 30]
• 두 번째 열: [2+14, 6+18, 10+22] = [16, 24, 32]
• 세 번째 열: [3+15, 7+19, 11+23] = [18, 26, 34]
• 네 번째 열: [4+16, 8+20, 12+24] = [20, 28, 36]

 

axis=0는 배열에서 첫 번째 축을 나타냅니다. 배열의 축(axis)은 각 배열의 차원을 나타내며, axis는 축의 인덱스를 가리킵니다.

 

• 2차원 배열인 경우:
• axis=0는 행을 의미합니다. axis=0을 따라 합산한다는 것은 각 열을 따라 값들을 합산하는 것을 의미합니다.
• 따라서, axis=0으로 합산하면 결과로 각 열의 값들을 합산한 값들이 반환됩니다
• axis=0을 따라 합산할 때는 각 열의 값들을 합산하여 열별로 결과를 반환합니다.

 

X.sum(axis=1)

array([[15, 18, 21, 24],
       [51, 54, 57, 60]])

• X.sum(axis=1)을 실행하면 각 '층'에서 동일한 열에 위치한 요소들의 합을 구하게 됩니다.
• 따라서 각 '층'의 열별 합은 다음과 같습니다:
  • 첫 번째 '층':
    • 첫 번째 열의 합: 1 + 5 + 9 = 15
    • 두 번째 열의 합: 2 + 6 + 10 = 18
    • 세 번째 열의 합: 3 + 7 + 11 = 21
    • 네 번째 열의 합: 4 + 8 + 12 = 24
  • 두 번째 '층':
    • 첫 번째 열의 합: 13 + 17 + 21 = 51
    • 두 번째 열의 합: 14 + 18 + 22 = 54
    • 세 번째 열의 합: 15 + 19 + 23 = 57
    • 네 번째 열의 합: 16 + 20 + 24 = 60

 

X.sum(axis=2)

array([[10, 26, 42],
       [58, 74, 90]])

• X.sum(axis=2)을 실행하면, 각 '층'의 각 행에 있는 요소들의 합을 구합니다:
• 첫 번째 '층':
  • 첫 번째 행의 합: 1 + 2 + 3 + 4 = 10
  • 두 번째 행의 합: 5 + 6 + 7 + 8 = 26
  • 세 번째 행의 합: 9 + 10 + 11 + 12 = 42
• 두 번째 '층':
  • 첫 번째 행의 합: 13 + 14 + 15 + 16 = 58
  • 두 번째 행의 합: 17 + 18 + 19 + 20 = 74
  • 세 번째 행의 합: 21 + 22 + 23 + 24 = 90

 

X.sum(axis=(1,2))

array([ 78, 222])

• X.sum(axis=(1,2))을 실행하면, 각 '층'에서 모든 행과 열에 있는 요소들의 총합을 구합니다:
  • 첫 번째 '층'의 합:
  • (1 + 2 + 3 + 4) + (5 + 6 + 7 + 8) + (9 + 10 + 11 + 12) = 10 + 26 + 42 = 78
  • 두 번째 '층'의 합:
  • (13 + 14 + 15 + 16) + (17 + 18 + 19 + 20) + (21 + 22 + 23 + 24) = 58 + 74 + 90 = 222
  • 결과적으로, X.sum(axis=(1,2))의 결과는 다음과 같은 배열이 됩니다:

 

X.sum(axis=(0,1,2))

# Result: 300

• X.sum(axis=(0,1,2))을 실행하면, 배열의 모든 요소들의 총합을 계산합니다:
  • 첫 번째 '층': (1 + 2 + 3 + 4) + (5 + 6 + 7 + 8) + (9 + 10 + 11 + 12) = 78
  • 두 번째 '층': (13 + 14 + 15 + 16) + (17 + 18 + 19 + 20) + (21 + 22 + 23 + 24) = 222
  • 모든 '층'의 합계: 78 + 222 = 300
  • 따라서, X.sum(axis=(0,1,2))의 결과는 300이 됩니다. 이는 배열 내 모든 요소의 총합을 나타내는 스칼라 값입니다.

# 2개의 3차원 점 X와 Y를 선언
X = np.array([0, 0, 0])  # 첫 번째 3차원 점 X
Y = np.array([1, 1, 1])  # 두 번째 3차원 점 Y

# 두 점 X와 Y 사이의 유클리드 거리 계산
distance = np.sqrt(np.sum((X - Y)**2))  # 차이 벡터(X - Y)의 제곱을 구하고, 합을 계산한 후 제곱근을 구함

print(distance)  # 계산된 거리를 출력

# Result: 1.7320508075688772

 

import numpy as np

# 2x3 배열을 역순으로 생성
X = np.array(np.arange(2 * 3, 0, -1).reshape(2, 3))
print(X)  # 생성된 배열 출력

print()  # 줄 바꿈

# axis=0에 대해 배열을 정렬
print("axis=0\\n", np.sort(X, axis=0))

print()  # 줄 바꿈

# axis=-1(또는 axis=1)에 대해 배열을 정렬
print("axis=-1\\n", np.sort(X, axis=-1))

print()  # 줄 바꿈

# 기본 축은 axis=-1(또는 axis=1)이므로 동일한 결과를 출력
print("default is -1\\n", np.sort(X))

print()  # 줄 바꿈

# axis=None을 사용하여 전체 배열을 1차원으로 정렬
print("axis=None\\n", np.sort(X, axis=None))

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

axis=0
 [[3 2 1]
 [6 5 4]]

axis=-1
 [[4 5 6]
 [1 2 3]]

default is -1
 [[4 5 6]
 [1 2 3]]

axis=None
 [1 2 3 4 5 6]

• X: 2x3 형태의 배열로, 2개의 행과 3개의 열을 가진 배열입니다.
  • 이 배열은*np.arange(2*3, 0, -1).reshape(2,3)를 사용하여 6부터 1까지의 숫자를 2x3 배열 형태로 정렬한 것입니다.
• 정렬 결과:
  • axis=0: 이 옵션을 사용하면 각 열을 따라 배열이 정렬됩니다. X 배열의 각 열을 정렬하면 다음과 같습니다:
    • 첫 번째 열: [3, 6]
    • 두 번째 열: [2, 5]
    • 세 번째 열: [1, 4]
  • axis=-1 또는 axis=1: 이 옵션을 사용하면 각 행을 따라 배열이 정렬됩니다. X 배열의 각 행을 정렬하면 다음과 같습니다:
    • 첫 번째 행: [1, 2, 3]
    • 두 번째 행: [4, 5, 6]
  • axis=None: 이 옵션을 사용하면 배열이 1차원으로 펼쳐진 다음 정렬됩니다. X 배열을 1차원으로 펼친 후 정렬하면 [1, 2, 3, 4, 5, 6]가 됩니다.
• 요약
  • axis=0: 각 열을 따라 정렬합니다.
  • axis=1 또는 axis=-1: 각 행을 따라 정렬합니다.
  • axis=None: 배열을 1차원으로 펼친 후 전체를 정렬합니다.

---

sort vs argsort vs partition vs argpartition

• argmin, argmax, …

# 배열 `X` 초기화
X = np.array([4,10,1,20,45,100,2,1])
print('X =\\n', X)

# 배열 `X`의 요소를 오름차순으로 정렬
print('sorted =\\n', np.sort(X))

# 배열 `X`를 정렬했을 때 요소의 원래 인덱스를 반환
print('argsorted =\\n', np.argsort(X))

# 배열 `X`에서 `3`번째 작은 값이 위치해야 할 자리를 기준으로 부분적으로 정렬
# 첫 `3`개의 요소는 작은 값들로 구성되고, 나머지 요소들은 아직 정렬되지 않은 상태로 배열됨
print('partitioned first 3 =\\n', np.partition(X, 3))

# 배열 `X`에서 `3`번째 작은 값이 위치해야 할 자리를 기준으로 부분 정렬했을 때의 요소의 인덱스를 반환
print('argpartitioned first 3 =\\n', np.argpartition(X, 3))

# 배열 `X`에서 `-3`번째 (마지막 세 번째) 큰 값이 위치해야 할 자리를 기준으로 배열을 부분적으로 정렬
# 마지막 `3`개의 요소는 큰 값들로 구성되고, 나머지 요소들은 아직 정렬되지 않은 상태로 배열됨
print('partitioned last 3=\\n', np.partition(X, -3))

# 배열 `X`에서 `-3`번째 (마지막 세 번째) 큰 값이 위치해야 할 자리를 기준으로 부분 정렬했을 때의 요소의 인덱스를 반환
print('argpartitioned last 3=\\n', np.argpartition(X, -3))

X =
 [  4  10   1  20  45 100   2   1]
sorted =
 [  1   1   2   4  10  20  45 100]
argsorted =
 [2 7 6 0 1 3 4 5]
partitioned first 3 =
 [  2   1   1   4  45 100  10  20]
argpartitioned first 3 =
 [6 7 2 0 4 5 1 3]
partitioned last 3=
 [  2   1   1   4  10  20  45 100]
argpartitioned last 3=
 [6 7 2 0 1 3 4 5]

 

Lab.

축 0을 따라 2-d 배열 T를 정렬하고, 정렬 키는 축 1을 따라 원소의 합입니다.

T = np.array([[2,2],[-1,10],[0,1]])  # 2차원 배열 T를 초기화
I = np.argsort(np.sum(T, axis=1))    # 축 1을 따라 각 행의 합계를 구한 후, 그 합계의 인덱스를 오름차순으로 정렬
T[I, :]                             # 정렬된 인덱스를 사용하여 배열 T의 행을 재정렬

 

• T = np.array([[2,2],[-1,10],[0,1]])은 2차원 배열 T를 초기화합니다. 이 배열은 다음과 같습니다.

[[ 2,  2],
 [-1, 10],
 [ 0,  1]]

• I = np.argsort(np.sum(T, axis=1)) 명령어는 두 부분으로 나뉩니다:
  • np.sum(T, axis=1)는 배열 T의 각 행에 대한 합계를 계산합니다.
  • 따라서, 각 행의 합계는 [4, 9, 1]이 됩니다.
• np.argsort(...)는 주어진 배열의 요소를 오름차순으로 정렬했을 때의 인덱스를 반환합니다.
  • [4, 9, 1]의 요소를 오름차순으로 정렬하면 [1, 4, 9]가 되고, 이에 해당하는 원래 배열의 인덱스는 [2, 0, 1]입니다.T[I, :]는 배열 T의 행을 I 배열에 따라 재정렬합니다.
  • I는 [2, 0, 1]이므로, T의 행도 이 인덱스 순서대로 재배치됩니다.
  • 이는 다음과 같은 순서를 의미합니다:
• T의 2번째 행이 첫 번째 위치로 이동합니다.
• ([0, 1])T의 0번째 행이 두 번째 위치로 이동합니다.
• ([2, 2])T의 1번째 행이 세 번째 위치로 이동합니다. ([-1, 10])
• 결과적으로, T[I, :]를 실행하면 다음과 같은 배열이 생성됩니다:

[[ 0,  1],
 [ 2,  2],
 [-1, 10]]

• 이 배열은 원래 배열 T의 행을 각 행의 합계가 작은 순서대로 재정렬한 것입니다.
• 첫 번째 행의 합계가 가장 작고([0, 1]의 합계는 1), 다음으로 [2, 2]의 합계는 4,
• 마지막으로 [-1, 10]의 합계는 9로, 오름차순으로 정렬된 순서를 반영합니다.

array([[ 0,  1],
       [ 2,  2],
       [-1, 10]])

---

Vectorized Function

벡터화된 함수는 배열을 요소별로 처리할 수 있도록 벡터화된 연산을 수행하는 함수입니다.

• Numpy에서 벡터화된 함수를 작성하는 것은 성능 향상과 코드 간결성 측면에서 매우 유용합니다.
• Numpy의 벡터화 기능을 통해 반복문을 사용하지 않고도 배열 전체에 대해 연산을 수행할 수 있습니다.
• map 함수와 유사합니다.

import math

# 주어진 값 중 절대값을 기준으로 가장 큰 값을 찾습니다.
# 주어진 값: 1, 2, 3, 4, 5, -100
# key 매개변수로 lambda 함수를 사용하여 각 값의 절대값을 비교합니다.
max_value = max(1, 2, 3, 4, 5, -100, key=lambda x: math.fabs(x))

# 가장 큰 절대값을 가진 값(이 경우 -100)을 반환합니다.
print(max_value)

# Result: -100

from functools import partial
import math

# functools 모듈에서 partial 함수를 불러옵니다.

# max 함수의 key 매개변수에 lambda 함수를 사용하여 각 입력값의 절대값을 기준으로 최대 값을 찾도록 부분 적용합니다.
mymax = partial(max, key=lambda x: math.fabs(x))

# 이제 mymax 함수를 사용할 때마다 자동으로 key 매개변수에 lambda 함수가 적용됩니다.

# 두 리스트 [10, 2, 3]와 [4, 5, 6]을 비교하여 각 요소에서 더 큰 값을 반환합니다.
result = list(map(max, [10,2,3], [4,5,6]))

# 결과는 [10, 5, 6]입니다. 이는 각 인덱스에서 더 큰 값을 반환한 것입니다.
print(result)  # [10, 5, 6]

• map 함수는 주어진 두 리스트를 max 함수에 각각의 요소가 대응하도록 매핑합니다.
• 즉, max 함수는 각 인덱스에 해당하는 요소를 비교하여 더 큰 값을 반환합니다.
  • 첫 번째 요소 비교: max(10, 4)는 10과 4를 비교하여 더 큰 값인 10을 반환합니다.
  • 두 번째 요소 비교: max(2, 5)는 2와 5를 비교하여 더 큰 값인 5를 반환합니다.
  • 세 번째 요소 비교: max(3, 6)는 3과 6을 비교하여 더 큰 값인 6을 반환합니다.

list(map(mymax, [-10,2,3], [4,5,-6]))

# Result: [-10, 5, -6]

u = np.array([100,2,3,4])
v = np.array([1,2,3,4])
w = np.array([4,3,2,1])
np.vectorize(max)(u, v, w)

# array([100,   3,   3,   4])

dist = np.vectorize(lambda x, y: np.sqrt(x**2 + y**2))
dist(v, w)

# array([4.12310563, 3.60555128, 3.60555128, 4.12310563])

• 위와 같이 np.vectorize는 람다 함수를 벡터화하여 각 요소에 적용하고, 결과를 배열로 반환합니다. 계산된 값은 다음과 같습니다:
  • 첫 번째 요소 쌍에 대한 거리: sqrt(v[0]**2 + w[0]**2)
  • 두 번째 요소 쌍에 대한 거리: sqrt(v[1]**2 + w[1]**2)
  • 세 번째 요소 쌍에 대한 거리: sqrt(v[2]**2 + w[2]**2)
  • 네 번째 요소 쌍에 대한 거리: sqrt(v[3]**2 + w[3]**2)

결과적으로 [4.12310563, 3.60555128, 3.60555128, 4.12310563]가 반환됩니다.

 

# 3D 포인트 0에서 계산된 벡터화된 거리를 계산합니다.

import numpy as np

def calculate_euclidean_distances(points):
    # 이 함수는 입력된 3D 점들의 배열에서 원점으로부터의 유클리드 거리를 계산합니다.
    # points: 각 행이 [x, y, z]로 표현된 3D 점을 나타내는 2차원 배열.
    
    # points 배열의 각 요소의 제곱을 계산하고, 각 점의 x^2 + y^2 + z^2를 계산하기 위해 축 1을 따라 합을 구합니다.
    squared_sum = np.sum(np.square(points), axis=1)
    
    # 제곱의 합의 제곱근을 계산하여 각 점에 대한 유클리드 거리를 구합니다.
    distances = np.sqrt(squared_sum)
    
    return distances

# 예시 사용법:
# 3D 점의 배열을 정의합니다.
points = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    [-1, -2, -3]
])

# 원점(0, 0, 0)에서 유클리드 거리를 계산합니다.
distances = calculate_euclidean_distances(points)

# 거리를 출력합니다.
print(distances)

• calculate_euclidean_distances 함수는 각 행이 3D 점 [x, y, z]를 나타내는 2차원 배열 points를 받습니다.
  • 함수 내부에서 points 배열의 각 요소의 제곱을 계산한 후, 축 1을 따라 합을 구합니다(각 점의 x^2+ y^2 + z^2를 합산).
  • 제곱의 합의 제곱근을 계산하여 각 점에 대한 유클리드 거리를 구합니다.
  • 함수는 원점에서 각 점까지의 거리를 반환합니다.

---

Numpy linear algebra (Numpy 선형 대수)

Numpy는 선형 대수 연산을 지원하기 위해 많은 함수를 제공합니다.

import numpy as np

# 2 x 3 랜덤 행렬 생성
X = np.random.randn(2, 3)
print(X)  # 행렬 X 출력

# 행렬 X의 전치(transpose) 계산
print(X.T)  # 행렬 X의 전치 출력

# 크기가 3인 랜덤 벡터 생성
y = np.random.randn(3)
print(y)  # 벡터 y 출력

# 행렬 X와 벡터 y의 행렬-벡터 곱셈
print(X.dot(y))  # 행렬-벡터 곱셈 결과 출력

# np.dot() 함수를 사용하여 행렬 X와 벡터 y의 곱셈
print(np.dot(X, y))  # 행렬-벡터 곱셈 결과 출력 (X.dot(y)와 동일)

# 행렬 X와 X의 전치(X.T)의 행렬-행렬 곱셈
print(X.dot(X.T))  # 행렬-행렬 곱셈 결과 출력

# 행렬 X의 전치(X.T)와 행렬 X의 행렬-행렬 곱셈
print(X.T.dot(X))  # 행렬-행렬 곱셈 결과 출력

[[-0.67521745 -0.25112232 -0.53902013]
 [-0.31444559  0.26792464 -0.91960302]]
[[-0.67521745 -0.31444559]
 [-0.25112232  0.26792464]
 [-0.53902013 -0.91960302]]
[-0.27857094  0.11301957 -0.0460988 ]
[0.1845624  0.16026873]
[0.1845624  0.16026873]
[[0.80952372 0.64072183]
 [0.64072183 1.01632936]]
[[ 0.55479463  0.08531445  0.65312091]
 [ 0.08531445  0.13484603 -0.11102433]
 [ 0.65312091 -0.11102433  1.13621241]]

y.dot(y) # 벡터 y와 자신 사이의 내적(dot product)을 계산
# 벡터 y와 자신 사이의 내적(dot product)을 계산

0.09250029216474008

import numpy as np

# 5x3 차원의 랜덤 행렬 X 생성
X = np.random.randn(5, 3)
print(X)

# X^T * X를 계산하여 C에 할당합니다. 이 결과는 3x3 크기의 정사각행렬입니다.
C = X.T.dot(X)               
print("C = X^T * X:\\n", C)

# C의 역행렬을 계산합니다. -> X * X**-1 = I
invC = np.linalg.inv(C)      
print("C의 역행렬:\\n", invC)

# C의 행렬식(determinant)을 계산합니다.
detC = np.linalg.det(C)      
print("C의 행렬식:", detC)

# C의 고유값(eigenvalue) S와 고유벡터(eigenvector) U를 계산합니다.
S, U = np.linalg.eig(C)      
print("C의 고유값 S:\\n", S)
print("C의 고유벡터 U:\\n", U)

 

• X: 5x3 크기의 랜덤 행렬을 생성합니다.
• C: X^T * X 연산을 수행하여 정사각 행렬 C를 계산합니다.
• invC: np.linalg.inv(C)를 사용하여 C의 역행렬을 계산합니다.
• detC: np.linalg.det(C)를 사용하여 C의 행렬식을 계산합니다.
• S, U: np.linalg.eig(C)를 사용하여 C의 고유값 S와 고유벡터 U를 계산합니다.

[[ 1.00517715 -0.29554381 -1.29674166]
 [ 1.28813155  0.05589876 -0.22072513]
 [ 0.46327488  0.5101119  -1.30901555]
 [-0.68836097  0.50845609 -0.06891248]
 [-0.79042016  1.3979979  -1.01016794]]
C = X^T * X:
 [[ 3.98289246 -1.44375394 -1.34831834]
 [-1.44375394  2.56361068 -1.74409033]
 [-1.34831834 -1.74409033  4.46896842]]
C의 역행렬:
 [[0.6600184  0.69051673 0.46861787]
 [0.69051673 1.25350588 0.69753544]
 [0.46861787 0.69753544 0.63737548]]
C의 행렬식: 12.749408257332224
C의 고유값 S:
 [0.46098261 4.83874418 5.71574477]
C의 고유벡터 U:
 [[ 0.48384751  0.75707829 -0.43900347]
 [ 0.73115789 -0.6253672  -0.27262429]
 [ 0.4809363   0.18907227  0.85612613]]

 

import numpy as np

# 2x2 크기의 행렬 L을 초기화합니다.
L = np.array([[2, 0], [0, 1]])

# 행렬 L의 고유값(eigenvalue) S와 고유벡터(eigenvector) U를 계산합니다.
S, U = np.linalg.eig(L)

# 계산된 고유값 S와 고유벡터 U를 출력합니다.
print("고유값 S:", S)
print("고유벡터 U:\\n", U)

고유값 S: [2. 1.]
고유벡터 U:
 [[1. 0.]
 [0. 1.]]

v = np.array([1,1])

v = L.dot(v)
v

# array([2,    1])

• L.dot(v)의 결과는 다음과 같습니다:
• L.dot(v) = np.array([21 + 01, 01 + 11]), 즉 np.array([2,1])입니다.

---

The Frobenius norm (프로베니우스 규범)

프로베니우스 규범(Frobenius norm)은 행렬의 요소들에 대한 유클리드 거리와 유사한 개념으로, 행렬의 크기나 길이를 측정하는 하나의 방법입니다.

• 이는 행렬의 각 원소의 제곱을 합한 뒤, 그 합의 제곱근을 취한 값으로 정의됩니다.

# 1차원 배열을 생성합니다.
X = np.array([1, 2])

# 2-노름(Euclidean norm)을 계산합니다.
# 유클리드 거리로, 배열의 모든 요소의 제곱을 더하고 그 제곱근을 취합니다.
print(np.linalg.norm(X))  # 결과: sqrt(1^2 + 2^2) = sqrt(5)

# 1-노름(Manhattan norm)을 계산합니다.
# 배열의 모든 요소의 절댓값을 합산합니다.
print(np.linalg.norm(X, ord=1))  # 결과: abs(1) + abs(2) = 3

# 무한대 노름(Infinity norm)을 계산합니다.
# 배열의 모든 요소 중 가장 큰 절댓값을 반환합니다. -> 최대값
print(np.linalg.norm(X, ord=np.inf))  # 결과: max(abs(1), abs(2)) = 2

# -무한대 노름을 계산합니다.
# 배열의 모든 요소 중 가장 작은 절댓값을 반환합니다. -> 최소값
print(np.linalg.norm(X, ord=-np.inf))  # 결과: min(abs(1), abs(2)) = 1

2.23606797749979
3.0
2.0
1.0

 

import math
import numpy as np

# 두 개의 벡터 x와 y를 정의합니다.
x = np.array([1, 0])  # 벡터 x는 [1, 0]입니다.
y = np.array([0, 1])  # 벡터 y는 [0, 1]입니다.

# 첫 번째 코사인 유사도 계산:
# 벡터 x와 y의 내적을 계산하고, 각 벡터의 크기를 계산한 다음, 둘을 나눕니다.
print("cosine =", x.dot(y) / (math.sqrt(x.dot(x)) * math.sqrt(y.dot(y))))

# 두 번째 코사인 유사도 계산:
# 벡터 x와 y의 내적을 계산하고, numpy의 np.linalg.norm 함수를 사용하여 벡터 크기를 계산한 다음, 둘을 나눕니다.
print("cosine =", x.dot(y) / (np.linalg.norm(x) * np.linalg.norm(y)))

cosine = 0.0
cosine = 0.0

---

LAB: distance matrix

• In case of 1-d points

import numpy as np

pts = np.array([1., 2, 3, 4, 5])  # 1차원 배열을 생성합니다.

# np.newaxis: 축 하나 더 만듬
u = pts[:, np.newaxis]  # 열 방향으로 1차원 배열을 확장합니다. 결과는 (5, 1) 크기의 2차원 배열입니다.
v = pts.T[np.newaxis, :]  # 행 방향으로 1차원 배열을 확장합니다. 결과는 (1, 5) 크기의 2차원 배열입니다.

# `u`와 `v`의 차이의 절대값을 계산합니다.
result = np.abs(u - v)

print(result)  # `u`와 `v`의 차이의 절대값으로 이루어진 5x5 행렬이 출력됩니다.

# 대칭 행렬
array([[0., 1., 2., 3., 4.],
       [1., 0., 1., 2., 3.],
       [2., 1., 0., 1., 2.],
       [3., 2., 1., 0., 1.],
       [4., 3., 2., 1., 0.]])

• pts.T는 pts 배열의 전치(transpose)를 의미합니다.
• 전치는 배열의 축(axis)을 바꾸는 연산으로, 배열의 행과 열을 바꾸는 역할을 합니다.

# pts = np.array([1., 2, 3, 4, 5])
pts.T

# array([1., 2., 3., 4., 5.])

 

• n-d 포인트인 경우

import numpy as np

# 2차원 배열 `pts`를 초기화합니다. (3, 2)의 모양으로 2차원 점들을 나타냅니다.
pts = np.array([[1, 0], [1, 1], [0, 1]])

# `pts`의 모양을 출력합니다.
print(pts.shape)

# 새로운 차원을 추가하여 3차원 배열 `u`를 생성합니다.
# `u`의 모양은 (3, 2, 1)이며, `pts`의 각 행을 새로운 세 번째 차원에 따라 1차원 배열로 확장합니다.
u = pts[:, :, np.newaxis]

# `pts`를 전치하고 새로운 차원을 추가하여 3차원 배열 `v`를 생성합니다.
# `v`의 모양은 (1, 2, 3)이며, `pts`의 각 열을 새로운 첫 번째 차원에 따라 1차원 배열로 확장합니다.
v = pts.T[np.newaxis, :, :]

# Result: (3,2)

import numpy as np

# 2차원 점들의 배열 `pts`를 초기화합니다. `pts`는 (3, 2) 모양의 배열입니다.
pts = np.array([[0, 0], [1, 1], [0, 0]])

# `pts`의 모양을 출력합니다.
print(pts.shape)

# `pts`의 각 행을 새로운 차원에 따라 확장하여 3차원 배열 `u`를 생성합니다.
# `u`의 모양은 (3, 2, 1)입니다.
u = pts[:, :, np.newaxis]

# `pts`를 전치한 후, 새로운 차원을 추가하여 3차원 배열 `v`를 생성합니다.
# `v`의 모양은 (1, 2, 3)이며, `pts`의 각 열을 새로운 차원에 따라 확장한 것입니다.
v = pts.T[np.newaxis, :, :]

# Result: (3,2)

# np.linalg.norm(pts)는 주어진 배열 pts의 노름(norm)을 계산하는 함수.
# 노름은 주어진 벡터의 크기를 나타내는 척도

np.linalg.norm(pts)

# 1.4142135623730951

 

• u = pts[:, :, np.newaxis]은 입력 배열 pts를 새로운 차원으로 확장하여 (3, 2, 1) 형상의 배열로 변환합니다.
• v = pts.T[np.newaxis, :, :]은 pts의 전치 배열을 새로운 차원으로 확장하여 (1, 2, 3) 형상의 배열로 변환합니다.

print(v.shape)
print(u.shape)

(1, 2, 3)
(3, 2, 1)

np.sqrt(np.sum((u - v)**2, axis=1))

 

 

1. 배열 u와 v:
   • u와 v는 각각 (3, 2, 1) 및 (1, 2, 3) 형상의 3차원 배열입니다.
   • u는 pts 배열의 각 점을 z 축(마지막 차원)에 배열하여 3차원 배열로 만든 것입니다.
   • v는 pts 배열의 전치(transpose) 후 새로운 차원을 추가하여 x 축(첫 번째 차원)에 배열한 것입니다.
2. u - v:
   • u와 v의 형상이 각각 (3, 2, 1) 및 (1, 2, 3)이므로, 두 배열은 브로드캐스팅을 통해 형상이 맞춰집니다.
   → (3 ,2, 1) (1, 2, 3) ⇒ (3, 2, 3)
   • u - v는 각각의 u 요소와 v 요소 간의 차이를 계산합니다. 이 연산은 각 점의 좌표 차이를 나타냅니다.
   • 결과는 (3, 2, 3) 형상의 배열이 됩니다. 이는 3개의 점 (u)과 3개의 점 (v) 사이의 차이 값을 나타냅니다.
3. np.sum((u - v)**2, axis=1):
   • axis=1을 지정하면 u와 v 간의 차이 제곱을 y 축(두 번째 차원)에서 합산합니다.
   • axis=1의 합산 결과는 (3, 3) 형상의 배열로, 각 점 간의 거리를 나타냅니다.
4. np.sqrt(np.sum((u - v)**2, axis=1)):
   • u와 v의 각 점 간 차이의 제곱을 합산한 값을 sqrt를 사용하여 제곱근을 계산합니다.
   • 이 연산은 3개의 점 간의 유클리드 거리를 계산하여 (3, 3) 형상의 배열을 반환합니다.

array([[0.        , 1.        , 1.41421356],
       [1.        , 0.        , 1.        ],
       [1.41421356, 1.        , 0.        ]])

 

 

• np.linalg.norm(u - v, axis=1)는 u와 v 사이의 차이 벡터의 유클리드 거리(Euclidean distance)를 계산하는 코드입니다.
  • u와 v는 각각 (3, 2, 1)과 (1, 2, 3)의 형상을 가진 NumPy 배열로, 각각 2차원 포인트를 표현합니다. u와 v는 서로 다른 형상이지만, 브로드캐스팅을 통해 두 배열을 연산할 수 있습니다.
  • u - v는 u 배열과 v 배열의 차이 벡터를 계산합니다. 두 배열은 브로드캐스팅을 통해 (3, 2, 3) 형상으로 확장됩니다. 이는 u와 v 사이의 차이를 나타내는 배열입니다.
  • np.linalg.norm(u - v, axis=1)은 차이 벡터의 유클리드 거리를 계산합니다. axis=1은 행 단위로 연산을 수행하도록 지시합니다. 즉, 각 포인트 u와 v 사이의 차이 벡터의 유클리드 거리를 계산합니다.

np.linalg.norm(u - v, axis=1)

np.linalg.norm(u - v, axis=1)
array([[0.        , 1.        , 1.41421356],
       [1.        , 0.        , 1.        ],
       [1.41421356, 1.        , 0.        ]])

 

실제 응용 프로그램에서 sklearn.metrics.pairwise를 사용하여 쌍별 거리를 계산합니다

• euclidean_distances(pts): pts 배열의 각 요소 간의 유클리드 거리를 계산합니다.
  • 유클리드 거리는 두 점 사이의 직선 거리를 의미합니다. 반환되는 값은 pts 배열의 각 쌍에 대한 거리 값으로 구성된 행렬입니다.
• manhattan_distances(pts): pts 배열의 각 요소 간의 맨해튼 거리를 계산합니다.
  • 맨해튼 거리는 두 점 사이의 좌표 차이의 절대값을 합한 값으로, 택시 거리라고도 불립니다. 반환되는 값은 pts 배열의 각 쌍에 대한 거리 값으로 구성된 행렬입니다.
• cosine_similarity(pts): pts 배열의 각 요소 간의 코사인 유사도를 계산합니다.
  • 코사인 유사도는 두 벡터 사이의 각도를 나타내며, 1에 가까울수록 유사한 방향을 가지고 있음을 의미합니다. 반환되는 값은 pts 배열의 각 쌍에 대한 유사도 값으로 구성된 행렬입니다.

from sklearn.metrics.pairwise import euclidean_distances, manhattan_distances, cosine_similarity

# 2차원 포인트 배열 `pts`의 요소들 간의 유클리드 거리를 계산합니다.
print(euclidean_distances(pts))

# 2차원 포인트 배열 `pts`의 요소들 간의 맨해튼 거리를 계산합니다.
print(manhattan_distances(pts))

# 2차원 포인트 배열 `pts`의 요소들 간의 코사인 유사도를 계산합니다.
print(cosine_similarity(pts))

[[0.         1.         1.41421356]
 [1.         0.         1.        ]
 [1.41421356 1.         0.        ]]
[[0. 1. 2.]
 [1. 0. 1.]
 [2. 1. 0.]]
[[1.         0.70710678 0.        ]
 [0.70710678 1.         0.70710678]
 [0.         0.70710678 1.        ]]

 

이제 여기서 자신의 거리를 정의하려면?

• 이 코드는 pairwise_distances 함수를 사용하여 pts 배열의 각 요소 간의 무한대 거리를 계산합니다.
• inf_dist 함수는 두 벡터 x와 y 사이의 각 요소 간 절대 차이의 최대값을 반환하는 람다 함수입니다.
• pairwise_distances(pts, metric=inf_dist)는 주어진 pts 배열의 각 쌍에 대한 무한대 거리를 계산하여 행렬로 반환합니다.

from sklearn.metrics.pairwise import pairwise_distances

# 사용자 정의 거리 함수 inf_dist는 두 점 x와 y 사이의 무한대 거리를 계산합니다.
# 무한대 거리(inf_dist)는 두 벡터 x와 y의 각 요소 간 절대 차이의 최대값을 의미합니다.
inf_dist = lambda x, y : np.max(np.abs(x - y))

# pairwise_distances 함수를 사용하여 주어진 2차원 포인트 배열 pts의 각 쌍에 대한 무한대 거리를 계산합니다.
# metric 매개변수로 사용자 정의 거리 함수 inf_dist를 사용하여 무한대 거리를 계산합니다.
print(pairwise_distances(pts, metric=inf_dist))

[[0. 1. 1.]
 [1. 0. 1.]
 [1. 1. 0.]]