728x90
반응형
- 강의 목록
-numpy
-벡터가 뭐에요?
- 요약
강의
파이썬에서 수학을 다루기 위한 모듈인 Numpy에 대해 자세한 사용법과 개념을 익히는 시간을 가졌다.
또한 수학의 벡터, 행렬의 자세한 개념을 학습하고 Numpy를 활용한 계산법을 학습했다.
피어세션
AI에 관련해서 많은 학습을 하신 모더레이터께 데이터 구조에 관련된 내용들과 AI를 공부하기 위한 강의와 책 추천 등을 받았다.
- 학습정리
Numpy
- 다양한 매트릭스 계산 및 처리할 때 처리 속도의 문제가 발생했다.
- 이러한 문제 해결을 위해 고성능 과학 계산용 패키지인 Numpy를 사용한다.
- Numpy는 Matrix와 Vector와 같은 배열 연산의 표준이다.
- 일반 리스트에 비해 빠르고 메모리 효율적임
- 반복문 없이 데이터 배열에 대한 처리를 지원
- 선형대수와 관련된 다양한 기능을 제공
- C, C++ 등의 언어와 통합이 가능함.
ndarray
- numpy의 np.array 함수를 활용해 생성한 배열
- numpy는 하나의 데이터 타입만 배열에 넣을 수 있다. (Dynamic Typing이 지원이 안됨. List와 가장 큰 차이점.)
- C의 Array를 사용해 배열을 생성
- Python으로 리스트를 만들면 내부의 데이터들이 주소값을 가짐 (-5~256)
- 넘파이는 연속된 값의 메모리를 가짐.
- 한 번의 연산만 거치기 때문에 메모리 효율성이 좋음.
Array Shape
- (ndarray명).shape을 하면 shape 확인 가능.
- shape : array의 크기, 형태 등에 대한 정보
- rank(차원)에 따라 불리는 이름이 있음.
import numpy as np
test_arr = np.array([], int) #뒤의 int가 dtype_타입을 미리 지정해야 함.
print(test_arr)
test_arr = np.array(int)
print(test_arr)
test_arr = np.array([1,2,3,"8"], int) #string을 입력해도 int로
print(test_arr)
#dtype : type 반환
print(test_arr.dtype) #int32
#shape : 배열의 shape 반환
print(test_arr.shape) #(4,)
#nbytes : ndarray의 메모리 크기
test_arr = np.array([[1,2,3],[4,5,6]], dtype = np.float32)
print(test_arr.nbytes) #24 (4*6)
test_arr = np.array([[1,2,3],[4,5,6]], dtype = np.int8)
print(test_arr.nbytes) #6 (1*6)
test_arr = np.array([[1,2,3],[4,5,6]], dtype = np.int32)
print(test_arr.nbytes) #24 (4*6)
test_arr = np.array([[1,2,3],[4,5,6]], dtype = np.float64)
print(test_arr.nbytes) #48 (8*6)
#Handling shape
#reshape : Array의 shpae 크기 변경. element 갯수는 유지
test_mat = np.array([[1,2,3,4], [4,3,2,1]], np.int32)
print(test_mat, test_mat.shape) #[[1 2 3 4] [4 3 2 1]] (2, 4)
test_mat2 = test_mat.reshape(4,2)
print(test_mat2, test_mat2.shape) #[[1 2] [3 4] [4 3] [2 1]] (4, 2)
test_mat2 = test_mat.reshape(-1, 2) #-1은 size 기반으로 row 개수 선정
print(test_mat2, test_mat2.shape) #[[1 2] [3 4] [4 3] [2 1]] (4, 2)
#flatten : 다차원 array를 1차원 array로 반환
test_mat2 = test_mat.flatten()
print(test_mat2, test_mat2.shape) #[1 2 3 4 4 3 2 1] (8,)
#indexing & slicing
#numpy는 list와 달리 이차원 배열에서 [0,0] 표기법을 제공
#matrix일 경우 앞은 row 뒤는 column
test_mat = np.array([[1,2,3,4], [4,3,2,1]], np.int32)
print(test_mat[0][0], test_mat[0,0]) #1 1
print(test_mat[:2,:2]) #[[1 2] [4 3]]
print(test_mat[1]) #2행 [4 3 2 1]
print(test_mat[1:3]) #2행, 3행 (3행은 없으니 2행만) [[4 3 2 1]]
#arange : array의 범위를 지정해 list 생성
test_arr = np.arange(10) #0~9
print(test_arr, test_arr.dtype) #[0 1 2 3 4 5 6 7 8 9] int32
test_arr = np.arange(0,5,0.5) #시작, 끝, 추가
print(test_arr, test_arr.dtype) #[0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5] float64
test_arr = np.arange(10).reshape(2,5)
print(test_arr) #[[0 1 2 3 4] [5 6 7 8 9]]
#zeros : 0으로 가득 찬 배열
#ones : 1로 가득 찬 배열
#empty : shape만 주어지고 빈 배열
#셋 다 사용법은 같음.
test_arr = np.zeros(shape=(2,2), dtype=np.int8)
print(test_arr) #[[0 0] [0 0]]
test_arr = np.zeros((2,5))
print(test_arr) #[[0. 0. 0. 0. 0.] [0. 0. 0. 0. 0.]]
#shomething_likle : 기존 ndarray의 shape 크기 만큼 1, 9 또는 empty 배열 반환
test_mat = np.arange(10).reshape(2,5)
test_mat2 = np.ones_like(test_mat)
print(test_mat2) #[[1 1 1 1 1] [1 1 1 1 1]]
test_mat2 = np.zeros_like(test_mat)
print(test_mat2) #[[0 0 0 0 0] [0 0 0 0 0]]
test_mat2 = np.empty_like(test_mat)
print(test_mat2) #[[1 1 1 1 1] [1 1 1 1 1]]
#identity : 단위 행렬 (i 행렬)을 생성
test_mat = np.identity(n=3, dtype=np.int8)
print(test_mat)#[[1 0 0] [0 1 0] [0 0 1]]
test_mat = np.identity(5)
print(test_mat)#[[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.]]
#eye : 대각선이 1인 행렬
#identity와 달리 k 값의 시작 index의 변경이 가능하다.
test_mat = np.eye(3)
print(test_mat) #[[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
test_mat = np.eye(3,5,k=2) #k=2니까 0,2 1,3 2,4 이렇게 감.
print(test_mat) #[[0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.]]
#diag : 대각 행렬의 값을 추출함
test_mat = np.arange(9).reshape(3,3)
test_mat2 = np.diag(test_mat)
print(test_mat2) #[0 4 8]
test_mat2 = np.diag(test_mat, k=1) #k로 인덱스 지정. 1로 시작하면 0,1 1,2 빼옴
print(test_mat2) #[1 5]
#random sampling : 데이터 분포에 따른 샘플링으로 배열 생성
#uniform : 균등분포
test_mat = np.random.uniform(0,1,6).reshape(2,3)
print(test_mat) #[[0.74121581 0.97107722 0.63974734] [0.13097324 0.01189465 0.13999]]
#normal : 정규분포
test_mat = np.random.normal(0,1,6).reshape(2,3)
print(test_mat) #[[0.10622527 0.41903508 1.14964914] [1.83511822 0.75200466 0.88822292]]
#operation
#sum : 합계
test_array = np.arange(1,5) #[1 2 3 4]
print(test_array.sum(dtype = np.int32)) #10
#axis : 차원 축
#0 : 행, 1: 열 => [3,4] : axis0 = 3, axis1 = 4
test_array = np.arange(0,10).reshape(2,5) #[[0 1 2 3 4] [5 6 7 8 9]]
print(test_array.sum(axis=0)) #[5 7 9 11 13]
print(test_array.sum(axis=1)) #[10 35]
#mean : 평균
#std : 표준편차
test_array = np.arange(1,11).reshape(2,5) #[[1 2 3 4 5] [6 7 8 9 10]]
print(test_array.mean(), test_array.mean(axis = 0)) #5.5 [3.5 4.5 5.5 6.5 7.5]
print(test_array.std(), test_array.std(axis = 0)) #2.8722813232690143 [2.5 2.5 2.5 2.5 2.5]
#exp
#sqrt
test_arr = np.array([1,2,3])
print(np.exp(test_arr)) #지수함수 [ 2.71828183 7.3890561 20.08553692]
print(np.sqrt(test_arr)) #루트 [1. 1.41421356 1.73205081]
#concatenate : ndarray를 합치는 함수
#vstack : 여러 행을 결합
#hstack : 여러 열을 결함
a = np.array([1,2,3])
b = np.array([2,3,4])
c = np.vstack((a,b))
print(c) #[[1 2 3] [2 3 4]]
a = np.array([[1,],[2,],[3,]])
b = np.array([[2,],[3,],[4,]])
c = np.hstack((a,b))
print(c) #[[1 2] [2 3] [3 4]]
#vstack => concatenate, axis = 0
#hstack => concatenate, axis = 1
a = np.array([1,2,3])
b = np.array([2,3,4])
c = np.concatenate((a,b), axis = 0)
print(c) #[1 2 3 2 3 4]
a = np.array([[1,],[2,],[3,]])
b = np.array([[2,],[3,],[4,]])
c = np.concatenate((a,b), axis = 1)
print(c) #[[1 2] [2 3] [3 4]]
#dot prodict : matrix의 기본 연산. dot 함수 사용
test_a = np.arange(1,7).reshape(2,3)
test_b = np.arange(7,13).reshape(3,2)
print(test_a.dot(test_b)) #test_a * test_b = [[58 64] [139 154]]
#transpose : 전치
test_a = np.arange(1,7).reshape(2,3) #[[1,2,3], [4,5,6]]
print(test_a.transpose()) #[[1 4] [2 5] [3 6]]
print(test_a.T) ##[[1 4] [2 5] [3 6]]
#broadcasting : shape이 다른 배열 간 연산을 지원
#알아서 연산 대상에 맞춰 같은 행이나 열을 추가하며 reshape 진행
#scalar - vector 외에도 vector-matrix 간의 연산도 지원한다.
test_mat = np.arange(1,5).reshape(2,2)
print(test_mat) #[[1 2] [3 4]]
print(test_mat + 1) #[[2 3] [4 5]]
print(test_mat * 2) #[[2 4] [6 8]]
print(test_mat - 1) #[[0 1] [2 3]]
print(test_mat / 2) #[[0.5 1. ] [1.5 2. ]]
print(test_mat // 2) #[[0 1] [1 2]]
print(test_mat ** 2) #[[ 1 4] [ 9 16]]
#timeit : Jupyter 환경에서 코드의 퍼포먼스를 체크하는 함수
'''
def sclar_vector_product(scalar, vector):
result = []
for value in vector:
result.append(scalar * value)
return result
iternation_max = 100000000
vector = list(range(iternation_max))
scalar = 2
%timeit sclar_vector_product(scalar, vector) # for loop을 이용한 성능
%timeit [scalar * value for value in range(iternation_max)]
# list comprehension을 이용한 성능
%timeit np.arange(iternation_max) * scalar # numpy를 이용한 성능
'''
'''
-일반적으로 속도는 for < list comprehension < numpy
-100,000,000 번의 loop이 돌 때 약 4배 이상의 성능 차이
-Numpy는 c로 구현되어 성능을 확보하지만 Dynamic typing 포기
-대용량 계산에서 가장 흔히 사용
-Concatenate처럼 계산이 아닌 할당에는 연산 속도 이점 없음
'''
#comparisons
#all : 전체 / any : 일부
a = np.arange(0,10) #[0 1 2 3 4 5 6 7 8 9]
print(np.any(5 < a), np.any(11 < a)) #True False
print(np.all(a >= 0), np.all(a > 0)) #True False
#배열간 비교
#배열간 크기가 동일할 때는 element간 비교 결과를 Boolean으로 반환
a = np.array([1,2,3])
b = np.array([1,2,4])
c = np.array([2,3,4])
print(a > b, b < a) #[False False False] [False False False]
print(a > c, a < c) #[False False False] [ True True True]
print(b > c, b < c) #[False False False] [ True True False]
print(a == b) #[ True True False]
print((a>b).any(), (a<b).any()) #False True
#and 조건
print(np.logical_and(a>0, a<3)) #[ True True False]
#not 조건
print(np.logical_not(a<2)) #[False True True]
#or 조건
print(np.logical_or(a>0, a>5)) #[ True True True]
#xor 조건
print(np.logical_xor(a>0, a>5)) #[ True True True]
#where : (condition, True, False)
print(np.where(a > 1, 10, 0)) #[ 0 10 10]
print(np.where(a>1)) #(array([1, 2], dtype=int64),)
#isnan, isfinite
a = np.array([1,np.NaN, np.Inf], np.float)
print(np.isnan(a)) #[False True False]
#isfinite는 무한, nan이 아니면 다 true
print(np.isfinite(a)) #[ True False False]
#argmax, argmin : array내 최대값과 최소값의 index
a = np.array([1,2,3,4,5,6,7])
print(np.argmax(a), np.argmin(a)) #6 0
a = np.array([[1,3,0],[4,2,1],[9,5,3]])
print(np.argmax(a, axis = 1), np.argmin(a, axis = 0)) #[1 0 0] [0 1 0]
#argsort : index 정렬
a = np.array([1,3,5,2,9,7,5])
print(a) # [1 3 5 2 9 7 5]
a = np.argsort(a)
print(a) #[0 3 1 2 6 5 4]
#Boolean index : 특정 조건에 따라 Boolean 배열 형태로 추출
#Comparison operaion 함수들도 모두 사용이 가능하다.
a = np.array([1, 4, 7, 2, 5, 8, 0, 9])
b = a > 3
print(b) #[False True True False True True False True]
b = a[a>3] #조건이 True인 index의 원소만 추출
print(b) #[4 7 5 8 9]
#fancy index : array를 인덱스 값으로 사용해서 값 추출
b = np.array([1,0,3,2,2], int) #반드시 inr로
print(a[b]) #[4 1 2 7 7] bracket index라고 부름.
print(a.take(b)) #[4 1 2 7 7]
#matrix일 경우 두 개 선언해서 a[b,c] 이런 식으로.
#numpy data IO
a = np.arange(1,11).reshape(2,5)
#save
a = a.astype(int)
np.savetxt('test_str.csv', a, fmt = "%.2e", delimiter = ',')
np.save("test_num", arr=a) #npy 포맷으로 저장
#load
#a = np.loadtxt('./test_str.csv')
a = np.load("test_num.npy")
print(a) #[[ 1 2 3 4 5] [ 6 7 8 9 10]]
#덧셈
a = np.array([1,2,3])
b = np.array([3,4,5])
print(a + b) #[4 6 8]
print(a - b) #[-2 -2 -2]
print(a * b) #[ 3 8 15]
벡터 (Vector)
- 숫자를 원소로 가지는 리스트 또는 배열
- 벡터는 공간에서 한 점을 나타낸다.
- 벡터는 원점으로부터 상대적 위치를 표현한다.
- 벡터에 숫자를 곱해주면 길이만 변한다.
벡터의 연산
- 같은 모양을 가지면 성분곱을 계산할 수 있다. (+, -, *)
- 덧셈은 다른 벡터로부터 상대적 위치이동을 표현
- 뺄셈은 방향을 뒤집은 덧셈
- 곱셈은 길이 변환
벡터의 노름 (Norm)
- 원점에서부터의 거리
- 노름의 종류에 따라 기하학적 성질이 달라진다.
- 머신러닝에선 각 성질들이 필요할 때가 있으므로 둘 다 사용한다.
- L1-노름, L2-노름을 이용해 두 벡터 사이의 거리를 계산할 수 있다.
- 두 벡터 사이의 거리를 계산할 때는 벡터의 뺄셈을 사용한다.
- 뺄셈을 거꾸로 해도 거리는 같다 => ||y-x|| = ||x-y||
- 두 벡터 사이의 거리를 이용하면 각도 계산도 가능하다. ( L2-노름만 가능)
- 제 2 코사인 법칙에 의해 두 벡터 사이의 각도 계산이 가능하다.
- 해당 연산을 내적이라 부른다.
- 내적은 np.inner 함수로 구현이 가능하다.
#Norm
def l1_norm(x) :
x_norm = np.abs(x)
x_norm = np.sum(x_norm)
return x_norm
def l2_norm(x) :
x_norm = x**2
x_norm = np.sum(x_norm)
x_norm = np.sqrt(x_norm)
return x_norm
#거리 계산
def angle(x, y) :
v = np.inner(x, y) / (l2_norm(x) * l2_norm(y))
theta = np.arcos(v)
return theta
내적
- 내적은 정사영된 벡터의 길이와 연관이 있다.
- Proj(x)의 길이는 코사인법칙에 의해 ||x|| cos 가 된다.
- 내적은 정사영의 길이를 벡터 y의 길이 ||y||만큼 조정한 값이다.
- 내적은 두 벡터의 유사도를 측정하는 데 사용 가능하다.
행렬 (Matrix)
- 벡터를 원소로 가지는 2차원 배열
- 행(row)과 열(column)이라는 인덱스를 가진다. i번째 데이터의 j번째 변수 값
- 벡터가 한 점이라면 행렬은 여러 점을 의미한다.
- 행렬의 특정 행(열)을 고정하면 행(열)벡터라 부른다.
- 행렬의 행벡터 는 I번째 데이터를 의미한다.
- 행과 열의 인덱스를 바꾸면 전치행렬(Transpose matrix)라고 부른다.
행렬의 연산
- 행렬끼리 같은 모양을 가지면 덧셈과 뺄셈이 가능하다. (각 원소끼리 합(뺄셈))
- 성분곱은 벡터와 같다. (각 인덱스 위치끼리 곱)
- 스칼라곱도 벡터와 별 차이가 없다. (aX일 경우 X의 모든 원소에 a 곱셈)
- 행렬 곱셈은 I번째 행벡터와 j번째 열벡터 사이의 내적을 성분으로 가지는 행렬 계산
- 행렬 곱셈은 X의 열의 개수와 Y의 행의 개수가 같아야 한다.
- Numpy의 np.inner은 i번째 행벡터와 j번째 행벡터 사이의 내적을 성분으로 가지는 행렬을 계산한다.
- np.inner은 두 행렬의 행의 개수가 같아야 한다.
- 수학에서 말하는 내적과는 다르다. (수학에서는 보통 tr(XY^T)를 내적으로 계산한다.
- 행렬은 벡터공간에서 사용되는 연산자로 이해한다.
- 행렬곱을 통해 벡터를 다른 차원의 공간으로 보낼 수 있다.
- 행렬곱을 통해 패턴을 추출할 수 있고, 데이터를 압축할 수도 있다.
- 모든 선형변환 (Linear transform)은 행렬곱으로 계산이 가능하다.
역행렬 (Inverse Matrix)
- 어떤 행렬 A의 연산을 거꾸로 되돌리는 행렬을 역행렬이라 부른다.
- 역행렬은 행과 열 숫자가 같고 행렬식이 0이 아닌 경우에만 계산할 수 있다.
- 행렬식 : 행렬의 가역성을 판별. 정사각행렬을 확장해서 사용한다.
- I :항등행렬 (단위행렬) : 주 대각소의 원소가 1, 나머지가 0인 정사각 행렬 ex) [[1 0 0] [0 1 0] [0 0 1]]
- np.linalg.inv(x)로 구할 수 있다.
- 만약 역행렬을 계산할 수 없다면 유사역행렬 (pseudo-inverse) 또는 무어펜로즈(Moore-Penrose) 역행렬 를 이용한다.
x = np.array([[1, -2, 3], [7, 5, 0], [-2, -1, 2]])
x1 = np.linalg.inv(x) #역행렬
print(x.dot(x1))
print(x @ x1) #컴퓨터 연산이라 정확하게 1, 0은 안나옴.
x = np.array([[1,0,1],[0,1,0]])
print(np.linalg.pinv(x)) #무어-펜로즈 유사역원 역행렬
연립방정식
- np.linalg.pinv를 이용하면 연립방정식의 해를 구할 수 있다.
- n <= m 일 경우 무어-펜로즈 역행렬을 이용하면 해를 하나 구할 수 있다.
선형회귀분석
- np.linalg.pinv를 활용하면 데이터를 선형모델로 해석하는 선형회귀식을 찾을 수 있다.
- 선형회귀분석은 연립방정식과 달리 행이 더 크므로 방정식을 푸는 것은 불가능하다.
- Moore-Penrose 역행렬을 이용하면 y에 근접하는 를 찾을 수 있다.
- np.linalg.pinv의 경우, y절편항을 직접 추가해야 sklearn의 LinearRegression과 같은 결과를 가져올 수 있다.
- 피어세션 회의 내용
파이썬의 데이터 관련 함수
Pandas
- 데이터를 읽는 가장 인기 있는 방법.
- 케글에서 디폴트값으로 사용한다.
- 유연하게 많은 데이터 세트를 읽고 처리할 수 있도록 많은 옵션과 기능이 탑재되어있다.
- 많은 데이터를 읽기 위해 데이터를 가져올 때 열마다 최적의 데이터 유형을 미리 정의하면 읽는 시간을 단축할 수 있다.
dtypes = {
"row_id" : "int64"
"열이름1" : "int32"
"열이름2" : "int8"
#...
}
data = pd.read_csv("파일이름.csv", dtype = dtypes)
Dask
- 병렬 처리 아키텍처를 사용하여 기본적으로 판다 워크플로우를 확장할 수 있는 프레임워크 제공.
- 스파크와 비슷한 면이 있음.
- 마찬가지로 열별 데이터 유형을 미리 지정하면 훨씬 빠른 읽기 가능.
DataTable
- 대규모 데이터 셋을 판다스보다 빠르게 읽을 수 있다.
- 개형 데이터에 대한 속도와 지원을 강조하는 표 데이터 세트의 데이터 처리를 위해 제작되었다.
Rapids
- GPU에서 데이터 처리를 확장할 수 있는 옵션
- 많은 머신러닝 모델링이 GPU로 이동함에 따라 Rapids도 하나 이상의 GPU에 end-to-end 데이터 과학 솔루션을 구축할 수 있다.
데이터 관련 포멧
CSV
- 대부분의 데이터 세트의 형식
Feather
- 판다스를 위해 데이터를 이진 형식으로 저장하는 방식
- 데이터 세트의 읽기 속도가 크게 향상되었다.
HDF5
- 크고 복잡한 데이터를 저장, 관리 및 처리할 수 있는 고성능 데이터 관리 제품군
JAY
- 데이터 테이블이 사용하는 형식
- 이진 형식의 데이터이며 빠르게 저장할 수 있다.
Parquet
- 하둡 에코시스템에서 기본 파일 포맷으로 사용하고 있다.
- 현재 스파크에서도 사용중에 있다.
- 판다스에서 지원 가능하다.
Pickle
- 파이썬 오브젝트를 저장하는 형태이다.
- 팬더스가 피클 오브젝트로 데이터 프레임을 읽고 쓸 수 있는 기능을 내장하고 있다.
- 해야할 일
Numpy의 선형대수 관련 함수들을 찾아보았고, 사용법을 공부했다.
#numpy 선형대수
#diag
#정사각 행렬의 대각/비대각 원소를 1차원 배열로 반환
#혹은 1차원 배열을 대각선 원소로 반환하고 나머지는 0으로 채운 원소 반환
x = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(np.diag(x)) #[1 5 9]
#dot : 행렬곱셈
y = np.array([[1],[2],[3]])
print(x.dot(y)) #[[14] [32] [50]]
#trace : 대각선 원소의 합 계산
print(x.trace()) #15
#np.linalg.det : 행렬식 계산
x = np.array([[1,0,1],[0,1,0], [-2, 4, 1]])
print(np.linalg.det(x)) #2.9999999999999996
#np.linalg.eig : 정사각 행렬의 고유 값과 고유 벡터 계산
print(np.linalg.eig(x))
#np.linalg.inv : 역행렬 계산
print(np.linalg.inv(x))
'''
[[ 0.33333333 1.33333333 -0.33333333]
[ 0. 1. 0. ]
[ 0.66666667 -1.33333333 0.33333333]]
'''
#np.linalg.pinv : 무어-펜로즈 유사역원 역행렬
print(np.linalg.pinv(x))
'''
[[ 3.33333333e-01 1.33333333e+00 -3.33333333e-01]
[ 3.54169268e-17 1.00000000e+00 1.90863898e-16]
[ 6.66666667e-01 -1.33333333e+00 3.33333333e-01]]
'''
#np.linalg.qr : qr분해
print(np.linalg.qr(x))
'''
(array([[-0.4472136 , -0.78072006, 0.43643578],
[-0. , -0.48795004, -0.87287156],
[ 0.89442719, -0.39036003, 0.21821789]]), array([[-2.23606798, 3.57770876, 0.4472136 ],
[ 0. , -2.04939015, -1.17108009],
[ 0. , 0. , 0.65465367]]))
'''
#np.linalg.svd : 특이값 분해
print(10000, np.linalg.svd(x))
'''
(array([[-0.04948967, -0.99295388, 0.10767251],
[ 0.1884501 , -0.11515162, -0.9753085 ],
[ 0.98083502, -0.0279768 , 0.19282108]]), array([4.67107974, 1.40421675, 0.45737226]), array([[-0.43055563, 0.88026546, 0.19938545],
[-0.66727611, -0.16169783, -0.72704636],
[-0.6077536 , -0.44607906, 0.65700002]]))
'''
#np.linalg.solve : 정사각 행렬일 때 Ax = b를 만족하는 x
#print(np.linalg.solve(A,b))
#np.linalg.lstsq : y = xA를 만족하는 최소제곱해
#print(np.linalg.lstsq(A,y)
728x90
반응형
'BOOSTCAMP AI TECH > 2주차_AI를 위한 수학' 카테고리의 다른 글
| [BOOSTCAMP AI TECH] 10일차_시각화 도구, 통계학 맛보기 (0) | 2021.01.29 |
|---|---|
| [BOOSTCAMP AI TECH] 9일차_Pandas 2, 확률론 (0) | 2021.01.28 |
| [BOOSTCAMP AI TECH] 8일차_Pandas / 딥러닝 학습방법 이해하기 (0) | 2021.01.27 |
| [BOOSTCAMP AI TECH] 7일차_경사하강법 (0) | 2021.01.26 |
