문제 유형별 완성 코드와 시험장 전략

이 챕터에서 배우는 것
새로 배우는 딥러닝 개념은 없습니다. Ch02부터 Ch07까지 조각으로 익힌 코드를 한 벌로 이어 붙이고, 문제 유형이 바뀔 때 손대는 곳만 골라내는 것이 목표입니다. 예외는 8.5절 하나로, 오류를 진단하는 데 쓰는 보조 도구 몇 개(np.isnan, np.bincount, model.layers[-1], try/except)를 그 자리에서 새로 씁니다. 모두 시험 범위를 넓히는 개념이 아니라, 막혔을 때 원인을 찾는 손전등입니다.
시험 연관성: 이 챕터의 세 템플릿이 실기 답안의 골격 그 자체입니다. 뒤이은 모의고사 2회분은 이 템플릿을 시간 압박 아래에서 재현하는 훈련입니다.

8.1 바뀌는 곳은 세 줄뿐입니다

한 줄 요약 — 세 유형의 코드는 출력층 한 줄, loss 한 줄, 평가지표 블록만 다르고 나머지는 전부 같습니다.

제목은 "세 줄"인데 표의 행은 다섯 개라 헷갈릴 수 있으니 숫자를 먼저 정리해 둡니다. 코드에서 실제로 손대는 교체 슬롯은 네 곳(출력층 · loss · metrics · 예측 변환)이고, 그중 metrics는 회귀에서만 바뀌므로 분류끼리 비교하면 세 곳입니다. 이 챕터의 코드 주석에 붙은 교체 지점 (1)~(4)가 그 네 곳입니다. 표 마지막 행의 평가 함수는 예측 변환 다음에 오는 출력 블록을 통째로 갈아 끼우는 자리입니다.

도해 하단의 회색 박스에 묶인 것들 — 결측치 처리, 인코딩, 데이터 분리, 스케일링, 은닉층 구성, Dropout, EarlyStopping, 학습 곡선 — 은 세 유형에서 완전히 동일합니다. 그래서 시험장에서 새 문제를 받았을 때 먼저 할 일은 유형 판정 하나입니다.

유형 판정의 근거는 타깃 변수의 형태입니다. 판정 기준과 손실 함수 선택 논리는 Ch05의 ch05_loss-decision 분기도가 정본이므로, 여기서는 반복하지 않고 판정을 코드로 확인하는 한 줄만 짚습니다.

print(y_train[:10])                 # 값의 생김새
print(y_train.dtype)                # 정수인가 실수인가
print(len(np.unique(y_train)))      # 서로 다른 값의 개수

• [0 1 1 0 ...], 서로 다른 값 2개 → 이진분류
• [2 0 1 1 ...], 서로 다른 값 3개 이상, 정수 → 다중분류(정수 라벨)
• [151. 75. 141. ...], 실수이고 값이 계속 다름 → 회귀

위 예시는 넘파이 배열(ndarray)을 출력한 모습입니다. y = df['churn']처럼 데이터프레임에서 뽑은 타깃은 pandas Series이므로 print(y_train[:10])을 하면 값 왼쪽에 인덱스가 함께 세로로 찍히고 마지막에 Name: churn, dtype: int64 한 줄이 붙습니다. 값만 나란히 보고 싶으면 print(y_train.values[:10])으로 확인하십시오. 시험장에서 실제로 만나는 형태는 Series 쪽이므로, 세로로 길게 찍혀도 당황하지 않으면 됩니다. 서로 다른 값의 개수를 세는 np.unique는 배열과 Series 어느 쪽에도 그대로 쓸 수 있습니다.

⚠️ 시험 포인트
유형을 바꿀 때 loss만 바꾸고 출력층을 그대로 두는 실수가 가장 흔합니다. 출력층과 loss는 언제나 짝으로 움직입니다. Dense(1,'sigmoid')를 남겨 둔 채 sparse_categorical_crossentropy로 컴파일하면 학습이 시작되자마자 오류가 납니다(8.5의 두 번째 증상).

8.2 템플릿 A — 이진분류 end-to-end

한 줄 요약 — 원본 데이터프레임에서 출발해 성능 출력까지 가는 8단계가 실기 답안의 전체 지도입니다.

아래는 도해의 8단계를 코드로 옮긴 것입니다. 데이터는 Ch02에서 만든 것과 같은 방식의 합성 고객 이탈 데이터이며, 시험장에서는 1번 블록만 df = pd.read_csv('data.csv')로 바꾸면 됩니다.

블록 번호와 도해 단계는 한 곳만 어긋납니다. 도해에서 인코딩(get_dummies)은 3단계(전처리)에 들어 있지만, 코드에서는 4번 블록의 첫 줄에 두었습니다. "인코딩은 분리 전, 스케일링은 분리 후"라는 순서 규칙을 한 블록 안에서 눈으로 확인할 수 있게 묶은 것입니다. 나머지 일곱 단계는 블록 번호와 그대로 대응합니다.

# ===== 0) import =====
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

np.random.seed(42)
tf.random.set_seed(42)

# ===== 1) 로딩 (시험에서는 df = pd.read_csv('data.csv')) =====
rng = np.random.default_rng(42)
n = 1000
tenure_months = rng.integers(1, 72, n)
monthly_fee = rng.normal(60, 15, n).round(2)
support_calls = rng.poisson(1.5, n)
contract_type = rng.choice(['month', 'one_year', 'two_year'], n)
bonus = np.where(contract_type == 'month', 0.8,
                 np.where(contract_type == 'one_year', 0.0, -0.8))
