기말시험
6/10(월) 16:00~, 장소 톡 알림 예정
객관식 10문제 *3 = 30점 (코드 중심, 관계점수/예측 함수는 무엇인지)
단답/서술형 5~8문제
마지막 문제: 방학계획, 또는 수강 소감/개선점 등
100점 * 30% = 30점
시험범위: 9주차~14주
출석 과제 중간 기말
과제 15점 만점
20 15 28 63
중간고사 평균 22.6 전체점수 평균 55.0
https://drive.google.com/file/d/131sfXw2hvUL-T8lYW7fL3Vn9m9IVdzAC/view
14_2_이미지_분류_신경망_실습.zip
drive.google.com
1. 이미지 분류를 위한 신경망
• LeNet-5
✓ 합성곱 신경망이라는 개념을 최초로 얀 르쿤(Yann LeCun)이 개발한 구조
▪ 1995년 얀 르쿤, 레옹 보토(Leon Bottu), 요슈아 벤지오(Yosua Bengio), 패트릭 하프너(Patrick Haffner)가
수표에 쓴 손글씨 숫자를 인식하는 딥러닝 구조 LeNet-5를 발표했는데, 그것이 현재 CNN의 초석이 되었음.
✓ 합성곱(convolutional)과 다운 샘플링(sub-sampling or pooling)을 반복적으로 거치면서 마지막에
완전 연결층에서 분류를 수행
이미지 분류를 위한 신경망 : LeNet-5
• LeNet-5 구조
✓ C1에서 5×5 합성곱 연산 후 28×28 크기의 특성 맵(feature map) 6개를 생성
✓ S2에서 다운 샘플링하여 특성 맵 크기를 14×14로 줄임
✓ C3에서 5×5 합성곱 연산하여 10×10 크기의 특성 맵 16개를 생성, S4에서 다운 샘플링하여 특성 맵 크기를 5×5로 줄임
✓ C5에서 5×5 합성곱 연산하여 1×1 크기의 특성 맵 120개를 생성하고,
✓ 마지막으로 F6에서 완전연결층으로 C5의 결과를 노드 84개에 연결시킴
이미지 분류를 위한 신경망 : LeNet-5
• LeNet-5
✓ 32×32 크기의 이미지에 합성곱층과 평균 풀링층이 쌍으로 두 번 적용된 후
완전 연결층을 거쳐 이미지가 분류되는 신경망
이미지 분류를 위한 신경망 : LeNet-5
• LeNet-5 신경망 상세
이미지 분류를 위한 신경망 : AlexNet
• AlexNet
✓ ImageNet 영상 데이터베이스를 기반으로 한 화상 인식 대회 ‘ILSVRC 2012’에서 우승한 CNN 구조
▪ 이미지를 다루기 때문에 기본적으로 3차원 데이터를 다룸.
▪ 이미지 크기를 나타내는 너비(width)와 높이(height)뿐만 아니라 깊이(depth)를 갖음.
✓ 보통 색상이 많은 이미지는 R/G/B 성분 세 개를 갖기 때문에 시작이 3이지만,
합성곱을 거치면서 특성 맵이 만들어지고 이것에 따라 중간 영상의 깊이가 달라짐.
이미지 분류를 위한 신경망 : AlexNet
• AlexNet 구조
✓ AlexNet은 합성곱층 총 5개와 완전연결층 3개로 구성되어 있음.
▪ 전체적으로 보면 GPU 두 개를 기반으로 한 병렬 구조인 점을 제외하면 LeNet-5와 크게 다르지 않음.
✓ 전체적으로 보면 GPU 두 개를 기반으로 한 병렬 구조인 점을 제외하면 LeNet-5와 크게 다르지 않음.
이미지 분류를 위한 신경망 : AlexNet
• AlexNet
✓ 네트워크에는 학습 가능한 변수가 총 6600만 개
✓ 입력은 227×227×3 크기의 RGB 이미지이며, 각 클래스에 해당하는 1000×1 확률 벡터를 출력
▪ AlexNet의 첫 번째 합성곱층 커널의 크기는 11×11×3이며, 스트라이드를 4로 적용하고
▪ 특성 맵을 96개 생성하여 55×55×96의 출력을 갖음
✓ 첫 번째 계층을 거치면서 GPU-1에서는 주로 컬러와 상관없는 정보를 추출하기 위한 커널이
학습되고, GPU-2에서는 주로 컬러와 관련된 정보를 추출하기 위한 커널이 학습
이미지 분류를 위한 신경망 : AlexNet
• AlexNet 신경망 상세
이미지 분류를 위한 신경망 : AlexNet
• AlexNet
이미지 분류를 위한 신경망 : VGGNet
• VGGNet
✓ 합성곱층의 파라미터 개수를 줄이고 훈련 시간을 개선하려는 시도
✓ 네트워크 계층의 총 개수에 따라 여러 유형의 VGGNet(VGG16, VGG19 등)이 있음
▪ VGG16에는 파라미터가 총 1억 3300만 개
▪ 모든 합성곱 커널의 크기는 3×3,
▪ 최대 풀링 커널의 크기는 2×2이며,
▪ 스트라이드는 2
이미지 분류를 위한 신경망 : VGGNet
• VGGNet16 신경망 상세
이미지 분류를 위한 신경망 : GoogleLeNet
• GoogLeNet, 인셉션 모듈
이미지 분류를 위한 신경망 : ResNet
• ResNet
2. 객체 인식을 위한 신경망
객체 인식을 위한 신경망
• 객체 인식(object detection)은 이미지나 영상 내에 있는 객체를 식별하는 컴퓨터 비전 기술
✓ 즉, 객체 인식이란 이미지나 영상 내에 있는 여러 객체에 대해 각 객체가 무엇인지를 분류하는 문제와
그 객체의 위치가 어디인지 박스(bounding box)로 나타내는 위치 검출(localization) 문제를 다루는 분야
▪ 객체 인식 = 여러 가지 객체에 대한 분류 + 객체의 위치 정보를 파악하는 위치 검출
객체 인식을 위한 신경망
• 딥러닝을 이용한 객체 인식 알고리즘은 크게 1단계 객체 인식(1-stage detector)과
2단계 객체 인식(2-stage detector)으로 나눌 수 있음
✓ 1단계 객체 인식은 이 두 문제(분류와 위치 검출)를 동시에 행하는 방법이고,
2단계 객체 인식은 이 두 문제를 순차적으로 행하는 방법
✓ 1단계 객체 인식은 비교적 빠르지만 정확도가 낮고,
2단계 객체 인식은 비교적 느리지만 정확도가 높음
✓ 2단계 객체 인식은 CNN을 처음으로 적용시킨 R-CNN 계열이 대표적이며,
1단계 객체 인식에는 YOLO(You Only Look Once) 계열과 SSD 계열 등이 포함
객체 인식을 위한 신경망 : R-CNN
• R-CNN
✓ 일정한 크기를 가지는 윈도우(window)를 가지고 이미지의 모든 영역을 탐색하면서 객체를 검출해 내는 방식
▪ 알고리즘의 비효율성 때문에 많이 사용하지 않았으며, 현재는 선택적 탐색(selective search) 알고리즘을
적용한 후보 영역(region proposal)을 많이 사용
▪ 이미지 분류를 수행하는 CNN과 이미지에서 객체가 있을 만한 영역을 제안해 주는 후보 영역 알고리즘을
결합한 알고리즘
객체 인식을 위한 신경망 : R-CNN
• R-CNN, 단계별 결과
VGGNet19 신경망 실습
%load_ext tensorboard
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import cv2
from tensorflow.keras import Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.losses import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, Dropoutclass VGG19(Sequential):
def __init__(self, input_shape):
super().__init__()
self.add(Conv2D(64, kernel_size=(3,3), padding= 'same',
activation= 'relu', input_shape= input_shape))
self.add(Conv2D(64, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(MaxPooling2D(pool_size=(2,2), strides= (2,2)))
self.add(Conv2D(128, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(128, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(MaxPooling2D(pool_size=(2,2), strides= (2,2)))
self.add(Conv2D(256, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(256, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(256, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(256, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(MaxPooling2D(pool_size=(2,2), strides= (2,2)))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(MaxPooling2D(pool_size=(2,2), strides= (2,2)))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(Conv2D(512, kernel_size=(3,3), padding= 'same',
activation= 'relu'))
self.add(MaxPooling2D(pool_size=(2,2), strides= (2,2)))
self.add(Flatten())
self.add(Dense(4096, activation= 'relu'))
self.add(Dropout(0.5))
self.add(Dense(4096, activation= 'relu'))
self.add(Dropout(0.5))
self.add(Dense(1000, activation= 'softmax'))
self.compile(optimizer= tf.keras.optimizers.Adam(0.003),
loss='categorical_crossentropy',
metrics=['accuracy'])model = VGG19(input_shape=(224, 224, 3))
model.summary()
실행결과
Model: "vgg19"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃ Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D) │ (None, 224, 224, 64) │ 1,792 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D) │ (None, 224, 224, 64) │ 36,928 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d (MaxPooling2D) │ (None, 112, 112, 64) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_2 (Conv2D) │ (None, 112, 112, 128) │ 73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_3 (Conv2D) │ (None, 112, 112, 128) │ 147,584 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_1 (MaxPooling2D) │ (None, 56, 56, 128) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_4 (Conv2D) │ (None, 56, 56, 256) │ 295,168 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_5 (Conv2D) │ (None, 56, 56, 256) │ 590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_6 (Conv2D) │ (None, 56, 56, 256) │ 590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_7 (Conv2D) │ (None, 56, 56, 256) │ 590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_2 (MaxPooling2D) │ (None, 28, 28, 256) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_8 (Conv2D) │ (None, 28, 28, 512) │ 1,180,160 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_9 (Conv2D) │ (None, 28, 28, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_10 (Conv2D) │ (None, 28, 28, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_11 (Conv2D) │ (None, 28, 28, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_3 (MaxPooling2D) │ (None, 14, 14, 512) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_12 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_13 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_14 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_15 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_4 (MaxPooling2D) │ (None, 7, 7, 512) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten) │ (None, 25088) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense) │ (None, 4096) │ 102,764,544 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout (Dropout) │ (None, 4096) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense) │ (None, 4096) │ 16,781,312 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_1 (Dropout) │ (None, 4096) │ 0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_2 (Dense) │ (None, 1000) │ 4,097,000 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘
Total params: 143,667,240 (548.05 MB)
Trainable params: 143,667,240 (548.05 MB)
Non-trainable params: 0 (0.00 B)
Test
model.load_weights("./data/vgg19_weights_tf_dim_ordering_tf_kernels.h5")
classes= {282: 'cat',
681: 'notebook, notebook computer',
970: 'alp'}
img=cv2.imread('./data/labtop.jpg')
#img=cv2.imread('./data/starrynight.jpeg')
#img=cv2.imread('./data/cat.jpg')
img = cv2.resize(img, (224, 224))
plt.figure()
plt.imshow(img)
img = img[np.newaxis, :]
predicted_value = model.predict (img)
predicted_value = np.argmax(predicted_value)
print (predicted_value)
plt.title(classes[predicted_value])
'Artificial Intelligence > AI' 카테고리의 다른 글
| XVIII 합성곱 신경망의 구성요소, CNN 모델 학습 (0) | 2024.05.29 |
|---|---|
| XVII 텐서플로 기반 신경망 구현 실습 (0) | 2024.05.27 |
| XVI 신경망 추론 실습 (MNIST) (0) | 2024.05.22 |
| XV 퍼셉트론과 신경망 (0) | 2024.05.20 |
| XIV 서포트 벡터 머신 (SVM) (0) | 2024.05.17 |