ML(KNN, Decision Tree), DL(RCNN, YOLO) educational slide

머신러닝/딥러닝 이론
김봄

Input Feature Extraction Classification Output
Input Feature Extraction + Classification Output
Machine Learning
Deep Learning

AI
인공지능
whffu@gmail.com
wlqdprkrhtlvdj@snu.ac.kr
W_W@naver.com
naver@line-com
@iamgroot.com
YES
YES
YES
NO
NO
이메일 유효성 검사 제품 평가 검사
김**: ★ ★ ★ ★ ★ 너무 좋아서 또 구매 했어요~~ 감사합니다^^
이**: ★ ★ ★ ★ ★ 제 인생템 >< 꺅꺅
송**: ★ ☆ ☆ ☆ ☆ 별 하나도 아깝습니다.. 이런 걸 제품이라고 ㅡㅡ;;
황**: ★ ★ ★ ☆ ☆ 아이엠그루트
최**: ★ ★ ★ ★ ★ 아니 이런 제품을 이 가격에 팔아도 되는 건가요? 당신은 도덕책!!
어떤 작업이 컴퓨터에게 쉽고 어떤 작업이 어려울까

인간은 어떻게 생각할까
0
1
AI
인공지능

인간은 어떻게 생각할까
0
1
고전적 분류 방법
Closing = Dilation(팽창) + Erosion(침식)
가
가
가
가
Dilation
Erosion
Counting Contours(윤곽의 개수 세기)
바깥 윤곽
안쪽 윤곽
AI
인공지능

0 분류 정확도
1 분류 정확도
Total 분류 정확도
84%
825 / 980 = 84.18367346938776
1122 / 1135 = 98.85462555066078
1947 / 2115 = 92.05673758865248
98%
92%
실패 케이스
import os
import cv2
import numpy as np
kernel = np.ones((5, 5), np.uint8)
ans = [0, 0]
dirs = ["0", "1"]
images = list(map(os.listdir, dirs))
labels = [2, 1]
if not os.path.exists("fail/"):
os.mkdir("fail/")
for i in range(2):
for file in images[i]:
img = cv2.imread(os.path.join(dirs[i], file), 0)
img = cv2.dilate(img, kernel)
img = cv2.erode(img, kernel)
ret, img = cv2.threshold(img, 127, 255, 0)
contours, _ = cv2.findContours(img, 1, 2)
if (len(contours) == labels[i]):
ans[i] += 1
else:
cv2.imwrite("fail/" + file, img)
total = [len(images[0]), len(images[1])]
for i in range(2):
print(f"{ans[i]} / {total[i]} = {ans[i] / total[i] * 100}")
def add(a, b):
return a + b
print(f"{add(*ans)} / {add(*total)} = {add(*ans) / add(*total) * 100}")
Code
AI
인공지능

28px
28px
𝑥!
𝑥"
𝑏𝑖𝑎𝑠 𝑣𝑎𝑙𝑢𝑒
𝑤!
𝑤"
𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛 𝑜𝑢𝑡
𝑥#$%
𝑤#$%
𝑤#$&(𝑏𝑖𝑎𝑠)
...
$ 𝑥! & 𝑤!
2155 장의 0,1 이미지 분류 정확도는 99.95%
,단지 785(784+1) 개의 실수(Real number) 값으로
AI
인공지능

CPU GPU
NPU
C/C++ CUDA
NVIDIA
GPU
AMD GPU ARM GPU
Intel CPU AMD CPU ARM CPU
TPU
(Google)
Mobile NPU
(Apple, Qualcomm, Samsung, HiSilicon)
CL
TensorFlow/PyTorch
H/W-type
H/W-level
Low-level
Application-level
AI
인공지능

NVIDIA GPU
(Train/Inference)
FPGA
(Inference)
NVIDIA Jetson tx2
(Inference)
AMD Radeon Pro
(Train/Inference)
CPU
(Inference)
Neural Stick
(Inference)
AI
인공지능

AI
인공지능
어떤 그래픽 카드를 구매해야 할까?
NVIDIA GPU
Tesla(2006) Fermi(2010) Kepler(2012) Maxwell(2014/2015)
Pascal(2016) Volta(2017) Turing(2018/2019) Ampere(2020)
Architecture
Purpose
GeForce
Quadro
Tesla
GeForce GTX 1080ti (11G)
GeForce GTX 1080 (8G)
Titan X (12G)
Titan Xp (12G)
Quadro GP100 (16G)
Quadro P6000 (24G)
Quadro P5000 (16G)
Quadro P4000 (8G)
Tesla P100 (16G)
GeForce RTX 2080ti (11G)
GeForce RTX 2080 super (8G)
GeForce RTX 2080 (8G)
GeForce GTX 1660 super (6G)
GeForce GTX 1650 super (4G)
Titan RTX (24G)
Quadro RTX 8000 (48G)
T4 (16G)
Titan V (12G)
Quadro GV100 (32G)
Tesla V100 (32G)
Tesla V100S (32G)
GPU구매 고려 사항: GDDR 크기, Tensor Cores, CUDA Cores
Quadro RTX A6000 (48G)
A10 (24G)
A40 (48G)
A100 (40G, 80G)

AI
인공지능
OPEN-AIR BLOWER
밀폐형 케이스의 경우 OPEN-AIR방식의 GPU는 발열로 인해 문제가 발생할 가능성이 매우 높음

AI/ML/DL
인공지능/머신러닝/딥러닝
Decision Tree
Support Vector Machine(SVM)
Random Forest
Artificial Neural Networks(ANN)
K-Nearest Neighbors(KNN)
K-Means
Principal Component Analysis(PCA)
Artificial Intelligence(인공지능)
Machine Learning(기계학습)
Supervised Learning
(지도학습)
Unsupervised Learning
(비지도학습)
Reinforcement Learning
(강화학습)
Q-Learning
Deep Learning(DNN, CNN, RNN, SNN)
DNN: Deep Neural Networks CNN: Convolutional Neural Networks RNN: Recurrent Neural Networks SNN: Spiking Neural Networks

Prediction
예측
Input
(입력)
Output
(출력)
0 Red
-1 Red
-3 Red
-4 Red
-5 Red
2 Blue
4 Blue
5 Blue
Input
(입력)
Prediction
(예측)
3
-2
1

Prediction
예측
Input
(입력)
Output
(출력)
0 Red
-1 Red
-3 Red
-4 Red
-5 Red
2 Blue
4 Blue
5 Blue
Input
(입력)
Prediction
(예측)
3
-2
1
3
1
-2

Prediction
예측
Input
(입력)
Output
(출력)
0 Red
-1 Red
-3 Red
-4 Red
-5 Red
2 Blue
4 Blue
5 Blue
Input
(입력)
Prediction
(예측)
3 Blue
-2 Red
1 Blue
3
1
-2
0.5 이상이면 Blue 일 수도 있다.
양수이면 Blue 인가?
2 이상이면 Blue 일 수도 있다.

Prediction
예측
Input
(입력)
Output
(출력)
0 Red
-1 Red
1 Red
2 Red
-5 Blue
-4 Blue
-3 Blue
4 Blue
5 Blue
Input
(입력)
Prediction
(예측)
3 ?
6 ?
−1 ≤ 𝑥 ≤ 2 이면 Red 인가?

Prediction
예측
𝑥& < 9 이면 Red 인가?
입력값을 제곱하여 (𝑥, 𝑥!)로
2차원 그래프로 확인

Prediction
예측
Input
(입력)
Output
(출력)
0 Red
-1 Red
1 Red
2 Red
-5 Blue
-4 Blue
-3 Blue
4 Blue
5 Blue
Input
(입력)
Prediction
(예측)
3 ?
6 ?
if-else로 구현할 수도 있다.
def predict(x: float):
if x > 3:
return "Blue"
else:
if x <= -2:
return "Blue"
else:
return "Red"
Python

Prediction
예측
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
0 0 Red
1 1 Red
1 3 Red
0 4 Red
-1 1 Red
-1 -2 Red
-2 3 Red
-2.5 -2.5 Red
-3 -1 Red
-3 2 Red
-4 0 Red
-4 3.5 Red
-4 -3 Red
1 -1 Blue
1 -3 Blue
2 0 Blue
2 -4 Blue
3 2 Blue
4 0 Blue
4.5 2.5 Blue
5 -2 Blue
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
-1 -1 ?
3 1 ?