score = -0.04 * tenure_months + 0.02 * monthly_fee + 0.45 * support_calls + bonus
prob = 1 / (1 + np.exp(-(score - score.mean())))
df = pd.DataFrame({
    'tenure_months': tenure_months,
    'monthly_fee': monthly_fee,
    'support_calls': support_calls,
    'contract_type': contract_type,
    'churn': rng.binomial(1, prob),
})
df.loc[rng.choice(n, size=50, replace=False), 'monthly_fee'] = np.nan

# ===== 2) 탐색 =====
print(df.shape)
print(df.isnull().sum())
print(df['churn'].value_counts())

# ===== 3) 결측치 처리 =====
df['monthly_fee'] = df['monthly_fee'].fillna(df['monthly_fee'].median())

# ===== 4) 인코딩(분리 전) → 분리 → 스케일링(분리 후) =====
df = pd.get_dummies(df, columns=['contract_type'], dtype=int)
X = df.drop(columns=['churn'])
y = df['churn']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print('입력 특성 수:', X_train_scaled.shape[1])

# ===== 5) 구성 =====
model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))          # 교체 지점 (1)
model.summary()

# ===== 6) 컴파일 =====
model.compile(optimizer='adam',
              loss='binary_crossentropy',          # 교체 지점 (2)
              metrics=['accuracy'])                # 교체 지점 (3)

# ===== 7) 학습 =====
es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
mc = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True)
history = model.fit(X_train_scaled, y_train,
                    epochs=100, batch_size=32,
                    validation_split=0.2,
                    callbacks=[es, mc], verbose=1)
print('실제로 학습한 epoch 수:', len(history.history['loss']))

# ===== 8) 평가 =====
loss, acc = model.evaluate(X_test_scaled, y_test, verbose=0)
print('test loss:', round(loss, 4), '/ test accuracy:', round(acc, 4))

pred = model.predict(X_test_scaled, verbose=0)
y_pred = (pred > 0.5).astype(int).flatten()        # 교체 지점 (4)
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='val loss')
plt.xlabel('epoch'); plt.ylabel('loss'); plt.legend(); plt.show()

예상 출력 요지입니다.

(1000, 5)
... 결측 50건 ...
churn 클래스 분포 2줄
입력 특성 수: 6
실제로 학습한 epoch 수: 1x~2x   ← EarlyStopping이 멈추는 시점이라 실행마다 달라집니다
test loss: 0.5xxx / test accuracy: 0.7xxx
classification_report 표 + 2x2 혼동 행렬

df.shape는 (1000, 5)인데 입력 특성 수는 6입니다. 헷갈리기 쉬운 지점이므로 한 번 세어 보십시오. 5개 컬럼 중 타깃 churn이 빠지고, 범주 컬럼 contract_type 하나가 get_dummies로 3컬럼(month/one_year/two_year)으로 펼쳐집니다. 그래서 수치 3개(tenure_months, monthly_fee, support_calls) + 더미 3개 = 6이 됩니다. Input(shape=)에 숫자를 직접 쓰지 않고 X_train_scaled.shape[1]로 받는 이유가 여기 있습니다. 원-핫 인코딩 뒤의 특성 수는 사람이 세다가 틀리기 쉽습니다.

정확도가 0.7 근처인 것은 데이터 자체가 어려운 합성 데이터이기 때문이며, 코드가 잘못된 것이 아닙니다. 시험에서도 점수의 절대값보다 지시한 절차를 지켰는지가 채점 대상입니다.

이 교재의 예상 출력에서 1x~2x, 0.5xxx처럼 자리를 가려 둔 값은 실행할 때마다 달라지는 값입니다. np.random.seed(42)와 tf.random.set_seed(42)를 걸어 두어도 학습 연산에는 미세한 비결정성이 남아 소수점 아래가 고정되지 않습니다. 반대로 입력 특성 수: 6이나 predict 결과의 shape처럼 데이터 구조에서 결정되는 값은 몇 번을 실행해도 같습니다. 가려진 자리는 맞춰 볼 대상이 아니고, 고정된 숫자가 다르게 나오면 그때는 원인을 찾아야 하는 신호입니다.

⚠️ 시험 포인트
4번 블록의 순서를 외우십시오. 인코딩은 분리 전, 스케일링은 분리 후입니다(Ch02 ch02_split-leakage). 그리고 딥러닝 모델에는 반드시 스케일링된 배열(X_train_scaled)을 넣습니다. 원본 X_train을 그대로 넣으면 학습이 잘 진행되지 않습니다.

이 교재는 스케일링 결과를 X_train_scaled/X_test_scaled라는 별도 이름에 담는 표기를 씁니다. X_train = scaler.fit_transform(X_train)처럼 같은 이름에 덮어써도 동작은 같지만, 이름이 다르면 "모델에 넣어야 할 것은 스케일링된 쪽"이라는 사실이 코드에 드러나고, 스케일러를 실수로 두 번 fit하는 사고도 눈에 띕니다.

8.3 템플릿 B — 다중분류 end-to-end

한 줄 요약 — 이진분류 코드에서 출력층 units를 클래스 수로, loss를 sparse_categorical_crossentropy로, 예측 변환을 argmax로 바꾸면 끝입니다.

