케라스로 딥러닝하기

import pandas as pd

df = pd.read_csv("../diabetes.csv")
df.tail()

import numpy as np

np.random.seed(5)  # 랜덤시드 고정시키기
# 다운받은 파일이 같은 폴더에 있다고 가정합니다.
dataset = np.genfromtxt("../diabetes.csv", delimiter=",")
# 데이터를 학습용과 검증용으로 나눕니다.
x_train = dataset[1:700, 0:8]  # 700개는 학습용으로 68개는 검증용으로 쓰겠습니다
y_train = dataset[1:700, 8]
x_test = dataset[700:, 0:8]
y_test = dataset[700:, 8]
x_train  # 데이터를 확인해봅니다.

import keras
from keras.models import Sequential
from keras.layers import Dense

# 모델 만들기
model = Sequential()
model.add(Dense(12, input_dim=8, activation="relu"))
model.add(Dense(8, activation="relu"))
model.add(Dense(1, activation="sigmoid"))
# 모델 학습과정 설정
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
# loss : 평가에 사용된 손실 함수입니다. 이진 분류에서는 binary_crossentropy를 사용합니다
# optimizer : 최적 파라미터를 찾는 알고리즘으로 경사 하강법의 하나인 adam을 사용합니다.
# metrics : 평가척도, 분류문제에서는 보통 accuracy를 씁니다.

hist = model.fit(x_train, y_train, epochs=200, batch_size=64, verbose=0)
# 모델 평가하기
score = model.evaluate(x_test, y_test)
print("정확도는 {}% 입니다.".format(score[1] * 100))

import matplotlib.pyplot as plt

%matplotlib inline

fig, (ax0, ax1) = plt.subplots(nrows=1, ncols=2, sharey=False)
ax0.plot(hist.history["acc"], label="acc")
ax0.set(title="Accuracy")
ax1.plot(hist.history["loss"], label="loss")
ax1.set(title="Accuracy")

# 필요한 라이브러리 불러오기
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Flatten, Dropout
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator

# 랜덤시드 고정시키기
np.random.seed(5)
# 데이터셋 불러오기
train_datagen = ImageDataGenerator(
    rescale=1.0 / 255,
    rotation_range=10,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.7,
    zoom_range=[0.9, 2.2],
    horizontal_flip=True,
    vertical_flip=True,
    fill_mode="nearest",
)

train_generator = train_datagen.flow_from_directory(
    "../hard_handwriting_shape/train",
    target_size=(24, 24),
    batch_size=3,
    class_mode="categorical",
)

test_datagen = ImageDataGenerator(rescale=1.0 / 255)

test_generator = test_datagen.flow_from_directory(
    "../hard_handwriting_shape/test",
    target_size=(24, 24),
    batch_size=3,
    class_mode="categorical",
)

import warnings

warnings.filterwarnings("ignore", message="numpy.dtype size changed")
# numpy로인한 경고 무시

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation="relu", input_shape=(24, 24, 3)))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dense(3, activation="softmax"))

# 모델 설정하기
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

# 모델 학습시키기
model.fit_generator(
    train_generator,
    steps_per_epoch=1000,
    epochs=20,
    validation_data=test_generator,
    validation_steps=5,
    verbose=0,
)

# 모델 평가하기
scores = model.evaluate_generator(test_generator, steps=5)
print("예측의 정확도는 {} % 입니다.".format(scores[1] * 100))

# 모델 예측하기
print("-- 예측 --")
output = model.predict_generator(test_generator, steps=5)
np.set_printoptions(formatter={"float": lambda x: "{0:0.3f}".format(x)})
print(output)

# 사용할 패키지 불러오기
import keras
from keras.models import Sequential
from keras.layers import Dense, LSTM
from keras.utils import np_utils
import numpy as np
import matplotlib.pyplot as plt

%matplotlib inline

# 코드 사전 정의
code2idx = {"A": 0, "C": 1, "T": 2, "G": 3}
idx2code = {0: "A", 1: "C", 2: "T", 3: "G"}

# 2. 데이터셋 생성하기
seq = list(
    "AGATAGACAGATTAGATGATAGGGAGATGATACATAGAAGG\
TAGATAGATAGATAGATAGATAGATAGATAGATAGATAGATAGATAATACATA\
GATAATTAATGGATAGATATATAGA"
)


# 데이터셋 생성 함수
def seq2dataset(seq, window_size):
    dataset = []
    for i in range(len(seq) - window_size):
        subset = seq[i : (i + window_size + 1)]
        dataset.append([code2idx[item] for item in subset])
    return np.array(dataset)


dataset = seq2dataset(seq, window_size=4)

print(dataset.shape)
print(dataset[:4])  # 앞쪽 4개만 확인하기

# 입력(X)과 출력(Y) 변수로 분리하기
x_train = dataset[:, 0:4]
y_train = dataset[:, 4]

max_idx_value = 13

# 입력값 정규화 시키기
x_train = x_train / float(max_idx_value)

# 입력을 (샘플 수, 타입스텝, 특성 수)로 형태 변환
x_train = np.reshape(x_train, (115, 4, 1))

# 라벨값에 대한 one-hot 인코딩 수행
y_train = np_utils.to_categorical(y_train)

one_hot_vec_size = y_train.shape[1]

print("one hot encoding vector size is ", one_hot_vec_size)

# 3. 모델 구성하기
model = Sequential()
model.add(LSTM(128, input_shape=(4, 1)))
model.add(Dense(one_hot_vec_size, activation="softmax"))

# 4. 모델 학습과정 설정하기
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])