Prediction
예측
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
0 0 Red
1 1 Red
1 3 Red
0 4 Red
-1 1 Red
-1 -2 Red
-2 3 Red
-2.5 -2.5 Red
-3 -1 Red
-3 2 Red
-4 0 Red
-4 3.5 Red
-4 -3 Red
1 -1 Blue
1 -3 Blue
2 0 Blue
2 -4 Blue
3 2 Blue
4 0 Blue
4.5 2.5 Blue
5 -2 Blue
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
-1 -1 ?
3 1 ?
ex) 5개의 가까운 점 중 많은 색상으로 결정.
가까운 점들을 확인하여 색상을 결정

Prediction
예측
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
0 0 Red
1 1 Red
1 3 Red
0 4 Red
-1 1 Red
-1 -2 Red
-2 3 Red
-2.5 -2.5 Red
-3 -1 Red
-3 2 Red
-4 0 Red
-4 3.5 Red
-4 -3 Red
1 -1 Blue
1 -3 Blue
2 0 Blue
2 -4 Blue
3 2 Blue
4 0 Blue
4.5 2.5 Blue
5 -2 Blue
1.5𝑥# − 𝑥$ − 1.5 의 값이 음수이면 Red 인가?
𝑦 = 1.5𝑥 − 1.5 직선 위에 있다면 Red 인가?

Prediction
예측
Input 0
(𝑿𝟎)
Input 1
(𝑿𝟏)
Output
(출력)
0 0 Red
1 1 Red
1 3 Red
0 4 Red
-1 1 Red
-1 -2 Red
-2 3 Red
-2.5 -2.5 Red
-3 -1 Red
-3 2 Red
-4 0 Red
-4 3.5 Red
-4 -3 Red
1 -1 Blue
1 -3 Blue
2 0 Blue
2 -4 Blue
3 2 Blue
4 0 Blue
4.5 2.5 Blue
5 -2 Blue
1.5𝑥# − 𝑥$ − 1.5 의 값이 음수이면 Red 인가?
𝑦 = 1.5𝑥 − 1.5 직선 위에 있다면 Red 인가?
( 1 , 3 ) 은 Red,
1.5 / 1 − 3 − 1.5 = −3
( 5 , 2 ) 는 Blue,
1.5 / 5 − (−2) − 1.5 = 8

Prediction
예측
대략 적절한 것 같은데..
이 예측은 신뢰성이 있나?
알 수 없다.
점 (-4, -1)은 Red가 확실한가?
데이터가 너무 부족하기 때문이다.
왜 확신할 수 없을까
무슨 데이터인지 모르기 때문이다.

Prediction
예측
점 (-4, -1)은 Blue였다.

Prediction
예측
데이터가 많아야 한다는 뜻
더 많은 데이터를 보면 결과가 달라질 수 있다.

Prediction
예측
* 위 설명은 대략적인 설명임.
신경망
: 수식과 비슷하게(왼쪽 예제에서는 2차식)으로 해결하자
Decision Tree (결정 트리)
: if-else 로 해결하자
SVM (Support Vector Machine)
: 차원을 늘려서 문제를 해결하자
KNN (K-Nearest Neigbors)
: 가까운 데이터를 보고 결정하자

Structured data
정형 데이터
https://www.kaggle.com/datasets/shashwatwork/construction-spending-dataset
meter_hours category is_new manufacturer region price_usd year
0 80 0 96 38 10000 1998
461 111 0 108 71 10000 2010
0 56 0 30 33 10100 2002
277 90 0 95 39 10100 2011
905 87 0 208 35 10100 2011
0 56 0 30 16 10200 2001
0 58 0 30 36 10200 2004
0 58 0 30 54 10200 2005
437 87 0 208 72 10200 2011
311 90 0 95 35 10200 2011
1612 24 0 30 16 150900 2013
0 101 0 165 30 152100 2010
1142 125 0 96 72 152600 2018
1201 111 0 30 75 152900 2013
721 111 0 30 0 153100 2016
2431 112 0 30 53 153200 2013
5212 112 0 96 64 153500 2012
2103 111 0 30 53 153500 2015
0 91 1 97 45 154000 2019
0 91 1 97 67 155000 2018
0 91 1 97 67 155000 2019
0 91 1 97 45 155000 2019
다양한 입력 데이터와 출력 데이터가 존재
표로 나타낼 수 있는 데이터
meter_hours (가동 시간)
category (중장비 카테고리)
is_new (새 장비유무)
manufacturer (제조사)
year (생산 연도)
price_usd (예상 가격, 달러)

Structured data
정형 데이터
키
(Height)
몸무게
(Weight)
성별
(Gender)
160.0181 47.57438 Female
171.1632 75.07518 Female
168.4182 45.9684 Female
168.0309 63.64062 Female
191.1731 83.63134 Male
157.1956 76.05757 Female
160.2908 57.11077 Female
166.0337 50.68615 Female
165.4573 76.98605 Female
170.9834 57.26852 Male
164.3251 72.10525 Female
175.2434 77.13018 Male
162.7635 54.91955 Female
157.9005 46.14417 Female
158.5758 83.60794 Female
183.0966 64.05785 Male
155.0624 79.42228 Female
163.7915 82.67118 Female
162.6725 77.96467 Female
158.1863 77.11418 Female
162.2115 53.9853 Female
161.7831 63.11812 Female
161.7494 69.49572 Female
https://www.kaggle.com/datasets/saranpannasuriyaporn/male-female-height-and-weight

Structured data
정형 데이터

Structured data
정형 데이터
● 정상 제품
● 비정상(불량) 제품
정상 제품을 불량으로 판별하여 폐기하는건 큰 문제가 없으나,
불량 제품을 정상으로 판별하여 출고하면 큰 문제가 생기는 경우
목적에 따라 원하는 분류 방식이 다를 수 있다.

Structured data
정형 데이터
키
(Height)
몸무게
(Weight)
신발 크기
(Shoe size)
성별
(Gender)
160.0181 47.57438 40 Female
171.1632 75.07518 39 Female
168.4182 45.9684 39 Female
168.0309 63.64062 40 Female
191.1731 83.63134 46 Male
157.1956 76.05757 37 Female
160.2908 57.11077 38 Female
166.0337 50.68615 39 Female
165.4573 76.98605 38 Female
170.9834 57.26852 41 Male
164.3251 72.10525 39 Female
175.2434 77.13018 44 Male
162.7635 54.91955 38 Female
157.9005 46.14417 37 Female
158.5758 83.60794 38 Female
183.0966 64.05785 44 Male
155.0624 79.42228 37 Female
163.7915 82.67118 39 Female
162.6725 77.96467 39 Female
158.1863 77.11418 35 Female
162.2115 53.9853 37 Female
161.7831 63.11812 37 Female
161.7494 69.49572 38 Female
https://osf.io/66fvm

Dimension
차원
키
(Height)
몸무게
(Weight)
신발 크기
(Shoe size)
성별
(Gender)
160.0181 47.57438 40 Female
171.1632 75.07518 39 Female
168.4182 45.9684 39 Female
168.0309 63.64062 40 Female
191.1731 83.63134 46 Male
https://osf.io/66fvm
키
(Height)
몸무게
(Weight)
성별
(Gender)
160.0181 47.57438 Female
171.1632 75.07518 Female
168.4182 45.9684 Female
168.0309 63.64062 Female
191.1731 83.63134 Male
meter_hours category is_new manufacturer region price_usd year
0 80 0 96 38 10000 1998
461 111 0 108 71 10000 2010
0 56 0 30 33 10100 2002
277 90 0 95 39 10100 2011
905 87 0 208 35 10100 2011
입력이 2개: 2차원 데이터
시각화 할 수 없다.

Unstructured data
비정형 데이터
김**: ★ ★ ★ ★ ★ 너무 좋아서 또 구매 했어요~~ 감사합니다^^
이**: ★ ★ ★ ★ ★ 제 인생템 >< 꺅꺅
송**: ★ ☆ ☆ ☆ ☆ 별 하나도 아깝습니다.. 이런 걸 제품이라고 ㅡㅡ;;
황**: ★ ★ ★ ☆ ☆ 아이엠그루트
최**: ★ ★ ★ ★ ★ 아니 이런 제품을 이 가격에 팔아도 되는 건가요? 당신은 도덕책!!
텍스트, 이미지, 음성, 동영상 등
형태가 다양하며 크기, 길이 등이 모두 다른 데이터

