python Numpy 정리

행렬의 필요성

• 그림을 표시할 때는 행렬로 표시. 영상은 행렬
• 첫번째 해야할 일 > 그림을 2차원 행렬로 바꾼다
• 행렬을 나타내는 데이터형 numpy
• 자바는 행렬을 다루는 데이터형이 없다
• 행렬 맨 처음에 정답을 준다. 정답을 먼저 주는 학습 : 슈퍼바이스트링

numpy 사용법

import numpy as np

• 외부 코드를 불러올 때 import를 사용한다
• 함수를 사용할 때 type을 반드시 확인할 것

from numpy import exp

• numpy 중에서 필요로 하는 함수 exp 만 가져온다
• numpy를 붙여주지 않아도 된다
• 별로 좋지 않은 방법(커스텀 함수와 기존 함수의 이름이 헷갈린다)

vector / matrix 생성

• 선형대수에서 vecotr는 1차원 배열을 의미한 matrix는 2차원 배열. tensor는 3차원 배열.
• 4차원은 시간만 다른 것. 예를 들어 4차원은 동일한 토끼그림을 시간대에 따라 다르게 그려진 것

numpy vs list

A = [[1,0], [0, 1]]
B = [[1,1], [1,1]]
A+B
[[1, 0], [0, 1], [1, 1], [1, 1]]

• list를 사용하지 않는 이유는 A + B 시 행렬 연산이 안되기 때문이다.(리스트 연산이 되어서 리스트에 값이 추가됨)
• list로 행렬 연산을 하려면 for문을 돌려서 각 각 연산을 해줘야함.

Vector 생성

A = np.array([1,2,3])
B = np.array([4,5,6])

# vector A, B 출력
print("A ==", A, "B ==", B)

# vector A, B 형상 출력 => shape
print("A.shape ==", A.shape, ", B.shape ==", B.shape)

# vector A, B 차원 출력 => ndim
print("A.ndim==", A.ndim, "B.ndim ==", B.ndim)

C = A.reshape(1,3)
print(C.shape)
print(C.ndim)

A == [1 2 3] B == [4 5 6]
A.shape == (3,) , B.shape == (3,)
A.ndim== 1 B.ndim == 1
(1, 3)
2

• list와 달리 대괄호로 묶지 않고 괄호로 묶는다
• 대괄호 안에 대괄호가 있는 건 행렬, 숫자만 있으면 vector
• (3,) 는 1행에 3열이나 3행에 1열이라는 뜻이다. 또 벡터로 인식된다
• 모호하므로 reshape로 정확하게 잡아준다
• reshape를 해서 행렬로 인식되어서 차원이 1에서 2로 변경된다
• A.shape, A.ndim 숙지할 것
• 행렬의 사칙연산을 할 때 shape이 같아야 한다

행렬 생성

A = np.array([[1,2,3],[4,5,6]])
B = np.array([[-1,-2,-3],[-4,-5,-6]])

# matrix A, B형상 출력 => shape
print("A.shape ==", A.shape, "B.shape ==", B.shape)

# matrix A, B차원 출력
print("A.ndim ==", A.ndim, "B.ndim ==", B.ndim)

• vector처럼 대괄호로 묶지 않고 괄호로 묶는다
• 괄호안에 대괄호 안에 대괄호가 있음.
• 행렬이기 때문에 형상을 정확히 인식함

형상 변경

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

# vector C형상 출력 => shape
print("C.shape ==", C.shape)

# vector를 (1,3) 행렬로 형 변환
C = C.reshape(1, 3)

print("C.shape ==", C.shape)
C.shape == (3,)
C.shape == (1, 3)

• -1을 붙이는 경우는 행은 상관없고 열 크기로 만들어라
• 열을 만드는데 2,2,1 이런식으로 값이 비워지면 행렬을 만들 수 없으므로 에러가 나온다
• 이미지를 비교할 때 사용

형 변환 reshape

import numpy as np
A = np.array([[1,2,3,4]
            , [10,20,30,40]
            , [100,200,300,400]])

print(A.shape)

B = A.reshape(-1, 3)
print(B.shape)
print(B)
C = A.reshape(-1, 6)
print(C.shape)
print(C)

(3, 4)
(4, 3)
[[  1   2   3]
 [  4  10  20]
 [ 30  40 100]
 [200 300 400]]
(2, 6)
[[  1   2   3   4  10  20]
 [ 30  40 100 200 300 400]]

• reshape(-1, 6) 함수는 -1다음에 바꾸고 싶은 열 갯수를 입력한다

numpy broadcast

A = np.array([[1,2],[3,4]])
b = 5
print(A+b)

[[6 7]
 [8 9]]

C = np.array([[1,2],[3,4]])
D = np.array([4,5])
print(C+D)

[[5 7]
 [7 9]]

