본문 바로가기
컴퓨터/파이썬을 활용한 머신러닝 쿡북

1. 벡터, 행렬, 배열

by 하링아 2020. 6. 23.
반응형

1. 벡터, 행렬, 배열

이 카테고리의 내용은 파이썬을 활용한 머신러닝 쿡북의 각 챕터별 요약으로 코드는 생략될 수 있습니다.

 

코드가 필요하신 분들은 아래 GitHub를 통해 확인하세요.

 

rickiepark/machine-learning-with-python-cookbook

파이썬을 활용한 머신러닝 쿡북. Contribute to rickiepark/machine-learning-with-python-cookbook development by creating an account on GitHub.

github.com

 

- 넘파이는 파이썬 머신러닝 스택의 기초

- 머신러닝에 자주 사용되는 벡터, 행렬, 텐서같은 데이터 구조에서 효율적인 연산 제공

- 넘파이 연산을 다룸

 

벡터 만들기 

- 넘파이 핵심 데이터 구조는 다차원 배열. 벡터는 1차원 배열로 만듦. 행 또는 열로 가능

- 넘파이 배열은 ndarray 클래스 객체

 

- ndarray를 사용하여 넘파이 배열 만드는건 비추천

- asarray 함수 사용시 입력이 넘파이 배열일 때 새로운 배열 생성 안함

- array 함수는 입력 배열을 복사할 지 선택하는 copy 매개변수 존재. copy의 기본값은 True -> 배열이 입력되면 복사본 생성.

- 배열을 복사하려면 의도가 명확하도록 배열 객체의 copy 메서드를 사용하는 것이 좋음. copy는 새로운 배열 생성

 

행렬 만들기
import numpy as np

 

- np.array 함수를 이용해 넘파이의 2차원 배열(행렬) 만듦.

- 넘파이에 행렬에 특화된 데이터 구조 (np.mat)존재.

- 다음 두 가지 이유로 np.mat 권장하지 않음.

1. 배열이 넘파이 표준 데이터 구조

2. 대부분 넘파이 함수는 행렬 객체가 아니라 배열을 반환한다.

 

###( ### 주석 ### 이렇게 생각하면 됨)

- np.mat을 권장하지 않는 이유가 이해가 되지 않아 직접 실행해봄.

- np.mat을 이용해 만든 데이터 구조는 행렬 구조이고 np.array를 이용해 만든 데이터 구조는 배열 구조임

- 대부분의 구조가 배열 구조임 그래서 np.mat은 호환이 되지 않아 권장하지 않는다는 뜻

###

 

- np.empty 함수는 임의의 값이 채워진 배열 생성

- np.zeros 함수는 0으로 채워진 배열 생성

- np.ones 함수는 1로 채워진 배열 생성

- np.full([x, y], z) [x, y] 크기의 행렬의 요소를 전부 z로 채움  # [] 대신 () 사용해도 결과 같음

 

- 만들어진 배열에 다른 수 사칙연산 가능

 

희소 행렬 만들기 
from scipy import sparse
import numpy as np

matrix = np.array([[0, 0],
                   [0, 1],
                   [3, 0]])
matrix_sparse = sparse.csr_matrix(matrix)

 

- 데이터의 원소는 대부분 0

- 희소 행렬은 0이 아닌 원소만 저장

- 다른 모든 원소는 0이라 가정하므로 계산 비용 크게 감소

 

print(matrix_sparse)

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

 

- 1은 2행 1열, 3은 3행 1열(0부터 시작하므로)에 위치한 0이 아닌 원소임을 나타냄

- 0인 원소를 아무리 추가해도 희소 행렬의 크기는 변하지 않음

 

- 희소 행렬은 여러 종류 있음. CSC(composed sparse column, 리스트의 리스트, 키의 딕셔너리 등)

- 각각의 차이가 있고 상황에 따라서 적절하게 골라야 함

 