Unstructured data
비정형 데이터
이미지
흑백 이미지는 2차원 배열 구조이다.
각 픽셀은 0~255 사이의 값을 가진다.
255 0 140 160 0
0 0 0 67 8
0 0 0 0 87
0 0 0 13 55
8 8 8 0 0
width : x열
height : y 행
img[0,0]
img[0,2]
img[3,4]

Unstructured data
비정형 데이터
이미지
색상 이미지는 3차원 배열 구조 이다.
각 픽셀은 0~255 사이의 값을 가진다.
(일반적인 영상처리 기준 0~255, 딥러닝 에서는
0~1 또는 -1~1 과 같은 방식으로 사용)
width : x열
height : y 행
channel : c 채널
255 0 140 160 0
0 0 0 67 8
0 0 0 0 87
0 0 0 13 55
8 8 8 0 0

Unstructured data
비정형 데이터
이미지는 28x28 개의 숫자이다.
MNIST: 숫자 필기체 데이터

Unstructured data
비정형 데이터
28px
...
이러한 연산을 Flatten 이라고 한다.
28px
0
0
0
0
0
0
0
0
0
0
0
0
255
0
0
0
0
0
...
...
28x28 (784)개의 숫자 데이터

Unstructured data
비정형 데이터
28px
...
28px
28x28 (784)개의 숫자 데이터
Pixel [0,0] Pixel [0,1] Pixel [0,2] Pixel [0,3] Pixel [0,4]
0 0 0 0 0
0 0 128 128 0
0 0 0 255 0
0 0 0 0 0
0 255 0 0 255
Pixel [27,27] Label
0 0
0 7
0 1
0 2
0 1
...
MNIST는 784차원 데이터이다.

KNN
K-Nearest Neighbors
모든 데이터와의 거리를 확인해야 함.
K개의 가까운 데이터(학습 데이터)를 통해 추론한다.

Decision Tree
결정 트리
𝑋! < −2.5
𝑅𝑒𝑑

Decision Tree
결정 트리
𝑋! < −2.5
𝑋! > 3.5
𝑅𝑒𝑑
𝑅𝑒𝑑
𝑙𝑢𝑒

Decision Tree
결정 트리
𝑋! < −2.5
𝑋! > 3.5
𝑅𝑒𝑑
𝑋" > 3
𝑅𝑒𝑑
𝐵𝑙𝑢𝑒
𝑅𝑒𝑑

Decision Tree
결정 트리
𝑋! < −2.5
𝑋" > 1

Decision Tree
결정 트리
𝑋! < −2.5
𝑋" > 1
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = − $ 𝑝! log(𝑝!)
𝑝%: i번째 클래스에 대한 확률
− (1.00 , 𝑙𝑜𝑔(1.00) + 0.00 , 𝑙𝑜𝑔(0.00)) = 0 − (0.33 , 𝑙𝑜𝑔(0.33) + 0.67 , 𝑙𝑜𝑔(0.67)) = 0.92
− (0.50 , 𝑙𝑜𝑔(0.50) + 0.50 , 𝑙𝑜𝑔(0.50)) = 1.00 − (0.54 , 𝑙𝑜𝑔(0.54) + 0.46 , 𝑙𝑜𝑔(0.46)) = 1.00
− (0.53 , 𝑙𝑜𝑔(0.53) + 0.47 , 𝑙𝑜𝑔(0.47)) = 1.00

𝐼𝐺 = 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 𝑝𝑎𝑟𝑒𝑛𝑡 − A 𝑊:𝐸𝑛𝑡𝑟𝑜𝑝𝑦(𝑐ℎ𝑖𝑙𝑑:)
Decision Tree
결정 트리
𝑋! < −2.5
𝑋" > 1
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = − ; 𝑝% log(𝑝%)
𝑤%: 노드의 데이터 비율
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 0 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 0.92
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00
Information Gain이 더 높은 분기를 선택한다.

Decision Tree
결정 트리
𝑋! < −2.5
𝑋" > 1
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = − ; 𝑝% log(𝑝%)
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 0 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 0.92
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00
𝐸𝑛𝑡𝑟𝑜𝑝𝑦 = 1.00
1 −
5
19
/ 0 +
14
19
/ 0.92 = 0.32
1 −
5
19
/ 0 +
14
19
/ 0.92 = 0.0
𝐼𝐺 = 𝐸𝑛𝑡𝑟𝑜𝑝𝑦 𝑝𝑎𝑟𝑒𝑛𝑡 − A 𝑊:𝐸𝑛𝑡𝑟𝑜𝑝𝑦(𝑐ℎ𝑖𝑙𝑑:)
𝑤%: 노드의 데이터 비율
Information Gain이 더 높은 분기를 선택한다.

Deep Learning
딥러닝
심층신경망 모델은 통계학 기반의 기계학습보다 데이터가 많을 때 차이가 두드러진다.

