AICE Associate 딥러닝 실전 교본목차

부록 A

부록 — 외워야 하는 코드 3단 분해

시험은 제한적 오픈북이지만, 아래 아홉 묶음은 찾아보지 않고 바로 써야 시간이 남습니다. 긴 코드를 통째로 외우지 않고 세 단계로 나눠 외웁니다.

3단 분해로 외우는 방법

  1. 1단 흐름

    블록 전체를 낱말 네다섯 개의 순서로 줄입니다. 먼저 이 순서만 소리 내어 말할 수 있게 합니다.

  2. 2단 줄

    순서의 낱말 하나를 코드 한두 줄로 바꿉니다. 주석의 번호가 1단의 순서와 같습니다.

  3. 3단 값

    문제마다 바뀌는 자리와 넣을 값을 따로 외웁니다. 나머지는 손대지 않는 고정 부분입니다.

읽기만 해서는 잘 외워지지 않습니다. 묶음마다 아래 순서로 직접 꺼내 보십시오.

  1. 순서의 이유를 읽는다. 왜 이 순서인지 알면 낱말 순서를 덜 잊습니다.
  2. 가리고 떠올린다. 2단 코드 위의 값 가리기는 이름과 값만, 줄 가리기는 주석만 남기고 가립니다. 가린 자리를 누르면 하나씩 열립니다. 열기 전에 먼저 답을 말해 보십시오.
  3. 보지 않고 써 본다. 1단 흐름만 주석으로 남은 셀에 코드를 쓰고 Shift+Enter로 확인합니다. 따옴표 종류와 띄어쓰기는 보지 않고, 변수 이름과 핵심 값을 봅니다.
  4. 간격을 두고 다시 한다. 통과하면 다음 복습 날짜가 1일, 3일, 7일, 14일, 30일로 늘어납니다. 아래 복습 일정에서 오늘 할 묶음을 확인하십시오.
묶음문항1단 흐름
A. 첫 셀 임포트문항 1텐서플로 → 넘파이·판다스 → 그래프 둘 → 사이킷런 넷 → 케라스 셋
B. 결측치 · 이상치 · 인코딩문항 4~6결측치 채우기 → IQR 경계 구하기 → 범위 안의 행만 남기기 → 인덱스 다시 매기기 → 원-핫 인코딩
C. 분리와 스케일링문항 7X·y 나누기 → 학습·평가 분리 → 스케일러 만들기 → 학습 데이터에 fit_transform → 평가 데이터에 transform
D. 머신러닝 모델 3줄문항 8~10모델 만들기 → fit → predict → 지표 출력
E. 딥러닝 모델 구성문항 11입력 → 은닉층 → Dropout → 은닉층 → 출력층
F. 컴파일 · 콜백 · 학습문항 11~12compile → EarlyStopping → ModelCheckpoint → fit
G. 학습 곡선문항 13loss 선 → val_loss 선 → 축 이름 → 범례 → show
H. 평가와 예측값 변환문항 14 앞부분evaluate → predict → 클래스로 변환 → 지표 출력
I. 새 입력 한 건 예측문항 14 뒷부분표로 만들기 → 같은 인코딩 → 컬럼 맞추기 → 같은 스케일러로 변환 → 예측

전체 순서도 한 줄로 외웁니다: 임포트 → 결·이·인 → 분·스 → 머신러닝 → 구·컴·학 → 곡선 → 평·예 (결측치·이상치·인코딩 / 분리·스케일링 / 구성·컴파일·학습 / 평가·예측).

A. 첫 셀 임포트

쓰는 곳: 문항 1

1단 흐름

  1. 텐서플로
  2. 넘파이·판다스
  3. 그래프 둘
  4. 사이킷런 넷
  5. 케라스 셋

앞 글자로 줄이면: 텐 → 넘·판 → 맷·시 → 분리·스케일·모델·지표 → 모델·층·콜백

순서의 이유 뒤에서 쓰는 순서대로 가져옵니다. 데이터를 다루는 도구, 그리는 도구, 나누고 맞추는 도구, 마지막에 신경망 도구입니다. 텐서플로를 첫 줄에 두면 일부 환경에서 학습 셀이 멈추는 문제를 피할 수 있습니다.

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)의 경로는 바뀌지 않습니다.

말로 확인하는 질문
  1. train_test_split은 sklearn의 어느 모듈에 있습니까?
  2. EarlyStopping을 가져오는 줄을 처음부터 끝까지 쓰십시오.

B. 결측치 · 이상치 · 인코딩

쓰는 곳: 문항 4~6

1단 흐름

  1. 결측치 채우기
  2. IQR 경계 구하기
  3. 범위 안의 행만 남기기
  4. 인덱스 다시 매기기
  5. 원-핫 인코딩

앞 글자로 줄이면: 결 → 이 → 인 (채우고, 자르고, 숫자로 바꾼다)

순서의 이유 빈 값이 있으면 분위수 계산이 흔들리므로 결측치를 먼저 채웁니다. 행을 지우면 인덱스에 구멍이 생기니 바로 다시 매깁니다. 인코딩은 행이 확정된 뒤에 합니다.

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이 됩니다.