- 밀집 배열로부터 희소 행렬을 만드는 일은 드묾. 원소의 행과 열의 인덱스를 직접 지정하여 희소 행렬 만들 수 있음

- 희소 행렬을 밀집 행렬로 변환하기 위해 toarray 메서드 사용

- todense 메서드는 np.matrix 객체 반환

 

원소 선택하기
import numpy as np

vector = np.array([1, 2, 3, 4, 5, 6])
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print(vector[:3])
[1 2 3]

print(vector[3:])
[4 5 6]

 

- :x의 경우 x 포함

- x:의 경우 x 제외

 

print(matrix[[0, 2]])
[[1 2 3]
 [7 8 9]]
       
print(matrix[[0, 2], [1, 0]])
[2 7]

 

- 리스트를 전달하여 원소 선택 가능

- 첫번째의 경우 1행과 3행의 원소 출력

- 두번째는 1행 2열, 3행 1열 원소 출력

 

mask = matrix > 5

print(mask)
[[False False False]
 [False False  True]
 [ True  True  True]]
 
print(matrix[mask])
[6 7 8 9]

 

- boolean mask 배열을 만들어 원소 선택 가능

- 원소 출력 시  True 원소만 출력

 

행렬 정보 확인하기
import numpy as np

matrix = np.array([[1,2,3,4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])
matrix.shape
(3, 4)

matrix.size
12

- 기본적인 행렬의 모양과 크기

print(matrix.dtype)
int64

- 데이터 타입

print(matrix.itemsize)
8

- 원소 하나가 차지하는 바이트 크기

print(matrix.nbytes)
96

- 배열 전체가 차지하는 바이트 크기

 

벡터화 연산 적용
import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
# 100을 더하는 함수 
add_100 = lambda i: i + 100

# 벡터화된 함수
vectoried_add_100 = np.vectorize(add_100)

# 행렬의 모든 원소에 함수 적용
print(vectoried_add_100(matrix))
[[101 102 103]
 [104 105 106]
 [107 108 109]]
 
# 200을 더하는 함수 (람다 사용 안하고)
def add_200(i):
  return i + 200
  
# 벡터화된 함수
vectoried_add_200 = np.vectorize(add_200)

# 행렬의 모든 원소에 함수 적용
print(vectoried_add_200(matrix))
[[201 202 203]
 [204 205 206]
 [207 208 209]]

- vectorize 클래스는 배열의 일부나 전체에 적용하도록 함수 변환

- vectorize는 기본적으로 원소를 순회하는 for루프 구현한 것 -> 성능 향상 없음

print(matrix + 100)
[[101 102 103]
 [104 105 106]
 [107 108 109]]

- numpy 배열은 차원이 달라도 배열 간의 연산을 수행할 수 있음 ( 브로드 캐스팅 Broadcasting)

matrix  = np.array([[1, 1, 1],
                    [1, 1, 1],
                    [1, 1, 1]])
                    
print(matrix + [1, 2, 3]) 
[[2 3 4]
 [2 3 4]
 [2 3 4]]
 
print(matrix + [[1], [2], [3]])
[[2 2 2]
 [3 3 3]
 [4 4 4]]

- 브로드 캐스팅은 배열에 차원을 추가하거나 반복해서 배열 크기 맞춤

- (3, 3) 크기 행렬에 (3, ) 크기 벡터를 더하면 (1, 3) 행렬로 변환하여 행을 따라 반복

- (3, 3) 크기 행렬에 (3, 1) 크기 벡터를 터하면 열을 따라 반복

 

최댓값, 최솟값 찾기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# 최댓값
np.max(matrix)
9

# 최솟값
np.min(matrix)
1

# 행렬의 각 열의 최댓값
print(np.mat(matrix, axis=0))
[7 8 9]

# 행렬의 각 행의 최솟값
print(np.min(matrix, axis=1))
[1 4 7]

- keepdims 매개변수를 True로 지정하면 원본 배열의 차원과 동일한 결과 만듦

vector_column = np.max(matrix, axis=1, keepdims=True)

print(vector_column)
[[3]
 [6]
 [9]]
 
print(matrix - vector_column)
[[-2 -1  0]
 [-2 -1  0]
 [-2 -1  0]]

 

평균, 분산, 표준편차 계산하기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
 
# 평균
np.mean(matrix)
5.0

# 분산
np.var(matrix)
6.666666666666667

# 표준 편차
np.std(matrix)
2.581988897471611

# 행렬의 각 열의 평균
print(np.mean(matrix, axis=0))
[4. 5. 6.]

- 통계학에서 종종 모집단에서 추출한 샘플의 자유도(degree of freedom)를 고려하여 편향되지 않은 분산과 표준편차 계산

- 훈련 데이터의 독립적인 샘플 수 = 전체 샘플 수 - 1

- np.std, np.var 함수의 ddof 매개변수를 True로 지정하면 편향되지 않은 추정값 얻음

- ddof 매개변수 기본값 = 0

# 편향되지 않은 표준 편차
np.std(matrix, ddof=1)
2.7386127875258306

- 판다스(pandas) 데이터프레임(dataframe)의 std 메서드는 ddof 매개변수 기본값 1

import pandas as pd

df = pd.DataFrame(matrix.flatten())
# 편향되지 않은 표준 편차 추정값
df.std()
0    2.738613
dtype: float64

- 실제 머신러닝 모델에서는 자유도 고려 하지 않는 경우가 많음

- 넘파이 mean, std, var 메서드도 keepdims 매개변수 지원

 

배열 크기 바꾸기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9],
                   [10, 11, 12]])
                   