클래스가 3개인 sklearn 내장 와인 데이터로 확인합니다. 라벨은 0/1/2 정수입니다.

import numpy as np
import tensorflow as tf
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_wine(return_X_y=True)
print('타깃 앞 10개:', y[:10], '/ 클래스 수:', len(np.unique(y)))   # 유형 판정

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

n_classes = len(np.unique(y_train))

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(n_classes, activation='softmax'))        # 교체 (1) units = 클래스 수
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',    # 교체 (2) 정수 라벨
              metrics=['accuracy'])                      # 교체 (3) 동일

es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=100, batch_size=16,
                    validation_split=0.2, callbacks=[es], verbose=0)

loss, acc = model.evaluate(X_test_scaled, y_test, verbose=0)
print('test loss:', round(loss, 4), '/ test accuracy:', round(acc, 4))

pred = model.predict(X_test_scaled, verbose=0)
print('predict shape:', pred.shape, '/ 한 행의 합:', pred[0].sum().round(3))
y_pred = np.argmax(pred, axis=1)                         # 교체 (4) argmax, 축은 1
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

예상 출력 요지입니다.

타깃 앞 10개: [0 0 0 0 0 0 0 0 0 0] / 클래스 수: 3
test loss: 0.0x~0.1x / test accuracy: 0.9xxx
predict shape: (54, 3) / 한 행의 합: 1.0
classification_report에 클래스 0/1/2 세 행 + 3x3 혼동 행렬

두 가지를 확인하십시오. 첫째, predict 결과가 (54, 3)입니다. 샘플마다 클래스 개수만큼의 확률이 나오고 그 합이 1입니다(softmax). 둘째, 혼동 행렬이 2×2가 아니라 3×3입니다. 다중분류에서는 cm.ravel()로 TN/FP/FN/TP를 꺼내는 방식이 성립하지 않으므로 표 전체를 출력해 클래스별로 읽습니다.

n_classes를 숫자 3으로 직접 쓰지 않고 len(np.unique(y_train))으로 구한 이유는, 시험장에서 클래스 수를 눈으로 세다가 틀리는 일을 막기 위해서입니다.

⚠️ 시험 포인트
라벨이 정수(0/1/2)면 sparse_categorical_crossentropy, 원-핫([1,0,0])이면 categorical_crossentropy입니다. 출력층은 둘 다 Dense(K,'softmax')로 같습니다. 라벨 형태에 따라 바뀌는 것은 loss 이름뿐입니다(Ch05 ch05_loss-decision).

8.4 템플릿 C — 회귀 end-to-end

한 줄 요약 — 회귀는 출력층에 활성화 함수를 넣지 않는 것이 핵심이고, 평가는 분류 지표가 아니라 mse·mae·r2로 합니다.

import numpy as np
import tensorflow as tf
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_diabetes(return_X_y=True)
print('타깃 앞 5개:', y[:5], '/ dtype:', y.dtype)        # 실수 → 회귀

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)                # stratify 없음
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))                                      # 교체 (1) 활성화 없음
model.compile(optimizer='adam',
              loss='mse',                                # 교체 (2)
              metrics=['mae'])                           # 교체 (3) accuracy 아님

es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=200, batch_size=32,
                    validation_split=0.2, callbacks=[es], verbose=0)
print('history 키:', list(history.history.keys()))

loss, mae_keras = model.evaluate(X_test_scaled, y_test, verbose=0)
print('keras mse:', round(loss, 2), '/ keras mae:', round(mae_keras, 2))

y_pred = model.predict(X_test_scaled, verbose=0).flatten()   # 교체 (4) 모양 정리
print('mse:', round(mean_squared_error(y_test, y_pred), 2))
print('mae:', round(mean_absolute_error(y_test, y_pred), 2))
print('r2 :', round(r2_score(y_test, y_pred), 4))

예상 출력 요지입니다.

타깃 앞 5개: [151.  75. 141. 206. 135.] / dtype: float64
history 키: ['loss', 'mae', 'val_loss', 'val_mae']
keras mse: 3xxx.xx / keras mae: 4x.xx
mse: 3xxx.xx
mae: 4x.xx
r2 : 0.4xxx

회귀에서 달라지는 부수적인 지점 세 가지를 함께 기억하십시오.

1. stratify를 쓰지 않습니다. 타깃이 연속값이라 계층을 나눌 수 없어 오류가 납니다.
2. history 키가 다릅니다. accuracy가 아니라 mae, val_mae이므로 학습 곡선을 그릴 때 h['accuracy']를 쓰면 KeyError가 납니다. print(history.history.keys())로 먼저 확인하는 습관이 여기서 값을 합니다.
3. classification_report를 쓰지 않습니다. 연속값에는 정확도·정밀도 개념이 없습니다.

⚠️ 시험 포인트
회귀 출력층에 activation='sigmoid'를 붙이는 실수가 자주 나옵니다. sigmoid는 출력을 0~1로 눌러 버리므로, 타깃이 151·206 같은 값이면 예측이 영원히 1을 넘지 못하고 r2가 크게 음수가 됩니다. 회귀 출력층은 Dense(1), 활성화 인자 자체를 적지 않습니다.

8.5 오류 응급처치 — 메시지로 원인을 좁힙니다

한 줄 요약 — 시험장에서 만나는 오류는 사실상 네 종류이고, 긴 메시지를 다 읽지 않아도 키워드 한 개로 원인을 좁힐 수 있습니다.

