[24일차] ABC 부트캠프 인공지능_6

Recurrent Neural Network, 순환 신경망이라고 하며 각 레이어의 결과값이 출력층을 향하면서도 다음 계산에 사용된다는 특성이 있음.

순환 신경망은 노드가 출력값을 반환하는 동시에 이전 상태를 기억하는 메모리 역할을 수행한다.

---

Keras를 이용한 삼성 주가 예측

import FinanceDataReader as fdr
import numpy as np
from matplotlib import pyplot as plt

# samsung = fdr.DataReader(symbol='005930', start='01/01/2016', end='12/23/2020')

samsung = fdr.DataReader(symbol='005930', start='01/01/2016', end=None)
print(samsung)
print(samsung.shape)
print(samsung.columns)
print(samsung[['Open']])
open_values = samsung[['Open']]
print(open_values)
print(open_values.shape)
# 데이터가 너무 크다 : 간격도 크고, 그리고 값이 크다. -> 정규화
# MinMaxScaler 사용
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0,1))
scaled_open_values = scaler.fit_transform(X=open_values)
print(scaled_open_values)
print(scaled_open_values.shape)

TEST_SIZE = 200
# 훈련데이터, 테스트 데이터 : 테스트 200
train_data = scaled_open_values[:-TEST_SIZE]
test_data = scaled_open_values[-TEST_SIZE:]
print(train_data)
print(train_data.shape) # 1914
print(test_data)
print(test_data.shape)  # 200

# RNN - LSTM : 입력 데이터 타입이 Tensor 3
def make_feature(open_values, windowing:int) -> tuple:
    train = list()
    test = list()
    for i in range(len(open_values) - windowing):
        train.append(open_values[i: i + windowing])
        test.append(open_values[i + windowing])
    print(train)
    print(test)
    return np.array(train), np.array(test)

(X_train, y_train) = make_feature(open_values=train_data, windowing=30)
print(f'X_train : {X_train}')
print(f'X_train.shape : {X_train.shape}')
print(f'y_trian : {y_train}')
print(f'y_train.shape : {y_train.shape}')

# LSTM 으로 구현하기
import keras
model = keras.models.Sequential(name='LSTM_MODEL')
model.add(keras.Input(shape=(X_train.shape[1], 1), name='INPUT'))
# LSTM units = 32, cell : 32 = 메모리 갯수
model.add(keras.layers.LSTM(units=32, return_sequences=True, activation='tanh', name='LAYER1'))
model.add(keras.layers.LSTM(units=16, return_sequences=False, activation='tanh', name='LAYER2')) # 마지막 단계에선 False를 씀
model.add(keras.layers.Dense(units=1, activation='sigmoid', name='OUTPUT'))
model.summary()

# 모델 학습
model.compile(loss='mse', optimizer='adam')
# model.fit(x=X_train, y=y_train, epochs=100, batch_size=16)
# model.save('LSTM_MODEL.keras')

model2 = keras.models.load_model('LSTM_MODEL.keras')
# TEST 진행
(X_test, y_test) = make_feature(open_values=test_data, windowing=30)
predictions = model2.predict(x=X_test)
print(predictions)
print(predictions.shape)

# 그래프를 그려서 정답과 예측을 확인해보기
plt.figure(figsize=(10, 8))
plt.plot(y_test, label='STOCK PRICE', color='blue')
plt.plot(predictions, label='Predictions', color='red')
plt.legend()
plt.show()

빨간색은 예측한 값, 파란색이 실제 값. 잘 따라옴.

---

얼굴인식 모델

import cv2 
import numpy as np 
from matplotlib import pyplot as plt

# 얼굴 이미지 리스트 초기화
face_images = list()
# 1부터 15까지의 이미지 파일을 읽어와서 처리
for i in range(15):
    # 파일 경로 생성
    file = "./faces/" + "img{0:02d}.jpg".format(i+1)
    # 이미지 읽기
    img = cv2.imread(file)
    # 이미지를 64x64 크기로 리사이즈
    img = cv2.resize(img, (64, 64))
    # BGR에서 RGB로 색상 변환
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    # 처리된 이미지를 리스트에 추가
    face_images.append(img)

# 여러 장의 이미지를 한번에 보여주는 함수 정의
def plot_images(n_row:int, n_col:int, image:list[np.array]) -> None:
    # 새로운 그림 생성
    fig = plt.figure()
    # 서브플롯 생성
    (fig, ax) = plt.subplots(n_row, n_col, figsize=(n_col, n_row))
    # 각 서브플롯에 이미지를 배치
    for i in range(n_row):
        for j in range(n_col):
            if n_row < 1:
                axis = ax[j]  # 행이 1일 경우
            else:
                axis = ax[i, j]  # 다수의 행과 열이 있을 경우
                axis.get_xaxis().set_visible(False)  # x축 눈금 숨기기
                axis.get_yaxis().set_visible(False)  # y축 눈금 숨기기
                axis.imshow(image[i * n_col + j])  # 이미지 표시
    plt.show()  # 이미지 출력
    return None

# 동물 이미지 리스트 초기화
animal_images = []
# 1부터 15까지의 이미지 파일을 읽어와서 처리
for i in range(15):
    # 파일 경로 생성
    file = "./animals/" + "img{0:02d}.jpg".format(i+1)
    # 이미지 읽기
    img = cv2.imread(file)
    # 이미지를 64x64 크기로 리사이즈
    img = cv2.resize(img, (64, 64))
    # BGR에서 RGB로 색상 변환
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) 
    # 처리된 이미지를 리스트에 추가
    animal_images.append(img)