# 2x6 크기의 행렬로 바꾸기
# 새로운 행렬은 기존 행렬과 원소 개수 같아야 함
print(matrix.reshape(2, 6))
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]
 
# 행렬의 원소 개수
matrix.size
12

# 매개변수 -1은 '가능한 많게'라는 뜻
print(matrix.reshape(1, -1))
[[ 1  2  3  4  5  6  7  8  9 10 11 12]]

# 정수 한 개 입력 시 그 길이의 1차원 행렬 반환
print(matrix.reshpae(12))
[ 1  2  3  4  5  6  7  8  9 10 11 12]

# reshape 매개변수로 -1 입력시 1차원 배열 반환
print(matrix.reshape(-1))
[ 1  2  3  4  5  6  7  8  9 10 11 12]

# ravel 메서드 사용시 1차원 배열 반환
print(matrix.ravel())
[ 1  2  3  4  5  6  7  8  9 10 11 12]

 

벡터나 행렬 전치하기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# 전치행렬
print(matrix.T)
[[1 4 7]
 [2 5 8]
 [3 6 9]]

- 선형대수학에서 자주 사용하는 연산

- 각 원소의 행과 열의 인덱스를 바꿈

- 기술적으로 벡터는 단지 값의 모음이기 때문에 전치 불가

# 벡터 전치
print(np.array([1,2,3,4,5,6]).T)
[1 2 3 4 5 6]

# 대괄호 두 번 사용하여 벡터 전치
print(np.array([[1,2,3,4,5,6]]).T)
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]
 
# transpose 메서드를 이용한 전치 행렬
print(matrix.transpose())
[[1 4 7]
 [2 5 8]
 [3 6 9]]
 
# 2x3x2 행렬을 2x2x3행렬로 바꿈(2,3번째 원소를 바꿈)
matrix = np.array([[[1,2],
                    [3, 4],
                    [5, 6]],
                   [[7, 8],
                    [9, 10],
                    [11, 12]]])
print(matrix.transpose((0, 2, 1)))
[[[ 1  3  5]
  [ 2  4  6]]

 [[ 7  9 11]
  [ 8 10 12]]]

 

행렬 펼치기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# flatten 메서드를 이용한 행렬 펼치기
print(matrix.flatten())
[1 2 3 4 5 6 7 8 9]