①과 ②를 실제로 재현해 메시지를 눈에 익히는 코드입니다. try 블록으로 감쌌기 때문에 노트북이 멈추지 않습니다.

import numpy as np
import tensorflow as tf
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense

X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ① 입력 shape를 10으로 잘못 적은 경우 (실제 특성은 13개)
bad1 = Sequential()
bad1.add(Input(shape=(10,)))
bad1.add(Dense(16, activation='relu'))
bad1.add(Dense(3, activation='softmax'))
bad1.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
try:
    bad1.fit(X_train_scaled, y_train, epochs=1, verbose=0)
except Exception as e:
    print('① 오류 종류:', type(e).__name__)
    key = [ln for ln in str(e).split('\n') if 'label value' in ln or 'incompatible' in ln]
    print('  메시지 요지:', (key[0].strip() if key else str(e).split('\n')[0])[:180])

# ② 클래스는 3개인데 출력층을 Dense(1)로 둔 경우
bad2 = Sequential()
bad2.add(Input(shape=(X_train_scaled.shape[1],)))
bad2.add(Dense(16, activation='relu'))
bad2.add(Dense(1, activation='sigmoid'))
bad2.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
try:
    bad2.fit(X_train_scaled, y_train, epochs=1, verbose=0)
except Exception as e:
    print('② 오류 종류:', type(e).__name__)
    key = [ln for ln in str(e).split('\n') if 'label value' in ln or 'incompatible' in ln]
    print('  메시지 요지:', (key[0].strip() if key else str(e).split('\n')[0])[:180])

key = [...] 한 줄이 이 코드의 핵심입니다. Keras의 오류 메시지는 여러 줄로 길고 진단에 필요한 문구가 첫 줄에 있지 않습니다. 그래서 str(e)를 줄 단위로 쪼갠 뒤 incompatible·label value 같은 키워드가 들어 있는 줄만 골라내 출력합니다. 시험장에서도 같은 방식으로 읽으십시오. 메시지 전체를 처음부터 읽는 것이 아니라, 이 두 단어를 먼저 찾는 것입니다.

출력 요지입니다. incompatible이 보이면 ①, label value가 보이면 ②로 판별하면 됩니다.

① 오류 종류: ValueError
  메시지 요지: Input 0 with name 'None' of layer 'dense' is incompatible with the layer: expected axis -1 of input shape to have value 10, but received input with shape (None, 13)
② 오류 종류: InvalidArgumentError
  메시지 요지: Received a label value of 2 which is outside the valid range of [0, 1).  Label values: 1 2 1 1 0 0 0 1 1 1 2 0 …

①에서 확인할 것은 한 줄 안에 나란히 놓인 숫자 두 개입니다. to have value 10은 모델이 기대한 특성 수(Input(shape=(10,))에 적은 값)이고, received input with shape (None, 13)은 실제로 들어온 데이터의 특성 수입니다. 두 숫자가 다르다는 것이 원인 그 자체입니다. None 자리는 batch 크기라 비교 대상이 아닙니다.

이 줄은 172자로 길어서 [:110] 정도로 자르면 expected axis -1 of input shape 근처에서 끊기고 정작 필요한 숫자가 보이지 않습니다. 위 코드에서 슬라이스를 [:180]으로 넉넉히 잡은 이유입니다. 그래도 잘린다면 print(e)로 메시지 전체를 찍으십시오. 참고로 이 문구는 Keras 3 기준이며, Keras 2 환경에서는 expected shape=(None, 10), found shape=(None, 13) 형태로 나옵니다. 표현은 달라도 숫자 두 개를 비교해 읽는 방법은 같습니다.

②의 뒤에 붙는 Label values: ...는 그 batch에 실제로 들어 있던 라벨을 나열한 것이라 실행할 때마다 값이 달라집니다. 거기에서 0과 1 말고 2가 섞여 있다는 사실만 확인하면 충분합니다.

③ loss가 nan이 되는 상황을 재현합니다. 결측치를 처리하지 않고 그대로 학습에 넣은 경우입니다.

X_nan = X_train_scaled.copy()
X_nan[0, 0] = np.nan                                  # 결측치 하나만 남겨도 전파됩니다

bad3 = Sequential()
bad3.add(Input(shape=(X_nan.shape[1],)))
bad3.add(Dense(16, activation='relu'))
bad3.add(Dense(3, activation='softmax'))
bad3.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
h = bad3.fit(X_nan, y_train, epochs=3, verbose=0)
print('loss 기록:', h.history['loss'])
print('입력에 남은 결측치 개수:', np.isnan(X_nan).sum())

출력 요지: loss 기록: [nan, nan, nan], 입력에 남은 결측치 개수: 1. nan이 하나만 있어도 전체 손실이 nan이 되고, 그 뒤로는 어떤 epoch을 돌려도 회복되지 않습니다. 오류 메시지가 나지 않으므로 loss: nan을 직접 보고 알아채야 합니다.

④ 학습이 안 될 때 돌리는 자가 진단 4줄입니다. 이 네 줄이면 원인의 대부분이 걸러집니다. 여기서는 방금 ③에서 만든 bad3 모델을 그대로 진단해 봅니다. 실제 답안에서는 bad3 자리에 자신의 model을 넣으십시오.