단층 퍼셉트론
𝑥!
𝑥"
1
𝑤!
𝑤"
𝑜𝑢𝑡
𝑏𝑖𝑎𝑠
; 𝑥% / 𝑤% + 𝑏𝑖𝑎𝑠
모든 입력 값을 각각의 가중치와 곱해서 더한다.
더해진 값이 양수이면 1, 음수이면 0으로 분류한다.
𝑓 𝑥 =
1, 𝑥 ≥ 0
0, 𝑥 < 0
{
Deep Learning
딥러닝

단층 퍼셉트론 (순전파, forward)
𝑥!
𝑥"
1
𝑤!
𝑤"
𝑜𝑢𝑡
𝑏𝑖𝑎𝑠
; 𝑥% / 𝑤% + 𝑏𝑖𝑎𝑠 𝑓 𝑥 =
1, 𝑥 ≥ 0
0, 𝑥 < 0
{
퍼셉트론의 입력 개수는 동적으로 조절할 수 있다.
아래의 퍼셉트론은 입력이 2개(x=𝑥#, y=𝑥$)인 좌표들을 분류할 수 있다.
𝑤#𝑥#+ 𝑤$ 𝑥$ = 0
Bias가 없는 경우 Bias가 있는 경우
𝑦 =
−𝑎
𝑏
𝑥
𝑎𝑥 + 𝑏𝑦 = 0
𝑤#𝑥#+ 𝑤$ 𝑥$ + 𝑏𝑖𝑎𝑠 = 0
𝑦 =
−𝑎
𝑏
𝑥 −
−𝑏𝑖𝑎𝑠
𝑏
𝑎𝑥 + 𝑏𝑦 + 𝑏𝑖𝑎𝑠 = 0
(x , y) 의 좌표를 가지는 점들을 2개의 클래스
로 분 류 하 고 이 들 을 구 분 짓 는 결 정 선
(Decision boundary) 를 찾는 것이다.
옆의 이미지에서 빨간 점과 초록선을 나누는 결
정선의 함수 중 하나는 y=2x+3 이다.
위와 같이 Sparse 한 점들 사이에서는 무수히
많은 결정선이 존재 한다.
몸무게
키
165
152
139 177 190 203
45kg
68kg
90kg
113kg
남성
여성
Deep Learning
딥러닝

단층 퍼셉트론 (역전파, backward)
𝑥!
𝑥"
1
𝒘𝟎 = 𝑤" − 𝑥"(𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙)
(𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙)
𝑥# / (𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙)
for each weights
역전파는 앞선 순전파에서 사용하는 가중치를 갱신하는 작업을 한다.
순전파는 0 또는 1의 값을 반환하므로 해당 결과 값으로 오차를 구해 가중치를 수정하면 된다.
𝑤! = 𝑤! - 𝑥!η 𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙
𝒘𝟏 = 𝑤% − 𝑥%(𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙)
𝒃𝒊𝒂𝒔 = 𝑏𝑖𝑎𝑠 − 1(𝑜𝑢𝑡 − 𝑙𝑎𝑏𝑒𝑙)
η :Learning Rate(학습률)
4가지 경우가 있다.
(0-0): 정답을 맞춘 경우(W는 갱신되지 않는다)
(1-1): 정답을 맞춘 경우(W는 갱신되지 않는다)
(1-0): 정답을 틀린 경우
(0-1): 정답을 틀린 경우
Out에 기여한 정도를 비율로 나타내기 위함
𝑥%가 크다면 out에 더 많은 값을 더했으므로
𝑊%를 더 많이 수정한다.
Error(오차)
학습률은 가중치가 너무 많이 변하
지 않게 도와준다.
왜 값을 뺄까요?
왜 비어 있을 까요?
Deep Learning
딥러닝

단층 퍼셉트론 (순전파, forward)
iteration : 순전파(forward)와 역전파(backward)를 반복한 횟수.
epoch : 전체 데이터를 모두 한번씩 학습한 단위.
(데이터가 100개이고 한번에 1개의 데이터를 학습할 경우 100 iteration = 1 epoch)
1 2 3 4
순전파(forward) 역전파(backward) 가중치갱신(update)
데이터 입력(load)
Deep Learning
딥러닝

몇 층 일까요
Perceptron(Neuron)
= 가중치(Weights) + 활성화 함수(Activation Function)
Neuron(s) = Neuron Layer
Not layer. Just inputs.
즉, 위의 신경망은 Two-Layer Neural Networks 임.
Deep Learning
딥러닝

다층 퍼셉트론
단층 퍼셉트론은 어떤 가중치를 넣어
도 1차 식 밖에 나오지 않는다.
선형 분류의 문제
𝑤#𝑥#+ 𝑤$ 𝑥$ + 𝑏𝑖𝑎𝑠 = 0
𝑦 =
−𝑎
𝑏
𝑥 − 𝑏𝑖𝑎𝑠
𝑎𝑥 + 𝑏𝑦 + 𝑏𝑖𝑎𝑠 = 0
(입력이 2개면 2차원이다. 위의 그림에서 y=2x+3, 즉 1차식이라고 1차원이 아니다. 차수와 차원은 다른 의미이다)
2𝑥! + 𝑦 + 4𝑧" = 0
변수가 3개이므로 3차원
차수
Deep Learning
딥러닝

다층 퍼셉트론
𝑥#
𝑥$
1
𝑤!
𝑤"
𝑜𝑢𝑡#
𝑏𝑖𝑎𝑠 !
% 𝑥! ' 𝑤! + 𝑏𝑖𝑎𝑠 𝑓 𝑥 =
𝑥#
𝑥$
1
𝑤#
𝑤$
𝑜𝑢𝑡$
% 𝑥! ' 𝑤! + 𝑏𝑖𝑎𝑠 𝑓 𝑥 =
1
𝑤%
𝑤&
𝑜𝑢𝑡./012
% 𝑥! ' 𝑤! + 𝑏𝑖𝑎𝑠 𝑓 𝑥 =
𝑤#𝑥#+ 𝑤$ 𝑥$ + 𝑏𝑖𝑎𝑠 # = 𝑜𝑢𝑡#
𝑏𝑖𝑎𝑠 "
𝑏𝑖𝑎𝑠 #
𝑤!𝑥#+ 𝑤( 𝑥$ + 𝑏𝑖𝑎𝑠 $ = 𝑜𝑢𝑡$
𝑤)𝑜𝑢𝑡#+ 𝑤* 𝑜𝑢𝑡$ + 𝑏𝑖𝑎𝑠 ( = 𝑜𝑢𝑡+%,-.
𝑤)(𝑤#𝑥#+ 𝑤$ 𝑥$ + 𝑏𝑖𝑎𝑠 #)+ 𝑤* (𝑤!𝑥#+ 𝑤( 𝑥$ + 𝑏𝑖𝑎𝑠 $)+𝑏𝑖𝑎𝑠 ( = 𝑜𝑢𝑡+%,-.
𝐴𝑥#+ 𝐵𝑥$ + 𝐶 = 𝑜𝑢𝑡+%,-.
퍼셉트론을 선형 함수로 다층으로 구성해도 차수는 증가하지 않는다.
Deep Learning
딥러닝

활성화 함수
단층 퍼셉트론은 활성화 함수로 계단함수를 사용했지만 다층 퍼셉트론에서는 다양한 비선형 함수를 사용한다.
선형함수는 중첩원리가 적용된다. 즉, 선형함수를 다층으로 쌓아도 쌓지 않은 하나의 선형함수로 정의가 가능하다.
이는 다( )층의 의미가 없어진다.
ReLU : 𝑚𝑎𝑥(0, 𝑥)
Sigmoid :
"
"#$78 Tanh :
$8%$78
$8#$78
Leaky : 𝑚𝑎𝑥(0.1𝑥, 𝑥) Swish :
&
"#$78
Deep Learning
딥러닝

다층 퍼셉트론(순전파)
𝜎(;
MN"
O
𝑊 · 𝑋)
𝜎 : activation function
다층 퍼셉트론의 순전파 연산은 단층 퍼셉트론의 연산과 동일하다.
𝑂P = 𝜎(;
MN"
O
𝑊 · 𝑋)
𝑝𝑟𝑒𝑑𝑖𝑐𝑡 𝑙𝑎𝑏𝑒𝑙 = 𝐴𝑟𝑔𝑚𝑎𝑥(𝑂M)
Deep Learning
딥러닝

Scalar Vector Matrix Tensor
Deep Learning
딥러닝

다층 퍼셉트론 역전파
∆𝑤>? = η 𝑡? − 𝑦? 𝑔´(ℎ?)𝑥>
delta
learning
rate
input
(neuron)
error gradient
Delta Rule
• Delta Rule 이란 어떤 입력 노드가 출력 노드의 오차에 기여했다면, 두 노드의 연결 가중
치는 해당 입력 노드의 출력과 출력 노드의 오차에 비례해 조절하는 것을 말한다.
• Loss 는 학습을 통해 직접적으로 줄이고자 하는 값(Scalar)이다.
• Error 는 각각의 뉴런이 얼마나 틀렸는지를 나타내는 값(Vector)이다.
• Delta 는 델타 규칙을 적용하기 위해 계산하는 값(Vector)입니다. 일반적으로 오류에 미
분 값을 곱하면 델타입니다. Delta와 Error는 동일할 수 있습니다.
• Gradient 는 가중치들을 얼마나 갱신할지 나타내는 값(Matrix)이다..
• Backpropagation Algorithm : 은닉층의 Delta 값을 계산하고 각각의 뉴런에 Delta
Rule을 적용하는 알고리즘.
Deep Learning
딥러닝

손실률(loss)
𝑂" = 0.9
𝑂' = 0.6
𝑂( = 0.4
𝑝𝑟𝑒𝑑𝑖𝑐𝑡 𝑙𝑎𝑏𝑒𝑙 = 𝐴𝑟𝑔𝑚𝑎𝑥(𝑂B)
Loss(손실률) 은 네트워크가 얼마나 잘 학습되었는지를 나타내는 지표이다.
predicted label 은 0 이다.
y (정답 레이블)
1
0
0
One-hot encoding
𝑀𝑆𝐸 𝐿𝑜𝑠𝑠 =
1
2
1
𝑛
1
#$%
&
(𝜎 𝑊𝑥 − 𝑦)"
Deep Learning
딥러닝

손실률(loss)
1
2
1
𝑛
1
#$%
&
(𝜎 𝑊𝑥 − 𝑦)"
MSE Loss의 수식을 각각 n이 1 또는 2일 때의 그래프를 그려보면 위와 같다.
가장 이상적인 경우는 모든 (𝜎 𝑊𝑥 − 𝑦) 가 0이 되는 경우로 함수의 극소점이다.
각 차원(x, y 또는 z) 에 대하여 극소점으로 나아가는 방향과 거리를 계산해 가중치를 갱신한다.
Deep Learning
딥러닝

손실률(loss)
1
2
1
𝑛
1
#$%
&
(𝜎 𝑊𝑥 − 𝑦)"
𝑦 = 𝑥C
인 그래프에서 x=1 일 때 함수의 극소점으로 내려가는 방법은, 기
울기를 구해 기울기가 양수이면 x는 감소해야 하고 기울기가 음수이면 x는
증가해야 한다.
기울기는 미분을 함으로서 구할 수 있다!!
Deep Learning
딥러닝

경사하강법(Gradient decent)
1
2
1
𝑛
1
#$%
&
(𝜎 𝑊𝑥 − 𝑦)"
𝑑
𝑑𝑥
𝑥'
= 2𝑥
𝑑
𝑑𝑥
𝑓(𝑥) = 𝑓′(𝑥)
𝑑
𝑑𝑥
𝑓(𝑔(𝑥)) = 𝑔Q 𝑥 · 𝑓′(𝑔 𝑥 )
𝑑
𝑑𝑥
𝑓(𝑔(ℎ(𝑥))) = ℎQ 𝑥 · 𝑔Q ℎ 𝑥 · 𝑓′(𝑔 ℎ 𝑥 )
𝑑
𝑑𝑥
𝑓 𝑔 ℎ 𝑗 𝑥 = 𝑗Q 𝑥 · ℎ′ 𝑗 𝑥 · 𝑔′ ℎ 𝑗 𝑥 · 𝑓′(𝑔 ℎ 𝑗 𝑥 )
합성함수의 미분
(Chain Rule)
다항식의 미분
위 함수를 미분하기 위해서는 아래의 2가지 공식만 알면 된다.
Deep Learning
딥러닝

MSE Loss(Mean Square Error Loss)
1
2
1
𝑛
;
PN"
R
(𝜎 𝑊𝑥 − 𝑦)& 𝑑
𝑑𝑊
1
2
(𝜎 𝑊𝑥 − 𝑦)&
𝜎(𝑧)는 해당 출력 뉴런에만 영향을 미치므로 시그마 기호를 제거하고 미분을 진행해도 무방하다.
𝑊를 갱신할 것이므로 𝑊로 편미분을 진행한다.
𝑑
𝑑𝑡
1
2
𝑓 𝑔 ℎ 𝑗 𝑡 =
1
2
· 𝑗/
𝑡 · ℎ′ 𝑗 𝑡 · 𝑔′ ℎ 𝑗 𝑡 · 𝑓′(𝑔 ℎ 𝑗 𝑡 )
𝑔 𝑡 = 𝑡 − 𝑦
𝑓 𝑡 = 𝑡&
ℎ 𝑡 = 𝜎(t)
j 𝑡 = 𝑡𝑥
"
&
· 𝑥 · 𝜎′(Wx) · 1 · 2(𝜎 𝑊𝑥 − y)
𝐷𝑒𝑟𝑖𝑣𝑎𝑡𝑖𝑣𝑒
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛
위 수식의 미분식은 합성함수의 미분으로 쉽게 구할 수 있다. 먼저 위 함수를 4개의 함수( f, g, h ,j )로 치환하고
합성함수의 미분을 통해 미분식을 계산한다.
𝑔′ 𝑡 = 1
𝑓′ 𝑡 = 2𝑡
ℎ′ 𝑡 = 𝜎′(t)
j′ 𝑡 = 𝑥
= 𝑥 · 𝜎′(Wx) · (𝜎 𝑊𝑥 − y)
𝐸𝑟𝑟𝑜𝑟
𝐷𝑖𝑓𝑓 𝑒𝑙𝑡𝑤𝑖𝑠𝑒
X
𝐷𝑒𝑙𝑡𝑎
(𝑟𝑜𝑤 𝑣𝑒𝑐𝑡𝑜𝑟) (𝑟𝑜𝑤 𝑣𝑒𝑐𝑡𝑜𝑟)
(𝑟𝑜𝑤 𝑣𝑒𝑐𝑡𝑜𝑟)
𝐼𝑛𝑝𝑢𝑡
(𝑐𝑜𝑙 𝑣𝑒𝑐𝑡𝑜𝑟)
𝐺𝑟𝑎𝑑𝑖𝑒𝑛𝑡
(𝑚𝑎𝑡𝑟𝑖𝑥)
Deep Learning
딥러닝

𝑂" = 0.9
𝑂' = 0.6
𝑂( = 0.4
정답 레이블
(Ground truth)
1
0
0
𝑂! = 𝜎 𝑊!𝑥
오차
(Error)
0.9-1
0.6-0
0.4-0
미분 값
(Differential Value)
𝜎′ 𝑊!𝑥
𝜎′ 𝑊!𝑥
𝜎′ 𝑊!𝑥
Delta
(−0.1) · 𝜎′ 𝑊!𝑥
(−0.6) · 𝜎′ 𝑊!𝑥
(−0.4) · 𝜎′ 𝑊!𝑥
X
(element
wise)
=
Delta
(−0.1) · 𝜎′ 𝑊!𝑥
(−0.6) · 𝜎′ 𝑊!𝑥
(−0.4) · 𝜎′ 𝑊!𝑥
𝑥"
𝑥'
𝑥(
𝑥)
𝑥" 𝑥' 𝑥( 𝑥)
Input
X
(matrix
multiplication)
𝑥"𝑑𝑒𝑙𝑡𝑎" 𝑥'𝑑𝑒𝑙𝑡𝑎" 𝑥(𝑑𝑒𝑙𝑡𝑎" 𝑥)𝑑𝑒𝑙𝑡𝑎"
𝑥"𝑑𝑒𝑙𝑡𝑎' 𝑥'𝑑𝑒𝑙𝑡𝑎' 𝑥(𝑑𝑒𝑙𝑡𝑎' 𝑥)𝑑𝑒𝑙𝑡𝑎'
𝑥"𝑑𝑒𝑙𝑡𝑎( 𝑥'𝑑𝑒𝑙𝑡𝑎( 𝑥(𝑑𝑒𝑙𝑡𝑎( 𝑥)𝑑𝑒𝑙𝑡𝑎(
Gradient
=
Deep Learning
딥러닝

CE Loss(Cross Entropy Loss)
−
1
𝑛
;
PN"
R
𝑦 ln 𝜎 𝑊𝑥 −
𝑑
𝑑𝑊
𝑦 ln 𝜎 𝑊𝑥
𝜎(𝑧)는 해당 출력 뉴런에만 영향을 미치므로 시그마 기호를 제거하고 미분을 진행해도 무방하다.
𝑊를 갱신할 것이므로 𝑊로 편미분을 진행한다.
−
𝑑
𝑑𝑡
𝑓 𝑔 ℎ 𝑗 𝑡 = −1 · 𝑗/
𝑡 · ℎ′ 𝑗 𝑡 · 𝑔′ ℎ 𝑗 𝑡 · 𝑓′(𝑔 ℎ 𝑗 𝑡 )
𝑔 𝑡 = ln 𝑡
𝑓 𝑡 = 𝑦𝑡
ℎ 𝑡 = 𝜎(t)
j 𝑡 = 𝑡𝑥
−1 · 𝑥 · 𝜎′(Wx) ·
"
Z [
· 𝑦
𝐷𝑒𝑟𝑖𝑣𝑎𝑡𝑖𝑣𝑒
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛
Cross Entropy 함수는 𝜎 𝑊𝑥 의 범위가 [0,1]일 경우에 사용한다.
𝑔′ 𝑡 =
1
𝑡
𝑓′ 𝑡 = 𝑦
ℎ′ 𝑡 = 𝜎′(t)
j′ 𝑡 = 𝑥
= 𝑥 · 𝜎′(Wx) ·
−𝑦
𝜎 𝑊𝑥
𝑒𝑙𝑡𝑤𝑖𝑠𝑒
X
𝐷𝑖𝑓𝑓
𝐸𝑟𝑟𝑜𝑟
𝐷𝑒𝑙𝑡𝑎
𝐼𝑛𝑝𝑢𝑡
(𝑐𝑜𝑙 𝑣𝑒𝑐𝑡𝑜𝑟)
𝐺𝑟𝑎𝑑𝑖𝑒𝑛𝑡
(𝑚𝑎𝑡𝑟𝑖𝑥)
Deep Learning
딥러닝

활성화 함수 미분
ReLU(x) = 𝑚𝑎𝑥(0, 𝑥)
Sigm𝑜𝑖𝑑(𝑥) =
1
1 + 𝑒%&
Tanh x =
𝑒& − 𝑒%&
𝑒& + 𝑒%&
Leaky x = 𝑚𝑎𝑥(0.1𝑥, 𝑥)
Swish x =
𝑥
1 + 𝑒%&
𝑑
𝑑𝑥
𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 = 𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 · (1 − 𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 )
𝑑
𝑑𝑥
tanh 𝑥 = 𝑠𝑒𝑐ℎ' 𝑥 =
4
(𝑒%&+𝑒&)'
𝑑
𝑑𝑥
𝑅𝑒𝐿𝑈 𝑥 = 1 𝑖𝑓 𝑥 > 0 , 0 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒
𝑑
𝑑𝑥
𝑆𝑤𝑖𝑠ℎ 𝑥 = 𝑆𝑤𝑖𝑠ℎ(𝑥) + (1 − 𝑆𝑤𝑖𝑠ℎ(𝑥))(
1
1 + 𝑒%&
)
𝑑
𝑑𝑥
𝐿𝑒𝑎𝑘𝑦 𝑥 = 1 𝑖𝑓 𝑥 > 0 , 0.1 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒
Deep Learning
딥러닝

순전파 (행렬로 생각하기)
𝑀𝐵: 𝑚𝑖𝑛𝑖 𝑏𝑎𝑡𝑐ℎ 𝑠𝑖𝑧𝑒
𝑊: 𝑤𝑒𝑖𝑔ℎ𝑡𝑠
𝑏: 𝑏𝑖𝑎𝑠
𝑥: 𝑖𝑛𝑝𝑢𝑡 𝑛𝑒𝑢𝑟𝑜𝑛
y: 𝑜𝑢𝑡𝑝𝑢𝑡 𝑛𝑒𝑢𝑟𝑜𝑛
𝒙 R 𝑾 + 𝒃 = 𝒚
X =
𝑾𝒆𝒊𝒈𝒉𝒕𝒔
𝑜𝑢𝑡𝑝𝑢𝑡 𝑠𝑖𝑧𝑒
𝑖𝑛𝑝𝑢𝑡
𝑠𝑖𝑧𝑒
𝑖𝑛𝑝𝑢𝑡 𝑠𝑖𝑧𝑒
𝑀𝐵
𝑰𝒏𝒑𝒖𝒕
𝑀𝐵
행렬 곱을 이용하여 Mini-Batch가 있더라도 한번의 계산으로 순전파 연산이 가능하다.
1
+ =
가중치에 미니배치를 적용한 입력을 곱하면 미니배치 연산이 적용된 출력이 나온다.
이때, 모든 값이 1로 초기화된 열 벡터와 곱해 미니배치를 고려한 결과에 바로 더할 수 있는 Bias matrix가 나온다.
𝑀𝐵
𝑾𝒐𝒓𝒌𝒔𝒑𝒂𝒄𝒆
𝑀𝐵
1
X =
𝑶𝒖𝒕𝒑𝒖𝒕(𝐖𝐱)
𝑀𝐵
𝑶𝒖𝒕𝒑𝒖𝒕(𝐖𝐱 + 𝐛)
𝑩𝒊𝒂𝒔
𝑩𝒊𝒂𝒔
Deep Learning
딥러닝

순전파 (행렬로 생각하기)
Don’t do this
X =
𝑜𝑢𝑡𝑝𝑢𝑡
𝑠𝑖𝑧𝑒
𝑠𝑖𝑧𝑒
𝑀𝐵
𝑠𝑖𝑧𝑒
𝑀𝐵
일반적으로 미니배치를 사용할 때 입력 값들을 연속적으로 붙여서 사용한다. 그런데 위와
같이 구현하게 되면 대부분의 프로그래밍 언어가 2차원 행렬을 Row-major로 읽기 때문
에 제대로 동작하지 않는다.
𝑊 R 𝑥 + 𝑏 = 𝑦
𝒂𝟏𝟏 𝒂𝟏𝟐 𝒂𝟏𝟑
𝒂𝟐𝟏 𝒂𝟐𝟐 𝒂𝟐𝟑
𝒂𝟑𝟏 𝒂𝟑𝟐 𝒂𝟑𝟑
Row-major
𝒂𝟏𝟏 𝒂𝟏𝟐 𝒂𝟏𝟑
𝒂𝟐𝟏 𝒂𝟐𝟐 𝒂𝟐𝟑
𝒂𝟑𝟏 𝒂𝟑𝟐 𝒂𝟑𝟑
Column-major
𝑊𝑏 R 𝑥 = 𝑦
Bias를 가중치에 합쳐서 계산하면 편리하지만 입력의 끝에 상수 1을 붙여줘야 한다. 런타
임에서 입력 뒤에 1을 붙이는 건 조금 큰 비용이 들게 된다.
X =
𝑠𝑖𝑧𝑒
𝑀𝐵
𝑀𝐵
1
Bias
Deep Learning
딥러닝

역전파-오류전파 (행렬로 생각하기)
𝐸𝑟𝑟𝑜𝑟qrss R 𝑊t = 𝐸𝑟𝑟𝑜𝑟usvw
X =
𝑾𝒆𝒊𝒈𝒉𝒕𝒔𝑻
𝑠𝑖𝑧𝑒
𝑖𝑛𝑝𝑢𝑡 𝑠𝑖𝑧𝑒 𝑖𝑛𝑝𝑢𝑡 𝑠𝑖𝑧𝑒
𝑀𝐵
𝑀𝐵
Bias에 대한 오류전파는 없다.
𝑬𝒓𝒓𝒐𝒓𝒑𝒓𝒆𝒗
𝑬𝒓𝒓𝒐𝒓𝒄𝒖𝒓𝒓
Deep Learning
딥러닝

역전파-가중치갱신 (행렬로 생각하기)
𝑥t R 𝛿 = 𝐺𝑟𝑎𝑑𝑖𝑒𝑛𝑡
Bias에 대한 Gradient는 단순히 미니배치의 모든 델타의 합으로 구할 수 있다.
X =
𝑀𝐵
𝑮𝒓𝒂𝒅𝒊𝒆𝒏𝒕
𝑠𝑖𝑧𝑒
𝑠𝑖𝑧𝑒
𝑀𝐵
𝑠𝑖𝑧𝑒
𝑀𝐵
X
𝑠𝑖𝑧𝑒
1
=
𝑻
𝑫𝒆𝒍𝒕𝒂
𝑾𝒐𝒓𝒌𝒔𝒑𝒂𝒄𝒆
𝑀𝐵
1
𝑮𝒓𝒂𝒅𝒊𝒆𝒏𝒕
𝒃𝒊𝒂𝒔
𝑫𝒆𝒍𝒕𝒂
𝑻
Deep Learning
딥러닝

1957
1986
1998
퍼셉트론의 등장
퍼셉트론(perceptron)은 인공신경망의 한 종류로서, 1957년에 코넬 항공 연
구소(Cornell Aeronautical Lab)의 프랑크 로젠블라트 (Frank Rosenblatt)
에 의해 고안되었다. 이것은 가장 간단한 형태의 피드포워드(Feedforward)
네트워크 선형분류기로도 볼 수 있다.
다층 퍼셉트론의 등장
1986년 다층 퍼셉트론(multi-layer perceptron)의 지도 학습을 위한 역전
파 알고리즘(backpropagation algorithm)이 발견됨.
LeNet5 등장
Yann Lecun 1998년에 “Gradient-Based Learning Applied to
Document Recognition”라는 논문에서 LeNet-5라는 현대의
Convolutional Neural Networks(CNNs)의 시초가 되는 Neural
Networks 구조를 제안함.
성능 올리려고 레이어를 많이 쌓았더니 잘 안되네...
선형분류만 되네...30년간 암흑기
문제 많은 NN 쓸 바에는 SVM으로...
Deep Learning
딥러닝

2012
2015
현재
AlexNet 등장
이미지넷에서 주관하는 ILSVRC (Large Scale Visual Recognition
Competition) 이라는 대회에서, 2012년 제프리 힌튼 교수팀의 AlexNet이
top 5 test error(5개의 예측 값 중에 정답이 없는 경우) 기준 15.4%를 기록
해 2위(26.2%)를 큰 폭으로 이기고 1위를 차지했다. 이 대회는 1000개의 클
래스를 가진 120만장의 이미지를 학습하고 15만장의 이미지로 테스트하여
정답률을 겨루는 대회이다. AlexNet의 등장은 딥러닝, 특히 CNN이 본격적
으로 주목 받게 되는 계기가 되었고 여기서 소개된 ReLU, Dropout 등은 지
금도 표준으로 사용되고 있다.
Batch Normalization 등장
그래디언트 소실(vanishing gradient)과 폭주(exploding) 문제를 해결하는
방법인 배치 정규화(BN, Batch Normalization)의 등장
딥러닝의 시대
조금씩 변화를 거쳐 점점 강건한 모델이 연구되고 있지만 큰 획을 긋는 연구
는 아직까지 나오지 않았다.
Deep Learning
딥러닝

Flatten의 문제점
28px
...
1
(bias)
이렇게 1차원으로 풀어서 학습하는 것은
이미지의 특성을 고려하지 않은 것!
28px
Deep Learning
딥러닝

CNN 이전
Support Vector Machine(SVM) 이란 분류기가 CNN 이전에 많은 인기를 끌었다.
이때 사람들은 원본 이미지로 학습하는 것 보다 Histogram Of Gradients 라는 Feature로
이미지를 변형한 후 학습하는 것이 더 좋은 결과내는 것을 확인하였다.
원본 이미지 HOG Feature
Deep Learning
딥러닝

Histogram Of Gradients
• 복잡한 문제를 기계 학습에 사용하기 위한 전 처리 작업.
• 형태를 판별하는데 색상 정보는 중요하지 않다.
• 픽셀에 대해 어두워지는 방향을 나타낸다.
• 이미지의 밝기가 달라져도 HoG의 결과는 동일하다.
• 이미지의 밝기 변화에 강인하다.
N. Dalal et al., Histograms of Oriented Gradients for Human Detection, CVPR, 2005.
우측 상단으로 갈수록 어둡다.
HoG 결과 영상
원본 영상
Deep Learning
딥러닝

Feature?
컴퓨터가 이미지를 분류하는데 있어 원본 이미지가 최적의 이미지는 아닐 수 있다.
HoG는 최적의 Feature 인가?
이미지를 분류하는데 최적의 Feature를 찾게 하면 어떨까?
역전파를 할 때 오차를 전파하다 보면, 입력 이미지에도 오차가 전파 될 텐데,
이 오차를 통해 최적의 Feature를 찾자.
error
error?
Deep Learning
딥러닝

KMeans
• 임의의 K개의 클러스터 위치를 설정한다.
• 모든 점들은 자기와 가장 가까운 클러스터에 속하게 된다.
• 클러스터는 자신을 중심으로 하는 점들의 무게중심으로 이동한다.
• 모든 클러스터가 이동하지 않으면 종료한다. 그렇지 않으면 위의 알고리즘을 반복한다.
비지도학습은 Data에 Label이 없기 때문에 비슷한 군집끼리 분류를 해야 한다.
KMeans

개발환경
Python
- Tensorflow2
- PyTorch
- Scikit-learn
C/C++
- libtorch
- libsvm
- CUDA
- oneDNN
아두이노
라즈베리파이
Jetson
AI 개발 도구

Tensorflow2
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'
import tensorflow as tf
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
model.add(tf.keras.layers.Dense(100, activation=tf.keras.activations.relu))
model.add(tf.keras.layers.Dense(10, activation=tf.keras.activations.sigmoid))
model.compile(optimizer=tf.keras.optimizers.SGD(0.1),
loss=tf.keras.losses.MeanSquaredError(),
metrics=[tf.keras.metrics.CategoricalAccuracy()])
model.fit(x_train, y_train,
validation_data=(x_test, y_test),
batch_size=64, epochs=30)
loss, acc = model.evaluate(x_test, y_test, verbose=2)W
print(acc)
mnist 데이터 획득
one-hot encoding 적용
모델 구조 선언
28x28 이미지를 Flatten 합니다.
100개의 뉴런을 사용하고 활성화 함수는 relu입니다.
10개의 뉴런을 사용하고 활성화 함수는 sigmoid입니다.
Loss함수는 MSE를 사용합니다.
30번 반복해서 학습합니다.
Deep Learning
딥러닝

import os
(x_train, y_train), (x_test, y_test) =
tf.keras.datasets.mnist.load_data()
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(100, activation='relu'),
tf.keras.layers.Dense(10, activation='sigmoid')
])
model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=64, epochs=30)
loss, acc = model.evaluate(x_test, y_test, verbose=2)
print(acc)
import os
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)
model.add(tf.keras.layers.Dense(100, activation=tf.keras.activations.relu))
model.add(tf.keras.layers.Dense(10, activation=tf.keras.activations.sigmoid))
model.fit(x_train, y_train, batch_size=64, epochs=30)
loss, acc = model.evaluate(x_test, y_test, verbose=2)W
print(acc)
권장하는 코드
글쎄요
Deep Learning
딥러닝

Epoch 1/10
938/938 [==============================] - 6s 5ms/step - loss: 0.0937 - categorical_accuracy: 0.4399 - val_loss: 0.0452 - val_categorical_accuracy: 0.8135
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
313/313 - 1s - loss: 0.0171 - categorical_accuracy: 0.9115
Test accuracy: 0.9114999771118164
정확도 91%
Deep Learning
딥러닝

Loss Plot
Train 데이터에 대한 loss가 잘 줄어들고 Test데이터 역시 잘 줄어든다.
Deep Learning
딥러닝

일반적으로 5-Layer 이상의 네트워크를 Deep Neural Network 라고 함.
2-Layer 5-Layer
Deep Learning
딥러닝

Layer를 for문을 이용해 hidden레이어 5개 + output 레이어 1개로 구성된 네트워크를 만든다.
이 네트워크는 6-layer 이므로 DNN이라고 부를 수 있다.
정확도가 어떨까?
그냥 깊게…?
for i in range(5):
model.add(tf.keras.layers.Dense(100,
activation=tf.keras.activations.sigmoid))
Sigmoid :
"
"#$78
Deep Learning
딥러닝

0~9 까지의 숫자를 분류하는데 정확도가 11%라는 것은 그냥 찍었다는 것
그냥 깊게…?
Epoch 1/10
938/938 [==============================] - 7s 6ms/step - loss: 0.1021 - categorical_accuracy: 0.1073 - val_loss: 0.0900 -
val_categorical_accuracy: 0.1135
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Test accuracy: 0.11349999904632568
Deep Learning
딥러닝

Sigmoid 함수를 미분한 함수는 입력이 커질수록 0에 수렴한다.
이것은 수학적으론 문제가 없으나, 컴퓨터에서는 상황이 다르다.
Vanishing Gradient
𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 =
1
1 + 𝑒cd
𝑑
𝑑𝑥
𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 = 𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 · (1 − 𝑆𝑖𝑔𝑚𝑜𝑖𝑑 𝑥 )
Deep Learning
딥러닝

Vanishing Gradient
컴퓨터에서는 실수(Real number)를 표기하기 위해 일반적으로 단정밀도(Single Precision) 부동소수점을 사용한다.
단정밀도 부동소수점은 32개의 bit로 표현되며, 32개의 bit는 대략 42억(2%&) 개의 수를 표현할 수 있다.
단정밀도 부동소수점은 아래와 같이 표현된다.
1 1 0 0 0 0 1 0 1 1 1 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
부호 부분 지수 부분 가수 부분
10000101' = 133 1.110110101' = 1 +
"
'
+
"
)
+
"
"+
+
"
('
+
"
"',
+
"
-"'
= 1.853512625
(−1)"= −1
−1 · (1.853512625)·2"((%"'.
= −118.625
이렇게 정의된 단정밀도 부동소수점은 최소값(1.175494351(|%$)) , 최대값(3.402823466 %$ ≈ 1.6해) 까지 표현이 가능하다.
즉, 컴퓨터에서는 작은 수끼리 계속 곱하면 계속 작아지다가 0이 되어 버린다.
Deep Learning
딥러닝

다시 깊게 가보자
for i in range(5):
activation=tf.keras.activations.relu))
앞에서 실험한 sigmoid는 Vanishing Gradient 문제가 있어서 ReLU(Rectified Linear Units) 함수가 등장했다.
이번에는 활성화 함수를 ReLU를 사용하여 실험해 보자.
Deep Learning
딥러닝