# reshape 메서드를 이용한 행렬 펼치기
print(matrix.reshape(1, -1))
[[1 2 3 4 5 6 7 8 9]]

- reshape 메서드는 넘파이의 뷰를 반환(원래 행렬을 복제). 원본 행렬이 변하면 따라서 변함

- flatten 메서드는 새로운 행렬을 만듦. 원본 행렬이 변해도 변화 없음

# reshape, flatten을 이용하여 각각 행렬 만듦
vector_reshape = matrix.reshape(-1)
vector_flattened = matrix.flatten()

# 원본 행렬 원소 바꿈
matrix[0][0] = -1

# flatten 메서드를 이용하면 새로운 행렬은 만들기 때문에 원소 변화 없음
print(vector_flattened)
[1 2 3 4 5 6 7 8 9]

# reshape 메서드를 이용하면 배열의 뷰를 반환(원본 행렬을 복사)하기 때문에 원본 행렬의 변화를 따라서 변화함
print(vector_reshape)
[-1  2  3  4  5  6  7  8  9]

 

행렬의 랭크 구하기
# matrix_rank를 이용하여 랭크 반환

import numpy as np

matrix = np.array([[1, 1, 1],
                [1, 1, 10],
                [1, 1, 15]])
                
# matrix_rank 메서드를 이용한 matrix 행렬의 랭크
np.linalg.matrix_rank(matrix)
2

- 행렬의 랭크는 행이나 열이 만든 벡터 공간의 차원

 

- 행렬의 랭크(혹은 계수)는 '선형 독립적인' 행 또는 열의 개수

- rank 메서드와 혼동하지 말 것. 넘파이 1.19에서 삭제 예정. rank 메서드 대신 ndim 메서드 사용할 것

- matrix_rank 메서드는 특잇값 분해(singular value decomposition)방식으로 랭크 계산

- linalg 모듈의 svd 메서드로 특잇값을 구한 다음 0이 아닌 값의 수 구함.

# svd 메서드로 특잇값 계산
s = np.linalg.svd(matrix, compute_uv=False)

# 오차를 고려하여 0에 가까운 값을 지정
np.sum(s > 1e-10)
2

# 0도 지정해봄
np.sum(s > 0)
2

 

행렬식 계산하기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# 넘파이의 det 메서드 사용하여 행렬식 반환
np.linalg.det(matrix)   
0.0

- 행렬식은 정방행렬에 의한 선형 변환의 특징을 나타내는 스칼라값

- (2, 2) 크기의 행렬 A = [[a, b], [c, d]] 의 행렬식은 det(A) = ad - bc

 

행렬의 대각원소 추출하기

import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# diagonal 메서드를 이용한 대각 원소 반환
print(matrix.diagonal())
[1 5 9]

# diagonal의 offset 매개변수를 이용하면 주 대각선 주위 대각원소 반환 가능
# 주 대각선 하나 위의 대각원소 반환
print(matrix.diagonal(offset=1))
[2 6]

# 주 대각선 하나 아래의 대각원소 반환
print(matrix.diagonal(offset=-1))
[4 8]

- diagonal 메서드는 원본 배열의 뷰를 반환하므로 반환된 배열의 원소를 바꾸려면 배열을 복사하여 사용해야 함

- copy 메서드를 이용하여 행렬을 복사하면 원소 변경 가능

# diagonal 메서드는 원본 배열의 뷰를 반환하므로 원소 변경 불가 -> 오류 발생
a = matrix.diagonal()
a[0] = 10
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-57-88fe5a9b0ebf> in <module>()
----> 1 a[0] = 10

ValueError: assignment destination is read-only

# copy 메서드를 이용하여 만든 배열은 원소 변경 가능
a = matrix.diagonal().copy()
print(a)
[1 5 9]

a[0] = 10
print(matrix)
[[1 2 3]
 [4 5 6]
 [7 8 9]]