print('1. 입력 결측:', np.isnan(X_train_scaled).sum())
print('2. 입력 범위:', X_train_scaled.min().round(2), '~', X_train_scaled.max().round(2))
print('3. 라벨 분포:', np.bincount(y_train))
print('4. 출력층:', bad3.layers[-1].units, bad3.layers[-1].activation.__name__)

출력 요지입니다.

1. 입력 결측: 0
2. 입력 범위: -3.74 ~ 4.08
3. 라벨 분포: [41 50 33]
4. 출력층: 3 softmax

1번이 0인 것은 여기서 검사한 배열이 결측치가 없는 X_train_scaled이기 때문입니다. ③의 X_nan을 넣으면 1이 나옵니다. np.bincount는 정수 라벨의 개수를 클래스 번호 순서대로 세어 주는 함수이고, bad3.layers[-1]은 모델의 마지막 층, 즉 출력층을 가리킵니다.

읽는 법입니다. 1번이 0이 아니면 결측 처리를 빠뜨린 것입니다. 2번의 범위가 0 ~ 800처럼 넓으면 스케일링을 하지 않은 원본 배열을 넣은 것입니다. 3번이 [500, 3]처럼 심하게 치우쳤다면 정확도 자체가 의미 없는 상황입니다. 4번이 이진분류인데 1 relu나 1 linear로 나오면 출력층 활성화를 잘못 지정한 것입니다(이진은 1 sigmoid, 다중은 K softmax, 회귀는 1 linear).

⚠️ 시험 포인트
오류가 났을 때 코드를 처음부터 다시 쓰지 마십시오. 오류 메시지의 마지막 줄과 첫 줄에 답이 있습니다. 그리고 위 네 증상 모두 model.summary() 한 번으로 절반은 잡힙니다. 모델을 만든 직후 summary()를 찍는 것을 습관으로 삼으십시오.

8.6 시간 배분과 부분 점수 전략

한 줄 요약 — 점수는 완성도가 아니라 완료한 단계 수로 쌓입니다. 한 셀에 몰아 쓰면 한 번의 오류로 그 전부를 잃습니다.

Ch01에서 정한 배분(탐색 15 / 전처리 25 / 머신러닝 15 / 딥러닝 25 / 검토 10)을 딥러닝 구간만 더 쪼개면 이렇습니다.

딥러닝 25분에서 학습에 배정한 8분이 가장 위험한 구간입니다. epochs=100을 걸어 두고 기다리다 시간을 잃는 일이 흔합니다. 대응은 두 단계입니다.

1. 먼저 epochs=20 정도로 한 번 완주시킵니다. 코드가 끝까지 도는 것을 확인하고 평가 출력까지 만들어 둡니다.
2. 시간이 남으면 epochs=100 + EarlyStopping으로 다시 실행합니다. 지시문에 EarlyStopping이 있으면 1단계에서도 반드시 넣되, epochs만 줄여서 돌립니다.

부분 점수를 지키는 답안 구성 원칙은 네 가지입니다.

• 단계마다 셀을 나눕니다. 도해 왼쪽처럼 전처리부터 평가까지 한 셀에 몰아 쓰면, 모델 구성에서 오류가 나는 순간 그 셀 전체가 실행되지 않아 앞 단계 결과도 남지 않습니다.
• 셀 끝마다 print()로 결과를 남깁니다. 채점자가 보는 것은 화면에 출력된 결과입니다. 계산만 하고 출력하지 않으면 하지 않은 것과 같게 보일 수 있습니다.
• 막히면 최소 형태로라도 다음 단계에 넘깁니다. 인코딩이 잘 안 되면 문제가 되는 컬럼을 drop해서라도 분리·모델링 단계로 넘어가십시오. 뒤 문항의 배점이 더 큽니다.
• 지시문에 등장한 배점 요소부터 채웁니다. "은닉층 2개 이상", "Dropout 포함", "EarlyStopping 적용", "random_state=42"처럼 명시된 조건은 그 자체가 채점 항목입니다. 성능을 올리려 노드 수를 조정하기 전에 이 조건들이 코드에 들어가 있는지부터 확인하십시오.

⚠️ 시험 포인트
앞 문항에서 만든 변수명을 뒤 문항이 이어받습니다(Ch01). 중간에 변수명을 임의로 바꾸면 그 뒤 문항이 전부 흔들립니다. 지시된 이름이 있으면 그대로, 없으면 이 교재의 표준 이름(X_train, X_test, y_train, y_test, X_train_scaled, X_test_scaled, model, history)을 끝까지 유지하십시오. 스케일링 결과는 X_train_scaled/X_test_scaled에 담고, 모델에 넣는 것은 언제나 _scaled 쪽입니다.

8.7 제출 전 최종 점검

한 줄 요약 — 마지막 10분은 새로 쓰는 시간이 아니라 확인하는 시간입니다.

1번이 가장 중요합니다. 시험 중에는 셀을 위아래로 오가며 실행하기 때문에, 화면에는 결과가 있어도 처음부터 순서대로 실행하면 오류가 나는 상태가 만들어지기 쉽습니다. 자주 발생하는 원인은 두 가지입니다.

• 셀을 지우고 다시 쓰는 과정에서 정의가 사라진 변수 — 위쪽 셀에서 지운 변수를 아래쪽 셀이 쓰고 있는 경우
• 스케일러를 두 번 fit한 흔적 — 위에서 fit_transform을 한 배열에 다시 fit_transform을 걸어 값이 이중으로 변환된 경우