# 손실 이력 클래스 정의
class LossHistory(keras.callbacks.Callback):
    def init(self):
        self.losses = []

    def on_epoch_end(self, batch, logs={}):
        self.losses.append(logs.get("loss"))


history = LossHistory()  # 손실 이력 객체 생성
history.init()

# 5. 모델 학습시키기
model.fit(x_train, y_train, epochs=2000, batch_size=14, callbacks=[history], verbose=0)

# 6. 학습과정 시각화
plt.plot(history.losses)
plt.ylabel("loss")
plt.xlabel("epoch")
plt.show()

# 7. 모델 평가하기
scores = model.evaluate(x_train, y_train)
print("정확도는 {} % 입니다.".format(scores[1] * 100))

# 8. 모델 사용하기
pred_count = 115  # 최대 예측 개수 정의

# 한 구절만 예측
# AGAT
seq_out = ["A", "G", "A", "T"]
pred_out = model.predict(x_train)

for i in range(pred_count):
    idx = np.argmax(pred_out[i])  # one-hot 인코딩을 인덱스 값으로 변환
    seq_out.append(
        idx2code[idx]
    )  # seq_out는 최종 서열이므로 인덱스 값을 코드로 변환하여 저장

print("조각씩 서열 예측하기  : ", "".join(seq_out))

# 곡 전체 예측

seq_in = ["A", "G", "A", "T"]
seq_out = seq_in
# 코드를 인덱스값으로 변환
seq_in = [code2idx[it] / float(max_idx_value) for it in seq_in]

for i in range(pred_count):
    sample_in = np.array(seq_in)
    sample_in = np.reshape(sample_in, (1, 4, 1))  # 샘플 수, 타입스텝 수, 속성 수
    pred_out = model.predict(sample_in)
    idx = np.argmax(pred_out)
    seq_out.append(idx2code[idx])
    seq_in.append(idx / float(max_idx_value))
    seq_in.pop(0)

print("한번에 서열 예측하기: ", "".join(seq_out))

# 0. 사용할 패키지 불러오기
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, LSTM, Dropout
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt

%matplotlib inline
# 1. 데이터셋 생성하기
signal_data = np.cos(np.arange(1000) * (20 * np.pi / 1000))[:, None]
plt.plot(np.arange(1000), signal_data)  # 생성한 데이터 시각화

def create_dataset(signal_data, look_back=1):
    dataX, dataY = [], []
    for i in range(len(signal_data) - look_back):
        dataX.append(signal_data[i : (i + look_back), 0])
        dataY.append(signal_data[i + look_back, 0])
    return np.array(dataX), np.array(dataY)


class CustomHistory(keras.callbacks.Callback):
    def init(self):
        self.train_loss = []
        self.val_loss = []

    def on_epoch_end(self, batch, logs={}):
        self.train_loss.append(logs.get("loss"))
        self.val_loss.append(logs.get("val_loss"))


look_back = 40

# 데이터 전처리
scaler = MinMaxScaler(feature_range=(0, 1))
signal_data = scaler.fit_transform(signal_data)

# 데이터 분리
train = signal_data[0:700]
val = signal_data[600:700]
test = signal_data[700:]

# 데이터셋 생성
x_train, y_train = create_dataset(train, look_back)
x_val, y_val = create_dataset(val, look_back)
x_test, y_test = create_dataset(test, look_back)

# 데이터셋 전처리
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
x_val = np.reshape(x_val, (x_val.shape[0], x_val.shape[1], 1))
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))

# 2. 모델 구성하기
model = Sequential()
for i in range(2):
    model.add(
        LSTM(
            32,
            batch_input_shape=(1, look_back, 1),
            stateful=True,
            return_sequences=True,
        )
    )
    model.add(Dropout(0.3))
model.add(LSTM(32, batch_input_shape=(1, look_back, 1), stateful=True))
model.add(Dropout(0.3))
model.add(Dense(1))

# 3. 모델 학습과정 설정하기
model.compile(loss="mean_squared_error", optimizer="adam")

# 4. 모델 학습시키기
custom_hist = CustomHistory()
custom_hist.init()

for i in range(50):
    model.fit(
        x_train,
        y_train,
        epochs=1,
        batch_size=1,
        shuffle=False,
        callbacks=[custom_hist],
        validation_data=(x_val, y_val),
        verbose=0,
    )
    model.reset_states()

# 5. 학습과정 살펴보기
plt.plot(custom_hist.train_loss)
plt.plot(custom_hist.val_loss)
plt.ylim(0.0, 0.15)
plt.ylabel("loss")
plt.xlabel("epoch")
plt.legend(["train", "val"])
plt.show()

# 6. 모델 평가하기
trainScore = model.evaluate(x_train, y_train, batch_size=1, verbose=0)
model.reset_states()
print("Train Score: ", trainScore)
valScore = model.evaluate(x_val, y_val, batch_size=1, verbose=0)
model.reset_states()
print("Validataion Score: ", valScore)
testScore = model.evaluate(x_test, y_test, batch_size=1, verbose=0)
model.reset_states()
print("Test Score: ", testScore)

# 7. 모델 사용하기
look_ahead = 260
xhat = x_test[0]
predictions = np.zeros((look_ahead, 1))
for i in range(look_ahead):
    prediction = model.predict(np.array([xhat]), batch_size=1)
    predictions[i] = prediction
    xhat = np.vstack([xhat[1:], prediction])

plt.figure(figsize=(12, 5))
plt.plot(np.arange(look_ahead), predictions, "r", label="prediction")
plt.plot(np.arange(look_ahead), y_test[:look_ahead], label="test function")
plt.legend()
plt.show()