부록 — 외워야 하는 코드 3단 분해
시험은 제한적 오픈북이지만, 아래 아홉 묶음은 찾아보지 않고 바로 써야 시간이 남습니다. 긴 코드를 통째로 외우지 않고 세 단계로 나눠 외웁니다.
3단 분해로 외우는 방법
- 1단 흐름
블록 전체를 낱말 네다섯 개의 순서로 줄입니다. 먼저 이 순서만 소리 내어 말할 수 있게 합니다.
- 2단 줄
순서의 낱말 하나를 코드 한두 줄로 바꿉니다. 주석의 번호가 1단의 순서와 같습니다.
- 3단 값
문제마다 바뀌는 자리와 넣을 값을 따로 외웁니다. 나머지는 손대지 않는 고정 부분입니다.
읽기만 해서는 잘 외워지지 않습니다. 묶음마다 아래 순서로 직접 꺼내 보십시오.
- 순서의 이유를 읽는다. 왜 이 순서인지 알면 낱말 순서를 덜 잊습니다.
- 가리고 떠올린다. 2단 코드 위의 값 가리기는 이름과 값만, 줄 가리기는 주석만 남기고 가립니다. 가린 자리를 누르면 하나씩 열립니다. 열기 전에 먼저 답을 말해 보십시오.
- 보지 않고 써 본다. 1단 흐름만 주석으로 남은 셀에 코드를 쓰고 Shift+Enter로 확인합니다. 따옴표 종류와 띄어쓰기는 보지 않고, 변수 이름과 핵심 값을 봅니다.
- 간격을 두고 다시 한다. 통과하면 다음 복습 날짜가 1일, 3일, 7일, 14일, 30일로 늘어납니다. 아래 복습 일정에서 오늘 할 묶음을 확인하십시오.
| 묶음 | 문항 | 1단 흐름 |
|---|---|---|
| A. 첫 셀 임포트 | 문항 1 | 텐서플로 → 넘파이·판다스 → 그래프 둘 → 사이킷런 넷 → 케라스 셋 |
| B. 결측치 · 이상치 · 인코딩 | 문항 4~6 | 결측치 채우기 → IQR 경계 구하기 → 범위 안의 행만 남기기 → 인덱스 다시 매기기 → 원-핫 인코딩 |
| C. 분리와 스케일링 | 문항 7 | X·y 나누기 → 학습·평가 분리 → 스케일러 만들기 → 학습 데이터에 fit_transform → 평가 데이터에 transform |
| D. 머신러닝 모델 3줄 | 문항 8~10 | 모델 만들기 → fit → predict → 지표 출력 |
| E. 딥러닝 모델 구성 | 문항 11 | 입력 → 은닉층 → Dropout → 은닉층 → 출력층 |
| F. 컴파일 · 콜백 · 학습 | 문항 11~12 | compile → EarlyStopping → ModelCheckpoint → fit |
| G. 학습 곡선 | 문항 13 | loss 선 → val_loss 선 → 축 이름 → 범례 → show |
| H. 평가와 예측값 변환 | 문항 14 앞부분 | evaluate → predict → 클래스로 변환 → 지표 출력 |
| I. 새 입력 한 건 예측 | 문항 14 뒷부분 | 표로 만들기 → 같은 인코딩 → 컬럼 맞추기 → 같은 스케일러로 변환 → 예측 |
전체 순서도 한 줄로 외웁니다: 임포트 → 결·이·인 → 분·스 → 머신러닝 → 구·컴·학 → 곡선 → 평·예 (결측치·이상치·인코딩 / 분리·스케일링 / 구성·컴파일·학습 / 평가·예측).
A. 첫 셀 임포트
쓰는 곳: 문항 1
1단 흐름
- 텐서플로
- 넘파이·판다스
- 그래프 둘
- 사이킷런 넷
- 케라스 셋
앞 글자로 줄이면: 텐 → 넘·판 → 맷·시 → 분리·스케일·모델·지표 → 모델·층·콜백
순서의 이유 뒤에서 쓰는 순서대로 가져옵니다. 데이터를 다루는 도구, 그리는 도구, 나누고 맞추는 도구, 마지막에 신경망 도구입니다. 텐서플로를 첫 줄에 두면 일부 환경에서 학습 셀이 멈추는 문제를 피할 수 있습니다.
2단 줄
import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Input, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 스케일러 | StandardScaler / MinMaxScaler — 지문이 정한 것 |
| 머신러닝 모델 | 분류 …Classifier, 회귀 …Regressor. 트리는 sklearn.tree, 랜덤 포레스트는 sklearn.ensemble |
| 지표 | 분류 accuracy_score·classification_report, 회귀 mean_absolute_error·r2_score |
| 층 | BatchNormalization이 지문에 있으면 layers 줄에 추가 |
고정 별칭 tf, np, pd, plt, sns와 케라스 세 줄(models, layers, callbacks)의 경로는 바뀌지 않습니다.
말로 확인하는 질문
train_test_split은sklearn의 어느 모듈에 있습니까?EarlyStopping을 가져오는 줄을 처음부터 끝까지 쓰십시오.
B. 결측치 · 이상치 · 인코딩
쓰는 곳: 문항 4~6
1단 흐름
- 결측치 채우기
- IQR 경계 구하기
- 범위 안의 행만 남기기
- 인덱스 다시 매기기
- 원-핫 인코딩
앞 글자로 줄이면: 결 → 이 → 인 (채우고, 자르고, 숫자로 바꾼다)
순서의 이유 빈 값이 있으면 분위수 계산이 흔들리므로 결측치를 먼저 채웁니다. 행을 지우면 인덱스에 구멍이 생기니 바로 다시 매깁니다. 인코딩은 행이 확정된 뒤에 합니다.
2단 줄
# ① 결측치: 그 컬럼의 중앙값으로 채우고 다시 대입
df['age'] = df['age'].fillna(df['age'].median())
# ② 이상치: Q1, Q3, IQR 을 구한 뒤 경계 안의 행만 남김
q1 = df['monthly_fee'].quantile(0.25)
q3 = df['monthly_fee'].quantile(0.75)
iqr = q3 - q1
df = df[(df['monthly_fee'] >= q1 - 1.5 * iqr) & (df['monthly_fee'] <= q3 + 1.5 * iqr)]
df = df.reset_index(drop=True)
# ③ 인코딩: 문자열 컬럼을 0/1 컬럼으로
df = pd.get_dummies(df, columns=['contract'], dtype=int)
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 채우는 값 | 수치형 .median() 또는 .mean(), 범주형 .mode()[0] |
| 결측 행 삭제 | 지문이 삭제를 요구하면 df = df.dropna() |
| IQR 배수 | 1.5 — 지문에 다른 값이 없으면 고정 |
| 인코딩 대상 | columns=[…]에 문자열 컬럼 이름 |
| 타깃이 문자열일 때 | LabelEncoder().fit_transform(df['target']) |
고정 fillna 결과는 반드시 다시 대입합니다. 행을 지운 뒤에는 reset_index(drop=True)를 붙입니다. dtype=int를 주면 True/False가 아니라 0/1이 됩니다.
말로 확인하는 질문
- IQR 하한과 상한을 구하는 식을 쓰십시오.
- 조건 두 개를 묶을 때 쓰는 연산자와 괄호의 위치를 말하십시오.
C. 분리와 스케일링
쓰는 곳: 문항 7
1단 흐름
- X·y 나누기
- 학습·평가 분리
- 스케일러 만들기
- 학습 데이터에 fit_transform
- 평가 데이터에 transform
앞 글자로 줄이면: 나누고 → 쪼개고 → 만들고 → 맞추고 → 따르고
순서의 이유 정답을 떼어 내야 나눌 수 있고, 나눈 뒤에야 학습 데이터만으로 기준을 잡을 수 있습니다. 평가 데이터로 기준을 잡으면 시험 문제를 미리 본 것과 같습니다.
2단 줄
# ① 특성과 타깃
X = df.drop(columns=['churn'])
y = df['churn']
# ② 분리: 변수 네 개의 순서는 X_train, X_test, y_train, y_test
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y)
# ③ 스케일링: 학습 데이터로만 기준을 잡고, 평가 데이터는 변환만
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 타깃 컬럼 | 'churn' 자리에 지문의 타깃 이름 |
test_size | 8:2면 0.2, 7:3이면 0.3 |
stratify | 분류는 stratify=y, 회귀는 쓰지 않음 |
| 스케일러 | StandardScaler() / MinMaxScaler() |
고정 random_state=42, 반환 변수 네 개의 순서, fit_transform은 학습 데이터에만 쓴다는 점은 바뀌지 않습니다.
말로 확인하는 질문
train_test_split이 돌려주는 네 변수를 순서대로 쓰십시오.- 평가 데이터에
fit_transform을 쓰면 안 되는 이유를 한 문장으로 말하십시오.
D. 머신러닝 모델 3줄
쓰는 곳: 문항 8~10
1단 흐름
- 모델 만들기
- fit
- predict
- 지표 출력
앞 글자로 줄이면: 만들고 → 학습 → 예측 → 점수
순서의 이유 모델이 있어야 학습시킬 수 있고, 학습한 뒤에야 예측할 수 있으며, 예측이 있어야 정답과 비교할 수 있습니다.
2단 줄
rf_model = RandomForestClassifier(n_estimators=100, random_state=42) # ① 만들기
rf_model.fit(X_train, y_train) # ② 학습
rf_pred = rf_model.predict(X_test) # ③ 예측
print(accuracy_score(y_test, rf_pred)) # ④ 점수
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 모델 클래스 | DecisionTreeClassifier(max_depth=5, random_state=42), RandomForestClassifier(…), XGBClassifier(…), LGBMClassifier(…) |
| 회귀 | 이름 끝을 Regressor로, 지표를 mean_absolute_error·r2_score로 |
| 변수 이름 | dt_model, rf_model, xgb_model — 지문이 정한 이름 |
| 입력 데이터 | 지문이 스케일링한 데이터를 쓰라고 하면 X_train_scaled, X_test_scaled |
고정 어떤 모델이든 fit(학습 X, 학습 y) → predict(평가 X) → 지표(y_test, 예측) 순서입니다. 지표 함수의 첫 인자는 정답입니다.
말로 확인하는 질문
accuracy_score에 넣는 두 인자의 순서를 말하십시오.- 랜덤 포레스트 분류 모델을 만드는 한 줄을 쓰십시오.
E. 딥러닝 모델 구성
쓰는 곳: 문항 11
1단 흐름
- 입력
- 은닉층
- Dropout
- 은닉층
- 출력층
앞 글자로 줄이면: 입 → 은 → 드 → 은 → 출
순서의 이유 데이터가 지나가는 순서 그대로입니다. 들어오는 모양을 먼저 알리고, 가운데에서 특징을 뽑고, 마지막 층이 문제 유형에 맞는 답의 모양을 만듭니다.
2단 줄
# Sequential 방식: 빈 모델에 층을 순서대로 add
model = Sequential()
model.add(Input(shape=(X_train_scaled.shape[1],))) # ① 입력: 특성 개수
model.add(Dense(64, activation='relu')) # ② 은닉층
model.add(Dropout(0.3)) # ③ Dropout
model.add(Dense(32, activation='relu')) # ④ 은닉층
model.add(Dense(1, activation='sigmoid')) # ⑤ 출력층
같은 모델을 함수형(Functional) 방식으로
inputs = Input(shape=(X_train_scaled.shape[1],)) # ① 입력
x = Dense(64, activation='relu')(inputs) # ② 앞 층의 결과를 괄호로 넘김
x = Dropout(0.3)(x) # ③
x = Dense(32, activation='relu')(x) # ④
outputs = Dense(1, activation='sigmoid')(x) # ⑤ 출력층
model = Model(inputs=inputs, outputs=outputs) # ⑥ 처음과 끝을 묶음
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 출력층 — 이진분류 | Dense(1, activation='sigmoid') |
| 출력층 — 다중분류 | Dense(클래스 수, activation='softmax') |
| 출력층 — 회귀 | Dense(1) — 활성화 함수 없음 |
| 은닉층 노드 수, Dropout 비율 | 지문의 숫자 그대로 |
고정 입력은 Input(shape=(특성 수,))이며 쉼표를 빼면 안 됩니다. 은닉층 활성화 함수는 'relu'입니다. 문제 유형이 바뀌어도 고치는 곳은 출력층 한 줄입니다.
말로 확인하는 질문
- 3개 클래스 분류의 출력층 한 줄을 쓰십시오.
- 함수형 방식에서 마지막에
Model로 묶는 줄을 쓰십시오.
F. 컴파일 · 콜백 · 학습
쓰는 곳: 문항 11~12
1단 흐름
- compile
- EarlyStopping
- ModelCheckpoint
- fit
앞 글자로 줄이면: 컴 → 얼 → 체 → 핏 / compile 안은 옵·로·메(optimizer, loss, metrics)
순서의 이유 학습 방법을 정해야(compile) 학습을 시작할 수 있습니다. 콜백은 학습 도중에 불리므로 fit 보다 먼저 만들어 두어야 합니다.
2단 줄
# ① 컴파일: optimizer, loss, metrics
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# ② 조기 종료: 무엇을 볼지, 몇 번 참을지, 가장 좋았던 가중치로 되돌릴지
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,
validation_split=0.2, epochs=50, batch_size=32,
callbacks=[es, mc])
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
loss — 이진분류 | 'binary_crossentropy' |
loss — 다중분류 | 정수 라벨 'sparse_categorical_crossentropy', 원-핫 라벨 'categorical_crossentropy' |
loss — 회귀 | 'mse', 지표는 metrics=['mae'] |
patience, epochs, batch_size | 지문의 숫자 그대로 |
| 검증 데이터 | validation_split=0.2 또는 validation_data=(X_val, y_val) |
고정 monitor='val_loss', restore_best_weights=True, save_best_only=True, 저장 확장자 .keras, metrics와 callbacks는 대괄호 리스트라는 점은 바뀌지 않습니다. 분류 지표 이름은 'accuracy'로 풀어 씁니다.
말로 확인하는 질문
EarlyStopping의 인자 세 개를 이름과 값으로 쓰십시오.- 정수 라벨 다중분류의
loss문자열을 철자까지 쓰십시오.
G. 학습 곡선
쓰는 곳: 문항 13
1단 흐름
- loss 선
- val_loss 선
- 축 이름
- 범례
- show
앞 글자로 줄이면: 선 둘 → 축 → 범례 → 보여 주기
순서의 이유 그릴 선을 먼저 올리고, 그 선이 무엇인지 알려 주는 축 이름과 범례를 붙인 다음, 마지막에 화면에 내보냅니다.
2단 줄
plt.plot(history.history['loss'], label='loss') # ① 학습 손실
plt.plot(history.history['val_loss'], label='val_loss') # ② 검증 손실
plt.xlabel('epoch') # ③ 축 이름
plt.ylabel('loss')
plt.legend() # ④ 범례
plt.show() # ⑤ 출력
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 정확도 곡선 | 'accuracy', 'val_accuracy' |
| 회귀 지표 곡선 | 'mae', 'val_mae' |
| 제목 | 지문이 요구하면 plt.title('…') |
고정 history.history처럼 history를 두 번 씁니다. 키 이름은 compile의 metrics에 적은 문자열과 같고, 검증 쪽은 앞에 val_이 붙습니다.
말로 확인하는 질문
- 검증 정확도를 꺼내는 식을 쓰십시오.
label을 줬는데 범례가 보이지 않는다면 빠진 줄은 무엇입니까?
H. 평가와 예측값 변환
쓰는 곳: 문항 14 앞부분
1단 흐름
- evaluate
- predict
- 클래스로 변환
- 지표 출력
앞 글자로 줄이면: 평가 → 예측 → 변환 → 보고
순서의 이유 먼저 전체 점수를 확인하고, 그다음 한 건씩의 예측을 받아 정답과 같은 모양으로 바꾼 뒤, 클래스별로 어디에서 틀렸는지 봅니다.
2단 줄
loss, acc = model.evaluate(X_test_scaled, y_test) # ① 손실과 지표
pred = model.predict(X_test_scaled) # ② 확률 (N, 1)
y_pred = (pred > 0.5).astype(int).flatten() # ③ 0/1 로 바꾸고 1차원으로
print(classification_report(y_test, y_pred)) # ④ 클래스별 성능
print(confusion_matrix(y_test, y_pred))
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 변환 — 이진분류 | (pred > 0.5).astype(int).flatten() |
| 변환 — 다중분류 | np.argmax(pred, axis=1) |
| 변환 — 회귀 | pred.flatten(), 지표는 mean_absolute_error·r2_score |
| 클래스 이름으로 되돌리기 | le.inverse_transform(y_pred) |
고정 evaluate는 [손실, 지표] 순서로 돌려줍니다. predict의 결과는 확률이거나 값이므로, 정답과 비교하기 전에 반드시 변환합니다.
말로 확인하는 질문
- 다중분류에서 확률을 클래스 번호로 바꾸는 한 줄을 쓰십시오.
(N, 1)모양을(N,)으로 바꾸는 메서드 이름을 말하십시오.
I. 새 입력 한 건 예측
쓰는 곳: 문항 14 뒷부분
1단 흐름
- 표로 만들기
- 같은 인코딩
- 컬럼 맞추기
- 같은 스케일러로 변환
- 예측
앞 글자로 줄이면: 표 → 인 → 맞 → 변 → 예
순서의 이유 새 입력도 학습 데이터가 지나온 길을 똑같이 지나가야 합니다. 표로 만들고, 같은 방법으로 인코딩하고, 같은 컬럼 구성으로 맞추고, 같은 스케일러를 거친 뒤에야 모델에 넣을 수 있습니다.
2단 줄
new_data = {'age': 35, 'monthly_fee': 70.0, 'contract': 'month'}
new_df = pd.DataFrame([new_data]) # ① 딕셔너리를 대괄호로 감싸 1행 표로
new_df = pd.get_dummies(new_df, columns=['contract'], dtype=int) # ② 학습 때와 같은 인코딩
new_df = new_df.reindex(columns=X.columns, fill_value=0) # ③ 학습 때의 컬럼 구성과 순서로
new_scaled = scaler.transform(new_df) # ④ 이미 학습된 스케일러로 변환만
new_pred = model.predict(new_scaled) # ⑤ 예측
print(new_pred[0][0], int(new_pred[0][0] > 0.5))
3단 값
| 바뀌는 자리 | 넣을 값 |
|---|---|
| 입력 값 | 지문이 준 딕셔너리 그대로 |
| 인코딩 컬럼 | 학습 데이터에 썼던 columns=[…]와 같게 |
| 결과 해석 — 이진분류 | 확률과 > 0.5 판정 |
| 결과 해석 — 다중분류 | np.argmax(new_pred, axis=1) 뒤 le.inverse_transform |
| 결과 해석 — 회귀 | new_pred[0][0] 값 그대로 |
고정 reindex(columns=X.columns, fill_value=0)과 scaler.transform은 그대로 씁니다. 새 입력에는 fit이나 fit_transform을 쓰지 않습니다.
말로 확인하는 질문
- 1행짜리 표에
get_dummies를 쓰면 컬럼이 모자라는 이유를 말하십시오. - 컬럼을 학습 때와 같게 맞추는 한 줄을 쓰십시오.
문제 유형이 바뀔 때 고치는 네 곳
아홉 묶음 가운데 문제 유형에 따라 값이 달라지는 자리는 네 곳뿐입니다. 이 표를 3단 값의 요약으로 외웁니다.
| 유형 | 출력층 (E) | loss (F) | metrics (F) | 예측값 변환 (H) |
|---|---|---|---|---|
| 이진분류 | Dense(1, activation='sigmoid') | 'binary_crossentropy' | ['accuracy'] | (pred > 0.5).astype(int).flatten() |
| 다중분류 (정수 라벨) | Dense(K, activation='softmax') | 'sparse_categorical_crossentropy' | ['accuracy'] | np.argmax(pred, axis=1) |
| 다중분류 (원-핫 라벨) | Dense(K, activation='softmax') | 'categorical_crossentropy' | ['accuracy'] | np.argmax(pred, axis=1) |
| 회귀 | Dense(1) | 'mse' | ['mae'] | pred.flatten() |
문항 수와 배점, 지문이 요구하는 세부 값은 회차마다 달라질 수 있습니다. 응시 전 KT AICE 공식 공지를 확인하십시오.