다시 깊게 가보자
ReLU를 사용하니, 정확도가 93%로 높게 측정되었다.
Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Test accuracy: 0.9377999901771545
Deep Learning
딥러닝

다시 좀 더 깊게 가보자
for i in range(20):
activation=tf.keras.activations.relu))
이번에는 정확도를 더 높이기 위해 ReLU를 사용한 레이어를 20층 정도 쌓아 보자!
Deep Learning
딥러닝

또 죽음 ㅠ
또, 정확도가 11%로 찍은거나 마찬가지인 정확도가 나왔다.
Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Test accuracy: 0.11349999904632568
Deep Learning
딥러닝

ReLU 함수는 미분 값이 아닌 함수 자체가 ∞까지 표현이 가능하여 많은 연산을 할 경우 float overflow가 발생한다.
Exploding Gradient
ReLU(x) = 𝑚𝑎𝑥(0, 𝑥)
𝑑
𝑑𝑥
𝑅𝑒𝐿𝑈 𝑥 = 1 𝑖𝑓 𝑥 > 0 , 0 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒
Deep Learning
딥러닝

해결 방법은?
for i in range(5):
model.add(tf.keras.layers.BatchNormalization())
Epoch 10/10
938/938 [==============================] - 10s 11ms/step - loss: 0.0103 -
categorical_accuracy: 0.9429 - val_loss: 0.0088 - val_categorical_accuracy:
0.9491
Test accuracy: 0.9491000175476074
Normalization은 여러 종류가 있지만 BatchNormalization이 대표적이다.
위 그림은 빠른 이해를 위한 예시. 실제 배치정규화는 추가 보정작업이 존재한다.
Deep Learning
딥러닝