# 동물 이미지를 3행 5열로 출력
plot_images(n_row=3, n_col=5, image=animal_images)

# 얼굴 이미지와 동물 이미지를 합쳐서 X 생성
X = face_images + animal_images
# 얼굴 이미지는 [1, 0], 동물 이미지는 [0, 1]로 레이블 생성
y = [[1, 0]] * len(face_images) + [[0, 1]] * len(animal_images)
# 리스트를 NumPy 배열로 변환
X = np.array(X)
y = np.array(y)
# 레이블 배열의 형태 출력
print(y.shape)

import keras

# CNN 모델 정의
model = keras.models.Sequential([  # 순차적으로 레이어를 쌓는 모델 생성
    keras.Input(shape=(64, 64, 3)),  # 입력 레이어: 64x64 픽셀 크기의 컬러 이미지
    keras.layers.Conv2D(filters=32, kernel_size=(3, 3)),  # 첫 번째 합성곱 레이어: 32개의 필터 사용, 3x3 크기
    keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2),  # 첫 번째 맥스풀링 레이어: 2x2 영역에서 최대값 추출
    keras.layers.Conv2D(filters=32, kernel_size=(3, 3)),  # 두 번째 합성곱 레이어
    keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2),  # 두 번째 맥스풀링 레이어
    keras.layers.Conv2D(filters=32, kernel_size=(3, 3)),  # 세 번째 합성곱 레이어
    keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2),  # 세 번째 맥스풀링 레이어
    keras.layers.Conv2D(filters=32, kernel_size=(3, 3)),  # 네 번째 합성곱 레이어
    keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2),  # 네 번째 맥스풀링 레이어
    keras.layers.Flatten(),  # 다차원 배열을 1차원으로 변환하여 다음 레이어에 전달

    keras.layers.Dense(units=64, activation='relu', name="LAYER1"),  # 첫 번째 밀집 레이어: 64개의 뉴런, ReLU 활성화
    keras.layers.Dense(units=32, activation='relu', name="LAYER2"),  # 두 번째 밀집 레이어: 32개의 뉴런, ReLU 활성화
    keras.layers.Dense(units=2, activation='softmax', name="OUTPUT"),  # 출력 레이어: 2개의 클래스 (얼굴, 동물) 예측
], name="FACE_CNN")  # 모델 이름 설정

# 모델 요약 출력: 모델 구조를 확인
model.summary()

# 모델 컴파일: Adam 옵티마이저 사용, 손실 함수는 categorical_crossentropy, 정확도를 지표로 설정
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 모델 학습: X는 입력 데이터, y는 레이블, 1000 에포크 동안 학습
history = model.fit(x=X, y=y, epochs=1_000)

# 학습된 모델 저장: 'FACE_DETECTOR.keras' 파일로 저장
model.save('FACE_DETECTOR.keras')

# 예제 이미지 리스트 초기화
example_images = list()  # 빈 리스트 생성
# 1부터 10까지의 이미지 파일을 읽어와서 처리
for i in range(10):
    # 파일 경로 생성: './examples/img01.jpg'부터 './examples/img10.jpg'까지
    file = "./examples/" + "img{0:02d}.jpg".format(i+1)
    # 이미지 읽기: OpenCV를 사용하여 이미지 파일을 읽음
    img = cv2.imread(file)
    # 이미지를 64x64 크기로 리사이즈
    img = cv2.resize(img, (64, 64))  # 이미지 크기 변경
    # BGR에서 RGB로 색상 변환: OpenCV는 BGR 형식으로 이미지를 읽기 때문에 RGB로 변환
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    # 처리된 이미지를 리스트에 추가
    example_images.append(img)

# 리스트를 NumPy 배열로 변환: 모델에 입력하기 위해 배열 형식으로 변환
example_images = np.array(example_images)

# 저장된 모델 로드: 학습된 모델을 다시 불러옴
model2 = keras.models.load_model('FACE_DETECTOR.keras')

# 예제 이미지에 대한 예측 수행: 모델이 예제 이미지를 분류함
predict_images = model2.predict(x=example_images)

# 예측 결과를 반올림하여 출력: 각 클래스에 대한 확률 결과를 0 또는 1로 변환
print(np.round(predict_images))

# 예제 이미지를 출력하는 함수 호출: 이미지를 시각화하기 위한 함수
plot_images(n_col=5, n_row=2, image=example_images)

# 예측 결과에 따라 이미지를 출력하는 서브플롯 생성
(fig, ax) = plt.subplots(2, 5, figsize=(10, 4))  # 2행 5열의 서브플롯 생성
for i in range(2):
    for j in range(5):
        axis = ax[i, j]  # 각 서브플롯의 축 가져오기
        axis.get_xaxis().set_visible(False)  # x축 눈금 숨기기
        axis.get_yaxis().set_visible(False)  # y축 눈금 숨기기
        # 예측 결과가 0.5보다 크면 이미지를 표시
        if predict_images[i * 5 + j][0] > 0.5:  # 예측 확률이 0.5보다 크면
            axis.imshow(example_images[i*5 + j])  # 해당 이미지를 표시
plt.show()  # 모든 이미지를 출력

사진을 캡쳐하지 못한 제 잘못입니다..ㅠ

 

곧 미니프로젝트 시작인데 벌써부터 주제를 뭐로할지 고민입니다..ㅠ