A B C d E F G H I K L M N O P Q R S T U V W Z A statsmodels.ap.stats.anova_lm(x) statsmodels.formula.api.ols 에 의해 생성되는 모형 즉, 클래스 인스턴스(x)를 인수로 받아 anova를 실행합니다. np.argsort(x, axis=-1, kind=None) 객체 x를 정렬할 경우 각 값에 대응하는 인덱스를 반환합니다. Axis는 기준 축을 지정하기 위한 매개변수로서 정렬의 방향을 조정할 수 있음(-1은 기본값으로 마지막 축) pandas.Series.autocorr(lag=1) lag에 전달한 지연수에 따른 값들 사이의 자기상관을 계산 B scipy.stats.bernoulli(x, p) 베르누이분포에 관련된 통계량을 계산하기 위한 클래스를 생성합니다. x: 랜덤변수 p: 단일 시행에서의 확률 scipy.stats.binom(x, n, p) 이항분포에 관련된 통계량을 계산하기 위한 클래스를 생성합니다. x: 랜덤변수 n: 총 시행횟수 p: 단일 시행에서의 확률 C scipy.stats.chi2.pdf(x, df, loc=0, scale=1) 카이제곱분포의 확률밀도함수를 계산 $$f(x, k) =\frac{1}{2^{\frac{k}{2}−1}Γ(\frac{k}{2})}x^{k−1}\exp\left(−\frac{x^2}{2}\right)$$ x: 확률변수 df: 자유도 pd.concat(objs, axis=0, join=’outer’, …) 두 개이상의 객체를 결합한 새로운 객체를 반환. objs: Series, DataFrame 객체. Axis=0은 행단위 즉, 열 방향으로 결합, Axis=1은 열단위 즉, 행 방향으
Convolutional Neutral Network(CNN)
CNN
CNN(Convolutional Neural Networks)은 이미지 분류, 객체 감지, 분할 등과 같은 이미지 및 비디오와 관련된 기계 학습 문제를 해결하는 것으로 알려진 딥 러닝 모델 유형입니다. CNN은 학습 가능한 매개변수를 공유하는 함성곱충(convolutional layer)이라는 특수한 유형의 레이어를 사용하기 때문입니다. 가중치 또는 매개변수 공유는 이미지에서 학습할 패턴(예: 가장자리 또는 윤곽)이 이미지의 픽셀 위치와 무관하다고 가정하기 때문에 작동합니다.
CNN의 구성; CONV: 합성곱 연산 → 활성화 함수:ReLU 등 → POOL:풀링연산
적용이유
- 다층 퍼셉트론 : 이미지를 1차원 텐서로 변환하여 입력층에 입력, 그러므로 공간적/지역적 구조의 정보(spatial/topological information)가 유실
- 합성곱 신경망: 공간적인 구조 정보를 보존하면서 학습할 수 있는 방법
- 공간 구조의 정보 : 이미지는 높이, 너비, 채널로 구성된 3차원 텐서
- 높이는 세로방향의 픽셀 수, 너비는 가로방향을 픽셀 수 채널은 색성분을 의미
- 예를들어 흑백이미지는 채널수가 1. 각 픽셀은 0~255사이의 값
CNN의 주요포인트는 이미지 전체 보다는 부분에 집중하며 집중한 정보와 주변정보들의 연관성을 찾는 것입니다. 예를 들어 새의 이미지에서 다른 형태들과 두드러진 특징은 부리에 있습니다. 그러므로 부리의 유무로 다른 형태들과의 구분할 수 있습니다. 이러한 이유로 전체를 파악하는 것보다는 부리부분 만을 조사하는 것이 더 효율적일 것입니다. 이와같은 중요부분을 이해하고자 하는 모델이 CNN입니다.
각 새들마다 부리의 위치에 차이가 있습니다. 그러므로 부리의 유무와 함께 주변 부분과의 연관성도 분석을 위한 대상이 됩니다.
이미지는 2차원 행렬로 나타낼 수 있습니다. CNN에는 이미지 행렬의 특정부분을 선택하기 위한 커널(필터)를 고려합니다. 이 커널의 모양과 초기값은 랜덤으로 지정하며 학습을 통해 적정값으로 조정됩니다. 즉, 입력값인 행렬의 모든 영역에 커널을 반복 적용하여 일정한 패턴을 찾는 것이 CNN 모델의 목적입니다.
이 목적을 위해 입력 행렬과 커널간의 동일 차원의 요소들의 곱을 실행합니다. 그러므로 입력행렬과 커널의 형태는 같아야 합니다.이 과정을 합성곱이라 합니다.
다음 코드는 이미지의 높이×너비의 텐서 input과 가중치를 나타내는 kernel 행렬(일반적으로 3 × 3 또는 5 × 5 차원으로 여기서는 3 ×3)의 곱의 합을 나타낸 것입니다. 이미지 5 × 5 차원이므로 3 × 3인 kernel 차원과의 곱 연산을 위해서는 이미지에서 6개의 3 × 3 부분 행렬을 추출할 수 있습니다. 결과로서 각 곱의 합으로 구성된 3 &time;3의 행렬이 반환됩니다.
import numpy as np import pandas as pd
inPut=np.array([[1,2,3,4,5], [2,1,0,1,2],[3,0,1,1,0],[1,4,1,1,2], [2,1,1,0,0]]) inPut
array([[1, 2, 3, 4, 5],
[2, 1, 0, 1, 2],
[3, 0, 1, 1, 0],
[1, 4, 1, 1, 2],
[2, 1, 1, 0, 0]])
kernel=np.array([[1,0,1], [1,0,1], [0,1,0]]) kernel
array([[1, 0, 1],
[1, 0, 1],
[0, 1, 0]])
result=np.zeros((3,3))
for i in range(3):
for j in range(3):
result[i,j]=(inPut[i:(i+3), j:(j+3)]*kernel).sum()
result
array([[ 6., 9., 11.],
[10., 4., 4.],
[ 7., 7., 4.]])
위 코드의 일부인 첫번째 추출 이미지와 kernel을 곱한것에 대한 진행은 다음 그림 1과 같이 나타낼 수 있습니다.
위 과정과 같이 합성곱에 의한 결과 행렬은 특성맵(feature map)이라고 합니다.
위 과정의 참여하는 각 객체의 차원은 다음과 같습니다.
- 입력: inr × inc
- 커널: kr × kc
- 특성맵: (inr-kr+1) × (inc-kc+1)
Padding과 Stride
위의 특성맵의 차원은 3 × 3으로 입력 차원보다 감소했습니다. 즉, 손실이 발생한 것입니다. 이 손실의 부분을 임의의 값으로 채워줌으로서 입력과 동일한 형태로 변형할 수 있습니다. 이러한 과정을 패딩(Padding)이라 합니다.
위의 경우 입력 행렬의 차원을 7 × 7로 변형함으로서 특성맵의 형태를 5 × 5로 변경할 수 있습니다.
inPut1=np.zeros((7,7))
for i in range(1, 6):
for j in range(1, 6):
inPut1[i, j]=inPut[(i-1), (j-1)]
inPut1
array([[0., 0., 0., 0., 0., 0., 0.],
[0., 1., 2., 3., 4., 5., 0.],
[0., 2., 1., 0., 1., 2., 0.],
[0., 3., 0., 1., 1., 0., 0.],
[0., 1., 4., 1., 1., 2., 0.],
[0., 2., 1., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0.]])
featureMap=np.zeros((5,5))
for i in range(5):
for j in range(5):
featureMap[i,j]=(inPut1[i:(i+3),j:(j+3)]*kernel).sum()
featureMap
array([[ 4., 5., 6., 9., 6.],
[ 6., 6., 9., 11., 5.],
[ 2., 10., 4., 4., 4.],
[ 6., 7., 7., 4., 2.],
[ 5., 5., 6., 4., 1.]])
위의 과정에서 padding을 적용하지 않은 경우 최종 특성맵은 3 × 3 차원입니다. 이 결과는 커널과 합성곱을 위해 입력 행렬에서 3 × 3 행렬을 각 행과 열을 한칸씩 이동하면서 선택한 결과입니다. 이 특성맵의 차원을 2 × 2로 만들기 위해서는 대상 행렬을 추출하기 위해 두 칸 씩이동하여 선택하여야 합니다. 이와 같이 특성맵의 차원을 조정하기 위해 입력창의 이동 간격을 스트라이드(stride)라고 합니다.
다음은 원시행렬의 상,하, 좌, 우에 padding을 첨가하고(inPut1) stride를 2로 하는 경우의 특성맵입니다.
featureMap2=np.zeros((3,3))
rng=np.arange(0, 7, 3)
m=0
for i in range(1, len(rng)):
n=0
for j in range(1, len(rng)):
featureMap2[m, n]=(inPut1[rng[i-1]:rng[i], rng[j-1]:rng[j]]*kernel).sum()
n+=1
m+=1
featureMap2
array([[4., 9., 0.],
[6., 4., 0.],
[0., 0., 0.]])
입력 대상과 커널의 합성곱에 의한 특성맵의 형태는 다음과 같이 수학적으로 정리할 수 있습니다.
$$\begin{align}&O_h = \text{floor}\left(\frac{I_h-K_h}{S}+1 \right)\\ &O_w = \text{floor}\left(\frac{I_w-K_w}{S}+1 \right)\\ &O_h = \text{floor}\left(\frac{I_h-K_h+2P_h}{S}+1 \right)\\ &O_w = \text{floor}\left(\frac{I_w-K_w+2P_w}{S}+1 \right)\\ &\begin{aligned}&I_h:\text{입력높이} &I_w: \text{입력너비}\\ &K_h:\text{커널높이} &K_w: \text{커널너비}\\ &P_h:\text{패딩높이} &P_w: \text{패딩너비}\\ &S:\text{Stride}&\\ &\text{floor}:\text{소수점이하 절삭함수}&\\ &O_h:\text{특성맵높이} &O_w: \text{특성맵너비}\end{aligned}\end{align}$$위 예는 2차원 입력에 대한 것으로 이 과정은 3차원 텐서로 확장될 수 있습니다.
퍼셉트론의 경우는 입력의 모든 요소에 가중치가 적용됩니다. 예를 들어 그림 2에서 나타낸 것과 같이 3 × 3의 2차원 입력은 입력층에 1차원 벡터로 구성되며 가중치는 각 요소에 적에 적용되어야 36개의 가중치가 필요합니다.
그림 2와 같이 퍼셉트론은 전파과정에 입력층의 모든 요소가 가중치가 적용됩니다. 반면에 그림 3과 같이 합성곱 모형에서는 특성맵의 한 원소는 입력이미지에서 커널의 차원과 같은 차원의 원소들을 추출하여 합성곱 연산을 실행한 결과가 됩니다. 즉, 퍼셉트론에서는 은닉층의 유닛 하나의 결과를 위해 입력층의 모든 요소들이 적용되어야 하지만 합성곱 모형에서는 일부의 요소들만 연결됩니다. 합성곱의 결과인 특성맵이 되는 은닉층을 합성곱층(convolution layer)라고 합니다.
CNN의 구조
다층퍼셉트론(MLP)의 경우 완전연결계층(fully coonected layer 또는 Dense layer)로 연결되어 있어 Affine 층과 활성화함수를 통과하는 구조를 갖는 반면에 CNN은 합성곱층과 폴링층(pooling layer)를 활성화 함수 앞뒤에 배치하는 구조를 갖습니다.
위에서 소개한 것과 같이 Convolution Layer(합성곱 층)에서 특성맵이 생성된 결과를 활성함수에 의해 처리됩니다. 그 이후에 Pooling 층을 통과하게 됩니다.
Pooling은 특성맵의 차원 축소를 위해 실시합니다. 예를 들어 28 × 28 크기의 이미지를 5 × 5 크기의 filter(kenel)로 합성곱을 실시하면 특성맵의 차원은 (28-5+1),(28-5+1)로 24 × 24가 됩니다. 또한 이러한 커널을 10개 적용하고 1차원 벡터화(flatten)하면 5760의 크기로 동일한 갯수의 가중치가 필요하게 됩니다. 이렇게 증가한 요소들의 수는 overfitting(과적합)의 원인이 됩니다. 이를 방지하기 위해 요소들의 갯수를 감소시킬 필요가 있습니다.이 과정을 pooling이라 합니다.
(28-5+1)*(28-5+1)*10
5760
Pooling의 대표적인 방법으로 특성맵에 일정한 구간에서 최대값만을 추출하는 Max Pooling과 그 구역의 평균값을 계산하여 사용하는 Average Pooling이 있습니다. 예를 들어 4 × 4의 특성맵을 2 × 2로 축소하기 위해 각 2행, 2열 씩 구분하여 원 행렬로부터 부분행렬을 생성합니다. 이 분할은 numpy 패키지의 split(x, 부분을 위한 인덱스, axis=0) 함수를 사용하여 다음과정에 의해 실행됩니다.
- 행 단위로 분할합니다. np.split(x, index, axis=0)
- 1번의 결과 행렬 각각을 열 단위로 분할 합니다. np.split(x, index, axis=1)
- 2번의 각 결과 행렬에서 최대값 또는 평균값을 계산하여 행렬로 전환합니다.
| 40 | 15 | 72 | 22 | ➪ | $\begin{matrix}40&15\\43&82\end{matrix}$ | $\begin{matrix}72&22\\75&7\end{matrix}$ |
| 43 | 82 | 75 | 7 | |||
| 34 | 49 | 95 | 75 | $\begin{matrix}34&49\\85&47\end{matrix}$ | $\begin{matrix}95&75\\63&31\end{matrix}$ | |
| 85 | 47 | 63 | 31 |
위의 분할된 각 부분에서 최대값을 계산한 결과가 Max Pooling입니다.
| 82 | 75 |
| 85 | 95 |
위의 분할된 각 부분에서 평균값을 계산한 결과가 average Pooling입니다.
| 45 | 44 |
| 53.75 | 66 |
np.random.seed(2) featMap=np.random.randint(0, 100, size=(4,4)) featMap
array([[40, 15, 72, 22],
[43, 82, 75, 7],
[34, 49, 95, 75],
[85, 47, 63, 31]])
rowsplit=np.split(featMap, [2]) rowsplit
[array([[40, 15, 72, 22],
[43, 82, 75, 7]]),
array([[34, 49, 95, 75],
[85, 47, 63, 31]])]
colsplit=[np.split(i, 2, axis=1) for i in rowsplit] colsplit
[[array([[40, 15],
[43, 82]]),
array([[72, 22],
[75, 7]])],
[array([[34, 49],
[85, 47]]),
array([[95, 75],
[63, 31]])]]
maxPool=np.array([[colsplit[0][0].max(), colsplit[0][1].max()],[colsplit[1][0].max(), colsplit[1][1].max()]]) maxPool
array([[82, 75],
[85, 95]])
averagePool=np.array([[colsplit[0][0].mean(), colsplit[0][1].mean()],[colsplit[1][0].mean(), colsplit[1][1].mean()]]) averagePool
array([[45. , 44. ],
[53.75, 66. ]])
위 과정을 함수로 작성하면 다음과 같습니다.
def poolMat(x, nr, nc, option='max'):
def sameRowSplit(x, nr):
r, c=x.shape
if r % nr==0:
idx=np.arange(0, r, nr)[1:]
return(np.split(x, idx))
def sameColSplit(x, nc):
r, c=x.shape
if r % nc==0:
idx=np.arange(0, c, nc)[1:]
return(np.split(x, idx, axis=1))
rer=sameRowSplit(x, nr)
pr,pc=x.shape
poolMat=np.zeros((pr//nr, pc//nc))
if option == 'max':
for i in range(len(rer)):
poolMat[i, :]=[j.max() for j in sameColSplit(rer[i], nc)]
else:
for i in range(len(rer)):
poolMat[i, :]=[j.mean() for j in sameColSplit(rer[i], nc)]
return(poolMat)
maxP=poolMat(featMap, 2, 2, 'max') maxP
array([[82., 75.],
[85., 95.]])
averagePool=poolMat(featMap, 2, 2, 'avg') averagePool
array([[45. , 44. ],
[53.75, 66. ]])
위와 같이 합성곱-활성화 층과 풀링층의 단계를 반복한 후 나온 결과는 이미지와는 다른 특성값들로 구성된 행렬이 됩니다. 최종적으로 이 특성행렬을 1차원 벡터 데이터로 변형하여 퍼셉트론 또는 다중 퍼셉트론 모형에 대입합니다. 즉, Dense Layer(s)을 만들고 softmax 활성함수를 적용하여 최종 결과물을 출력합니다.
CNN 모델 구축
MNIST 데이터를 대상으로 CNN 모델을 구축합니다.
입력 벡터를 사용하는 대신 입력 텐서는 이제 회색조 MNIST 이미지에 대해 새로운 차원(높이, 너비, 채널) 또는 (image_size, image_size, 1) = (28, 28, 1)을 갖습니다. 이 입력 모양 요구 사항을 준수하려면 학습(train) 및 테스트 이미지의 크기를 조정해야 합니다.
import numpy as np from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Activation, Dense, Dropout from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten from tensorflow.keras.utils import to_categorical, plot_model from tensorflow.keras.datasets import mnist
#load mnist dataset (xtr, ytr),(xte, yte)=mnist.load_data() #label의 길이 numLabel=len(np.unique(ytr)) #label을 one-hot vector로 전환 ytr=to_categorical(ytr) yte=to_categorical(yte) ytr[1]
array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)
#입력 벡터의 형태 xtr.shape
(60000, 28, 28)
위 입력 벡터는 (배치, 높이, 너비)의 형태입니다. 이를 (높이, 너비, 채널)의 형태로 전환합니다. 이 데이터의 경우 흑백이므로 채널을 1이 됩니다.
imageSize=xtr.shape[1]
xtr=np.reshape(xtr, [-1, imageSize, imageSize, 1])
xte=np.reshape(xte, [-1, imageSize, imageSize, 1])
#데이터의 표준화
xtr=xtr.astype("float32")/255
xte=xte.astype("float32")/255
xtr[0].shape
(28, 28, 1)
CNN 신경망의 매개변수를 지정합니다. 다음 매개변수에서 filers는 각 층의 출력 크기를 지정하는 것입니다.
inputShape=(imageSize, imageSize, 1) batchSize=128 kernelSize=3 poolSize=2 filters=64 dropout=0.2CNN-ReLU-MaxPooling으로 구성한 모델을 구축합니다.
Sequential()클래스를 적용합니다.
model=Sequential()
model.add(Conv2D(filters=filters, kernel_size=kernelSize, activation='relu', input_shape=inputShape))
model.add(MaxPooling2D(poolSize))
model.add(Conv2D(filters=filters, kernel_size=kernelSize, activation='relu'))
model.add(MaxPooling2D(poolSize))
model.add(Conv2D(filters=filters, kernel_size=kernelSize, activation='relu'))
model.add(Flatten())
#정규화의 수단으로 dropout 층을 첨가
model.add(Dropout(dropout))
#출력층은 10차원의 원-핫 벡터
model.add(Dense(numLabel))
model.add(Activation("softmax"))
model.summary()
Model: "sequential_9"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d_12 (Conv2D) (None, 26, 26, 64) 640
_________________________________________________________________
max_pooling2d_8 (MaxPooling2 (None, 13, 13, 64) 0
_________________________________________________________________
conv2d_13 (Conv2D) (None, 11, 11, 64) 36928
_________________________________________________________________
max_pooling2d_9 (MaxPooling2 (None, 5, 5, 64) 0
_________________________________________________________________
conv2d_14 (Conv2D) (None, 3, 3, 64) 36928
_________________________________________________________________
flatten_4 (Flatten) (None, 576) 0
_________________________________________________________________
dropout_4 (Dropout) (None, 576) 0
_________________________________________________________________
dense_3 (Dense) (None, 10) 5770
_________________________________________________________________
activation_1 (Activation) (None, 10) 0
=================================================================
Total params: 80,266
Trainable params: 80,266
Non-trainable params: 0
_________________________________________________________________
원-핫 벡터를 위한 비용함수로 categorial_crossentropy, 최적화를 위해 adam, 분류작업의 신뢰도는 accuracy로 나타냅니다.
model.compile(loss="categorical_crossentropy", optimizer='adam', metrics=['accuracy'])
모델 훈련은 .fit() 매소드를 사용합니다.
model.fit(xtr, ytr, epochs=10, batch_size=batchSize)
Epoch 1/10
469/469 [==============================] - 55s 111ms/step - loss: 0.5883 - accuracy: 0.8134
Epoch 2/10
469/469 [==============================] - 53s 112ms/step - loss: 0.0699 - accuracy: 0.9783
Epoch 3/10
469/469 [==============================] - 54s 115ms/step - loss: 0.0507 - accuracy: 0.9844
Epoch 4/10
469/469 [==============================] - 55s 116ms/step - loss: 0.0389 - accuracy: 0.9879
Epoch 5/10
469/469 [==============================] - 54s 116ms/step - loss: 0.0314 - accuracy: 0.9907
Epoch 6/10
469/469 [==============================] - 57s 122ms/step - loss: 0.0290 - accuracy: 0.9912
Epoch 7/10
469/469 [==============================] - 54s 115ms/step - loss: 0.0252 - accuracy: 0.9918
Epoch 8/10
469/469 [==============================] - 57s 121ms/step - loss: 0.0217 - accuracy: 0.9931
Epoch 9/10
469/469 [==============================] - 63s 135ms/step - loss: 0.0180 - accuracy: 0.9939
Epoch 10/10
469/469 [==============================] - 55s 117ms/step - loss: 0.0172 - accuracy: 0.9942
<tensorflow.python.keras.callbacks.History at 0x7f77f57bbe80>
모델의 평가는 .evaluate()를 사용합니다.
model.evaluate(xte, yte, batch_size=batchSize, verbose=0)
[0.02676335722208023, 0.9915000200271606]
여기서 주요 변경 사항은 Conv2D 레이어의 사용입니다. ReLU 활성화 함수는 이미 Conv2D의 인수입니다. ReLU 기능은 Batch normalization layer가 모델에 포함될 때 Activation layer로 나올 수 있습니다. 배치 정규화는 훈련 중 불안정을 일으키지 않고 큰 학습률을 활용할 수 있도록 심층 CNN에서 사용됩니다.
댓글
댓글 쓰기