두 경우 모두 재실행 한 번이면 드러납니다. 시간이 정말 없다면 딥러닝 문항이 있는 셀들만이라도 순서대로 다시 실행해 보십시오.

⚠️ 시험 포인트
마지막 10분에 "성능을 조금 더 올려 보자"며 모델 구조를 바꾸는 것은 가장 위험한 선택입니다. 바꾼 뒤 재학습이 끝나기 전에 시간이 끝나면, 이미 확보했던 평가 출력까지 사라집니다. 성능 개선보다 실행 가능한 상태 유지가 우선입니다.

시험장 표준 코드

여기까지의 세 템플릿을 한 화면 골격으로 압축한 것입니다. 이 골격을 통째로 외워 두고, 문제 유형에 따라 표시된 네 곳만 아래 교체 카드에서 골라 끼우십시오.

# ===== 공통 골격 (이진분류 기준, 실행 가능) =====
import numpy as np
import tensorflow as tf
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

np.random.seed(42)
tf.random.set_seed(42)

# 1) 데이터 — 시험에서는 df = pd.read_csv(...) 이후 X, y 분리
X, y = load_breast_cancer(return_X_y=True)
print('타깃 앞 5개:', y[:5], '/ 서로 다른 값:', len(np.unique(y)))   # 유형 판정

# 2) 분리 → 스케일링
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)     # 회귀는 stratify 제거
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3) 구성
model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))                 # ★교체 (1) 출력층
model.summary()

# 4) 컴파일
model.compile(optimizer='adam',
              loss='binary_crossentropy',                 # ★교체 (2) 손실 함수
              metrics=['accuracy'])                       # ★교체 (3) 지표

# 5) 학습
es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=100, batch_size=32,
                    validation_split=0.2, callbacks=[es], verbose=1)
print('학습한 epoch 수:', len(history.history['loss']))

# 6) 평가
loss, metric = model.evaluate(X_test_scaled, y_test, verbose=0)
print('test loss:', round(loss, 4), '/ test metric:', round(metric, 4))

pred = model.predict(X_test_scaled, verbose=0)
y_pred = (pred > 0.5).astype(int).flatten()               # ★교체 (4) 예측 변환
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

교체 카드 — 다중분류(K클래스, 정수 라벨)

n_classes = len(np.unique(y_train))
model.add(Dense(n_classes, activation='softmax'))         # (1)
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',     # (2) 원-핫이면 categorical_crossentropy
              metrics=['accuracy'])                       # (3)
y_pred = np.argmax(pred, axis=1)                          # (4)

교체 카드 — 회귀

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

model.add(Dense(1))                                       # (1) 활성화 없음
model.compile(optimizer='adam',
              loss='mse',                                 # (2)
              metrics=['mae'])                            # (3)
y_pred = pred.flatten()                                   # (4)
print('mse:', mean_squared_error(y_test, y_pred))
print('mae:', mean_absolute_error(y_test, y_pred))
print('r2 :', r2_score(y_test, y_pred))

핵심 요약

한 문장으로: 유형이 바뀌어도 네 줄만 갈아 끼우면 됩니다. 나머지 시간은 그 네 줄을 정확히 고르는 판단(Ch05 ch05_loss-decision)과, 결과를 화면에 남기는 습관에 쓰십시오.

# 데이터 A
print(y_train[:8])              # [1 1 1 1 1 1 1 0]
print(y_train.dtype)            # int64
print(len(np.unique(y_train)))  # 2

# 데이터 B
print(y_train[:8])              # [0 0 0 0 1 0 2 1]
print(y_train.dtype)            # int64
print(len(np.unique(y_train)))  # 3

# 데이터 C
print(y_train[:8])              # [208. 261. 179. 258. 262.  51. 237.  71.]
print(y_train.dtype)            # float64
print(len(np.unique(y_train)))  # 192

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)          # 그대로
scaler = StandardScaler()                                       # 그대로
X_train_scaled = scaler.fit_transform(X_train)                  # 그대로
X_test_scaled = scaler.transform(X_test)                        # 그대로

n_classes = ______(가)______          # 클래스 개수를 데이터에서 뽑습니다
print('클래스 수:', n_classes)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))              # 그대로
model.add(Dense(64, activation='relu'))                         # 그대로
model.add(Dropout(0.3))                                         # 그대로
model.add(Dense(32, activation='relu'))                         # 그대로
model.add(______(나)______)                                      # ★교체 (1) 출력층

model.compile(optimizer='adam',
              loss=______(다)______,                             # ★교체 (2) 손실 함수
              metrics=['accuracy'])                             # ★교체 (3)

es = EarlyStopping(monitor='val_loss', patience=5,
                   restore_best_weights=True)                   # 그대로
history = model.fit(X_train_scaled, y_train, epochs=100, batch_size=16,
                    validation_split=0.2, callbacks=[es], verbose=0)   # 그대로

loss, acc = model.evaluate(X_test_scaled, y_test, verbose=0)
print('test loss:', round(loss, 4), '/ test accuracy:', round(acc, 4))

pred = model.predict(X_test_scaled, verbose=0)
print('predict shape:', pred.shape, '/ 한 행의 합:', round(float(pred[0].sum()), 3))
y_pred = ______(라)______                                        # ★교체 (4) 예측 변환

print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_diabetes(return_X_y=True)
print('타깃 앞 5개:', y[:5], '/ dtype:', y.dtype)      # 유형 판정