• 행렬 사칙연산 시 크기가 같아야하는데 broadcast로 행렬의 크기를 자동으로 변경시켜 계산한다
• 차원이 작은 쪽이 큰쪽의 행 단위로 반복적으로 숫자를 끼워 크기를 맞춤
• 행렬곱(dot product)일 땐 사용 안됨

다음 벡터를 numpy로 계산

A = (1 2)
B = (3 4)
T = (5 6)
(1-A)*A
T*(1-A)*A

• 수학 풀이((1-A)*A)

(1-(1 2)) * (1 2)
= (1 - 1 1 -2 ) * (1 2)
= (0 -1) * (1 2)
= (0 -2)

• 수학 풀이(T_(1-A)_A)

 (5 6)*(1-(1 2))*(1-2)
    = (5 6)* (0 -2)
    = (0 -12)
    ```

-   python

    ```
    C = np.array([[2, 3]])
    D = np.array([[4, 5]])
    T = np.array([[7, 8]])

    ```


print((1-C)_C)  
print(T_(1-C)\*C)

다음 행렬식을 계산

C = (2 3)  
D = (4 5)  
T = (7 8)  
(1-C)_C  
T_(1-C)\*C형상

• 수학풀이

(1-C) \* C  
\= (1 - (2 3)) \* (2 3)  
\= (-1 -2) \*(2 3)  
\= (-2 -6)

T\_(1-C)\*C  
\= (7 8)\_(-2 -6)  
\= (-14 -48)

• 파이썬

C = np.array(\[\[2, 3\]\])  
D = np.array(\[\[4, 5\]\])  
T = np.array(\[\[7, 8\]\])

print((1-C)_C)  
print(T_(1-C)\*C)

미분,확률,통계,평균(시그마) => 공식이 무엇을 의미하는지 이해 필요

행렬 곱(dot product)

A = np.array(\[\[1,2,3\],\[4,5,6\]\]) # 2x3행렬  
B = np.array(\[\[-1,-2\],\[-3,-4\],\[-5,-6\]\])

### (2X3)dot porduct (3X2) == (2X2) 행령

C = np.dot(A, B) #행렬 곱 수행  
#matrix A, B 형상 출력=>shape  
print("A.shape ==", A.shape, "B.shape ==", B.shape)  
print("C.shape ==", C.shape)  
print(C)

• 2X2 . 2X2일 때 2X(2 . 2)X2 숫자가 같아야 한다
• 그림판에서 그림그릴 때, 지울 때
• 사진 필터 같은게 기존 사진(행렬)에 필터(행렬)을 행렬 곱한 결과
• 이렇게 2X(2 . 2)X2 맞춰야 하는 이유?
• 행렬곱을 사용하면 어떤 이미지에 효과를 주고 싶을 때 사칙연산은 행,열을 맞춰줘야 하지만 행렬곱은 가운데만 맞춰주면 된다
• 행렬곱은 원본 크기와 무관하게 다양한 데이터 조합으로 다양한 데이터를 만들 수 있다.

전치행렬

A = np.array(\[\[1,2\],\[3,4\],\[5,6\]\])  
B = A.T  
print("A.shape ==", A.shape, ", B.shape ==", B.shape)  
print(A)  
print(B)

A.shape == (3, 2) , B.shape == (2, 3)  
\[\[1 2\]  
\[3 4\]  
\[5 6\]\]  
\[\[1 3 5\]  
\[2 4 6\]\]

• 행과 열이 바꿔서 나타내는 행렬곱
• 행렬.T 를 하면 행렬의 전치행렬을 구할 수 있다

C = np.array(\[1,2,3,4,5\]) # vector, matrixx 아님  
D = C.T # c는 vector 이므로 transpose 안됨  
E = C.reshape(1, 5) # 1x5 matrix  
F = E.T # E의 전치행렬  
print("C.shape ==", C.shape, ", D.shape ==", D.shape)  
print("E.shape ==", E.shape, ". F.shape ==", F.shape)  
print(D)  
print(F)

C.shape == (5,) , D.shape == (5,)  
E.shape == (1, 5) . F.shape == (5, 1)  
\[1 2 3 4 5\]  
\[\[1\]  
\[2\]  
\[3\]  
\[4\]  
\[5\]\]

• 벡터는 전치행렬이 안되고 행렬만 가능하다

정규화

• 정규화는 너무 큰 값은 데이터타입 크기가 초과해 저장할 수 없으므로 최대값을 모든 값에 곱해줘서 0 ~ 1사이의 값을 만들어서 데이터를 저장가능하게 만들고 크기를 줄인다(원하는 곳으로 위치도 이동시킬 수 있다)
• 최대값이 0인 경우?최대, 최소값을 구한 후 위치 이동 후 정규화
• 머신러닝의 모든 데이터는 정규화해야한다
• 1 -6 -15 = -22
• 2 -8 -18 = -28
• 4 -15 -30 = -49
• 8 -20 -36 = -64

미분
현재몸무게 n인데 닭다리 하나 먹었으면 몸무게 얼마나 변할까? 미분으로 구할 수 있다

indexing, slicing

X = np.array(\[\[7,5,3,1\],\[1,2,3,4\],\[4,0,2,8\]\])  
A = X.reshape(-1, 3)  
B = A\[0:2, 1:2\]  
C = A\[1:, :-1\]

• A[0:2, 1:2] 에서 콤마 앞에 있는건 행, 뒤에 있는 건 열을 의미한다
• 0:2는 행의 0번 index부터 3번 index 앞까지를 의미한다
• 1:2는 열의 1번 index부터 2번 index 앞까지를 의미한다
• [: , 0] : 모든 행에 대해서 0번째 index를 뽑아낸다

[[7 5 3]
[1 1 2]
[3 4 4]
[0 2 8]]

loadtxt

import numpy as np  
loaded\_data = np.loadtxt('./data-01.csv', delimiter=',', dtype=np.float32)  
print(type(loaded\_data))  
print(loaded\_data.shape)  
x\_data = loaded\_data\[:, 0:-1\]  
t\_data = loaded\_data\[:, \[-1\]\]

• csv 파일 데이터를 행렬로 만든다
• 정답은 맨 앞에 있거나 끝에 있다(T는 맨 뒤에 있어서 T에서 마지막 열의 값을 주고있다)
• X는 값
• T는 정답

itorator

A = np.array(\[\[10,20,30,40\],\[50,60,70,80\]\])  
print(A, '\\n')  
#행렬 A의 iterator 생성  
it = np.nditer(A, flags=\['multi\_index'\], op\_flags=\['readwrite'\])  
while not it.finished:  
idx = it.multi\_index  
print('index=', idx, ', type(idx)=', type(idx), ', value=', A\[idx\])  
it.iternext()

\[\[10 20 30 40\]  
\[50 60 70 80\]\]

index= (0, 0) , type(idx)= <class 'tuple'> , value= 10  
index= (0, 1) , type(idx)= <class 'tuple'> , value= 20  
index= (0, 2) , type(idx)= <class 'tuple'> , value= 30  
index= (0, 3) , type(idx)= <class 'tuple'> , value= 40  
index= (1, 0) , type(idx)= <class 'tuple'> , value= 50  
index= (1, 1) , type(idx)= <class 'tuple'> , value= 60  
index= (1, 2) , type(idx)= <class 'tuple'> , value= 70  
index= (1, 3) , type(idx)= <class 'tuple'> , value= 80

• 데이터를 차례대로 가져오고 싶을 때 쓴다(for문과 비슷)

• 행을 기준으로 순서대로 가져온다

• 머신러닝은 기울기와 y절편을 찾는 것

• 그것이 학습. 기울기와 비슷한 데이터를 만들거나 찾는게 목표이다

random numpy 함수

• X = np.array([2,3,4,5])
• numpy 객체의 값을 전부 더하는 함수 np.sum(X)
• numpy 객체의 값의 exp 구함 np.exp(X)
• numpy 객체의 값을 log를 구함 np.log(X)

X = np.array(\[2,4,6,8\])  
print("np.max(x) ==", np.max(X))  
print("np.min(x) ==", np.min(X))  
print("np.argmax(X) ==", np.argmax(X))  
print("np.argmin(X) ==", np.argmin(X))

X = np.array(\[\[2,4,6\], \[1,2,3\], \[0,5,8\]\])  
print("np.max(X) ==", np.max(X, axis=0))  
print("np.min(X) ==", np.min(X, axis=0))  
print("np.max(X) ==", np.max(X, axis=1))  
print("np.min(X) ==", np.min(X, axis=1))

• max는 최대값 min은 최소값
• argmax 최대값이 있는 곳의 인덱스를 리턴
• 입력값 x가 01사이의 값일 때 행렬곱으로 곱해도 01 소수점. 그래서 가장 큰 값, 작은 값을 쉽게 찾으려면 argmax,argmin으로 찾는다
• axis 1은 기준이 행을 기준으로 최대값,최소값을 빼낸다. 0은 열을 기준으로 빼내는 데 거의 쓰지 않는다

matplotlib, scatter plot

• 데이터를 그려보는 함수

import matplotlib.pyplot as plt  
import numpy as np

# 주피터 노트북을 사용하는 경우 노트북 내부에 그림 표시

%matplotlib inline

#x data, y data 생성  
x\_data = np.random.rand(100)  
y\_data = np.random.rand(100)

plt.title('scatter plot')  
plt.grid()  
plt.scatter(x\_data, y\_data, color='b', marker='x')  
plt.show()

import matplotlib.pyplot as plt  
%matplotlib inline

x\_data = \[x for x in range(-5, 5)\]  
y\_data = \[y\*y for y in range(-5, 5)\]  
plt.title('line plot')  
plt.grid()  
plt.plot(x\_data, y\_data, color='b')  
plt.show()