TensorFlow로 배우는 뉴럴 네트워크(2), 학습, 평가, 테스트 구현

손실 함수 설정 → 최적화(SGD) → 학습률 · 배치 사이즈 → 모델 컴파일
→ 학습(Backpropagation) → 손실 그래프 평가 → 테스트(예측 · 일반화 성능)

LOSS = 'mean_squared_error'  # 손실 함수: 평균 제곱 오차

import tensorflow as tf

OPTIMIZER = tf.keras.optimizers.SGD  # 최적화: 확률적 경사 하강법

LEARNING_RATE = 0.03  # 학습률: 0.03

BATCH_SIZE = 15  # 배치 사이즈: 15

import tensorflow.keras.backend as K

def tanh_accuracy(y_true, y_pred):
    # tanh 출력(-1.0 ~ 1.0)에서 0.0 기준으로 분류
    # y_pred >= 0.0이면 1, 아니면 0으로 변환 후 x2-1.0으로 -1.0/1.0 복원
    threshold = K.cast(0.0, y_pred.dtype)
    y_pred = K.cast(y_pred >= threshold, y_pred.dtype)
    return K.mean(K.equal(y_true, y_pred * 2 - 1.0), axis=-1)

import tensorflow as tf

INPUT_FEATURES = 2
LAYER1_NEURONS = 3
LAYER2_NEURONS = 3
OUTPUT_RESULTS = 1
ACTIVATION = 'tanh'

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(
        input_shape=(INPUT_FEATURES,),
        units=LAYER1_NEURONS,
        activation=ACTIVATION
    ),
    tf.keras.layers.Dense(units=LAYER2_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=OUTPUT_RESULTS, activation='tanh'),
])

LOSS = 'mean_squared_error'
OPTIMIZER = tf.keras.optimizers.SGD
LEARNING_RATE = 0.03

model.compile(
    optimizer=OPTIMIZER(learning_rate=LEARNING_RATE),  # 최적화 알고리즘
    loss=LOSS,                                          # 손실 함수
    metrics=[tanh_accuracy]                             # 평가 지표
)

새 가중치 = 기존 가중치 - (학습률 × 손실에 대한 가중치의 편미분)

import plygdata as pg

PROBLEM_DATA_TYPE = pg.DatasetType.ClassifyTwoGaussData
TRAINING_DATA_RATIO = 0.5
DATA_NOISE = 0.0

data_list = pg.generate_data(PROBLEM_DATA_TYPE, DATA_NOISE)
X_train, y_train, X_valid, y_valid = pg.split_data(
    data_list, training_size=TRAINING_DATA_RATIO
)

EPOCHS = 100

hist = model.fit(
    x=X_train,                           # 훈련 데이터
    y=y_train,                           # 훈련 레이블
    validation_data=(X_valid, y_valid),  # 검증 데이터
    batch_size=BATCH_SIZE,               # 배치 사이즈
    epochs=EPOCHS,                       # 에포크 수
    verbose=1                            # 진행 상황 출력
)

import matplotlib.pyplot as plt

train_loss = hist.history['loss']
valid_loss = hist.history['val_loss']
epochs = len(train_loss)

plt.plot(range(epochs), train_loss, marker='.', label='loss (Training)')
plt.plot(range(epochs), valid_loss, marker='.', label='loss (Validation)')
plt.legend(loc='best')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

# 조기 종료: 검증 손실이 2 에포크 연속 개선되지 않으면 중단
es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=2)

# CSV 로거: 에포크별 학습 이력 저장
csv_logger = tf.keras.callbacks.CSVLogger('training.log')

hist = model.fit(
    x=X_train,
    y=y_train,
    validation_data=(X_valid, y_valid),
    batch_size=BATCH_SIZE,
    epochs=EPOCHS,
    verbose=1,
    callbacks=[es, csv_logger]
)

from google.colab import files
files.download('training.log')

import plygdata as pg
import numpy as np

# 독립적인 테스트 데이터 생성
PROBLEM_DATA_TYPE = pg.DatasetType.ClassifyTwoGaussData
TEST_DATA_RATIO = 1.0
DATA_NOISE = 0.0
data_list = pg.generate_data(PROBLEM_DATA_TYPE, DATA_NOISE)
X_test, y_test, _, _ = pg.split_data(data_list, training_size=TEST_DATA_RATIO)

# 예측 (predict)
result_proba = model.predict(X_test)
result_class = np.frompyfunc(lambda x: 1 if x >= 0.0 else -1, 1, 1)(result_proba)
print('proba:'); print(result_proba[:5])
print('class:'); print(result_class[:5])

# 일반화 성능 평가 (evaluate)
score = model.evaluate(X_test, y_test)
print('test loss:', score[0])
print('test acc:', score[1])