합성곱(Convolution)
NxNxC 크기의 Kernel (3차원 Weights) 를 이용하여 Feature를 생성.
depth
height
width
depth = 1
kernel, weights
Deep Learning
딥러닝

이미지 형태
NHWC, RGBRGB NCHW, RRGGBB
Image Processing Format Deep Learning Format
NCHW가 속도가 더 빠르다.
Deep Learning
딥러닝

Filtering
-1 -1 -1
-1 8 -1
-1 -1 -1
-1 -1 -1
-1 9 -1
-1 -1 -1
1 2 1
0 0 0
-1 -2 -1
Deep Learning
딥러닝

이미지를 분류하기 위한 최적의 Feature를 찾자
Insulator
0.
2
0.
1
0.
1
0.6
Insulator
Deep Learning
딥러닝

Pooling(Subsampling)
width
width/2
height/2
Pooling
height
Deep Learning
딥러닝

Pooling(Subsampling)
x축으로 한 칸 이동
단순히 한 픽셀만 움직였을 뿐인데, 컴퓨터에게는 완전히 다른 이미지이다.
물체의 위치에 조금 더 강인한 특성을 가지게 한다.
Deep Learning
딥러닝

CPU vs GPU vs MultiGPU
Deep Learning
딥러닝

Sliding Window
Loop X:
Loop Y:
Loop W:
Loop H:
NxN이미지에서 시간 복잡도
가 O(𝑛&
)여서 너무 느린 알고
리즘
객체 검출을 위한 가장 기초적인 생각.
Deep Learning
딥러닝