- 넘파이의 diag 메서드도 대각원소 반환

- 넘파이의 diag 메서드는 1차원 배열이 주어졌을때 역으로 대각행렬 반환

# 넘파이의 diag 메서드를 이용한 대각원소 추출
a = np.diag(matrix)
print(a)
[1 5 9]

# 넘파이의 diag 메서드는 1차원 배열 입력시 대각 행렬로 반환
print(np.diag(a))
[[1 0 0]
 [0 5 0]
 [0 0 9]]

 

행렬의 대각함 계산하기
import numpy as np

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
                   
# trace 메서드를 사용하여 대각합(대각원소의 합) 반환
matrix.trace()
15

# diagonal, sum 메서드를 이용하여 대각합 구하기
sum(matrix.diagonal())
15

# trace 메서드로 offset 매개변수 사용 가능
# 주 대각선 하나 위의 대각원소 합 구하기
matrix.trace(offset=1)
8

 

고윳값과 고유벡터 찾기

- 넘파이의 linalg.eig 메서드 사용

import numpy as np

matrix = np.array([[1, -1, 3],
                   [1, 1, 6],
                   [3, 8, 9]])

# 넘파이의 linalg.eig 메서드를 이용한 고유값과 고유벡터 값 구하기 
eigenvalues, eigenvectors = np.linalg.eig(matrix) 

# 고유값
eigenvalues
array([13.55075847,  0.74003145, -3.29078992])

# 고유벡터
eigenvectors
array([[-0.17622017, -0.96677403, -0.53373322],
       [-0.435951  ,  0.2053623 , -0.64324848],
       [-0.88254925,  0.15223105,  0.54896288]])

- 고유벡터는 머신러닝 라이브러리에서 널리 사용

- 행렬 A로 표현되는 선형변환 적용 시 고유벡터는 스케일만 바뀌는 벡터(방향은 x)

- 공식으로 나타내면 Av = λ

- A가 정방행렬일 때 λ는 고윳값, v는 고유벡터

 

- 대칭행렬일 경우 linalg.eigh 메서드를 이용하여 고윳값, 고유벡터 더 빠르게 계산 가능

- (주의) linalg.eigh 메서드는 입력값이 대칭행렬인지 검사 안함

# 대칭행렬
matrix = np.array([[1, -1, 3],
                    [-1, 1, 6],
                    [3, 6, 9]])
 
# 대칭행렬의 경우  linalg.eigh 메서드 이용
eigenvalues, eigenvectors = np.linalg.eigh(matrix)

# 고윳값
eigenvalues
array([-3.47535395,  1.84536862, 12.62998534])

# 고유벡터
eigenvectors
array([[-0.48107069, -0.85602522,  0.18918723],
       [-0.73926367,  0.51210152,  0.43731139],
       [ 0.47123265, -0.07051844,  0.87918538]])

 

점곱 계산하기
import numpy as np

# 벡터 생성
vector_a = np.array([1,2,3])
vector_b = np.array([4,5,6])

# 넘파이의 dot 메서드를 이용한 점곱
np.dot(vector_a, vector_b)
32

- 두 벡터의 점곱은 아래 그림과 같이 정의

- ai는 벡터 a의 i 번째 원소

- 넘파이 dot 메서드를 사용하여 점곱 가능

 

- 파이썬 3.5 이상에서 @ 연산자 사용 가능

# @ 연산자를 이용한 점곱
vector_a @ vector_b
32

 

- (주의) @ 연산자는 np.dot이 아니라 np.matmul 메서드. 스칼라 베열에 사용 불가

# 스칼라 배열 생성
scalar_a = np.array(1)
scalar_b = np.array(2)

# 넘파이의 dot 메서드 이용한 점곱(결과 잘 나옴)
np.dot(scalar_a, scalar_b)

# @ 연산자 이용시 오류
scalar_a @ scalar_b
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-85-019764208522> in <module>()
----> 1 scalar_a @ scalar_b

