당신은 주제를 찾고 있습니까 “이미지 데이터 전처리 – [14] 머신러닝, 데이터 준비 방법 – 데이터 제공 사이트, 전처리 방법“? 다음 카테고리의 웹사이트 https://you.charoenmotorcycles.com 에서 귀하의 모든 질문에 답변해 드립니다: https://you.charoenmotorcycles.com/blog/. 바로 아래에서 답을 찾을 수 있습니다. 작성자 친절한 AI 이(가) 작성한 기사에는 조회수 15,003회 및 좋아요 365개 개의 좋아요가 있습니다.
이미지 데이터 전처리 주제에 대한 동영상 보기
여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!
d여기에서 [14] 머신러닝, 데이터 준비 방법 – 데이터 제공 사이트, 전처리 방법 – 이미지 데이터 전처리 주제에 대한 세부정보를 참조하세요
안녕하세요, 친절한AI 미정입니다 🙂
이번시간은 머신러닝을 하기 위해 데이터를 어떻게 준비할 수 있는지 알아보겠습니다.
공개되어있는 데이터가 많이많이 올라와있는 좋은 사이트 주소가 아래 있으니 꼭 한번 들려보세요!
[국내]– AI 팩토리 : http://aifactory.space
– 공공데이터포털 : https://www.data.go.kr/datasetsearch
– AI허브 : http://www.aihub.or.kr
– 데이콘 : https://dacon.io
– 보건의료빅데이터개방시스템 : https://opendata.hira.or.kr
[국외]– 캐글 : https://www.kaggle.com/datasets
– 구글 : https://toolbox.google.com/datasetsearch
– 레딧 : https://www.reddit.com/r/datasets/
– UCI : https://archive.ics.uci.edu/ml/
이미지 데이터 전처리 주제에 대한 자세한 내용은 여기를 참조하세요.
CNN 이미지 데이터 전처리 및 변환 기초 지식 [메모리와 하드 …
feature (image) 값과 label값(cat & dog)을 numpy array값을 변환 하여야 한다. 데이터 전처리 하는데, 이미지 데이터 원본 그대로 학습 하려면, …
Source: rdmkyg.blogspot.com
Date Published: 9/13/2021
View: 7477
이미지 처리를 위한 데이터 전처리 – velog
얼굴 인식 카메라화질 개선(Super Resolution)\*이미지 자동 태깅기존에 다루던 데이터들: 정형데이터 DataFrame형태로 정리되어있던.이미지 데이터는 …
Source: velog.io
Date Published: 5/23/2021
View: 3859
0310 – 이미지 데이터 전처리 – study blog
0310 – 이미지 데이터 전처리. ivo_lee 2020. 3. 10. 15:29. 오픈 소스 컴퓨터 비전 라이브러리 open source computer vision library (OpenCV)
Source: ivo-lee.tistory.com
Date Published: 7/15/2022
View: 4262
이미지 데이터 전처리하기 – HONG’S DB
이미지 데이터 전처리하기. Kellyyyy 2020. 5. 4. 08:00. * 저는 머신러닝/딥러닝에 관해 공부하고 있는 사람입니다. 잘못된 내용이나 참고할 만한 내용이 있다면 댓글 …
Source: hyjykelly.tistory.com
Date Published: 6/28/2021
View: 9566
augmentation, normalization(이미지 수집부터 분류 모델까지)
데이터 수집 – 전처리 – 모델링 – 성능 개선. 이번 포스팅은 직접 수집한 이미지들에 대해서 전처리를 해줍니다. 이 과정은 모델이 보다 더 잘 학습할 …
Source: inhovation97.tistory.com
Date Published: 12/20/2022
View: 5645
[머신러닝] 07.다양한 신경망_(1) 이미지 처리를 위한 전처리, 딥 …
1. MNIST 분류 CNN 모델 – 데이터 전 처리, 모델 구현, 평가 및 예측. – 손글씨로 된 사진을 모아 둔 데이터이다. – MNIST 데이터는 이미지 데이터이지만 …
Source: kcy51156.tistory.com
Date Published: 1/15/2021
View: 5446
1.Data Load 및 Preprocessing (전처리) – Time Traveler
1. Custom dataset directory 설정. 1) 학습데이터는 이미지 파일이므로 파일데이터와 관련된 module를 import합니다. OS 모듈은 환경 변수나 디렉터리, …
Source: 89douner.tistory.com
Date Published: 7/11/2022
View: 2639
이미지 인식의 꽃, CNN 학습 데이터 전처리 과정 – bbokday
CNN 데이터 전처리 과정을 정리해보자 ! from keras.datasets import mnist # 케라스 이용 mnist 데이터셋 가져오기 MNIST 데이터 셋 : 손글씨 데이터 …
Source: re-b-iew.tistory.com
Date Published: 1/7/2021
View: 2013
[Pytorch] Image Preprocessing 이미지 전처리 – IT_World
모델을 통한 이미지 분류 (Image Classification)를 파이썬 (Python)과 파이 토치 (Pytorch)로 진행했다. 이미지 데이터 전처리 (Image Preprocessing).
Source: niniit.tistory.com
Date Published: 11/30/2022
View: 5074
12. 고양이와 개 이미지 분류하기 – Codetorial
Kaggle Dogs Vs. Cats 데이터셋 살펴보기. 모델 구성하기. 모델 컴파일하기. 이미지 데이터 전처리하기. 모델 훈련하기. 정확도와 손실 확인하기. 테스트 이미지 분류 …
Source: codetorial.net
Date Published: 6/2/2022
View: 4229
주제와 관련된 이미지 이미지 데이터 전처리
주제와 관련된 더 많은 사진을 참조하십시오 [14] 머신러닝, 데이터 준비 방법 – 데이터 제공 사이트, 전처리 방법. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.
![[14] 머신러닝, 데이터 준비 방법 - 데이터 제공 사이트, 전처리 방법](https://i.ytimg.com/vi/5KSkNfX1wpU/maxresdefault.jpg)
주제에 대한 기사 평가 이미지 데이터 전처리
- Author: 친절한 AI
- Views: 조회수 15,003회
- Likes: 좋아요 365개
- Date Published: 2020. 3. 24.
- Video Url link: https://www.youtube.com/watch?v=5KSkNfX1wpU
오늘도 데이터: CNN 이미지 데이터 전처리 및 변환 기초 지식 [메모리와 하드 용량이 큰 경우 빠른 연산], Cat and dog dataset
CNN 하면서 이미지 데이터 전처리는 아주 중요한 것이다. 본인이 수집하거나 관찰 한 사진이 많고, 데이터 라벨 작업을 하였다면, 아래와 같은 딥러닝 할 수 있는 데이터 셋을 만들어야 한다.
즉 feature (image) 값과 label값(cat & dog)을 numpy array값을 변환 하여야 한다. 데이터 전처리 하는데, 아래의 2가지 방법이 있다. 이번 설명은 첫번째 설명 방법이다. 이런 방법으로 하려면, RAM 메모리와 HDD 용량이 커야 한다.
이미지 데이터 원본 그대로 학습
Data generator 로 학습
즉, 개별 설비를 AI로 자동 제어 하고자 하는 시스템을 구현하는 경우 첫번째 방법으로 한다.
Image processing
참고로 훈련할 파일은 아래에 있다.
이미지 전처리 기초 지식
데이터 디렉토리위치 및 파일이름 리스트 작업
데이터 디렉토리 위치를 알려면, 아래와 같이 os 모듈을 가져와서, 위치를 안 다음에, 그림 파일에 있는 위치로 바꾸어야 한다.
# numpy를 가져오는 것은 기본이다.
import numpy as np
# os 모듈을 로딩 하고 디렉토리 확인
import os print(os.getcwd())
# 디렉토리 위치 바꾸기 data_dir = os.chdir(“/home/아이디/zz.capston/image”)
glob 모듈은 파일이름을 리스트 형태로 변환 하는데 사용되며 위와 같이 디렉토리 위치를 이미지 화일 있는 곳으로 바꾸어야 한다.
import glob # from glob import glob
# 파일이름을 리스트 형태로 변환 하는데 사용 data_list = glob(‘*.jpg’) data_list[1:5] [‘cat.1484.jpg’, ‘cat.688.jpg’, ‘cat.550.jpg’, ‘dog.1795.jpg’]
# 리스트의 갯수 len(data_list)
4000
텍스트 토큰화
리스트에 있는 텍스트 값을 나누는 것을 텍스트 토큰화 작업이라고 한다. 즉 텍스트 값을 나누어야 라벨을 정리 하여 하는데, Target 값을 “cat”, “dog”로 나누는 것이다. 즉 2가지 분류로 나누어 지니, 2진 분류 함수를 사용하는 sigmod 함수를 사용할 것이다.
# 케라스의 text_to_word_sequence 모듈을 로딩한다.
from tensorflow.keras.preprocessing.text import text_to_word_sequence text_to_word_sequence(data_list[0])
라벨변환
‘cat’과 ‘dog’과 같은 문자열은 딥러닝에서 인식 하지 못 하므로, 1,0으로 인코딩 하여 라벨을 변환 하여야 한다. 아래는 100개의 샘플 데이터를 가지고, Token 화 작업을 한 다음에 라벨 변환 하는 작업 이다.
# label 100개를 하였다고 가정하자 label = [] for n, path in enumerate(data_list[:100]): token = text_to_word_sequence(data_list[n]) label.append(token[0])
위와 같이 loop문으로 토큰화 작업을 완료 하였으면, 아래와 같이 인코딩 작업을 한다.
# label 인코드를 불러온다 from sklearn.preprocessing import LabelEncoder items = label encoder = LabelEncoder() encoder.fit(items) label = encoder.transform(items)
# lebel 디코딩 확인한다 encoder.inverse_transform(label) array([‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘cat’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘cat’, ‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘dog’, ‘cat’], dtype=’
이미지 처리를 위한 데이터 전처리
1. 우리 주변의 이미지 처리 기술 예시
얼굴 인식 카메라 화질 개선(Super Resolution)* 이미지 자동 태깅
기존에 다루던 데이터들: 정형데이터 DataFrame형태로 정리되어있던.
이미지 데이터는 그렇지 않음
컴퓨터에게 이미지는 각 픽셀 값을 가진 숫자 배열로 인식
픽셀당 갖고 있는 값은 해당 픽셀을 채울 색상을 의미
2. 이미지 전 처리하기
모두 같은 크기를 갖는 이미지로 통일
1) 가로 세로 픽셀 사이즈를 표현하는 ‘해상도’ 통일
2) 색을 표현하는 방식 통일 (RGB, HSV, Gray-scale, Binary, …)
모든 이미지의 해상도를 28×28로 변환(통일)
모든 이미지의 색 표현도 Gray-scale로 변환(통일)
3. 실습. MNIST 분류 CNN 모델 – 데이터 전 처리
신경망을 이용한 학습을 시작할 때 대부분 MNIST를 접하게 됩니다. MNIST는 손글씨로 된 사진을 모아 둔 데이터입니다.
손으로 쓴 0부터 9까지의 글자들이 있고, 이 데이터를 사용해서 신경망을 학습시키고, 학습 결과가 손글씨를 인식할 수 있는지 검증합니다.
이번 실습에서는 우선 이미지 데이터를 출력하고 그 형태를 확인하여 CNN 모델에 적용할 수 있도록 데이터 전 처리를 수행합니다.
CNN을 위한 데이터 전처리
MNIST 데이터는 이미지 데이터이지만 가로 길이와 세로 길이만 존재하는 2차원 데이터입니다. CNN 모델은 채널(RGB 혹은 흑백)까지 고려한 3차원 데이터를 입력으로 받기에 채널 차원을 추가해 데이터의 모양(shape)을 바꿔줍니다. 결과는 아래와 같습니다.
[데이터 수, 가로 길이, 세로 길이]-> [데이터 수, 가로 길이, 세로 길이, 채널 수]
차원 추가 함수
tf.expand_dims(data, axis)
: Tensor 배열 데이터에서 마지막 축(axis)에 해당하는 곳에 차원 하나를 추가할 수 있는 코드입니다. ( axis에 -1을 넣으면 어떤 data가 들어오던 마지막 축의 index를 의미합니다.)
지시사항
학습용 및 평가용 데이터를 CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.
tf.expand_dims 함수를 활용하여 train_images, test_images 데이터의 형태를 변환하고 각각 train_images, test_images에 저장합니다.
이미지 데이터 전처리
오픈 소스 컴퓨터 비전 라이브러리 open source computer vision library
(OpenCV)
conda install –channel https://conda.anaconda.org/menpo opencv3
pip install opencv-python pip install opencv-contrib-python
# 이미지 로드
• 머신러닝을 이미지에 적용하기 전에 학습 알고리즘이 사용할 수 있는 특성으로 변환해야 합니다.
import cv2 cv2.__version__ #OpenCV 버전 확인
• OpenCV의 imread를 사용하여 전처리를 위한 이미지를 로드할 수 있습니다
• 파이썬의 그래프 라이브러리인 Matplotlib을 사용하여 이미지를 출력합니다.
• 이미지는 하나의 데이터입니다.
• imread() – 이미지를 넘파이 배열(행렬)로 변환합니다. 행렬의 각 원소는 개별 픽셀에 해당합니다
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 plt.imshow(image, cmap=”gray”), plt.axis(“off”) # 이미지를 출력 plt.show() type(image) # 데이터 타입을 확인 image # 이미지 데이터를 확인 image.shape # 차원을 확인 (해상도)
• 흑백 이미지에서는 개별 원소의 값이 픽셀 강도입니다.
• 강도는 0~255까지의 범위를 가집니다.
• OpenCV는 BGR을 사용하며, Matplot lib을 비롯하여 대부분의 이미지 애플리케이션은 RGB를 사용합니다.
• Matplotlib에서 OpenCV 컬러 이미지를 올바르게 출력하려면 먼저 컬러를 RGB로 변환합니다.
# 컬러로 이미지를 로드합니다. image_bgr = cv2.imread(“./data/images/plane.jpg”, cv2.IMREAD_COLOR) image_bgr[0,0] # 픽셀을 확인 image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) # RGB로 변환 plt.imshow(image_rgb), plt.axis(“off”) # 이미지를 출력 plt.show()
# 이미지 저장
• OpenCV의 imwrite 사용 하여 전처리를 위한 이미지를 저장할 수 있습니다
• 이미지 포맷은 파일 확장자에 의해서 정의
• imwrite가 에러나 확인 메시지 없이 기존의 파일을 overwrite한다
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 cv2.imwrite(“./data/images/plane_new.jpg”, image) # 이미지를 저장
# 이미지 크기 변경
• resize() – 이미지 크기를 변경
• 전처리로서 이미지 크기 변경이 필요한 이유는 이미지들은 제각기 다양한 크기를 가지며, 특성으로 사용하려면 동
일한 차원으로 만들어야 합니다.
• 이미지 행렬에 정보를 담고 있기 때문에 이미지 크기를 표준화하게 되면 이미지의 행렬 크기와 거기에 담긴 정보
도 줄어듭니다.
• 머신러닝에서는 수천 또는 수십만 개의 이미지가 필요하며 이미지의 크기를 줄여서 메모리 사용량을 크게 줄일
수 있습니다.
• 머신러닝에서 많이 사용하는 이미지 크기는 32X32 ,64X64 ,96X96 ,245X256 입니다
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 image_50x50 = cv2.resize(image, (50, 50)) # 이미지 크기를 50×50 픽셀로 변경 plt.imshow(image_50x50, cmap=”gray”), plt.axis(“off”) # 이미지를 출력 plt.show()
# 이미지 자르기
• 이미지 주변을 제거하여 차원을 줄일 수 있습니다.
• 이미지는 2차원 넘파이 배열로 저장됩니다.
• 배열 슬라이싱을 사용해 간단하게 이미지를 자를 수 있습니다
• OpenCV는 이미지를 행렬로 표현하므로 이미지에서 남기고 싶은 특정 부분을 행과 열을 선택하여 이미지 자르기
기능을 사용합니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 image_cropped = image[:,:128] # 열의 처음 절반과 모든 행을 선택 plt.imshow(image_cropped, cmap=”gray”), plt.axis(“off”) # 이미지를 출력 plt.show()
# 이미지 투명도 처리
• 이미지를 흐리게 하려면 각 픽셀을 주변 픽셀의 평균값으로 변환합니다.
• 주변 픽셀에 수행되는 연산을 수학적으로 커널이라 표현합니다.
• 커널의 크기는 흐림의 정도를 결정합니다.
• 커널이 클수록 이미지가 더 부드러워집니다.
• 커널은 이미지를 선명하게 만드는 것부터 경계선 감지까지 이미지 처리 작업을 하는데 널리 사용됩니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 #각 픽셀 주변의 5X5커널 평균값으로 이미지를 흐리게 합니다. image_blurry = cv2.blur(image, (5,5)) plt.imshow(image_blurry, cmap=”gray”), plt.axis(“off”) # 이미지를 출력 plt.show() # 커널 크기의 영향을 강조하기 위해 100X100 커널로 같은 이미지를 흐리게 합니다. image_very_blurry = cv2.blur(image, (100,100)) plt.imshow(image_very_blurry, cmap=”gray”), plt.xticks([]), plt.yticks([]) # 이미지를 출력 plt.show()
# 이미지 투명도 처리
• 커널은 이미지를 선명하게 만드는 것부터 경계선 감지까지 이미지 처리 작업을 하는데 널리 사용됩니다.
• 커널 PCA와 서포트 벡터 머신이 사용하는 비선형 함수를 커널이라 부릅니다.
• Meanshift 알고리즘에서는 샘플의 영향 범위를 커널이라 부릅니다.
• 신경망의 가중치를 커널이라 부릅니다
• 커널 크기는 (너비, 높이)로 지정합니다.
• 주변 픽셀값의 평균을 계산하는 커널은 이미지를 흐리게 처리합니다.
• blur 함수는 각 픽셀에 커널 개수의 역수를 곱하여 모두 더합니다. ( 이 값이 중앙 픽셀의 값이 됩니다.)
kernel = np.ones((5,5)) / 25.0 # 커널을 만듭니다. kernel # 커널을 확인 image_kernel = cv2.filter2D(image, -1, kernel) # 커널을 적용 plt.imshow(image_kernel, cmap=”gray”), plt.xticks([]), plt.yticks([]) # 이미지 출력 plt.show() image_very_blurry = cv2.GaussianBlur(image, (5,5), 0) # 가우시안 블러를 적용 plt.imshow(image_very_blurry, cmap=”gray”), plt.xticks([]), plt.yticks([]) # 이미지 출력 plt.show()
• GaussianBlur()의 세번째 매개변수는 X축9너비) 방향의 표준편차입니다.
• 0으로 지정하면 ((너비-1)*0.5-1)*0.3+0.8와 같이 계산합니다.
• Y축 방향의 표준편차는 기본값이 0입니다
• 가우시안 블러에 사용한 커널은 각 축 방향으로 가우시안 분포를 따르는 1차원 배열을 만든 다음 외적하여 생성합
니다.
• getGaussianKernel()를 사용하여 1차원 배열을 만들고 넘파이 outer 함수로 외적을 계산할 수 있습니다.
• filter2D()의 두번째 매개변수는 픽셀값의 범위를 지정하는 것으로 -1이면 입력과 동일한 범위를 유지합니다.
gaus_vector = cv2.getGaussianKernel(5, 0) gaus_vector gaus_kernel = np.outer(gaus_vector, gaus_vector) # 벡터를 외적하여 커널을 만듭니다. gaus_kernel # filter2D()로 커널을 이미지에 직접 적용하여 비슷한 흐림 효과를 만들 수 있습니다. image_kernel = cv2.filter2D(image, -1, gaus_kernel) # 커널을 적용 plt.imshow(image_kernel, cmap=”gray”), plt.xticks([]), plt.yticks([]) # 이미지 출력 plt.show()
# 이미지 선명하게 하기
• 대상 픽셀을 강조하는 커널을 만들고 filter2D를 사용하여 이미지에 커널을 적용합니다
• 중앙 픽셀을 부각하는 커널을 만들면 이미지의 경계선에서 대비가 더욱 두드러지는 효과가 생깁니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 kernel = np.array([[0, -1, 0], [-1, 5,-1], [0, -1, 0]]) # 커널을 만듭니다. # 이미지를 선명하게 만듭니다. image_sharp = cv2.filter2D(image, -1, kernel) plt.imshow(image_sharp, cmap=”gray”), plt.axis(“off”) # 이미지 출력 plt.show()
# 이미지 대비 높이기
• 히스토그램 평활화는 객체의 형태가 두드러지도록 만들어주는 이미지 처리 도구입니다
• Y는 루마(luma) 또는 밝기이고 U와 V는 컬러를 나타냅니다..
• 흑백 이미지에는 OpenCV의 equalizeHist()를 바로 적용할 수 있습니다.
• 히스토그램 평활화는 픽셀값의 범위가 커지도록 이미지를 변환합니다.
• 히스토그램 평활화는 관심 대상을 다른 객체나 배경과 잘 구분되도록 만들어줍니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 image_enhanced = cv2.equalizeHist(image) # 이미지 대비를 향상시킵니다. plt.imshow(image_enhanced, cmap=”gray”), plt.axis(“off”) # 이미지 출력 plt.show() image_bgr = cv2.imread(“./data/images/plane.jpg”) # 이미지 로드 image_yuv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2YUV) # YUV로 변경합니다. image_yuv[:, :, 0] = cv2.equalizeHist(image_yuv[:, :, 0]) # 히스토그램 평활화를 적용 image_rgb = cv2.cvtColor(image_yuv, cv2.COLOR_YUV2RGB) # RGB로 바꿉니다. plt.imshow(image_rgb), plt.axis(“off”) # 이미지 출력 plt.show()
# 색상 구분
• 이미지에서 한 색상을 구분하려면 색 범위를 정의하고 이미지에 마스크를 적용합니다.
• 이미지를 HSV(색상, 채도, 명도)로 변환 -> 격리시킬 값의 범위를 정의 -> 이미지에 적용할 마스크를 만듭니다.(마
스크의 흰색 영역만 유지)
• bitwise_and()는 마스크를 적용하고 원하는 포맷으로 변환
import cv2 import numpy as np from matplotlib import pyplot as plt image_bgr = cv2.imread(‘./data/images/plane_256x256.jpg’) # 이미지 로드 image_hsv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV) # BGR에서 HSV로 변환 lower_blue = np.array([50,100,50]) # HSV에서 파랑 값의 범위를 정의 upper_blue = np.array([130,255,255]) mask = cv2.inRange(image_hsv, lower_blue, upper_blue) # 마스크를 만듭니다. image_bgr_masked = cv2.bitwise_and(image_bgr, image_bgr, mask=mask) # 이미지에 마스크를 적용 image_rgb = cv2.cvtColor(image_bgr_masked, cv2.COLOR_BGR2RGB) # BGR에서 RGB로 변환 plt.imshow(image_rgb), plt.axis(“off”) # 이미지를 출력 plt.show() plt.imshow(mask, cmap=’gray’), plt.axis(“off”) # 마스크 출력 plt.show()
# 이미지 이진화
• 이미지 이진화(임계처리)thresholding은 어떤 값보다 큰 값을 가진 픽셀을 흰색으로 만들고 작은 값을 가진 픽셀은
검은색으로 만드는 과정입니다.
• 적응적 이진화(임계처리)adaptive thresholding은 픽셀의 임계값이 주변 픽셀의 강도에 의해 결정됩니다.
• 이진화는 이미지 안의 영역 마다 빛 조건이 달라질 때 도움이 됩니다.
• adaptiveThreshold()의 max_output_value매개변수는 출력 픽셀 강도의 최대값을 결정
• cv2.ADAPTIVE_THRESH_GAUSSIAN_C는 픽셀의 임계값을 주변 픽셀 강도의 가중치 합으로 설정합니다
• cv2.ADAPTIVE_THRESH_MEAN_C는 픽셀의 임계값을 주변 픽셀의 평균으로 설정합니다
import cv2 import numpy as np from matplotlib import pyplot as plt image_grey = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 max_output_value = 255 neighborhood_size = 99 subtract_from_mean = 10 image_binarized = cv2.adaptiveThreshold(image_grey, max_output_value, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, neighborhood_size, subtract_from_mean) # 적응적 임계처리를 적용 plt.imshow(image_binarized, cmap=”gray”), plt.axis(“off”) # 이미지 출력 plt.show()
# cv2.ADAPTIVE_THRESH_MEAN_C를 적용합니다. image_mean_threshold = cv2.adaptiveThreshold(image_grey, max_output_value, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, neighborhood_size, subtract_from_mean) plt.imshow(image_mean_threshold, cmap=”gray”), plt.axis(“off”) # 이미지를 출력 plt.show()
# 배경 제거
• 이미지의 전경만 분리해내려면 원하는 전경 주위에 사각형 박스를 그리고 그랩컷 알고리즘을 실행합니다.
• 그랩컷은 사각형 밖에 있는 모든 것이 배경이라고 가정하고 이 정보를 사용하여 사각형 안에 있는 배경을 찾습니
다.
• 검은색 영역은 배경이라고 확실하게 가정한 사각형의 바깥쪽 영역이며, 회색 영역은 그랩컷이 배경이라고 생각하
는 영역이고 흰색 영역은 전경입니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image_bgr = cv2.imread(‘./data/images/plane_256x256.jpg’) # 이미지 로드 image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) # RGB로 변환 rectangle = (0, 56, 256, 150) # 사각형 좌표: 시작점의 x, 시작점의 y, 너비, 높이 mask = np.zeros(image_rgb.shape[:2], np.uint8) # 초기 마스크를 만듭니다. bgdModel = np.zeros((1, 65), np.float64) # grabCut에 사용할 임시 배열을 만듭니다. fgdModel = np.zeros((1, 65), np.float64)
# grabCut 실행 cv2.grabCut(image_rgb, # 원본 이미지 mask, # 마스크 rectangle, # 사각형 bgdModel, # 배경을 위한 임시 배열 fgdModel, # 전경을 위한 임시 배열 5, # 반복 횟수 cv2.GC_INIT_WITH_RECT) # 사각형을 사용한 초기화 # 배경인 곳은 0, 그외에는 1로 설정한 마스크를 만듭니다. mask_2 = np.where((mask==2) | (mask==0), 0, 1).astype(‘uint8′) # 이미지에 새로운 마스크를 곱해 배경을 제외합니다. image_rgb_nobg = image_rgb * mask_2[:, :, np.newaxis] plt.imshow(image_rgb_nobg), plt.axis(“off”) # 이미지 출력 plt.show() plt.imshow(mask, cmap=’gray’), plt.axis(“off”) # 마스크 출력 plt.show() plt.imshow(mask_2, cmap=’gray’), plt.axis(“off”) # 마스크 출력 plt.show()
# 경계선 감지
• 캐니(Canny) 경계선 감지기와 같은 경계선 감지 기술 사용
• 경계선 감지는 컴퓨터 비전의 주요 관심 대상이며 경계선은 많은 정보가 담긴 영역입니다.
• 경계선 감지를 사용하여 정보가 적은 영역을 제거하고 대부분의 정보가 담긴 이미지 영역을 구분할 수 있습니다.
• 캐니 감지기는 그레이디언트 임계값의 저점과 고점을 나타내는 두 매개변수가 필요합니다.
• 낮은 임계값과 높은 임계값 사이의 가능성 있는 경계선 픽셀은 약한 경계선 픽셀로 간주됩니다
• OpenCV의 Canny 함수는 낮은 임곗값과 높은 임곗값이 필수 매개변수입니다.
• Canny를 전체 이미지 모음에 적용하기 전에 몇 개의 이미지를 테스트하여 낮은 임계값과 높은 임곗값의 적절한 쌍
을 찾는 것이 좋은 결과를 만듭니다.
• 예제 실습은 낮은 임곗값과 높은 임곗값을 이미지 중간 픽셀 강도의 1표준편차 아래 값과 위 값으로 설정
import cv2 import numpy as np from matplotlib import pyplot as plt image_gray = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 median_intensity = np.median(image_gray) # 픽셀 강도의 중간값을 계산 # 중간 픽셀 강도에서 위아래 1 표준 편차 떨어진 값을 임계값으로 지정합니다. lower_threshold = int(max(0, (1.0 – 0.33) * median_intensity)) upper_threshold = int(min(255, (1.0 + 0.33) * median_intensity)) # 캐니 경계선 감지기를 적용합니다. image_canny = cv2.Canny(image_gray, lower_threshold, upper_threshold) plt.imshow(image_canny, cmap=”gray”), plt.axis(“off”) # 이미지 출력 plt.show()
# 모서리 감지
• cornerHarris – 해리스 모서리 감지의 OpenCV 구현
• 해리스 모서리 감지기는 두 개의 경계선이 교차하는 지점을 감지하는 방법으로 사용됩니다.
• 모서리는 정보가 많은 포인트입니다.
• 해리스 모서리 감지기는 윈도(이웃, 패치)안의 픽셀이 작은 움직임에도 크게 변하는 윈도를 찾습니다.
• cornerHarris 매개변수 block_size : 각 픽셀에서 모서리 감지에 사용되는 이웃 픽셀 크기
• cornerHarris 매개변수 aperture : 사용하는 소벨 커널 크기
import cv2 import numpy as np from matplotlib import pyplot as plt image_bgr = cv2.imread(“./data/images/plane_256x256.jpg”) # 흑백 이미지 로드 image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY) image_gray = np.float32(image_gray) block_size = 2 # 모서리 감지 매개변수를 설정 aperture = 29 free_parameter = 0.04
detector_responses = cv2.cornerHarris(image_gray, block_size, aperture, free_parameter) # 모서리를 감지 detector_responses = cv2.dilate(detector_responses, None) # 모서리 표시를 부각시킵니다. # 임계값보다 큰 감지 결과만 남기고 흰색으로 표시합니다. threshold = 0.02 image_bgr[detector_responses > threshold * detector_responses.max()] = [255,255,255] image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY) # 흑백으로 변환 plt.imshow(image_gray, cmap=”gray”), plt.axis(“off”) # 이미지 출력 plt.show() # 가능성이 높은 모서리를 출력합니다. plt.imshow(detector_responses, cmap=’gray’), plt.axis(“off”) plt.show()
image_bgr = cv2.imread(‘./data/images/plane_256x256.jpg’) image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY) # 감지할 모서리 개수 corners_to_detect = 10 minimum_quality_score = 0.05 minimum_distance = 25 corners = cv2.goodFeaturesToTrack(image_gray, corners_to_detect, minimum_quality_score, minimum_distance) # 모서리를 감지 corners = np.float32(corners) for corner in corners: x, y = corner[0] cv2.circle(image_bgr, (x,y), 10, (255,255,255), -1) # 모서리마다 흰 원을 그립니다. image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY) # 흑백 이미지로 변환 plt.imshow(image_rgb, cmap=’gray’), plt.axis(“off”) # 이미지를 출력 plt.show()
# 머신러닝 특성 만들기
• 이미지를 머신러닝에 필요한 샘플로 변환하려면 넘파이의 flatten()을 사용합니다.
• Flatten()은 이미지 데이터가 담긴 다차원 배열을 샘플값이 담긴 벡터로 변환
• 이미지가 흑백일 때 각 픽셀은 하나의 값으로 표현됩니다.
• 컬럼 이미지라면 각 픽셀이 하나의 값이 아니라 여러 개의 값으로 표현됩니다.
• 이미지의 모든 픽셀이 특성이 되기 때문에 이미지가 커질수록 특성의 개수도 크게 늘어납니다
import cv2 import numpy as np from matplotlib import pyplot as plt image = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) image_10x10 = cv2.resize(image, (10, 10)) # 이미지를 10×10 픽셀 크기로 변환 image_10x10.flatten() # 이미지 데이터를 1차원 벡터로 변환 plt.imshow(image_10x10, cmap=”gray”), plt.axis(“off”) plt.show() image_10x10.shape image_10x10.flatten().shape
image_color = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_COLOR) # 컬러 이미지로 로드 image_color_10x10 = cv2.resize(image_color, (10, 10)) # 이미지를 10 × 10 픽셀 크기로 변환 image_color_10x10.flatten().shape # 이미지 데이터를 1차원 벡터로 변환하고 차원을 출력
image_256x256_gray = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_GRAYSCALE) # 흑백 이미지로 로드 image_256x256_gray.flatten().shape # 이미지 데이터를 1차원 벡터로 변환하고 차원을 출력
image_256x256_color = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_COLOR) # 컬러 이미지로 로드 image_256x256_color.flatten().shape # 이미지 데이터를 1차원 벡터로 변환하고 차원을 출력
# 평균 색을 특성으로 인코딩
• 이미지의 각 픽셀은 여러 컬러 채널(빨간, 초록, 파랑)의 조합으로 표현되며, 채널의 평균값을 계산하여 이미지의
평균 컬러를 나타내는 세 개의 컬럼 특성을 만듭니다.
import cv2 import numpy as np from matplotlib import pyplot as plt # BGR 이미지로 로드 image_bgr = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_COLOR) channels = cv2.mean(image_bgr) # 각 채널의 평균을 계산 # 파랑과 빨강을 바꿉니다(BGR에서 RGB로 만듭니다) observation = np.array([(channels[2], channels[1], channels[0])]) observation # 채널 평균 값을 확인 plt.imshow(observation), plt.axis(“off”) # 이미지를 출력 plt.show()
# 컬러 히스토그램을 특성으로 인코딩
• 이미지의 각 픽셀은 여러 컬러 채널(빨간, 초록, 파랑)의 조합으로 표현되며, 채널의 평균값을 계산하여 이미지의
평균 컬러를 나타내는 세 개의 컬럼 특성을 만듭니다.
import cv2 import numpy as np from matplotlib import pyplot as plt image_bgr = cv2.imread(“./data/images/plane_256x256.jpg”, cv2.IMREAD_COLOR) image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)# RGB로 변환 features = [] # 특성 값을 담을 리스트 colors = (“r”,”g”,”b”) # 각 컬러 채널에 대해 히스토그램을 계산 # 각 채널을 반복하면서 히스토그램을 계산하고 리스트에 추가 for i, channel in enumerate(colors): histogram = cv2.calcHist([image_rgb], # 이미지 [i], # 채널 인덱스 None, # 마스크 없음 [256], # 히스토그램 크기 [0,256]) # 범위 features.extend(histogram) observation = np.array(features).flatten() # 샘플의 특성 값으로 벡터를 만듭니다. observation[0:5]
image_rgb[0,0] # RGB 채널 값을 확인 import pandas as pd data = pd.Series([1, 1, 2, 2, 3, 3, 3, 4, 5]) # 예시 데이터 data.hist(grid=False) # 히스토그램을 출력 plt.show() colors = (“r”,”g”,”b”) # 각 컬러 채널에 대한 히스토그램을 계산 # 컬러 채널을 반복하면서 히스토그램을 계산하고 그래프를 그립니다. for i, channel in enumerate(colors): histogram = cv2.calcHist([image_rgb], # 이미지 [i], # 채널 인덱스 None, # 마스크 없음 [256], # 히스토그램 크기 [0,256]) # 범위 plt.plot(histogram, color = channel) plt.xlim([0,256]) plt.show() # 그래프를 출력
이미지 데이터 전처리하기
* 저는 머신러닝/딥러닝에 관해 공부하고 있는 사람입니다.
잘못된 내용이나 참고할 만한 내용이 있다면 댓글로 남겨주시면 정말 감사드리겠습니다!
머신러닝/딥러닝 모델을 만들기 위해서는
학습 데이터를 ‘적절한 형태’로 가공해야한다.
여기서 ‘적절한 형태’란, 사용하는 모델에 따라 다르다.
내가 사용할 모델은 다층 퍼셉트론(MLP)이다.
MLP의 학습데이터는 다음과 같은 조건을 만족해야한다.
“정규화한 1차원배열”
그래서 이번 포스팅에서는 이미지데이터(X data)와 카테고리데이터(y data)를
정규화한 1차원배열로 만드는 방법 에 대해서 다룬다.
저번 포스팅에서 X_train, X_test, Y_train, Y_test 데이터를 다운로드 받았다.
하나씩 살펴보겠다.
1. X 데이터 (이미지 데이터)
X_train
X_train(RGB 형식 이미지 데이터)
shape 명령어를 사용하면 데이터 형식을 더 쉽게 파악할 수 있다.
X_train.shape
파이썬 shape() 명령어
(데이터 수, 세로, 가로, RGB 색공간) 순으로 출력한다.
총 데이터 수는 50000개 이고,
RGB 색공간을 가진 32 * 32 픽셀짜리 3차원 데이터임을 알 수 있다.
대표 사진 하나를 살펴보자.
plt.figure plt.imshow(X_train[0]) plt.colorbar() plt.grid(False) plt.show()
이미지데이터 출력
좌측과 아래쪽 눈금을 보면 크기가 32*32인 것을 확인할 수 있다.
우측의 컬러바는 한 픽셀이 가질 수 있는 값을 나타내는데 0~255사이의 값을 가질 수 있다고 보인다.
정리하면 X_train 데이터는
3차원 배열 형식이고, 정규화되지 않았다.
그래서 내가 해야할 일은
① 3차원 배열 → 1차원 배열
② 정규화(0~1사의 값으로 만들어주기)
① 3차원 배열 → 1차원 배열
reshape함수를 사용하면 차원축소를 할 수 있다.
첫 번째 인자에 -1을 넣어주면 1차원 배열로 차원 축소된다.
X_trian = X_train.reshape(-1, 32*32*3)
파이썬 reshape() 함수
2. 정규화
정규화를 위해서는 각 데이터들을 해당 데이터 셋이 가질 수 있는 값의 범위로 나눠주면 된다.
X_train의 경우 한 픽셀이 0~255사이의 값을 가질 수 있으므로 255로 나눠준다.
X_tain = X_train.reshape(-1, 32*32*3)/255
데이터 정규화
출력 결과를 보면 각 데이터가 정규화된 1차원 배열로 변환되었음을 확인할 수 있다.
2. y 데이터 (레이블 데이터)
y_train 데이터를 살펴보자.
len(y_train)
파이썬 len() 함수
X_train 데이터와 마찬가지로 데이터 수는 50000개이다.
좀 더 자세히 살펴보면,
y_train
레이블 데이터
각 데이터가 배열이 아닌 데이터(0차원(?))임을 알 수 있다.
y 데이터는 X 데이터가 어떤 사진인지, 그 카테고리를 뜻하는 데이터이기 때문에
위와 같은 형식을 갖는다.
각 레이블 값은 다음을 의미한다. (이전 포스팅 참조)
labels = [“airplane”,”automobile”,”bird”, “cat”, “deer”, “dog”, “frog”, “horse”, “ship”, “truck”]
나는 이 데이터들을 각각 정규화한 1차원 배열 형식으로 바꿔야 한다.
이런 카테고리 데이터를 정규화한 1차원 배열로 바꾸는 방법 중 하나는
one-hot vector 형식으로 바꾸는 것이다.
one-hot vector로 바꾸기
one-hot vector란 하나만 High(1) 상태이고, 다른 것은 Low(0) 상태인 데이터를 말한다.
예를 들어, ‘airplane’은 [1,0,0,0,0,0,0,0,0,0], ‘automobile’은 [0,1,0,0,0,0,0,0,0,0]
그리고 ‘truck’는 [0,0,0,0,0,0,0,0,0,1] 으로 표현할 수 있다.
tensorflow모듈 중 하나인 keras에서 제공하는 to_categorical 함수를 사용하면 손쉽게 바꿀 수 있다.
첫 번째 인자는 바꾸고자 하는 데이터셋을, 두 번째 인자에는 레이블 수를 입력하면 된다.
import keras y_train = keras.utils.to_categorical(y_train, 10)
파이썬 to_categorical() 함수
출력 결과를 보면 각 데이터가 정규화된 1차원 배열 형식임을 알 수 있다.
자, 이상으로 train셋에 대한 데이터 전처리는 끝났다.
X_test 와 y_test 데이터도 동일하게 변경해주자.
X_test = X_test.reshape(-1,32*32*3)/255 y_test = keras.utils.to_categorical(y_test, 10)
test 데이터 전처리
이상으로 다층퍼셉트론을 위한 데이터 전처리는 마쳤다.
다음 포스팅에서는 다층 퍼셉트론 모델을 정의 및 컴파일하고,
학습을 수행하는 내용에 대해 포스팅하겠다.
Reference.
https://www.tensorflow.org/tutorials/keras/classification
https://www.cs.toronto.edu/~kriz/cifar.html
3. (1) 이미지 전처리 – augmentation, normalization(이미지 수집부터 분류 모델까지)
이 포스팅은 아래 흐름대로 진행되는 포스팅입니다.
데이터 수집 – 전처리 – 모델링 – 성능 개선
이번 포스팅은 직접 수집한 이미지들에 대해서 전처리를 해줍니다.
이 과정은 모델이 보다 더 잘 학습할 수 있도록 여러 전처리를 진행합니다.
전처리 과정에서 torchvision.transform과 albumentations 라이브러리를 둘 다 사용해봅니다.
이번 포스팅은 torchvision.transform을 이용해서 이미지 전처리를 진행합니다.
https://inhovation97.tistory.com/36 << 이전 포스팅 [2. 파이썬 파일 정리하기 (이미지 수집부터 분류 모델까지)] 포스팅 순서
1. 이미지 resize하기
2. resize한 이미지 normalize하기
3. torchvision.transforms를 이용해 이미지 augmentation
티스토리 코드 가독성 때문에 먼저 코드 파일을 공유합니다. ( 주석도 잘 달아놓음 )
코랩으로 열기를 권장합니다.
https://github.com/inhovation97/personal_project/blob/main/pytorch/pytorch_project_Image_preprocessing.ipynb
이번 포스팅은 모델에 집어넣기 직전까지 데이터를 전처리해주는데, 포인트는 학습이 잘 되도록 데이터를 다듬어주는 데에 있습니다.
< trorchvision 라이브러리를 이용해 쉽게 이미지들을 전처리하기>
1. 이미지 resize
torchvision라이브러리를 이용하면 dataloader를 정의해주기가 굉장히 쉽습니다.
우선 파일들의 상황을 다시 확인해줍니다.
train/test 폴더를 만들어준 뒤 각 범주들의 폴더도 만들어 주었습니다.
train/test 데이터를 각 범주마다 8:2 split했습니다.
train : 1049
test : 263
제가 가져온 이미지들은 문제가 있습니다. size가 전부 다 다릅니다.
cnn 모델은 featuremap을 뽑기위해 input data의 형태에 맞게 아키텍쳐를 설계하기 때문에 이미지들의 size를 전부 맞춰주어야합니다.
폴더들을 위 처럼 정리해 두었다면, torchvision의 ImageFolder라는 함수를 이용해 root에 경로만 지정해주면, 알아서 각 범주의 이미지들을 읽어주기 때문에 매우 편리하게 dataset을 정의할 수 있습니다.
torchvision의 transforms을 이용해서 모든 이미지들을 128*128로 resize해준 뒤에 tensor형태로 바꿔줍시다. totensor는 numpy형태의 이미지를 torch의 (C,H,W) tensor형태로 바꿔줍니다.
위 transforms를 진행하면, 요로코롬 이미지 데이터가 텐서형태로 변환하면서 픽셀도 전부 255로 나뉘어 range가 (0~1)값으로 스케일링이 됩니다.
2. reize한 이미지 normalize하기
먼저 이렇게 transform을 해준 이유가 있습니다.
바로 이미지들을 normalize해주기 위함입니다.
범위를 조정함으로써 step해 나가는 landscape를 안정화 시켜서 local optima 문제를 예방하고, 속도 측면에서도 좋아진다고합니다.
저는 앞서 이 글 첫 번째 포스팅에서 resnet50 모델을 transfer leaning을 할 것이라고 말했었는데, 찾아보니 ImageNet에서 쓰인 데이터들의 평균을 이용해서 normalize해주는 경우도 있다고 하더라구요. 일단 저는 제가 크롤링한 데이터들의 mean, std로 normalize를 진행하겠습니다.
하지만 normalize를 진행할 시에 꼭 중요한 점이있습니다.
1. 꼭 resize한 이미지들의 mean과 std로 normalize를 진행할 것
-> resize한 이미지를 학습할 것이기 때문에 resize한 데이터의 mean과 std를 이용해야 합니다.
2. train/test셋을 독립적으로 해야할까? (수정)
-> 보통의 경우 train셋에는 절대로 test셋의 정보가 들어가면 안됩니다. 두 data를 독립적으로 normalization을 해주지 않으면 의도치 않게 과적합의 위험에 빠져있겠죠…?
이미지 데이터에서는 normalization이 크게 작용하지는 않나봅니다. 아래 아래 cs231n에서는 image normalization을 저런 식으로 설명했고, 보통은 imagenet의 mean과 std를 이용하기도 하고, 그냥 mean 0.5, std 0.5로 noramlization을 진행하는 경향도 있다고합니다.
아무래도 지금 제 데이터셋처럼 (해양생물이라 파란색이 굉장히 많죠?) 이미지가 굉장히 독특하다면 직접 구해서 normalizatio해주는 방법도 나쁘지는 않겠습니다. (수정)
앞서 말했 듯 제가 공부한 cs231n에서는 그냥 하나의 mean/std로 normalization한다고하며, 채널별로 따로 하는 것도 큰 차이가 없다고 강의 내용에 나옵니다.
하지만 또 여기저기 서칭해보면, 대부분 이미지 데이터를 train/test의 각 채널의 mean과 std로 normalization 진행하는 경우가 많습니다.
https://inhovation97.tistory.com/23
train 셋과 test 셋을 전 처리할 때에는 동일한 mean을 이용하여 zero-mean을 해준다고 합니다.
여기서 mean값을 이미지의 전체 데이터로 할지, 아니면 각각 독립된 채널마다의 mean으로 이용할지 선택할 수 있는데, 이는 큰 차이는 나지 않는다고 합니다.
VGGNet은 알렉스 넷보다 후에 나온 것인데, 각각의 채널별로 mean값을 두어 zero-mean을 했다고 합니다.
cs231n이 오래된 강의이기도 하고… 이 부분은 이 참에 포스팅하면서 확인해보겠습니다!
엄청 큰 차이는 없을 것 같아요.
이렇게 train/test 셋들의 RGB 채널마다 mean과 std를 따로 구하는 함수를 만들어 구해줍니다.
이제 normalization 준비는 끝났습니다.
전부 해양생물 사진이라 그런지 red픽셀값은 낮고 blue 픽셀값은 높네요 ㅋㅋ
3. torchvision.transforms를 이용해 이미지 augmentation
현재 제 train데이터의 양은 너무 적습니다. 과적합의 위험이 있죠.
이 글들을 포스팅할 때부터 개인적으로 직접 image data를 수집하는 데에는 당연히 한계가 있기에 trainset이 적을 것을 예상했습니다.
그래서 제가 생각한 첫 번째는 transfer learning이었고, 두번째가 바로 data augmentation이었습니다.
이미 학습이 진행된 모델을 가져와 제 데이터들로 fine tuning을 해주고,
data augmentation을 통해서 학습의 epoch의 부담을 줄여주는 것입니다.
data augmentation 직역하면 ‘데이터 증식’ 말 그대로인데,
data augmentation 추가해주면, epoch마다 train 이미지들에 변형이 가해져서 모델이 1049장의 이미지들을 조금씩 다른 이미지로 받아들이게 해주는 것입니다.
보통은 학습 데이터만 augmentation을 해준다고합니다.
이런식으로 완전 다른 이미지는 아니지만 아마 epoch 수를 높히는 데에 부담이 줄어들 것입니다.
그래서 위 처럼 이미지를 크롭, 지터링, 회전 등등 augmentation을 가해줍니다.
augmentation을 가한 이미지는 다시 renormalize와 rescaling을 해주어야 이미지가 잘 나오니 참고하세용
이제 이렇게 torchvision을 이용해 data loader까지 학습을 위한 데이터의 준비가 끝이 났습니다.
다음 글은 똑같이 data를 준비하지만, 직접 데이터 class를 정의하여 커스터마이징하는 방법을 포스팅합니다.
(1) 이미지 처리를 위한 전처리, 딥러닝 모델
728×90
이미지 처리와 자연어 처리를 위한 데이터 전 처리와 딥러닝 모델을 알아보도록 하겠습니다.
1. 이미지 처리를 이용한 예시
2021 NIPA AI 온라인 교육 AI(인공지능) 실무 심화 (elice.io)
– 이미지에 있는 어떤 동물인지 분류하고자 할 때,
– 컴퓨터에게 이미지는 각 픽셀 값을 가진 숫자 배열로 인식하게 합니다.
2. 이미지 전 처리
– 모두 같은 크기를 갖는 이미지로 통일
1) 가로 세로 픽셀 사이즈를 표현하는 해상도 통일
2) 색을 표현하는 방식 통일(RGB, HSV, Gray-scale, Binary, …)
MNIST 데이터 이미지 전 처리
3. 이미지 처리 딥러닝 모델
1) 기존 다층 퍼셉트론 기반 신경망의 이미지 처리 방식
– 극도로 많은 수의 파라미터가 필요하다.
2) 합성곱 신경망(Convolution Neural Network)
– 작은 필터를 순환시키는 방식
– 이미지의 패턴이 아닌 특징을 중점으로 인식
3) 합성곱 신경망 구조
합성곱층 → 풀링층 → 완전연결층
– 입력 이미지의 특징을 추출, 분류하는 과정으로 동작이다.
– 이미지에서 어떠한 특징이 있는지를 구하는 과정.
– 필터가 이미지를 이동하며 새로운 이미지(피쳐맵)를 생성.
4) 피쳐맵의 크기 변형
– Padding : 원본 이미지의 상하좌우에 한 줄씩 추가
– String : 필터를 이동시키는 거리 설정(ex) 1칸씩 이동)
5) Pooling Layer(풀링층) : 이미지의 왜곡의 영향(노이즈)를 축소하는 과정.
– 최대풀링 : 가장 큰 값만 나오는 과정
– 평균풀링 : 4개의 숫자의 평균 값으로 축소하는 과정
6) Fully Connected Layer(완전연결층) : 추출된 특징을 사용하여 이미지를 분류.
7) 분류를 위한 Softmax활성화함수
– 마지막 계층에 Softmax활성화함수 사용
a+b+c+d+e+f= 1, a,b,c,d,e,f>=0
8) 정리
– Convolution Layer는 특징을 찾아내고, PoolingLayer는 처리할 맵(이미지) 크기를 줄여준다. 이를 N번 반복한다.
– 반복할 때마다 줄어든 영역에서의 특징을 찾게 되고, 영역의 크기는 작아졌기 때문에 빠른 학습이 가능해진다
사물 인식과 화질 개선
4. 실습
1. MNIST 분류 CNN 모델 – 데이터 전 처리, 모델 구현, 평가 및 예측
– 손글씨로 된 사진을 모아 둔 데이터이다.
– MNIST 데이터는 이미지 데이터이지만 가로 길이와 세로 길이만 존재하는 2차원 데이터입니다. CNN 모델은 채널(RGB 혹은 흑백)까지 고려한 3차원 데이터를 입력으로 받기에 채널 차원을 추가해 데이터의 모양(shape)을 바꿔줍니다. 결과는 아래와 같습니다.
[데이터 수, 가로 길이, 세로 길이] -> [데이터 수, 가로 길이, 세로 길이, 채널 수]1. 학습용 및 평가용 데이터를 CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.
– tf.expand_dims 함수를 활용하여 train_images, test_images 데이터의 형태를 변환하고 각각 train_images, test_images에 저장합니다.
tf.expand_dims(data, axis)
– Tensor 배열 데이터에서 마지막 축(axis)에 해당하는 곳에 차원 하나를 추가할 수 있는 코드입니다. ( axis에 -1을 넣으면 어떤 data가 들어오던 마지막 축의 index를 의미합니다.)
2. keras를 활용하여 CNN 모델을 설정합니다.
– 분류 모델에 맞게 마지막 레이어의 노드 수는 10개, activation 함수는 ‘softmax’로 설정합니다.
#CNN 레이어 tf.keras.layers.Conv2D(filters, kernel_size, activation, padding)
: 입력 이미지의 특징, 즉 처리할 특징 맵(map)을 추출하는 레이어입니다.
filters : 필터(커널) 개수
kernel_size : 필터(커널)의 크기
activation : 활성화 함수
padding : 이미지가 필터를 거칠 때 그 크기가 줄어드는 것을 방지하기 위해서 가장자리에 0의 값을 가지는 픽셀을 넣을 것인지 말 것인지를 결정하는 변수. ‘SAME’ 또는 ‘VALID’
#Maxpool 레이어 tf.keras.layers.MaxPool2D(padding)
: 처리할 특징 맵(map)의 크기를 줄여주는 레이어입니다.
padding : ‘SAME’ 또는 ‘VALID’
#Faltten 레이어 tf.keras.layers.Flatten()
: Convolution layer 또는 MaxPooling layer의 결과는 N차원의 텐서 형태입니다. 이를 1차원으로 평평하게 만들어줍니다.
#Dense 레이어 tf.keras.layers.Dense(node, activation)
node : 노드(뉴런) 개수
activation : 활성화 함수
3. evaluate 메서드와 평가용 데이터를 사용하여 모델을 평가합니다.
– loss와 accuracy를 계산하고 loss, test_acc에 저장합니다.
model.evaluate(X, Y)
evaluate() 메서드는 학습된 모델을 바탕으로 입력한 feature 데이터 X와 label Y의 loss 값과 metrics 값을 출력합니다.
4. predict_classes 메서드를 사용하여 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다
model.predict_classes(X)
.X 데이터의 예측 label 값을 출력합니다.
import numpy as np np.seterr(divide=’ignore’, invalid=’ignore’) import tensorflow as tf from tensorflow.keras import models import matplotlib.pyplot as plt import logging, os logging.disable(logging.WARNING) os.environ[“TF_CPP_MIN_LOG_LEVEL”] = “3” # 동일한 실행 결과 확인을 위한 코드입니다. np.random.seed(123) tf.random.set_seed(123) # MNIST 데이터 세트를 불러옵니다. mnist = tf.keras.datasets.mnist # MNIST 데이터 세트를 Train set과 Test set으로 나누어 줍니다. (train_images, train_labels), (test_images, test_labels) = mnist.load_data() # Train 데이터 5000개와 Test 데이터 1000개를 사용합니다. train_images, train_labels = train_images[:5000], train_labels[:5000] test_images, test_labels = test_images[:1000], test_labels[:1000] print(“원본 학습용 이미지 데이터 형태: “,train_images.shape) print(“원본 평가용 이미지 데이터 형태: “,test_images.shape) print(“원본 학습용 label 데이터: “,train_labels) # 첫 번째 샘플 데이터를 출력합니다. plt.figure(figsize=(10, 10)) plt.imshow(train_images[0], cmap=plt.cm.binary) plt.colorbar() plt.title(“Training Data Sample”) plt.savefig(“sample1.png”) elice_utils.send_image(“sample1.png”) # 9개의 학습용 샘플 데이터를 출력합니다. class_names = [‘zero’, ‘one’, ‘two’, ‘three’, ‘four’, ‘five’, ‘six’, ‘seven’, ‘eight’, ‘nine’] for i in range(9): plt.subplot(3,3,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i], cmap=plt.cm.binary) plt.xlabel(class_names[train_labels[i]]) plt.savefig(“sample2.png”) elice_utils.send_image(“sample2.png”) “”” 1. CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다. * 차원 축소 : tf.expand_dims(data, axis) “”” train_images = tf.expand_dims(train_images, -1) test_images = tf.expand_dims(test_images, -1) print(“변환한 학습용 이미지 데이터 형태: “,train_images.shape) print(“변환한 평가용 이미지 데이터 형태: “,test_images.shape) “”” 2. CNN 모델을 설정합니다. 분류 모델에 맞게 마지막 레이어의 노드 수는 10개, activation 함수는 ‘softmax’로 설정합니다. “”” model = tf.keras.Sequential([ tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = ‘relu’, padding = ‘SAME’, input_shape = (28,28,1)), tf.keras.layers.MaxPool2D(padding = ‘SAME’), tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = ‘relu’, padding = ‘SAME’), tf.keras.layers.MaxPool2D(padding = ‘SAME’), tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = ‘relu’, padding = ‘SAME’), tf.keras.layers.MaxPool2D(padding = ‘SAME’), tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation = ‘relu’), tf.keras.layers.Dense(10, activation = ‘softmax’) ]) # CNN 모델 구조를 출력합니다. print(model.summary()) # CNN 모델의 학습 방법을 설정합니다. model.compile(loss = ‘sparse_categorical_crossentropy’, optimizer = ‘adam’, metrics = [‘accuracy’]) # 학습을 수행합니다. history = model.fit(train_images, train_labels, epochs = 20, batch_size = 512) # 학습 결과를 출력합니다. Visulaize([(‘CNN’, history)], ‘loss’) “”” 1. 평가용 데이터를 활용하여 모델을 평가합니다. loss와 accuracy를 계산하고 loss, test_acc에 저장합니다. “”” loss, test_acc = model.evaluate(test_images, test_labels, verbose = 0) “”” 2. 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다. “”” predictions = model.predict_classes(test_images) # 모델 평가 및 예측 결과를 출력합니다. print(‘
Test Loss : {:.4f} | Test Accuracy : {}’.format(loss, test_acc)) print(‘예측한 Test Data 클래스 : ‘,predictions[:10]) # 평가용 데이터에 대한 레이어 결과를 시각화합니다. def Plotter(test_images, model): img_tensor = test_images[0] img_tensor = np.expand_dims(img_tensor, axis=0) layer_outputs = [layer.output for layer in model.layers[:6]] activation_model = models.Model(inputs=model.input, outputs=layer_outputs) activations = activation_model.predict(img_tensor) layer_names = [] for layer in model.layers[:6]: layer_names.append(layer.name) images_per_row = 16 for layer_name, layer_activation in zip(layer_names, activations): n_features = layer_activation.shape[-1] size = layer_activation.shape[1] n_cols = n_features // images_per_row display_grid = np.zeros((size * n_cols, images_per_row * size)) for col in range(n_cols): for row in range(images_per_row): channel_image = layer_activation[0, :, :, col * images_per_row + row] channel_image -= channel_image.mean() channel_image /= channel_image.std() channel_image *= 64 channel_image += 128 channel_image = np.clip(channel_image, 0, 255.).astype(‘uint8’) display_grid[col * size : (col+1) * size, row * size : (row+1) * size] = channel_image scale = 1. / size print(‘레이어 이름: ‘, layer_name) plt.figure(figsize=(scale * display_grid.shape[1], scale * display_grid.shape[0])) plt.grid(False) plt.imshow(display_grid, aspect=’auto’, cmap=’viridis’) plt.savefig(“plot.png”) plt.show() Plotter(test_images, model) >>> 원본 학습용 이미지 데이터 형태: (5000, 28, 28) 원본 평가용 이미지 데이터 형태: (1000, 28, 28) 원본 학습용 label 데이터: [5 0 4 … 2 1 2] 변환한 학습용 이미지 데이터 형태: (5000, 28, 28, 1) 변환한 평가용 이미지 데이터 형태: (1000, 28, 28, 1)
Model: “sequential_1” _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_3 (Conv2D) (None, 28, 28, 32) 320 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 14, 14, 32) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 14, 14, 32) 9248 _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 7, 7, 32) 0 _________________________________________________________________ conv2d_5 (Conv2D) (None, 7, 7, 32) 9248 _________________________________________________________________ max_pooling2d_5 (MaxPooling2 (None, 4, 4, 32) 0 _________________________________________________________________ flatten_1 (Flatten) (None, 512) 0 _________________________________________________________________ dense_2 (Dense) (None, 64) 32832 _________________________________________________________________ dense_3 (Dense) (None, 10) 650 ================================================================= Total params: 52,298 Trainable params: 52,298 Non-trainable params: 0 _________________________________________________________________ None Epoch 1/20 10/10 [==============================] – 4s 366ms/step – loss: 11.6434 – accuracy: 0.1918 Epoch 2/20 10/10 [==============================] – 4s 411ms/step – loss: 2.8053 – accuracy: 0.4942 Epoch 3/20 10/10 [==============================] – 4s 363ms/step – loss: 1.1313 – accuracy: 0.6814 Epoch 4/20 10/10 [==============================] – 4s 376ms/step – loss: 0.7214 – accuracy: 0.7814 Epoch 5/20 10/10 [==============================] – 4s 398ms/step – loss: 0.5193 – accuracy: 0.8426 Epoch 6/20 10/10 [==============================] – 4s 399ms/step – loss: 0.4148 – accuracy: 0.8766 Epoch 7/20 10/10 [==============================] – 5s 489ms/step – loss: 0.3480 – accuracy: 0.8986 Epoch 8/20 10/10 [==============================] – 4s 448ms/step – loss: 0.2965 – accuracy: 0.9146 Epoch 9/20 10/10 [==============================] – 4s 387ms/step – loss: 0.2565 – accuracy: 0.9272 Epoch 10/20 10/10 [==============================] – 5s 510ms/step – loss: 0.2211 – accuracy: 0.9364 Epoch 11/20 10/10 [==============================] – 5s 539ms/step – loss: 0.1967 – accuracy: 0.9446 Epoch 12/20 10/10 [==============================] – 5s 502ms/step – loss: 0.1722 – accuracy: 0.9504 Epoch 13/20 10/10 [==============================] – 6s 603ms/step – loss: 0.1515 – accuracy: 0.9582 Epoch 14/20 10/10 [==============================] – 5s 468ms/step – loss: 0.1365 – accuracy: 0.9636 Epoch 15/20 10/10 [==============================] – 6s 609ms/step – loss: 0.1204 – accuracy: 0.9670 Epoch 16/20 10/10 [==============================] – 5s 487ms/step – loss: 0.1080 – accuracy: 0.9704 Epoch 17/20 10/10 [==============================] – 6s 552ms/step – loss: 0.0974 – accuracy: 0.9730 Epoch 18/20 10/10 [==============================] – 4s 428ms/step – loss: 0.0861 – accuracy: 0.9766 Epoch 19/20 10/10 [==============================] – 4s 414ms/step – loss: 0.0763 – accuracy: 0.9800 Epoch 20/20 10/10 [==============================] – 4s 443ms/step – loss: 0.0681 – accuracy: 0.9834 Test Loss : 0.1878 | Test Accuracy : 0.9369999766349792 예측한 Test Data 클래스 : [7 2 1 0 4 1 4 9 5 9] 레이어 이름: conv2d_6 레이어 이름: max_pooling2d_6 레이어 이름: conv2d_7 레이어 이름: max_pooling2d_7 레이어 이름: conv2d_8 레이어 이름: max_pooling2d_8
출처 : 2021 NIPA AI 온라인 교육 | AI(인공지능) 실무 심화 (elice.io)
728×90
1.Data Load 및 Preprocessing (전처리)
CNN모델을 학습시킬 때, 가장먼저 해야할 것은 train, validation, test dataset을 load하는 것입니다.
이번 장에서는 내가 구축한 (custom) dataset을 load하는 방식에 대해서 알아보도록 하겠습니다.
1. Custom dataset directory 설정
1) 학습데이터는 이미지 파일이므로 파일데이터와 관련된 module를 import합니다.
OS 모듈은 환경 변수나 디렉터리, 파일 등의 OS 자원을 제어할 수 있게 해주는 모듈
import os
2)학습할 데이터셋을 세팅합니다.
우선 학습할 데이터를 다운받고 아래와 같이 세팅이 되어 있는지 확인해 줍니다.
기본적으로 학습을 위한 데이터(cat_and_dogs)는 아래와 같이 train, validation, test 데이터 셋으로 구성이 되어있습니다.
base_dir 경로
train, validation, test 데이터셋(폴더)에는 각각 클래스와 관련된 폴더가 있고, 해당 폴더에 실제 이미지 데이터가 위치합니다. cats_and_dogs 분류문제는 개와 고양이 두 클래스를 구분하는 binary classification 문제이므로, 각 폴더에 2개의 클래스(개, 고양이)가 포함되어 있습니다.
train_dir 경로
!! 주석부분에 폴더 정보들을 기록해놨으니 꼭 확인해 주세요 !!
#base_dir → 다운받은 원본 데이터셋 경로 = 모든 training, validation, test 데이터셋이 포함되어 있음 #cats_and_dogs에 있는 총 이미지 데이터 개수 = 25,000 ← training:20,000 + validation:4,000 + test:500 base_dir = ‘./datasets/cats_and_dogs/’ #train_dir → 원본 데이터셋의 학습 데이터 경로 = 모든 class(개, 고양이)들의 이미지들이 포함되어 있음 #train_dir에 있는 총 이미지 데이터 개수 = 20,000 ← 강아지=10,000 + 고양이=10,000 train_dir = os.path.join(base_dir, ‘train’) #train_dir = ‘./datasets/cats_and_dogs/train’ #validation_dir → 원본 데이터셋의 학습 데이터 경로 = 모든 class(개, 고양이)들의 이미지들이 포함되어 있음 #validation_dir에 있는 총 이미지 데이터 개수 = 4,000 ← 강아지=2,000 + 고양이=2,000 validation_dir = os.path.join(base_dir, ‘validation’) #validation_dir = ‘./datasets/cats_and_dogs/validation’ #test_dir → 원본 데이터셋의 학습 데이터 경로 = 모든 class(개, 고양이)들의 이미지들이 포함되어 있음 #test_dir에 있는 총 이미지 데이터 개수 = 1,000 ← 강아지=500 + 고양이=500 test_dir = os.path.join(base_dir, ‘test’) #test_dir = ‘./datasets/cats_and_dogs/test’
2. Preprocessing (Normalization)
아래 링크에 걸어둔 글에서 볼 수 있듯이, 보통 효율적인 학습을 위해 딥러닝의 학습데이터들은 전처리의 일환으로 normalization이 적용됩니다
https://89douner.tistory.com/42?category=868069
간단하게 말하자면, normalization이 적용된 학습데이터의 problem space가 더 안정적으로 형성될 수 있으므르로 학습이 더 수월하게 된다는 이점이 있습니다.
위와 같은 normalization을 적용해주기 위해서는 아래와 같이 zero center를 맞춰준후, data를 normalization 해주어야 합니다.
위와 같이 “zero-center→normalization”을 적용시켜주려면 아래와 같은 순서를 따르면 됩니다.
Zero center: 모든 데이터들의 평균을 구한다 → 모든 데이터들 각각에 해당 평균 값을 빼준다. Normalization: 모들 데이터들의 표준편차를 구한다 → 모든 데이터들 각각에 해당 표준편차 값을 나눠준다.
이미지 출처: https://www.kdnuggets.com/2020/04/data-transformation-standardization-normalization.html
위와 같은 데이터 전처리를 이미지에 적용할 때, 가능한 2가지 경우의 수가 있습니다.
2-1) 하나의 이미지 데이터를 기반으로 normalization 적용하기
예를 들어, 224×224×3 이미지가 있다고 가정해보겠습니다. 하나의 pixel에는 0~255값들이 들어 있는데, 앞에서 언급한 이미지 크기를 기준으로 한다면 150528(=224×224×3) pixel들이 존재하게 됩니다.
이미지 출처: http://openframeworks.kr/ofBook/chapters/image_processing_computer_vision.html
즉, 하나의 이미지에 해당하는 고유의 평균 및 표준편차 값을 구할 수 있기 때문에, 하나의 데이터에만 normalization을 적용할 수 있게 됩니다. 예를 들어, 150528(=224×224×3) 개의 pixel값들을 기반으로 평균 및 표준편차 값을 구하고, 모든 pixel에 평균값을 빼준후 표준편차값을 나눠주게 됩니다.
Keras API에서 의 설명을 보면 알 수 있듯이, 하나의 이미지당 normalization을 적용시키려면 samplewise 속성을 이용하면 됩니다.
samplewise_center : Boolean. Set each sample mean to 0.
: Boolean. Set each sample mean to 0. samplewise_std_normalization: Boolean. Divide each input by its std.
tf.keras.preprocessing.image.ImageDataGenerator( samplewise_center=True, samplewise_std_normalization=True )
(↓↓↓Keras Image data Preprocessing API: ex) ImageDataGenerator↓↓↓)
https://keras.io/api/preprocessing/image/
2-2) 모든 이미지 데이터를 기반으로 normalization 적용하기
이번에는 하나의 이미지가 아닌 batch 단위로 묶인 이미지들을 기반으로 하여 해당 평균 및 표준편차 값을 구한 뒤, normalization을 적용 시키는 방식입니다. (사실, 전체 학습 이미지에 대한 평균 및 표준편차 값을 구하는건지 아닌지 모르겠으나 해당 API에서 “The data will be looped over (in batches).”라고 기술된 부분을 보고 ‘batch 단위로 평균 및 표준편차 값이 구해지겠구나’라고 추정했습니다. 혹시 아니면 알려주시면 감사하겠습니다)
예를 들어 batch가 4라고 하면, 224×224×3×4 개의 pixel값들을 기반으로 평균 및 표준편차 값을 구하고, 모든 pixel에 평균값을 빼준후 표준편차값을 나눠주게 됩니다.
Keras API에서 의 설명을 보면 알 수 있듯이, batch 이미지당 normalization을 적용시키려면 featurewise 속성을 이용하면 됩니다.
tf.keras.preprocessing.image.ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True )
featurewise_center : Boolean. Set input mean to 0 over the dataset, feature-wise.
: Boolean. Set input mean to 0 over the dataset, feature-wise. featurewise_center: Boolean. Set input mean to 0 over the dataset, feature-wise.
아래 API를 보면 featurewise와 samplewise 관련 속성은 모두 False로 적용되어 있는걸 확인할 수 있다.
(↓↓↓Tensorflow 2 API 에서 ImageDataGenerator ↓↓↓)
https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator
Q. DNN에서 봤을 때는 이러한 것이 많은 도움이 되는걸 이론적으로 확인할 수 있습니다. 그런데, 개인적으로 pytorch 기반으로 작성하여 CNN에 적용시켰을 때는 적용을 하나 안하나 큰 차이가 없었던 것 같습니다. 다른 분야에서는 어떻게 적용하고 있는지 궁금하네요.
3. Data augmentation
CNN은 굉장히 다양한 data augmentation 기법을 지원합니다.
따라서 분류하려는 대상에 따라 적절한 data augmentation 기법을 적용시키면 됩니다.
예를 들어, Chest X-ray 같은 경우는 90도 rotation 해서 evaluation 하는 경우는 없으니, 90도 rotation은 적용시키지 않아도 되겠죠?
아래 코드에서 rescale은 overfitting을 방지하고자 모든 pixel 값들을 0~1 범위로 normalization 해주는 것인데, 앞서 “2. Preprocessing (Normalization)”에서 언급한 것과 같은 목적으로 적용된 것이라 생각하시면 될 것 같습니다.
tf.keras.preprocessing.image.ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True, zca_whitening=False, zca_epsilon=1e-06, rotation_range=0, width_shift_range=0.0, height_shift_range=0.0, brightness_range=None, shear_range=0.0, zoom_range=0.0, channel_shift_range=0.0, fill_mode=”nearest”, cval=0.0, horizontal_flip=False, vertical_flip=False, rescale=1./255 )
(↓↓↓위에서 언급한 data augmentation 중 몇 가지 예시↓↓↓)
Q. rescaling=./255를 먼저 해주고, feature_wise or sample_wise같은 normalization을 적용을 해주는건지, 아니면 그 반대순서로 적용을 해주는건지 모르겠네요….
4. 총정리: Data Load
지금까지 배운 내용을 토대로 data load 코드를 작성하면 아래와 같습니다.
import os from tensorflow import keras from tensorflow.keras.preprocessing.image import ImageDataGenerator base_dir = ‘./datasets/cats_and_dogs/’ train_dir = os.path.join(base_dir, ‘train’) validation_dir = os.path.join(base_dir, ‘validation’) train_datagen = ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True, rescale=1./255, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, validation_split=0.2) validation_datagen = ImageDataGenerator(rescale=1./255) train_generator = train_datagen.flow_from_directory( # 타깃 디렉터리 train_dir, # 모든 이미지를 150 × 150 크기로 바꿉니다 target_size=(150, 150), batch_size=32, # binary_crossentropy 손실을 사용하기 때문에 이진 레이블이 필요합니다 class_mode=’binary’) #cats_and_dogs는 2개의 클래스만 있음 validation_generator = validation_datagen.flow_from_directory( validation_dir, target_size=(150, 150), batch_size=32, class_mode=’binary’)
위와 같이 코드를 세팅해주면 학습을 시켜주기 위한 data loader 과정이 마무리 됩니다.
이후 아래 코드를 실행시켜주면 학습이 진행됩니다.
아래 코드는 다음 글에서 설명하도록 하겠습니다.
from tensorflow.keras import layers from tensorflow.keras import models from tensorflow.keras import optimizers model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation=’relu’, input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation=’relu’)) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation=’relu’)) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation=’relu’)) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(512, activation=’relu’)) model.add(layers.Dense(1, activation=’sigmoid’)) model.compile(loss=’binary_crossentropy’, optimizer=optimizers.RMSprop(lr=1e-4), metrics=[‘accuracy’])
※보통 cifar10, mnist, fashion mnist와 같은 적은 양의 데이터셋은 아래 링크에 기재된 tensorflow.keras.datasets 에서 제공을 해줍니다. 하지만, ImageNet 같은 경우는 데이터양이 워낙 방대하여 직접다운로드 받고 학습을 위한 구조를 세팅해주고 학습시켜야 한다는점 알아두시면 좋을것 같습니다!
https://www.tensorflow.org/api_docs/python/tf/keras/datasets
이미지 인식의 꽃, CNN 학습 데이터 전처리 과정
728×90
반응형
CNN 데이터 전처리 과정을 정리해보자 !
from keras.datasets import mnist # 케라스 이용 mnist 데이터셋 가져오기
MNIST 데이터 셋 : 손글씨 데이터셋
머신러닝 계의 HELLO WORLD 같은 데이터 셋
출처 : 위키 백과
데이터 전처리
케라스를 이용해서 간단히 불러올 수 있다.
mnist.load_data() 함수로 사용할 데이터를 불러온다
이때 불러온 이미지 데이터를 X로, 이 이미지에 0~9까지 붙인 이름표를 Y_Class로 구분하여 명명
– 학습에 사용될 부분 : X_train, Y_class_train
– 테스트에 사용될 부분 : X_test , Y_class_test
1. 케라스 이용하여 mnist 데이터셋 가져오고 제대로 가져왔는지 확인
from keras.datasets import mnist # 케라스 이용 mnist 데이터셋 가져오기 (X_train, Y_class_train), (X_test, Y_class_test) = mnist.load_data() #이미지 데이터를 X 로, 이 이미지에 0~9 까지 붙인 이름표를 Y_Class로 명명 #학습 : train , 테스트 : test print(“학습셋 이미지수 : %d 개 ” % (X_train.shape[0])) print(“테스트셋 이미지수 : %d 개 ” % (X_test.shape[0])) # 케라스의 데이터셋에서는 학습셋을 – 60000개 테스트셋을 100000개로 구분해놓았음을 확인할 수 있다
2. 불러온 이미지 데이터를 확인해보자
#불러온 이미지 중 한개만 가져와보기 #matplotlib 라이브러리를 사용하고 imgshow를 통해 image를 출력한다. import matplotlib.pyplot as plt plt.imshow(X_train[2], cmap= ‘Greys’) plt.show() #cmap = ‘Greys’ 옵션을 주면 흑백으로 출력하게 된다 .
예제에서는 제일 첫번째 이미지를 가져왔는데 나는 3번째거를 한번 가져와봤다 4라는 손글씨 이미지가 보인다.
이 이미지는 가로 * 세로 = 28* 28 로 총 784 개의 픽셀로 이뤄져 있고, 밝기 정도에 따라 0~ 255 의 등급을 매긴다. 3. 각 픽셀 정보 ( 밝기 정보) 를 픽셀 형식으로 확인해보자
import sys for x in X_train[2]: for i in x : sys.stdout.write(‘%d\t’ % i) sys.stdout.write(‘
‘) #sys 모듈은 그냥 import sys로 해주면 끝
요렇게 픽셀로 되어 있는 이미지는 다시 숫자의 집합으로 변해 학습셋으로 사용된다.
속성을 담은 데이터를 딥러닝에 집어넣고 클래스를 예측한느 문제 !
28*28 = 784개의 속성을 이용해 0~9까지 10개 클래스 중 하나를 맞히게 되는 문제가 된다.
4. 딥러닝에 이용하도록 데이터를 바꿔주자
주어진 28*28 의 이차원 배열을 784개의 1차원 배열로 바꿔보자
이때 사용하는 함수는 reshape()
reshape 함수 사용법은 reshape (총 샘플 수, 1차원 속성의 수)
#28* 28 2차원 행렬을 784*1 1차원행렬로 바꿔주기 #reshape 사용 reshape (총 샘플수, 1차원 속성의 수 ) X_train = X_train.reshape(X_train.shape[0], 784)
1차원으로 변경되었다.
케라스는 데이터가 0~1 사이일때 최적의 성능을 보이므로 0~255로 이루어진 데이터를 0~1로 변경하는 정규화 작업을 해준다. 그러기 위해서 우선 정수형 데이터를 astype() 함수 를 이용해 실수형으로 바꿔준다.
train , test 데이터 둘 다 적용해주면 된다.
#케라스는 데이터를 0~1 사이 값으로 변환한 다음 구동할 때 최적의 성능을 보이는 특징이 있다. #현재 픽셀의 데이터느 0~255까지 값이므로 이를 0~1로 바꿔주어야 한다. #데이터의 폭이 클 때 적절한 값으로 분산의 정도를 바꾸는 과정을 데이터 정규화(Data nomalization) #정규화를 위해 데이터를 실수형으로 바꾼다. (astype 함수 이용) X_train = X_train.astype(‘float64’) X_train = X_train / 255 # 0~255 값을 0~1 사이 값으로 바꾸기 위해 형태를 실수로 바꾸고 가장 큰수 (255)로 나눠서 nomalization을 취해준다
5. 숫자 이미지에 학습된 데이터를 확인해본다.
print(“class: %d” %(Y_class_train[2]))
class: 4
숫자의 레이블 값이 제대로 박혀있다.
6. 원-핫 인코딩
여러개의 Y 값을 0과 1로만 이루어진 형태로 바꿔주는 기법을 말한다.
딥러닝의 분류 문제를 해결하기 위해서는 원-핫 인코딩 방식을 이용해야 한다.
즉, 0~9까지의 정수형 값을 가지는 레이블 형태를 0또는 1로만 이루어진 벡터로 값을 수정해야 한다.
예를 들어 class가 4라면 [0,0,0,1,0,0,0,0,0,0] 로 바꿔줘야 한다.
이 작업을 해주는 함수가 np_utils.to_categorical 이다.
to_categorical (클래스, 클래스의 개수) 형식으로 지정하여 사용한다.
!pip install np_utils # INSTALL from keras import utils from keras.utils.np_utils import to_categorical
np_utils 를 불러올수 없다는 에러가 나는데 대체 왜일까… ? ㅠㅠ
바이너리부터 문제가 생기니 답답하다..
반응형
[Pytorch] Image Preprocessing 이미지 전처리
engine
개발 환경 : 리눅스 (Ubuntu)
언어 : 파이썬 (Python)
라이브러리 : 파이 토치 (Pytorch)
이미지 분류 (Image Classification)
이미지는 컴퓨터 비전 (Computer Vision) 분야에 속한다.
4차 산업혁명의 핵심인 딥러닝 기술은 현재까지 해당 분야에서 가장 큰 발전을 이뤘다고 볼 수 있으며,
크게 아래의 3가지 분야로 연구가 진행되고 있다.
– Classification은 고양이라는 사물의 존재 여부를 분류한다.
– Detection은 고양이라는 사물의 위치를 찾아냄과 동시에 여러가지 사물을 인식한다.
– Segmentation은 고양이라는 사물의 형태를 찾아낸다.
이번 프로젝트는 4차 산업혁명과 딥러닝의 가능성을 처음으로 대두시킨 CNN (Convolution Neural Network)
모델을 통한 이미지 분류 (Image Classification)를 파이썬 (Python)과 파이 토치 (Pytorch)로 진행했다.
이미지 데이터 전처리 (Image Preprocessing)
딥러닝 모델이 잘 학습하기 위해선 준비된 데이터들을 모델에 맞게 정제하는 과정이 필요하다.
이를 데이터 전처리 과정 (Preprocessing)이라 부르며,
이미지 데이터는 Augmentation,Normalizing,OpenCV,Scaling 등의 과정을 거친다.
데이터에 적합한 딥러닝 모델 생성
데이터 처리에 대표적인 딥러닝 모델은 CNN (Convolution Neural Network)이다.
2012년 ImageNet Large Scale Visual Recognition Challenge (ILSVRC)에서Alexnet 등장으로 딥러닝에 대한 가능성이 화제 되면서 많은 사람들이 CNN을 활용하기 시작했다.
기존 딥러닝 Neural Network는 Image Pixel 단위로 학습하기 때문에 Image의 공간적 패턴을 가진 특징을 찾지 못하는 한계가 있다. 이를 해결하기 위해 CNN 은 Convolution, Pooling, ReLU 과정을 통해 이미지 공간적 특징을 추출 후 이를 Fully Connected Layer를 통해 분류하는 구조로 구성되어 있다. 한마디로 이미지 공간적 정보를 갖고 있는 채 특징을 추출해 학습시키는 원리이다.
torchsummary는 코드를 쉽게 나타낸다. 없으면 pip로 설치하면 된다.
pip install torchsummary
Code
import torch.nn as nn class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() self.layer = nn.Sequential( # 3*200*200 nn.Conv2d(3, 32, 3, stride = 1), nn.BatchNorm2d(32), nn.ReLU(), # 32*198*198 nn.Conv2d(32, 64, 3, stride = 1), nn.BatchNorm2d(64), nn.ReLU(), # 64*196*196 nn.MaxPool2d(2, 2), # 64*98*98 nn.Conv2d(64, 128, 3, stride = 1), nn.BatchNorm2d(128), nn.ReLU(), # 128*96*96 nn.Conv2d(128, 256, 3, stride = 1), nn.BatchNorm2d(256), nn.ReLU(), # 256*94*94 nn.MaxPool2d(2, 2), # 256*47*47 nn.Conv2d(256,512,3, stride=1), nn.BatchNorm2d(512), nn.ReLU() ) # 512*45*45 self.avg_pool = nn.AvgPool2d(45) self.classifier = nn.Linear(512,5) def forward(self, x): feat = self.layer(x) flat = self.avg_pool(feat).view(feat.size(0),-1) out = self.classifier(flat) return out, feat
torchsummary import summary를 이용해 출력
from torchsummary import summary model = CNN().cuda() summary(model)
728×90
딥러닝 Hyperparameter, Optimizer, Loss Function을 지정해주면 모델 제작이 끝나게 된다.
Hyperparameter는 기본적으로 Batch Size, Epoch, Learning Rate 가 있고, Parser 를 활용해서 쉽게 수치를 바꿔 실험할 수 있다. Optimizer와 Loss Function 은 가장 많이 사용되는 Adam, Cross Entropy를 사용해도 좋다. 자유롭게 사용하자.
Log Interval 은 학습 과정을 출력하는 데 사용되는 수치이다.
import torch.optim parser = argparse.ArgumentParser(description=’Image’) parser.add_argument(‘–Resize’,type=int) parser.add_argument(‘–batch-size’, type=int) parser.add_argument(‘–epochs’, type=int) parser.add_argument(‘–lr’, type=float) parser.add_argument(‘–log-interval’, type=float) args = parser.parse_args() optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) loss_func = nn.CrossEntropyLoss()
마지막으로 train & test code 작성
dataset Loader에서 batch에 따른 image, label 호출 후 학습 진행
code
def train(args, model, train_loader, optimizer, epoch, loss_func, min_loss): model.train() train_loss = 0 correct = 0 for batch_index,[image,label] in enumerate(train_loader): image = image.cuda() label = label.cuda() out, feat = model(image) loss = loss_func(out,label) train_loss += loss.item() optimizer.zero_grad() loss.backward() optimizer.step() pred = out.argmax(dim=1, keepdim=True) # get the index of the max log-probability correct += pred.eq(label.view_as(pred)).sum().item() if batch_index % args.log_interval == 0: print(‘Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}’.format( epoch, batch_index * len(image), len(train_loader.dataset), 100. * batch_index / len(train_loader), loss.item())) train_loss /= len(train_loader) acc = 100. * correct / len(train_loader.dataset) if train_loss < min_loss: min_loss = train_loss torch.save(model.state_dict(), '/path(모델 저장 경로)/') return train_loss, acc, min_loss 테스트 코드는 말 그대로 테스트만! 학습에 관여하면 안 되므로 loss.backward과 같은 코드를 제거 후 트레이닝과 유사하게 작성한다. def test(args, model, test_loader, loss_func): model.eval() test_loss = 0 correct = 0 pred_save = [] for image, label in test_loader: image = image.cuda() label = label.cuda() out, feat = model(image) loss = loss_func(out,label) test_loss += loss.item() pred = out.argmax(dim=1, keepdim=True) # 최대 확률 인덱스 가져오기 correct += pred.eq(label.view_as(pred)).sum().item() pred_save.append(pred) test_loss /= len(test_loader) print(' Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%) '.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) val_acc = 100.*correct/len(test_loader.dataset) return test_loss, val_acc, pred_save 모델 평가 (Evaluation) 딥러닝 모델에 대한 성능 평가 지표로 파이썬 (Python)의 Loss 값과 Accuracy를 사용했다. Loss 란 실제 주어진 값이랑 딥러닝이 예측한 결과 값 간의 오차를 나타낸다. deeplearning 학습을 통해 해당 오차를 줄이기 위한 최적의 가중치(weight)를 찾아나가는 과정을 반복한다. Accuracy는 딥러닝이 Classifier를 통해 최종 Class를 Predict 하면 예측 값과 실제 주어진 Class 가 일치했는지 확인할 수 있다. 참조 블로그 :
12. 고양이와 개 이미지 분류하기
% matplotlib inline import matplotlib.image as mpimg import matplotlib.pyplot as plt nrows , ncols = 4 , 4 pic_index = 0 fig = plt . gcf () fig . set_size_inches ( ncols * 3 , nrows * 3 ) pic_index += 8 next_cat_pix = [ os . path . join ( train_cats_dir , fname ) for fname in train_cat_fnames [ pic_index – 8 : pic_index ]] next_dog_pix = [ os . path . join ( train_dogs_dir , fname ) for fname in train_dog_fnames [ pic_index – 8 : pic_index ]] for i , img_path in enumerate ( next_cat_pix + next_dog_pix ): sp = plt . subplot ( nrows , ncols , i + 1 ) sp . axis ( ‘Off’ ) img = mpimg . imread ( img_path ) plt . imshow ( img ) plt . show ()
키워드에 대한 정보 이미지 데이터 전처리
다음은 Bing에서 이미지 데이터 전처리 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.
이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!
사람들이 주제에 대해 자주 검색하는 키워드 [14] 머신러닝, 데이터 준비 방법 – 데이터 제공 사이트, 전처리 방법
- 머신러닝
- 데이터
- 준비하기
- 친절한AI
- 인공지능
- Artificial Intelligence
- Machine Learning
- Data
- Preprocessing
- 데이터 전처리
YouTube에서 이미지 데이터 전처리 주제의 다른 동영상 보기
주제에 대한 기사를 시청해 주셔서 감사합니다 [14] 머신러닝, 데이터 준비 방법 – 데이터 제공 사이트, 전처리 방법 | 이미지 데이터 전처리, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.