Sliding Window
앞선 Sliding window 보다 빠르게 객체의 위치를 찾아 낼 수 있다.
Selective Search 알고리즘 결과 예시
Two-Stage Network
제안된 박스마다 분류기를 돌려서 객체 여부 확인
RCNN의 경우 이미지 1장당 약 2000개의 박스를 제안함
Deep Learning
딥러닝

Region Proposal
앞선 Sliding window 보다 빠르게 객체의 위치를 찾아 낼 수 있다.
Selective Search 결과 예시 Edgeboxes 결과 예시
Selective Search : 영상에서 Segmentation blob 들을 나누어 확장 시켜 최종 경계상자를 예측
Edgeboxes : 에지를 이용해 에지 그룹을 만들어 에지 그룹을 통해 경계상자를 예측
Region Proposal Network : CNN 방식을 이용한 경계상자 예측
Deep Learning
딥러닝

비 최대값 억제 (NMS: Non-Maximum Suppression)
Deep Learning
딥러닝

IOU(Intersection Over Union)
정답 박스(Ground-truth bounding box)
객체 검출기가 예측한 박스(Predicted bounding box)
중첩된 영역
실제 영역+검출한 영역
IOU =
(Intersection Of Union)
안 좋은 결과 좋은 결과 완벽한 결과
Deep Learning
딥러닝