ValueError: matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)

 

행렬 덧셈과 뺄셈
import numpy as np

# 행렬 생성
matrix_a = np.array([[1, 1, 1],
                     [1, 1, 1],
                     [1, 1, 2]])

matrix_b = np.array([[1, 3, 1],
                     [1, 3, 1],
                     [1, 3, 8]])
                     
# 행렬 덧셈
np.add(matrix_a, matrix_b)
array([[ 2,  4,  2],
       [ 2,  4,  2],
       [ 2,  4, 10]])
       
# 행렬 뺄셈
np.subtract(matrix_a, matrix_b)
array([[ 0, -2,  0],
       [ 0, -2,  0],
       [ 0, -2, -6]])
       
# 간단히 +, - 이용하여 덧셈, 뺄셈 가능
matrix_a + matrix_b
array([[ 2,  4,  2],
       [ 2,  4,  2],
       [ 2,  4, 10]])

 

행렬 곱셈

- 넘파이의 dot 메서드 사용

import numpy as np

# 행렬 생성
matrix_a = np.array([[1, 1],
                     [1, 2]])

matrix_b = np.array([[1, 3],
                     [1, 2]])

# 넘파이의 dot 메서드 사용하여 행렬 곱셈
np.dot(matrix_a, matrix_b)
array([[2, 5],
       [3, 7]])
       
# @ 연산자 이용하여 행렬 곱셈
matrix_a @ matrix_b
array([[2, 5],
       [3, 7]])
       
# * 연산자로 원소별 곱셈
matrix_a * matrix_b
array([[1, 3],
       [1, 4]])

 

- np.dot 메서드는 다차원 배열에도 적용 가능

- 첫번째 배열의 마지막 차원과 두번째 배열의 끝에서 두번째 차원이 같아야 함

- (a, b, c, D) 크기의 배열과 (e, f, D, h) 크기의 배열

- 두 배열의 점곱 결과는 (a, b, c, e, f, h) 크기의 배열

- (주의) np.matmul과 @ 연산자는 다차원 배열을 마지막 두 차원이 단순히 쌓인것으로 취급

- np.matmul과 @ 연산자를 적용하기 위해서는 각 차원의 크기가 같거나 한 차원이 1이어야 함(a, e가 같거나 한쪽이 1 ...)

- 연산 결과는 (a', b', c, h), a'는 a와 e 중에서 1이 아닌값, b'는 b와 f중에서 1이 아닌 값

# 행렬 생성
a = np.random.rand(2, 1, 4, 5)
b = np.random.rand(1, 3 ,5, 6)

# np.dot 메서드 사용한 배열의 크기
np.dot(a, b).shape
(2, 1, 4, 1, 3, 6)

# np.matmul 메서드 사용한 배열의 크기
np.matmul(a, b).shape
(2, 3, 4, 6)

 

역행렬

- 넘파이의 linalg.inv 메서드 이용

import numpy as np

matrix = np.array([[1, 4],
                   [2, 5]])
                   
# np.linalg.inv 메서드를 이용하여 역행렬 구하기
np.linalg.inv(matrix)
array([[-1.66666667,  1.33333333],
       [ 0.66666667, -0.33333333]])       

- 정방행렬 A의 역행렬은 다음 식의 두번째 행렬 A^-1

- I는 단위행렬

- A의 역행렬이 존재한다면 linalg.inv 메서드로 구할 수 있음

- 행렬과 그 행렬의 역행렬을 곱하면 단위행렬 나옴

# 행렬과 역행렬 곱
matrix @ np.linalg.inv(matrix)
array([[1.00000000e+00, 0.00000000e+00],
       [1.11022302e-16, 1.00000000e+00]])

# 정방행렬이 아닌 행렬의 역행렬(유사 역행렬)은 np.pinv 메서드 이용
matrix = np.array([[1,4,7],
                   [2,5,8]])