# (가) 이진·다중분류에서 쓰던 인자 하나를 반드시 빼야 합니다
X_train, X_test, y_train, y_test = ______(가)______

scaler = StandardScaler()                                       # 그대로
X_train_scaled = scaler.fit_transform(X_train)                  # 그대로
X_test_scaled = scaler.transform(X_test)                        # 그대로

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))              # 그대로
model.add(Dense(64, activation='relu'))                         # 그대로
model.add(Dropout(0.3))                                         # 그대로
model.add(Dense(32, activation='relu'))                         # 그대로
model.add(______(나)______)                                      # ★교체 (1) 출력층

model.compile(optimizer='adam',
              loss=______(다-1)______,                           # ★교체 (2)
              metrics=______(다-2)______)                        # ★교체 (3)

es = EarlyStopping(monitor='val_loss', patience=10,
                   restore_best_weights=True)                   # 그대로
history = model.fit(X_train_scaled, y_train, epochs=200, batch_size=32,
                    validation_split=0.2, callbacks=[es], verbose=0)   # 그대로
print('history 키:', list(history.history.keys()))

loss, metric = model.evaluate(X_test_scaled, y_test, verbose=0)
print('keras mse:', round(loss, 2), '/ keras mae:', round(metric, 2))

y_pred = ______(라)______                                        # ★교체 (4) 예측 변환
print('예측 shape:', y_pred.shape, '/ 정답 shape:', y_test.shape)

# (마) 회귀 지표 세 줄
print('mse:', round(______(마-1)______, 2))
print('mae:', round(______(마-2)______, 2))
print('r2 :', round(______(마-3)______, 4))

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True)          # 클래스 3개, 정수 라벨 0/1/2
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dense(1, activation='sigmoid'))                     # 이진분류 코드 그대로
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',         # loss만 교체
              metrics=['accuracy'])

history = model.fit(X_train_scaled, y_train, epochs=10, verbose=0)

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

X, y = load_diabetes(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])

history = model.fit(X_train_scaled, y_train, epochs=30, batch_size=32,
                    validation_split=0.2, verbose=0)

y_pred = model.predict(X_test_scaled, verbose=0).flatten()
print('r2 :', round(r2_score(y_test, y_pred), 4))

import numpy as np
from sklearn.datasets import load_breast_cancer, load_wine, load_diabetes
from sklearn.model_selection import train_test_split

for name, loader, strat in [('A', load_breast_cancer, True),
                            ('B', load_wine, True),
                            ('C', load_diabetes, False)]:
    X, y = loader(return_X_y=True)
    kw = dict(test_size=0.3, random_state=42)
    if strat:
        kw['stratify'] = y
    _, _, y_train, _ = train_test_split(X, y, **kw)
    print(f'[{name}] y_train[:8] = {y_train[:8]} | dtype={y_train.dtype} '
          f'| 서로 다른 값={len(np.unique(y_train))}')

[A] y_train[:8] = [1 1 1 1 1 1 1 0] | dtype=int64 | 서로 다른 값=2
[B] y_train[:8] = [0 0 0 0 1 0 2 1] | dtype=int64 | 서로 다른 값=3
[C] y_train[:8] = [208. 261. 179. 258. 262.  51. 237.  71.] | dtype=float64 | 서로 다른 값=192

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

n_classes = len(np.unique(y_train))                          # (가)
print('클래스 수:', n_classes)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(n_classes, activation='softmax'))            # (나)

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',        # (다)
              metrics=['accuracy'])

es = EarlyStopping(monitor='val_loss', patience=5,
                   restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=100, batch_size=16,
                    validation_split=0.2, callbacks=[es], verbose=0)
print('학습한 epoch 수:', len(history.history['loss']))

loss, acc = model.evaluate(X_test_scaled, y_test, verbose=0)
print('test loss:', round(loss, 4), '/ test accuracy:', round(acc, 4))

pred = model.predict(X_test_scaled, verbose=0)
print('predict shape:', pred.shape, '/ 한 행의 합:', round(float(pred[0].sum()), 3))
y_pred = np.argmax(pred, axis=1)                             # (라)
print('y_pred shape:', y_pred.shape, '/ 앞 8개:', y_pred[:8])

print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

클래스 수: 3
학습한 epoch 수: 47
test loss: 0.081 / test accuracy: 0.9815
predict shape: (54, 3) / 한 행의 합: 1.0
y_pred shape: (54,) / 앞 8개: [0 1 0 0 0 0 2 1]
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        18
           1       1.00      0.95      0.98        21
           2       0.94      1.00      0.97        15

    accuracy                           0.98        54
   macro avg       0.98      0.98      0.98        54
weighted avg       0.98      0.98      0.98        54

[[18  0  0]
 [ 0 20  1]
 [ 0  0 15]]

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_diabetes(return_X_y=True)
print('타깃 앞 5개:', y[:5], '/ dtype:', y.dtype)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)                     # (가) stratify 제거

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))                                           # (나) 활성화 없음

model.compile(optimizer='adam',
              loss='mse',                                     # (다-1)
              metrics=['mae'])                                # (다-2)

es = EarlyStopping(monitor='val_loss', patience=10,
                   restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=200, batch_size=32,
                    validation_split=0.2, callbacks=[es], verbose=0)
print('학습한 epoch 수:', len(history.history['loss']))
print('history 키:', list(history.history.keys()))

loss, metric = model.evaluate(X_test_scaled, y_test, verbose=0)
print('keras mse:', round(loss, 2), '/ keras mae:', round(metric, 2))