RCNN (Region-based Convolutional Network)
Feature
추출을
위한
Convolution
1. 입력 이미지 2. Region Proposal
(Selective Search)
3. CNN의 입력 크기로 조절
(Resize)
4. Feature 추출
(Convolution)
5. 분류
(SVM)
폴리머 현수 애자 : 0.00
세라믹 현수 애자 : 0.90
피뢰기: 0.05
컷 아웃 스위치: 0.05
배경: 0.00
Deep Learning
딥러닝

Fast-RCNN
RCNN은 Region Proposal 후에 CNN 연산(Feature 추출) 수행.
약 2000번의 CNN 연산 수행.
분류기로 SVM 사용.
Fast-RCNN은 CNN 연산(Feature 추출) 후에 Region Proposal 수행.
단, 한번의 CNN 연산으로 속도 향상 .
분류기로 Fully Connected 사용.
Convolution
Selective Search
Image Resize
Convolution
SVM
ROI Pooling
Region Proposal
Fully Connected
Deep Learning
딥러닝

ROI Pooling (Region Of Interest Pooling)
ROI Pooling은 서로 다른 크기의 Feature를 동일하게 맞춰줄 수 있습니다.
Image Resize ROI Pooling
Deep Learning
딥러닝

Faster-RCNN
Region Proposal 과 같은 알고리즘 대신 CNN 기반의 알고리즘을 사용하면 GPU에서 연산을 수행할 수 있어 속도 향상에 큰 도움이 된다.
RPN에서 객체이냐 배경인가를 구분하
고 박스의 위치와 크기를 추론한다.
Deep Learning
딥러닝

Anchors
feature map
Anchors
Anchors로 feature map에서 Sliding Windows를 이용해서 후보 영역을 추출한다.
Anchor boxes는 검출 박스를 추론하는데 있어서 사용하는
초기값.
Deep Learning
딥러닝

RCNN 계열 객체 검출기 속도 비교
Faster-RCNN은 초당 이미지를 5~7장 처리할 수 있다.
현재의 GPU가속 라이브러리와 양자화 등의 최신 기술을 사용하면 속도는 더욱 빨라진다.
RCNN Fast-RCNN Faster-RCNN Faster-RCNN(현재)
이미지당 처리 속도 47초 0.32초 0.2초 0.03초
속도 향상 1x 146x 235x 기존 Faster-RCNN 대
비 4.2x
Selective Search를 포
함한 이미지당 처리 속도
50초 2초 x x
속도 향상 1x 25x x x
Deep Learning
딥러닝

One-Stage Networks
현재 예측 박스가 위와 같다면 어떤 Ground Truth를 기준으로 학습해야 할지 알 수 없다.
?
Deep Learning
딥러닝

One-Stage Networks
이미지를 그리드로 분할하여 각 셀에서 박스를 예측한다.
Deep Learning
딥러닝

YOLO (You Only Look Once)
S x S 그리드 입력
검출 박스 + 확률 값
클래스별 확률 맵
최종 검출 박스
Deep Learning
딥러닝

?
하나의 셀에서 복수의 객체가 등장하면 앞서 발생한 문제가 똑같이 발생한다.
따라서, YOLO는 작은 객체를 탐지할 수 없다. (학습할 수 없다)
Deep Learning
딥러닝

마지막 레이어에서 어떻게 객체를 검출 할까요
YOLO v1 Architecture
( 24 convolutional layer + 2 Fully connected Layer ).
Conv. Layer
7x7x64-s-2
Maxpool Layer
2x2-s-2
448
448
7x7
112
112
192
3x3
56
56
256
3x3
Conv. Layer
3x3x192
Maxpool Layer
2x2-s-2
28
28
512
3x3
14
14
1024
3x3
Conv. Layer
1x1x128
3x3x256
1x1x256
3x3x512
Maxpool Layer
2x2-s-2
Conv. Layer
1x1x256
3x3x512
1x1x512
3x3x1024
Maxpool Layer
2x2-s-2
} x4
7
7
1024
3x3
Conv. Layer
1x1x512
3x3x1024
3x3x1024
3x3x1024-s-
2
} x2
7
7
1024
Conv. Layer
3x3x1024
3x3x1024
Fully Conn. Layer
4096
Fully Conn. Layer
7
7
10 + number of classes
One-Stage Network
Deep Learning
딥러닝

마지막 텐서 블록은 2개의 박스와 모든 클래스에 대한 확률 값을 가지고 있음.
7
1x16
1x(10+num of classes)
하나의 셀(Cell) 당 2개의 박스를 검출한다.
1x5 1x5
x, y, w, h, confidence
10 + 클래스 개수
Transmission tower has 6 types of facilities.
Ceramic
insulator
probability
Polymer
insulator
probability
Lighting
Arrester
probability
Damper
weight
probability
Space
damper
probability
Balisor
probability
1x6
Deep Learning
딥러닝

ML(KNN, Decision Tree), DL(RCNN, YOLO) educational slide

More Related Content

Similar to ML(KNN, Decision Tree), DL(RCNN, YOLO) educational slide (14)

More from Bomm (Rowen) Kim (7)

ML(KNN, Decision Tree), DL(RCNN, YOLO) educational slide