Numpy
파이썬 기본 라이브러리 Numpy
Array 연산의 특화된 library Numpy의 사용법을 정리하였다.
# Library importing
import numpy as np
1. Numpy
Array 객체 생성 및 연산을 도와주는 library
# 1. array 생성
A = np.array([])
print(A)
print(type(A))
[]
<class 'numpy.ndarray'>
1) Matrix, Vector 만들기
np.array와 List를 이용하여 벡터와 행렬을 만들 수 있다.
Matrix를 만드는 경우 list[list1, list2, …, listm] 형태로 만들 수 있는데, 첫 번째 list 안의 성분들이 row가 된다.
즉, 만약 list1, …, listm의 길이가 n일 때, 위 array는 $m\times n$의 shape를 가진다.
array 내부에 가질 수 있는 자료형은 임의의 자료형이 모두 사용이 된다. 이는 array.dtype을 이용하여 확인가능하다.
# 벡터 x 만들기
x = np.array([1, 2, 3])
print(f'벡터 x : {x}')
print(f'벡터 size : {x.shape}')
print(f'x 타입 : {x.dtype}')
print()
# 행렬 A 만들기
A = np.array([[1, 2, 3], [4, 5, 6]])
print(f'행렬 A : {A}')
print(f'행렬 size : {A.shape}')
print(f'행렬 A 타입 : {A.dtype}')
벡터 x : [1 2 3]
벡터 size : (3,)
x 타입 : int32
행렬 A : [[1 2 3]
[4 5 6]]
행렬 size : (2, 3)
행렬 A 타입 : int32
2) Matrix, Vector indexing
List index와 같은 방법으로 진행이 된다.
(시작 지점이 0부터 시작한다는 점, 끝에서부터 원소를 불러내려면 -를 붙어야한다는 점 모두 동일하다.)
List 안의 list의 경우 list[a][b] 형태로 indexing을 했어야 하나, array의 경우
array[a, b] 형태로 indexing이 가능하다.
slicing의 경우 list를 이용하여 원하는 index의 원소를 추출할 수 있다.
추출 시 특정 행이나 열의 일부만 추출한 경우, 벡터로 추출이 된다. 추출 시 여러 행과 여러 열을 동시에 추출한 경우, 행과 열을 보존하는 matrix로 추출이 된다. (shape를 참고할 것!)
# 벡터 indexing
x = np.array([1, 2, 3, 4, 5, 6 ])
print(f'x : {x}')
print()
print('Vector indexing')
print(f'{x[1]} : x[1]을 호출하면 x의 두 번째 원소가 출력된다.')
print (f'{x[-1]} : x[-1]을 호출하면 x의 마지막 원소가 출력된다.' )
print()
# 벡터 slicing
print('Vector slicing')
print(f'{x[[2, 4]]} : x[[2, 4]]를 호출하면 x의 세 번째, 네 번째 원소가 출력된다.')
print(f'{x[2:]} : x[2:]를 호출하면 x의 세 번째 원소부터 마지막 원소까지 출력된다.')
print(f'{x[:2]} : x[:2]를 호출하면 x의 세 번째 원소 전까지 호출된다.')
print()
# 행렬 indexing
A = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(f'A : {A}')
print()
print('Matrix indexing')
print(f'{A[1]} : A[1]을 호출하면 A의 두번째 행이 호출된다.')
print(f'{A[:, 1]} : A[:, 1]을 호출하면 A의 두번째 열이 호출된다.')
print(f'{A[1, 2]} : A[1, 2]을 호출하면 A의 두번째 행, 세번째 열이 호출된다.')
print()
# 행렬 slicing
print('Matrix slicing')
print(f'{A[0,[1, 3]]} : A[0, [1, 3]]을 호출하면 A의 첫 번째 행, 두 번째, 세 번째 열이 호출된다.')
print(f'A[0, [1, 3]]의 shape : {A[0, [1, 3]].shape}')
print(f'{A[:, [1, 2]]}) : A[:, [1, 2]]을 호출하면 A의 두 번째, 세 번째 열이 호출된다.')
print(f'A[:, [1, 2]]의 shape : {A[:, [1, 2]].shape}')
x : [1 2 3 4 5 6]
Vector indexing
2 : x[1]을 호출하면 x의 두 번째 원소가 출력된다.
6 : x[-1]을 호출하면 x의 마지막 원소가 출력된다.
Vector slicing
[3 5] : x[[2, 4]]를 호출하면 x의 세 번째, 네 번째 원소가 출력된다.
[3 4 5 6] : x[2:]를 호출하면 x의 세 번째 원소부터 마지막 원소까지 출력된다.
[1 2] : x[:2]를 호출하면 x의 세 번째 원소 전까지 호출된다.
A : [[1 2 3 4]
[5 6 7 8]]
Matrix indexing
[5 6 7 8] : A[1]을 호출하면 A의 두번째 행이 호출된다.
[2 6] : A[:, 1]을 호출하면 A의 두번째 열이 호출된다.
7 : A[1, 2]을 호출하면 A의 두번째 행, 세번째 열이 호출된다.
Matrix slicing
[2 4] : A[0, [1, 3]]을 호출하면 A의 첫 번째 행, 두 번째, 세 번째 열이 호출된다.
A[0, [1, 3]]의 shape : (2,)
[[2 3]
[6 7]]) : A[:, [1, 2]]을 호출하면 A의 두 번째, 세 번째 열이 호출된다.
A[:, [1, 2]]의 shape : (2, 2)
3) 기본 제공 array
np.zeros((dimension)) : 모든 원소가 0인 array를 만들어주는 함수 : dimension 부분에 array의 shape를 적어주면 된다.
np.ones((dimension)) : 모든 원소가 1인 array를 만들어주는 함수 : dimension 부분의 array의 shape를 적어주면 된다.
np.arange(start, stop, step, dtype) : start에서 stop까지 간격이 step인 array를 만들어주는 함수, dtype을 통해 데이터 타입을 지정 가능하다.
start를 지정하지 않은 경우 0으로 지정된다.
기존의 range함수와 다른 점은 range는 정수값만을 만들 수 있으나 np.arange의 경우 실수값까지 생성이 가능하다.
# np.zeros()
x_0 = np.zeros((3))
print(f'x_0 : {x_0}')
print(f'x_0 shape ; {x_0.shape}')
print()
A_0 = np.zeros((5, 3))
print(f'A_0 : {A_0}')
print(f'A_0 shape ; {A_0.shape}')
print()
# np.ones()
x_1 = np.ones((3))
print(f'x_1 : {x_1}')
print(f'x_1 shape ; {x_1.shape}')
print()
A_1 = np.ones((3, 5))
print(f'A_1 : {A_1}')
print(f'A_1 shape ; {A_1.shape}')
print()
# np.arange()
b = np.arange(start=2, stop=5, step = 0.5)
print(f'b : {b}')
x_0 : [0. 0. 0.]
x_0 shape ; (3,)
A_0 : [[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
A_0 shape ; (5, 3)
x_1 : [1. 1. 1.]
x_1 shape ; (3,)
A_1 : [[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
A_1 shape ; (3, 5)
b : [2. 2.5 3. 3.5 4. 4.5]
4) Numpy 연산
array간의 기본 연산이 가능하고, 두 array의 shape가 같은 경우에만 연산이 가능하다.
np.add or +: 각 entry 위치에 존재하는 원소끼리의 합을 도출
np.subtract or -: 각 entry 위치에 존재하는 원소끼리의 차를 도출
np.multiply or * : 각 entry 위치에 존재하는 원소끼리의 곱을 도출
np.divide or / : 각 entry 위치에 존재하는 원소끼리 나누기 결과 도출 (앞 부분의 원소를 뒷 부분의 원소로 나누기)
# numpy 기본 연산
A = np.array([[-1, 0, 1], [2, 5, 1]])
B = np.array([[1, 2, 3], [4, 5, 6]])
print(f'A+B : {A+B}')
print(f'A-B : {A-B}')
print(f'A*B : {A*B}')
print(f'A/B : {A/B}')
A+B : [[ 0 2 4]
[ 6 10 7]]
A-B : [[-2 -2 -2]
[-2 0 -5]]
A*B : [[-1 0 3]
[ 8 25 6]]
A/B : [[-1. 0. 0.33333333]
[ 0.5 1. 0.16666667]]
np.dot : 행렬간 곱셈을 제공해주는 함수 (곱셈 조건을 만족해야 계산 가능하다)
array.T : array의 transpose를 제공해주는 함수
array.T와 np.dot을 이용하여 두 벡터간 내적을 계산할 수 있다.
# 행렬 곱셈
A = np.array([[1, 2, 3], [4, 5, 6]])
B = np.array([[1, 2], [3, 4], [5, 6]])
print(f'A : {A}')
print(f'B : {B}')
print(f'AB : {np.dot(A, B)}')
print()
# 두 벡터간 내적
x = np.array([1, 2, 3])
y = np.array([2, 3, 4])
print(x)
print(y)
print(f'Inner product of x and y : {np.dot(x, y.T)}')
A : [[1 2 3]
[4 5 6]]
B : [[1 2]
[3 4]
[5 6]]
AB : [[22 28]
[49 64]]
[1 2 3]
[2 3 4]
Inner product of x and y : 20
np.sum(array, axis) : array 내의 행 또는 열의 모든 원소의 합
np.product(array, axis) : array 내의 행 또는 열의 모든 원소의 곱
np.mean(array, axis) : array 내의 행 또는 열의 평균
np.std(array, axis) : array 내의 행 또는 열의 표준편차
axis를 이용해 rowsum인지, columnsum인지 지정 가능함 (axis = 0 : row끼리의 합, axis =1 : column끼리의 합), axis를 지정해주지 않은 경우 array의 전체 원소의 연산 결과를 도출해줌
# axis 지정하기
A = np.array([[1, 2, 3], [4, 5, 6]])
print(A)
print()
print(f'axis = 0인 경우의 합 : {A.sum(axis=0)}')
print()
print(f'axis = 1인 경우의 합 : {A.sum(axis=1)}')
# product, mean, std 함수
print()
print(f'A의 product : {np.product(A)}')
print(f'A의 mean : {np.mean(A)}')
print(f'A의 std : {np.std(A)}')
[[1 2 3]
[4 5 6]]
axis = 0인 경우의 합 : [5 7 9]
axis = 1인 경우의 합 : [ 6 15]
A의 product : 720
A의 mean : 3.5
A의 std : 1.707825127659933
여러 수학 함수
abs : array 내부 원소를 원소의 절댓값으로 추출해주는 함수
sqrt : array 내부 원소의 제곱근으로 추출해주는 함수
square : array 내부 원소의 제곱값으로 추출해주는 함수
exp : array 내부 원소의 exponential 지수값으로 추출해주는 함수
log : array 내부 원소를 log 값으로 제공해주는 함수 (base : e, log10 : 10, log2 : 2)
sign : array 내부 원소부호를 설정해주는 함수 (1 : positive, 0 : zero, -1 : negative)
ceil : array 내부 원소보다 크거나 같은 최소 정수 값을 제공해주는 함수
floor : array 내부 원소보다 작거나 같은 최대 정수 값을 제공해주는 함수
round : array 내부 원소의 반올림 값을 제공해주는 함수(소숫점 자리수 설정 가능)
isnan : array 내부 원소 중 nan 값이 존재하는지 확인해주는 함수 (NAN값 위치에 True값을, 아닌 값 위치에 False 값을 도출)
isfinite, isinf : array 내부 원소가 유한한 값(무한한 값)인지 확인해주는 함수
cos, cosh, sin, sinh, tan, tanh, arccos, arccosh, arcsin, arcsinh, arctan, arctanh : 삼각함수
- 함수마다 np.함수명(array) 형태로만 가능한 함수가 존재하고, array.함수가 가능한 함수가 있음. np.함수명(array)는 모든 함수에 대해 성립하기 때문에 위 방법을 사용하면 좋을 것
A = np.array([[-1, 2.5, 3.12], [4, 5, 6]])
B = np.array([[1, 2, 3], [4, 5, 6]])
print(f'A : \n {A}')
print()
print(f'B : \n {B}')
print()
print(f'A에 abs 함수 사용 결과 :\n {np.abs(A)}')
print()
print(f'B에 sqrt 함수 사용 결과 : \n {np.sqrt(B)}')
print()
print(f'A에 square 함수 사용 결과 : \n {np.square(A)}')
print()
print(f'A에 exp 함수 사용 결과 : \n {np.exp(A)}')
print()
print(f'B에 log 함수 사용 결과 : \n {np.log(B)}')
print()
print(f'A에 sign 함수 사용 결과 : \n {np.sign(A)}')
print()
print(f'A에 ceil 함수 사용 결과 : \n {np.ceil(A)}')
print()
print(f'A에 floor 함수 사용 결과 : \n {np.floor(A)}')
print()
print(f'A에 round 함수 사용 결과 : \n {np.round(A)}')
print()
print(f'A에 round 함수 사용 결과 : \n {np.round(A, 1)}')
print()
print(f'A에 isnan 함수 사용 결과 : \n {np.isnan(A)}')
print()
print(f'A에 isfinite 함수 사용 결과 : \n {np.isfinite(A)}')
print()
print(f'A에 cos함수 사용 결과 : \n {np.cos(A)}')
A :
[[-1. 2.5 3.12]
[ 4. 5. 6. ]]
B :
[[1 2 3]
[4 5 6]]
A에 abs 함수 사용 결과 :
[[1. 2.5 3.12]
[4. 5. 6. ]]
B에 sqrt 함수 사용 결과 :
[[1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974]]
A에 square 함수 사용 결과 :
[[ 1. 6.25 9.7344]
[16. 25. 36. ]]
A에 exp 함수 사용 결과 :
[[3.67879441e-01 1.21824940e+01 2.26463796e+01]
[5.45981500e+01 1.48413159e+02 4.03428793e+02]]
B에 log 함수 사용 결과 :
[[0. 0.69314718 1.09861229]
[1.38629436 1.60943791 1.79175947]]
A에 sign 함수 사용 결과 :
[[-1. 1. 1.]
[ 1. 1. 1.]]
A에 ceil 함수 사용 결과 :
[[-1. 3. 4.]
[ 4. 5. 6.]]
A에 floor 함수 사용 결과 :
[[-1. 2. 3.]
[ 4. 5. 6.]]
A에 round 함수 사용 결과 :
[[-1. 2. 3.]
[ 4. 5. 6.]]
A에 round 함수 사용 결과 :
[[-1. 2.5 3.1]
[ 4. 5. 6. ]]
A에 isnan 함수 사용 결과 :
[[False False False]
[False False False]]
A에 isfinite 함수 사용 결과 :
[[ True True True]
[ True True True]]
A에 cos함수 사용 결과 :
[[ 0.54030231 -0.80114362 -0.99976689]
[-0.65364362 0.28366219 0.96017029]]
여러 선형 대수 함수 - np.linalg 사용해야 하는 경우 존재
diag : 행렬의 경우 대각 성분만을 뽑아서 벡터로 변환해주는 함수 or 벡터를 대각 성분으로 가지는 diagonal matrix를 만들어주는 함수
dot : Matrix multiplication
trace : Trace of matrix
np.linalg.det : matrix의 determinant
np.linalg.eig : square의 eigenvalue와 eigenvector를 나타내주는 함수
- array 형태로 제공, 첫 번째 원소는 eigenvalue, 두 번째 원소는 eigenvalue에 해당하는 eigenvector로 나옴
np.linalg.inv : square matrix의 inverse를 나타내주는 함수
np.linalg.pinv : matrix의 pseudo-inverse를 나타내주는 함수
np.linalg.qr : QR decomposition
- array 형태로 제공, decomposition
np.linalg.svd : singular value decomposition (SVD)
- array 형태로 제공, U, Sigma, V 순으로 제공
np.linalg.solve : Ax = b linear equation 풀어주는 함수
np.linalg.lstsq : Ax = b linear equation의 least square solution을 구해주는 함수
- b가 matrix인 경우 columwise로 least square solution을 제공
- 결과는 solution, residual, rank, singular value 순으로 제공
A = np.array([[1, 2, 3], [1, -1, 2], [3, 1, 0]])
b = np.array([0, 1, 2])
print(f'A : \n {A}')
print()
print(f'b : \n {b}')
print()
print(f'A에 diag 함수 사용 결과 :\n {np.diag(A)}')
print()
print(f'B에 diag 함수 사용 결과 : \n {np.diag(b)}')
print()
print(f'A에 trace 함수 사용 결과 : \n {np.trace(A)}')
print()
print(f'A에 det 함수 사용 결과 : \n {np.linalg.det(A)}')
print()
print(f'A에 eig 함수 사용 결과 : \n {np.linalg.eig(A)}')
print()
print(f'A에 inv 함수 사용 결과 : \n {np.linalg.inv(A)}')
print()
print(f'A에 pinv 함수 사용 결과 : \n {np.linalg.pinv(A)}')
print()
print(f'A에 qr 함수 사용 결과 : \n {np.linalg.qr(A)}')
print()
print(f'A에 svd 함수 사용 결과 : \n {np.linalg.svd(A)}')
print()
print(f'Ax=b linear system solution : \n {np.linalg.solve(A, b)}')
print()
print(f'Ax=b linear system least-square solution : \n {np.linalg.lstsq(A, b)}')
A :
[[ 1 2 3]
[ 1 -1 2]
[ 3 1 0]]
b :
[0 1 2]
A에 diag 함수 사용 결과 :
[ 1 -1 0]
B에 diag 함수 사용 결과 :
[[0 0 0]
[0 1 0]
[0 0 2]]
A에 trace 함수 사용 결과 :
0
A에 det 함수 사용 결과 :
22.000000000000004
A에 eig 함수 사용 결과 :
(array([ 4.36367121+0.j , -2.1818356 +0.53030162j,
-2.1818356 -0.53030162j]), array([[ 0.73089465+0.j , 0.00943147-0.34699234j,
0.00943147+0.34699234j],
[ 0.35387276+0.j , 0.73993815+0.j ,
0.73993815-0.j ],
[ 0.58358125+0.j , -0.44195836+0.36969137j,
-0.44195836-0.36969137j]]))
A에 inv 함수 사용 결과 :
[[-0.09090909 0.13636364 0.31818182]
[ 0.27272727 -0.40909091 0.04545455]
[ 0.18181818 0.22727273 -0.13636364]]
A에 pinv 함수 사용 결과 :
[[-0.09090909 0.13636364 0.31818182]
[ 0.27272727 -0.40909091 0.04545455]
[ 0.18181818 0.22727273 -0.13636364]]
A에 qr 함수 사용 결과 :
(array([[-0.30151134, 0.76752258, -0.56568542],
[-0.30151134, -0.63960215, -0.70710678],
[-0.90453403, -0.04264014, 0.42426407]]), array([[-3.31662479, -1.20604538, -1.50755672],
[ 0. , 2.13200716, 1.02336344],
[ 0. , 0. , -3.11126984]]))
A에 svd 함수 사용 결과 :
(array([[-0.78836495, 0.40409743, 0.46388142],
[-0.36634633, 0.29739568, -0.88167238],
[-0.49423787, -0.86502086, -0.08641672]]), array([4.41112591, 2.64133102, 1.88821044]), array([[-0.59790288, -0.38643682, -0.70226685],
[-0.71689972, -0.13410727, 0.68415644],
[-0.35856232, 0.91251402, -0.19685332]]))
Ax=b linear system solution :
[ 0.77272727 -0.31818182 -0.04545455]
Ax=b linear system least-square solution :
(array([ 0.77272727, -0.31818182, -0.04545455]), array([], dtype=float64), 3, array([4.41112591, 2.64133102, 1.88821044]))
C:\Users\Seo\AppData\Local\Temp/ipykernel_1376/3277811306.py:31: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.
To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.
print(f'Ax=b linear system least-square solution : \n {np.linalg.lstsq(A, b)}')
Random number 생성하기 - np.random 사용, size : 난수 개수
np.random.beta(a, b, size) : beta distribution
np.random.binomial(n, p, size) : binomial distribution
np.random.chisquare(df, size) : chi-square distribution
np.random.exponential(scale, size) : exponential distribution
np.random.f(dfnum, dfden, size) : F distribution
np.random.gamma(shape, scale, size) : Gamma distribution
np.random.geometric(p, size) : Geometric distribution
np.random.hypergeometric(ngood, nbad, size) : Hypergeometric distribution
np.random.multinomial(pvals, size) : Multinomial distribution
np.random.negative_binomial(n, p, size) : Negative binomial distribution
np.random.normal(mean, std, size) : Normal distribution
np.random.poisson(lam, size) : Poisson distribution
n = 5
print(f'a=1, b=1 beta sample : \SSn {np.random.beta(a=1, b=1, size=5)}')
print()
print(f'n=10, p=.5 binomial sample : \n {np.random.binomial(n=10, p=0.5, size=5)}')
print()
print(f'mean = 0, std= 1 normal sample : \n {np.random.normal(0, 1, 5)}')
a=1, b=1 beta sample :
[0.04810958 0.38883337 0.13787565 0.7316599 0.58057238]
n=10, p=.5 binomial sample :
[4 2 4 6 7]
mean = 0, std= 1 normal sample :
[-0.51471309 0.7058427 -0.88734163 -0.60854602 1.05352253]
댓글남기기