y_pred = model.predict(X_test_scaled, verbose=0).flatten()    # (라)
print('예측 shape:', y_pred.shape, '/ 정답 shape:', y_test.shape)

print('mse:', round(mean_squared_error(y_test, y_pred), 2))   # (마-1)
print('mae:', round(mean_absolute_error(y_test, y_pred), 2))  # (마-2)
print('r2 :', round(r2_score(y_test, y_pred), 4))             # (마-3)

타깃 앞 5개: [151.  75. 141. 206. 135.] / dtype: float64
학습한 epoch 수: 152
history 키: ['loss', 'mae', 'val_loss', 'val_mae']
keras mse: 3093.58 / keras mae: 43.6
예측 shape: (133,) / 정답 shape: (133,)
mse: 3093.58
mae: 43.6
r2 : 0.4269

InvalidArgumentError: Graph execution error:
...
Received a label value of 2 which is outside the valid range of [0, 1).
  Label values: 2 1 2 2 0 2 0 0 0 1 2 1 ...

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# --- 잘못된 코드: 구성·컴파일은 통과하고 fit에서 터집니다 ---
bad = Sequential()
bad.add(Input(shape=(X_train_scaled.shape[1],)))
bad.add(Dense(64, activation='relu'))
bad.add(Dense(1, activation='sigmoid'))
bad.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
            metrics=['accuracy'])
print('구성·컴파일 통과. 출력층:', bad.layers[-1].units,
      bad.layers[-1].activation.__name__)
try:
    bad.fit(X_train_scaled, y_train, epochs=1, verbose=0)
except Exception as e:
    print('오류 종류:', type(e).__name__)
    key = [ln for ln in str(e).split('\n') if 'label value' in ln]
    print('핵심 문구:', key[0].strip()[:80] if key else str(e)[:80])

# --- 수정: 출력층을 클래스 수에 맞춥니다 ---
n_classes = len(np.unique(y_train))
fixed = Sequential()
fixed.add(Input(shape=(X_train_scaled.shape[1],)))
fixed.add(Dense(64, activation='relu'))
fixed.add(Dense(n_classes, activation='softmax'))            # 출력층도 함께 교체
fixed.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
history = fixed.fit(X_train_scaled, y_train, epochs=10, verbose=0)
print('수정 후 출력층:', fixed.layers[-1].units,
      fixed.layers[-1].activation.__name__)
print('학습 성공, 마지막 loss:', round(history.history['loss'][-1], 4))

구성·컴파일 통과. 출력층: 1 sigmoid
오류 종류: InvalidArgumentError
핵심 문구: Received a label value of 2 which is outside the valid range of [0, 1).
수정 후 출력층: 3 softmax
학습 성공, 마지막 loss: 0.4103

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

np.random.seed(42)
tf.random.set_seed(42)

X, y = load_diabetes(return_X_y=True)

# --- 오류 ① 재현 ---
try:
    train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
except ValueError as e:
    print('①', type(e).__name__, ':', str(e)[:70])

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)                     # stratify 제거
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# --- 오류 ②③ 재현: 오류 없이 실행됩니다 ---
bad = Sequential()
bad.add(Input(shape=(X_train_scaled.shape[1],)))
bad.add(Dense(64, activation='relu'))
bad.add(Dense(32, activation='relu'))
bad.add(Dense(1, activation='sigmoid'))
bad.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
hb = bad.fit(X_train_scaled, y_train, epochs=30, batch_size=32,
             validation_split=0.2, verbose=0)
print('②③ history 키:', list(hb.history.keys()))
print('③ 마지막 accuracy:', round(hb.history['accuracy'][-1], 4))
yp_bad = bad.predict(X_test_scaled, verbose=0).flatten()
print('② 예측값 범위:', round(float(yp_bad.min()), 4), '~', round(float(yp_bad.max()), 4))
print('   실제값 범위:', float(y_test.min()), '~', float(y_test.max()))
print('   r2 :', round(r2_score(y_test, yp_bad), 4))

# --- 수정본 ---
np.random.seed(42)
tf.random.set_seed(42)

model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],)))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))                                           # ② 활성화 없음
model.compile(optimizer='adam', loss='mse', metrics=['mae'])  # ③ mae

es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
history = model.fit(X_train_scaled, y_train, epochs=200, batch_size=32,
                    validation_split=0.2, callbacks=[es], verbose=0)
print('수정 history 키:', list(history.history.keys()))

y_pred = model.predict(X_test_scaled, verbose=0).flatten()
print('수정 예측값 범위:', round(float(y_pred.min()), 2), '~', round(float(y_pred.max()), 2))
print('mse:', round(mean_squared_error(y_test, y_pred), 2))
print('mae:', round(mean_absolute_error(y_test, y_pred), 2))
print('r2 :', round(r2_score(y_test, y_pred), 4))

① ValueError : The least populated classes in y have only 1 member, which is
②③ history 키: ['accuracy', 'loss', 'val_accuracy', 'val_loss']
③ 마지막 accuracy: 0.0
② 예측값 범위: 0.9839 ~ 1.0
   실제값 범위: 37.0 ~ 310.0
   r2 : -4.0042
수정 history 키: ['loss', 'mae', 'val_loss', 'val_mae']
수정 예측값 범위: 30.62 ~ 279.15
mse: 3093.58
mae: 43.6
r2 : 0.4269