말로 확인하는 질문
  1. IQR 하한과 상한을 구하는 식을 쓰십시오.
  2. 조건 두 개를 묶을 때 쓰는 연산자와 괄호의 위치를 말하십시오.

C. 분리와 스케일링

쓰는 곳: 문항 7

1단 흐름

  1. X·y 나누기
  2. 학습·평가 분리
  3. 스케일러 만들기
  4. 학습 데이터에 fit_transform
  5. 평가 데이터에 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_size8:2면 0.2, 7:3이면 0.3
stratify분류는 stratify=y, 회귀는 쓰지 않음
스케일러StandardScaler() / MinMaxScaler()

고정 random_state=42, 반환 변수 네 개의 순서, fit_transform은 학습 데이터에만 쓴다는 점은 바뀌지 않습니다.

말로 확인하는 질문
  1. train_test_split이 돌려주는 네 변수를 순서대로 쓰십시오.
  2. 평가 데이터에 fit_transform을 쓰면 안 되는 이유를 한 문장으로 말하십시오.

D. 머신러닝 모델 3줄

쓰는 곳: 문항 8~10

1단 흐름

  1. 모델 만들기
  2. fit
  3. predict
  4. 지표 출력

앞 글자로 줄이면: 만들고 → 학습 → 예측 → 점수

순서의 이유 모델이 있어야 학습시킬 수 있고, 학습한 뒤에야 예측할 수 있으며, 예측이 있어야 정답과 비교할 수 있습니다.

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, 예측) 순서입니다. 지표 함수의 첫 인자는 정답입니다.

말로 확인하는 질문
  1. accuracy_score에 넣는 두 인자의 순서를 말하십시오.
  2. 랜덤 포레스트 분류 모델을 만드는 한 줄을 쓰십시오.

E. 딥러닝 모델 구성

쓰는 곳: 문항 11

1단 흐름

  1. 입력
  2. 은닉층
  3. Dropout
  4. 은닉층
  5. 출력층

앞 글자로 줄이면: 입 → 은 → 드 → 은 → 출

순서의 이유 데이터가 지나가는 순서 그대로입니다. 들어오는 모양을 먼저 알리고, 가운데에서 특징을 뽑고, 마지막 층이 문제 유형에 맞는 답의 모양을 만듭니다.

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'입니다. 문제 유형이 바뀌어도 고치는 곳은 출력층 한 줄입니다.

말로 확인하는 질문
  1. 3개 클래스 분류의 출력층 한 줄을 쓰십시오.
  2. 함수형 방식에서 마지막에 Model로 묶는 줄을 쓰십시오.

F. 컴파일 · 콜백 · 학습

쓰는 곳: 문항 11~12

1단 흐름

  1. compile
  2. EarlyStopping
  3. ModelCheckpoint
  4. 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'로 풀어 씁니다.

말로 확인하는 질문
  1. EarlyStopping의 인자 세 개를 이름과 값으로 쓰십시오.
  2. 정수 라벨 다중분류의 loss 문자열을 철자까지 쓰십시오.

G. 학습 곡선

쓰는 곳: 문항 13

1단 흐름

  1. loss 선
  2. val_loss 선
  3. 축 이름
  4. 범례
  5. 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_이 붙습니다.

말로 확인하는 질문
  1. 검증 정확도를 꺼내는 식을 쓰십시오.
  2. label을 줬는데 범례가 보이지 않는다면 빠진 줄은 무엇입니까?

H. 평가와 예측값 변환

쓰는 곳: 문항 14 앞부분

1단 흐름

  1. evaluate
  2. predict
  3. 클래스로 변환
  4. 지표 출력

앞 글자로 줄이면: 평가 → 예측 → 변환 → 보고

순서의 이유 먼저 전체 점수를 확인하고, 그다음 한 건씩의 예측을 받아 정답과 같은 모양으로 바꾼 뒤, 클래스별로 어디에서 틀렸는지 봅니다.

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의 결과는 확률이거나 값이므로, 정답과 비교하기 전에 반드시 변환합니다.

말로 확인하는 질문
  1. 다중분류에서 확률을 클래스 번호로 바꾸는 한 줄을 쓰십시오.
  2. (N, 1) 모양을 (N,)으로 바꾸는 메서드 이름을 말하십시오.

I. 새 입력 한 건 예측

쓰는 곳: 문항 14 뒷부분

1단 흐름

  1. 표로 만들기
  2. 같은 인코딩
  3. 컬럼 맞추기
  4. 같은 스케일러로 변환
  5. 예측

앞 글자로 줄이면: 표 → 인 → 맞 → 변 → 예

순서의 이유 새 입력도 학습 데이터가 지나온 길을 똑같이 지나가야 합니다. 표로 만들고, 같은 방법으로 인코딩하고, 같은 컬럼 구성으로 맞추고, 같은 스케일러를 거친 뒤에야 모델에 넣을 수 있습니다.

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. 1행짜리 표에 get_dummies를 쓰면 컬럼이 모자라는 이유를 말하십시오.
  2. 컬럼을 학습 때와 같게 맞추는 한 줄을 쓰십시오.

문제 유형이 바뀔 때 고치는 네 곳

아홉 묶음 가운데 문제 유형에 따라 값이 달라지는 자리는 네 곳뿐입니다. 이 표를 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 공식 공지를 확인하십시오.