np.linalg.pinv(matrix)       
array([[-1.16666667,  1.        ],
       [-0.33333333,  0.33333333],
       [ 0.5       , -0.33333333]])

 

난수 생성하기
import numpy as np

# 결과를 동일하게 하기 위해 초기값 설정
np.random.seed(0)

# 0.0과 1.0 사이에서 세 개 실수 난수 생성
np.random.random(3)
array([0.5488135 , 0.71518937, 0.60276338])

# 1과 10 사이에서 세 개 정수 난수 생성
np.random.randint(0, 11, 3)
array([3, 7, 9])

# 설정한 분포에서 난수 생성 가능
# 평균 0.0, 표준편차 1.0인 정규분포에서 세 개 난수 생성
np.random.normal(0.0, 1.0 ,3)
array([-1.42232584,  1.52006949, -0.29139398])

# 평균 0.0, 스케일 1.0인 로지스틱 분포에서 세 개 난수 생성
np.random.logistic(0.0, 1.0, 3)
array([-0.98118713, -0.08939902,  1.46416405])

# 1.0보다 크거나 같고 2.0보다 작은 세 개 난수 생성
np.random.uniform(1.0, 2.0, 3)
array([1.47997717, 1.3927848 , 1.83607876])

- random, sample 메서드는 random_sample 메서드의 단순 별칭

- uniform 메서드에 최솟값을 0.0, 최댓값을 1.0으로 지정한 것과 동일

- np.random.random((2, 3)) =  np.random.sample((2, 3)) = np.random.uniform(0.0, 1.0, (2, 3))

np.random.random_sample((2, 3))
array([[0.33739616, 0.64817187, 0.36824154],
       [0.95715516, 0.14035078, 0.87008726]])
       
# rand 함수는 크기를 튜플이 아니라 개별적인 매개변수로 전달
np.random.rand(2, 3)
array([[0.47360805, 0.80091075, 0.52047748],
       [0.67887953, 0.72063265, 0.58201979]])
       
# randint 함수는 최솟값을 포함하고 최댓값은 포함하지 않는 정수 난수 생성
# random_integers 함수는 최댓값도 포함하나 삭제될 예정이므로 randint 사용 권함
np.random.randint(0, 1, 10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

# standard_normal 함수로 평균 0.0, 표준편차 1.0인 정규분포의 난수 생성
np.random.standard_normal((2, 3))
array([[-0.13309028,  1.59456053,  0.23043417],
       [-0.06491034, -0.96898025,  0.59124281]])
       
# randn 함수는 크기를 튜플이 아니라 개별적인 매개변수로 전달
np.random.randn(2, 3)
array([[-0.7827755 , -0.44423283, -0.34518616],
       [-0.88180055, -0.44265324, -0.5409163 ]])
       
# 그 외 자주 사용하는 함수들
# choice 함수는 배열의 원소 중에서 랜덤하게 지정된 횟수만큼 샘플 만듦
# 또는 0~정수-1 사이에 원소 중에서 램덤하게 원소 선택
np.random.choice([0, 1, 2], 5)
array([0, 1, 2, 2, 0])

# shuffle 함수는 배열 섞음
a = np.array([0, 1, 2, 3, 4])
np.random.shuffle(a)
a
array([0, 2, 3, 4, 1])

# permutation 함수는 입력된 배열의 복사본을 만들어서 섞은 후 반환
# 정수를 입력하면 0에서부터 정수-1까지 숫자 섞은 후 반환
np.random.permutation(a)
array([2, 0, 1, 3, 4])

np.random.permutation(5)
array([4, 1, 2, 0, 3])
반응형

'컴퓨터 > 파이썬을 활용한 머신러닝 쿡북' 카테고리의 다른 글

2. 데이터 적재  (0) 2020.07.17
21. 훈련된 모델 저장과 복원  (2) 2020.06.19
18. 나이브 베이즈  (0) 2020.06.19

댓글1