bonggyulim 님의 블로그

추가로 알아두면 좋은 전처리: PCA, Vectorization, SMOTE

bonggyulim — Tue, 7 Apr 2026 15:56:29 +0900

전처리를 하다 보면 결측치 처리, 인코딩, 스케일링만으로 끝나지 않는 경우도 많다.
데이터 형태와 문제 유형에 따라 차원축소, 벡터화, 클래스 불균형 처리까지 함께 고려할 수 있다.

다만 이 기법들은 모든 문제에 무조건 사용하는 것이 아니라,
데이터 특성과 모델 목적에 맞게 선택적으로 적용해야 한다.

1. PCA

차원축소는 feature 수가 많을 때 정보를 최대한 유지하면서 차원을 줄이는 방법이다.
컬럼이 너무 많으면 학습 속도가 느려지고, 불필요한 노이즈가 많아질 수 있다.
이럴 때 대표적으로 PCA(Principal Component Analysis) 를 사용할 수 있다.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)

X_train_pca = pca.fit_transform(X_train_standard)
X_test_pca = pca.transform(X_test_standard)

print("원본 shape:", X_train_standard.shape)
print("축소 후 shape:", X_train_pca.shape)

2. TF-IDF 벡터화

벡터화는 텍스트 데이터를 숫자 형태로 바꾸는 작업이다.
머신러닝 모델은 문자열 자체를 직접 처리하지 못하기 때문에,
문장을 단어 빈도나 중요도 기반의 숫자 벡터로 변환한 뒤 사용한다.

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf_vectorizer = TfidfVectorizer()
X_train_tfidf = tfidf_vectorizer.fit_transform(X_train_text)
X_test_tfidf = tfidf_vectorizer.transform(X_test_text)

3. SMOTE

SMOTE는 클래스 불균형이 있는 분류 문제에서 소수 클래스를 늘려 학습 균형을 맞추는 방법이다.
예를 들어 정상 데이터는 많고 이상 데이터는 적다면, 모델이 다수 클래스를 중심으로만 학습할 가능성이 커진다.

이럴 때 SMOTE를 사용하면 소수 클래스를 보강할 수 있다.

from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split

X_train_cls, X_test_cls, y_train_cls, y_test_cls = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

smote = SMOTE(random_state=42)
X_train_smote, y_train_smote = smote.fit_resample(X_train_cls, y_train_cls)

print("원본 학습 데이터 분포:")
print(y_train_cls.value_counts())

print("SMOTE 적용 후 분포:")
print(y_train_smote.value_counts())

주의할 점

차원축소(PCA), 벡터화(TF-IDF/CountVectorizer)
→ 학습 데이터로만 fit 하고,
→ 테스트 데이터에는 transform만 한다.
SMOTE
→ 학습 데이터에만 적용해서 resample 한다.
→ 테스트 데이터에는 적용하지 않는다.

딥러닝 - RNN

bonggyulim — Tue, 7 Apr 2026 15:46:20 +0900

RNN 이란

RNN(Recurrent Neural Network)은 순서가 있는 데이터(Sequential Data) 를 처리하기 위해 만든 신경망이다.
일반적인 신경망은 입력 하나하나를 서로 독립적으로 처리하지만, RNN은 이전 입력의 정보까지 함께 반영할 수 있다.
그래서 RNN은 다음과 같은 문제에 자주 사용된다.

문장 데이터 처리
음성 인식
번역
주가 예측
센서 시계열 분석
행동 인식

하지만 RNN은 시퀀스가 길어질수록 오래된 정보를 잘 기억하지 못하는 한계가 있다.
이 한계를 보완한 구조가 LSTM(Long Short-Term Memory) 이다.
LSTM은 RNN처럼 순차 데이터를 처리하면서도,
중요한 정보는 오래 기억하고 불필요한 정보는 버릴 수 있도록 설계된 모델이다.

입력 시퀀스 → 이전 정보와 현재 입력 반영 → hidden state 갱신 → 반복 → 최종 출력

RNN의 동작 과정

1. 입력 시퀀스

RNN은 데이터를 한 번에 처리하지 않고,
시간 순서대로 하나씩 입력받는다.
예를 들어 시계열 데이터가 다음과 같다고 하자.
x1, x2, x3, x4
그러면 RNN은 다음과 같이 처리한다.

x1 처리
x2 처리 + 이전 정보 반영
x3 처리 + 이전 정보 반영
x4 처리 + 이전 정보 반영

2. Hidden State

RNN의 핵심은 Hidden State(은닉 상태) 다.
Hidden State는 쉽게 말하면 이전까지 입력된 정보의 요약본이다.
현재 시점에서는

현재 입력 x_t
이전 hidden state h_(t-1)

를 함께 사용해서 새로운 hidden state h_t를 만든다.

RNN 예제

import tensorflow as tf
from tensorflow.keras import models, layers

# 예시 데이터 shape: (batch, time_steps, features)
# 예: 시퀀스 길이 50, 특성 수 3

model = models.Sequential([
    layers.SimpleRNN(32, input_shape=(50, 3)),
    layers.Dense(3, activation='softmax')
])

# 모델 컴파일
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

RNN에서 주의할 점

1) RNN은 보통 3차원의 입력을 받는다

(batch, time_steps, features)

2) 순서가 중요한 데이터에 사용해야 한다

시계열 데이터를 다룰 때는 일반적인 표 데이터처럼 순서를 무작정 섞으면 안 된다.

3) 긴 시퀀스에서는 LSTM이나 GRU를 사용하는 것이 좋다

LSTM: 중요한 정보를 더 오래 기억할 수 있도록 만든 구조
GRU: LSTM보다 구조를 단순화한 모델

딥러닝 - CNN

bonggyulim — Tue, 7 Apr 2026 13:44:52 +0900

CNN이란

CNN(Convolutional Neural Network)은 이미지처럼 가로·세로 형태를 가진 데이터를 처리하는 데 강한 딥러닝 모델이다.
일반적인 신경망은 이미지를 1차원으로 펼쳐서 처리하지만, CNN은 이미지의 공간적 특징을 유지한 채 학습한다.

그래서 CNN은 다음과 같은 문제에서 많이 사용된다.

손글씨 숫자 분류
얼굴 이미지 분류
동물/사물 이미지 분류
의료 영상 분석

입력 이미지 → Convolution → ReLU → Pooling → 특징 추출 반복 → Flatten → Dense Layer → 출력

CNN의 동작 과정

1. Convolution

필터(커널)를 이미지 위로 이동시키며 특징(선, 모서리, 곡선)을 추출한다.

2. ReLU

음수 값을 0으로 바꾸는 활성화 함수다.
비선형성을 추가해 더 복잡한 패턴을 학습할 수 있게 만든다.

3. Pooling

특징맵의 크기를 줄여 계산량을 낮추고, 중요한 정보만 남긴다.
주로 MaxPooling을 많이 사용한다.

4. Flatten

2차원 특징맵을 1차원 벡터로 펼친다.

5. Dense Layer

추출한 특징을 종합해서 최종 클래스를 예측한다.

MNIST 예제

import tensorflow as tf
from tensorflow.keras import layers, models

# 1. MNIST 데이터 불러오기
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# 2. 정규화
x_train = x_train / 255.0
x_test = x_test / 255.0

# 3. CNN 입력 형태 맞추기
# (batch, height, width, channel)
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]

# 4. CNN 모델 구성
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),

    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),

    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 5. 모델 컴파일
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# 6. 학습
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.1)

# 7. 평가
test_loss, test_acc = model.evaluate(x_test, y_test)
print("Test Accuracy:", test_acc)

CNN에서 주의할 점

1) CNN은 보통 4차원의 입력을 받는다

(batch, height, width, channel)

2) 정규화를 해야 학습이 안정적이다

x_train = x_train / 255.0, x_test = x_test / 255.0

3) 출력층과 loss 함수가 맞아야 한다

라벨이 0,1,2,3... 같은 정수면 → sparse_categorical_crossentropy
라벨이 [0,0,1,0,...] 같은 원-핫이면 → categorical_crossentropy

4) 과적합 주의

Dropout 추가
데이터 증강(Data Augmentation)
Epoch 너무 크게 잡지 않기

5) Pooling을 너무 많이 하면 정보가 사라진다

딥러닝의 기본 개념 정리

bonggyulim — Mon, 6 Apr 2026 17:30:14 +0900

딥러닝을 처음 공부할 때 가장 헷갈리는 부분은 “모델이 도대체 어떤 계산을 하고, 어떻게 학습되는가”이다.
코드를 따라 치는 것은 가능해도, 입력값이 어떻게 예측값으로 바뀌고, 왜 가중치가 수정되는지, 활성화함수와 옵티마이저는 각각 언제 쓰이는지가 연결되지 않으면 전체 구조를 이해하기 어렵다.

이번 글에서는 딥러닝의 가장 기본이 되는 퍼셉트론, 다층 퍼셉트론(MLP), 행렬곱, 활성화함수, 순전파와 역전파, 옵티마이저까지 하나의 흐름으로 정리해보겠다.
마지막에는 정확도(ACC)를 높이기 위해 어떤 점을 고민해야 하는지도 함께 정리한다.

1. 딥러닝이란 무엇인가

딥러닝은 입력 데이터 x 를 받아 정답 에 가깝게 예측하도록, 모델 내부의 가중치(weight) 와 편향(bias) 를 반복적으로 조정하는 학습 방법이다.

사람이 직접 규칙을 하나하나 만드는 것이 아니라, 모델이 데이터를 통해 “어떤 특징이 중요한지”를 스스로 학습하게 만드는 방식이다.

입력 → 선형 계산 → 활성화함수 → 예측 → 손실 계산 → 역전파 → 옵티마이저 업데이트

이 과정을 수많은 반복을 통해 수행하면서 모델의 성능을 높여간다.

2. 퍼셉트론: 딥러닝의 가장 작은 계산 단위

딥러닝의 기본 단위는 퍼셉트론(Perceptron) 이다.
퍼셉트론은 여러 입력값을 받아 각각의 중요도를 반영한 뒤 하나의 값으로 합친다.

수식으로 표현하면 다음과 같다.

벡터 형태로 더 간단히 쓰면 다음과 같다.

여기서

: 입력값
: 가중치
b: 편향
: 선형 결합 결과

이다.

즉, 퍼셉트론은 입력 특징마다 서로 다른 중요도를 부여해 하나의 결과를 만드는 구조라고 볼 수 있다.
예를 들어 어떤 입력값은 예측에 매우 중요할 수 있고, 어떤 값은 거의 영향을 주지 않을 수 있다.
이때 그 중요도를 반영하는 값이 바로 가중치다.

3. 왜 활성화함수가 필요한가

퍼셉트론의 계산 결과 z 는 기본적으로 선형 결합이다.
그런데 선형 계산만 여러 번 반복하면, 층을 깊게 쌓더라도 결국 하나의 큰 선형식과 크게 다르지 않다.
즉, 복잡한 패턴을 학습하기 어렵다.

그래서 등장하는 것이 활성화함수(Activation Function) 다.

활성화함수는 모델에 비선형성을 추가한다.
이 비선형성이 있어야 딥러닝 모델은 단순한 직선 문제가 아니라, 실제 데이터에 존재하는 복잡한 패턴까지 학습할 수 있다.

4. 대표적인 활성화함수

4-1. Sigmoid

Sigmoid는 입력값을 0과 1 사이로 압축하는 함수다.
출력값을 확률처럼 해석하기 쉽기 때문에 이진 분류의 출력층에서 자주 사용된다.
입력이 커질수록 출력은 1에 가까워지고, 입력이 작아질수록 0에 가까워진다.

4-2. ReLu

ReLU는 음수는 0으로 만들고, 양수는 그대로 통과시키는 아주 단순한 함수다.
이미지 분류에서 많이 사용한다
계산이 빠르고 학습 효율도 좋아서 은닉층에서 가장 많이 사용되는 활성화함수 중 하나다.

4-3. Tanh

tanh는 출력을 -1에서 1 사이로 압축한다.
시계열 데이터에서 많이 사용한다.

4-4.SoftMax

Softmax는 여러 출력값을 전체 합이 1이 되도록 바꿔준다.
다중 분류 문제에서 클래스별로 합이 1인 확률분포 형태로 변환한다

5. 다층 퍼셉트론(MLP)

퍼셉트론 하나만으로는 복잡한 문제를 충분히 해결하기 어렵다.
그래서 여러 퍼셉트론을 층 형태로 쌓은 구조를 사용하게 되는데, 이를 다층 퍼셉트론(MLP, Multi-Layer Perceptron) 이라고 한다.

입력층→은닉층→출력층

여기서 중요한 것은 은닉층(Hidden Layer) 이다.
은닉층은 입력 데이터의 패턴을 더 추상적인 형태로 변환해 다음 층으로 전달한다.

1) 선형 계산

2) 활성화함수 적용

한 층은 결국

입력→행렬곱→편향더하기→활성화함수

라는 흐름으로 작동한다.

6. 순전파(Forward Propagation)

입력 데이터가 들어와서 최종 예측값이 계산되는 과정을 순전파라고 한다.
예를 들어 은닉층이 하나인 모델이라면 순전파는 다음과 같이 진행된다.

입력이 각 층을 통과하면서 점차 변환되고, 마지막에 예측값 ŷ 가 만들어진다.

순전파에서 중요한 점은 활성화함수는 바로 이 단계에서 사용된다는 것이다.
즉, 순전파는 단순히 행렬곱만 하는 과정이 아니라, 각 층마다 선형 계산과 활성화함수 적용을 함께 수행하는 과정이다.

7. 손실함수(Loss Function)

예측값이 나왔다면, 이제 그 값이 실제 정답과 얼마나 차이가 나는지 계산해야 한다.
이때 사용하는 것이 손실함수다.

손실함수는 모델의 예측이 얼마나 틀렸는지를 수치로 나타낸다.

회귀 문제: MSE

이진 분류: Binary Cross Entropy

다중 분류: Categorical Cross Entropy

손실값이 작을수록 예측이 정답에 더 가깝다는 뜻이다.

8. 역전파(Backpropagation)

손실함수를 계산한 뒤에는, 이 손실을 줄이기 위해 각 가중치와 편향을 어떻게 수정해야 할지 알아야 한다.
이 과정을 역전파라고 한다.

역전파의 핵심은 손실 L 을 각 파라미터에 대해 미분하는 것이다.

이 값들은 기울기(gradient) 이며, 손실을 줄이려면 어느 방향으로 이동해야 하는지를 알려준다.

출력층의 오차를 뒤에서부터 앞층으로 전달하면서 각 층의 기울기를 계산한다.

9. 옵티마이저(Optimizer)

역전파로 기울기를 계산했다면, 이제 실제로 파라미터를 수정해야 한다.
이 역할을 담당하는 것이 옵티마이저다.

가장 기본적인 업데이트 식은 다음과 같다.

여기서 η는 학습률(learning rate)이다.
손실이 줄어드는 방향으로 가중치와 편향을 조금씩 이동시키는 것이다.

대표적인 옵티마이저로는 다음이 있다.

SGD
Momentum
RMSProp
Adam
Nadam
AdamW

실무와 학습 예제에서는 Adam을 많이 사용하는 편이다.

10. 딥러닝 학습의 전체 흐름

1) 입력 데이터 준비

2) 순전파

3) 손실 계산

4) 역전파

5) 옵티마이저 업데이트

6) 1) ~ 5)를 반복

11. Epoch, Batch, Iteration

딥러닝에서는 전체 데이터를 한 번에 학습하지 않고, 여러 묶음으로 나누어 학습하는 경우가 많다.

Epoch: 전체 데이터를 한 바퀴 학습한 횟수
Batch: 한 번에 모델에 넣는 데이터 묶음
Iteration: 배치 하나를 학습한 횟수

예를 들어 데이터가 1000개이고 batch size가 100이라면,
1 epoch는 10 iteration으로 구성된다.

12. 모델 성능을 높이기 위해 어떤 고민을 해야 할까

딥러닝 모델을 만들다 보면 자연스럽게 “어떻게 하면 정확도를 더 높일 수 있을까?”라는 질문을 하게 된다.
하지만 정확도를 올리는 방법은 단순히 epoch를 늘리는 것만이 아니다.
오히려 데이터, 전처리, 모델 구조, 학습 방식, 평가 방법을 함께 고민해야 한다.

12-1. 데이터 품질을 먼저 의심해야 한다

성능이 낮을 때 가장 먼저 확인해야 할 것은 모델보다 데이터다.

라벨이 잘못 붙어 있지는 않은지
결측치나 이상치가 많은지
클래스별 데이터 수가 너무 불균형하지 않은지
학습 데이터와 테스트 데이터의 분포가 너무 다른지

아무리 좋은 모델을 써도 데이터 자체에 문제가 있으면 정확도는 쉽게 올라가지 않는다.
실무에서도 모델 구조보다 데이터 정제와 라벨 품질 개선이 더 큰 성능 향상을 만드는 경우가 많다.

12-2. 입력 전처리가 적절한지 확인해야 한다

입력값의 범위가 너무 크거나, 특성마다 단위 차이가 심하면 학습이 불안정해질 수 있다.
예를 들어 어떤 변수는 0~1 범위인데, 다른 변수는 0~10000 범위라면 가중치 학습이 한쪽에 치우칠 수 있다.

그래서 보통 다음과 같은 전처리를 고려한다.

정규화(Normalization)
표준화(Standardization)
원-핫 인코딩
텍스트 토큰화
이미지 리사이즈 및 정규화

전처리는 단순한 보조 작업이 아니라, 모델 성능에 직접 영향을 주는 핵심 단계다.

12-3. 모델 구조가 문제에 맞는지 봐야 한다

모든 문제를 MLP 하나로 해결할 수 있는 것은 아니다.

이미지 데이터: CNN 계열
시계열 데이터: RNN, LSTM, GRU, Transformer 계열
텍스트 데이터: Transformer 계열
표형 데이터: MLP, 트리 기반 모델과 비교 필요

즉, 데이터 형태에 맞는 모델 구조를 선택해야 한다.
문제 유형에 비해 지나치게 단순한 모델은 성능 한계가 있고, 반대로 지나치게 복잡한 모델은 과적합을 유발할 수 있다.

12-4. 과적합과 과소적합을 함께 봐야 한다

정확도를 높이고 싶다고 해서 무조건 더 오래 학습시키는 것은 위험하다.

과소적합(Underfitting): 학습 데이터조차 제대로 못 맞춤
과적합(Overfitting): 학습 데이터는 잘 맞추지만 새로운 데이터는 못 맞춤

따라서 학습 정확도와 검증 정확도를 함께 비교해야 한다.
학습 정확도만 높고 검증 정확도가 낮다면, 모델이 훈련 데이터만 외운 상태일 수 있다.

Dropout
Early Stopping
정규화(L1, L2)
데이터 증강(Data Augmentation)
모델 단순화

12-5. 하이퍼파라미터 튜닝이 필요하다

대표적으로 조정할 값은 다음과 같다.

학습률
batch size
epoch 수
은닉층 수
뉴런 수
optimizer 종류

예를 들어 학습률이 너무 크면 발산할 수 있고, 너무 작으면 학습이 지나치게 느려질 수 있다.
따라서 적절한 값을 찾는 과정이 필요하다.

12-6. Accuracy만 볼지 다시 생각해야 한다

정확도(Accuracy)는 직관적이지만, 항상 좋은 지표는 아니다. 예를 들어 클래스 불균형이 심한 문제에서는 정확도가 높아도 실제 성능은 나쁠 수 있다.

예를 들어 전체 데이터의 95%가 정상, 5%가 이상이라면 모든 데이터를 정상이라고 예측해도 Accuracy는 95%가 된다. 하지만 이런 모델은 이상 탐지에는 거의 쓸모가 없다.

그래서 경우에 따라 다음 지표도 함께 봐야 한다.

Precision
Recall
F1-score
ROC-AUC
PR-AUC

“ACC를 높이는 것”이 목표인지, 아니면 “정말 중요한 클래스를 잘 잡는 것”이 목표인지 먼저 정의해야 한다.

I/O 바운드와 CPU 바운드

bonggyulim — Mon, 6 Apr 2026 16:24:05 +0900

병렬처리를 할 때 가장 먼저 해야 할 일은 작업이 CPU 바운드인지, I/O 바운드인지 구분하는 것이다.
느린 원인이 계산인지 대기인지에 따라 적합한 병렬처리 방식이 달라지기 때문이다.

1. CPU 바운드란?

CPU 바운드는 계산량이 많아서 CPU가 오래 일하는 작업이다.

예를 들면:

이미지 처리
영상 프레임 분석
수치 계산
머신러닝 전처리
압축, 암호화
대규모 반복 연산

2. I/O 바운드란?

I/O 바운드는 외부 자원 응답을 기다리느라 느린 작업이다.

예를 들면:

파일 읽기/쓰기
API 호출
웹 크롤링
DB 조회
소켓 통신
업로드/다운로드

3. CPU 바운드는 어떻게 병렬처리 방법

CPU 바운드는 계산을 여러 CPU 코어나 프로세스에 나눠서 처리해야 한다.
그래서 보통 멀티프로세스를 사용한다.

왜 멀티프로세스인가?

계산이 많은 작업은 CPU를 실제로 오래 점유한다.
이 경우에는 스레드보다 프로세스를 여러 개 띄워서 CPU 코어를 분산 활용하는 방식이 더 맞다.

파이썬 기준으로는 보통 이렇게 한다.

from concurrent.futures import ProcessPoolExecutor

def heavy_task(x):
    return x * x

with ProcessPoolExecutor(max_workers=4) as executor:		# 4개의 프로세스를 사용
    results = list(executor.map(heavy_task, range(10)))

print(results)

4. I/O 바운드는 어떻게 병렬처리 방법

I/O 바운드는 CPU가 기다리는 시간이 길기 때문에,
그 기다리는 동안 다른 작업을 처리하게 만들면 된다.

4-1. 멀티스레드

파일 읽기, API 요청, DB 조회처럼 기다리는 작업이 많을 때 스레드를 여러 개 두면 효율적이다.

from concurrent.futures import ThreadPoolExecutor
import time

def fetch_data(x):
    time.sleep(1)
    return f"data-{x}"

with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(fetch_data, range(10)))

print(results)

4-2. 비동기(async)

API 요청, 채팅 서버, 웹소켓처럼 대기 중심 작업이 많을 때는 비동기 처리를 많이 쓴다.
비동기 처리는 병렬처리보다는 동시성 처리에 더 가깝다.

import asyncio

async def fetch_data(x):		# async = 비동기 처리
    await asyncio.sleep(1)		# await = 기다리는 동안 다른 작업 처리
    return f"data-{x}"

async def main():
    tasks = [fetch_data(i) for i in range(10)]
    results = await asyncio.gather(*tasks)	# gather를 통해 여러 비동기 동시 실행
    print(results)

asyncio.run(main())

5. 정리 및 주의점

정리하면 CPU 바운드는 계산이 병목인 작업이고, I/O 바운드는 외부 응답 대기가 병목인 작업이다.
따라서 CPU 바운드는 멀티프로세스, I/O 바운드는 멀티스레드나 비동기 방식을 주로 사용한다.

계산이 많다 → 멀티프로세스
파일/DB/API 대기가 많다 → 멀티스레드
네트워크 요청이 매우 많고 비동기 라이브러리를 쓸 수 있다 → async

CPU 바운드인데 스레드만 늘리는 경우 - 계산 작업은 기대만큼 빨라지지 않을 수 있다.
I/O 바운드인데 프로세스를 과하게 쓰는 경우 - 오버헤드만 커질 수 있다.
작업 성격을 안 보고 무조건 병렬화하는 경우 - 오히려 더 느려질 수 있다.
공유 자원을 많이 두는 경우 - 락 경쟁, 병목, 버그가 생기기 쉽다.
워커 수를 무조건 많이 늘리는 경우 - 컨텍스트 스위칭, 메모리 사용량, 관리 비용이 증가해 오히려 느려질 수 있다.

ML - 모델 학습 및 평가

bonggyulim — Sat, 4 Apr 2026 22:50:59 +0900

전처리가 끝났다면 이제 본격적으로 머신러닝 모델을 학습시키고 성능을 평가할 수 있다. 실제 머신러닝 프로젝트에서는 모델 하나만 사용하는 것이 아니라, 여러 모델을 비교해보고 데이터에 더 잘 맞는 모델을 선택하는 과정이 중요하다.

이번 글에서는 대표적인 회귀 모델과 분류 모델의 기본 사용법을 정리한다.

회귀 예제: tips 데이터셋
분류 예제: iris 데이터셋

1. 회귀 모델 학습 파트

회귀는 연속적인 숫자 값을 예측하는 문제이다.
예를 들어 집값, 매출, 온도, 점수처럼 숫자로 표현되는 값을 예측할 때 회귀 모델을 사용한다.

이번 예제에서는 tips 데이터셋을 사용해서 **팁 금액(tip)**을 예측해본다.

1.0. 데이터 준비

tips = sns.load_dataset("tips").copy()

# 결측치 / 중복 제거
tips = tips.dropna().drop_duplicates()

# 먼저 설명력이 높을 가능성이 큰 컬럼만 사용
selected_features_reg = ["total_bill", "size", "smoker", "time"]

X_reg = tips[selected_features_reg]
y_reg = tips["tip"]

categorical_cols_reg = X_reg.select_dtypes(include=["object", "category"]).columns.tolist()
numeric_cols_reg = X_reg.select_dtypes(include=["int64", "float64"]).columns.tolist()

preprocessor_reg = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), numeric_cols_reg),
        ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_cols_reg)
    ]
)

X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(
    X_reg, y_reg, test_size=0.2, random_state=42
)

tips 데이터셋에는 총 결제 금액, 성별, 흡연 여부, 요일, 시간대, 인원 수 등의 정보가 들어 있다.
이 중에서 tip을 타깃으로 두고 나머지 컬럼을 입력값으로 사용한다.
여기서는 수치형 컬럼에는 StandardScaler를 적용하고, 범주형 컬럼에는 OneHotEncoder를 적용한다.

1.1. LinearRegression

LinearRegression은 가장 기본적인 선형 회귀 모델이다.
입력 변수와 타깃 사이의 선형 관계를 바탕으로 예측한다.
해석이 쉽고 빠르기 때문에 회귀 문제의 첫 출발점으로 많이 사용한다.

lr_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", LinearRegression())
])

lr_reg_model.fit(X_train_reg, y_train_reg)
lr_reg_pred = lr_reg_model.predict(X_test_reg)

print(lr_reg_pred[:5])

선형 관계가 어느 정도 잘 맞는 데이터에서는 좋은 기준 모델이 될 수 있다.
다만 관계가 복잡하거나 비선형 패턴이 강하면 성능이 제한될 수 있다.

1.2. Ridge

Ridge는 선형 회귀에 L2 정규화를 추가한 모델이다.
변수가 많거나 다중공선성이 있을 때 계수가 지나치게 커지는 것을 완화하는 데 도움이 된다.

ridge_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", Ridge(alpha=1.0))
])

ridge_reg_model.fit(X_train_reg, y_train_reg)
ridge_reg_pred = ridge_reg_model.predict(X_test_reg)

선형 회귀와 비슷하게 사용할 수 있지만, 과적합을 조금 더 안정적으로 제어할 수 있다는 장점이 있다.

1.3. Lasso

Lasso는 선형 회귀에 L1 정규화를 추가한 모델이다.
불필요한 변수의 계수를 0으로 만들 수 있어서 변수 선택 효과가 나타날 수 있다.

lasso_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", Lasso(alpha=0.1))
])

lasso_reg_model.fit(X_train_reg, y_train_reg)
lasso_reg_pred = lasso_reg_model.predict(X_test_reg)

변수가 많고 어떤 변수가 중요한지 함께 보고 싶을 때 자주 사용한다.
다만 alpha 값에 따라 성능 차이가 크게 날 수 있으므로 튜닝이 중요하다.

선형 회귀 모델은 입력 변수가 많아지거나 서로 비슷한 정보를 가진 변수가 함께 들어오면, 특정 계수가 지나치게 커지면서 훈련 데이터에만 잘 맞는 방향으로 학습될 수 있다. 이런 문제를 완화하기 위해 사용하는 방법이 정규화(Regularization) 이다.

정규화는 모델의 계수가 너무 커지지 않도록 패널티를 주는 방식이다.
즉, 단순히 훈련 데이터에만 맞추는 것이 아니라 조금 더 일반화된 예측을 하도록 유도하는 역할을 한다.

L1 정규화(Lasso): 불필요한 변수의 계수를 0으로 만들 수 있음
L2 정규화(Ridge): 계수 크기를 전반적으로 줄여 과적합을 완화함

1.4. DecisionTreeRegressor

DecisionTreeRegressor는 데이터를 규칙 기반으로 계속 나누면서 예측하는 모델이다.
비선형 관계를 잘 다룰 수 있고, 구조를 이해하기도 비교적 쉽다.

tree_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", DecisionTreeRegressor(random_state=42))
])

tree_reg_model.fit(X_train_reg, y_train_reg)
tree_reg_pred = tree_reg_model.predict(X_test_reg)

데이터의 복잡한 패턴을 잡아낼 수 있지만, 깊이가 너무 깊어지면 과적합되기 쉽다.

1.5. RandomForestRegressor

RandomForestRegressor는 여러 개의 결정트리를 만들어 그 결과를 평균내는 앙상블 모델이다.
단일 트리보다 일반화 성능이 더 좋은 경우가 많고, 실무에서도 자주 사용한다.

rf_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", RandomForestRegressor(random_state=42))
])

rf_reg_model.fit(X_train_reg, y_train_reg)
rf_reg_pred = rf_reg_model.predict(X_test_reg)

기본 성능이 안정적인 편이라 회귀 문제에서 자주 비교 대상으로 올라오는 모델이다.

1.6. KNeighborsRegressor

가까운 이웃들의 값을 참고해서 예측하는 모델이다.
단순하지만 데이터 스케일에 민감하고, 데이터 양이 많아지면 예측 속도가 느려질 수 있다.

knn_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", KNeighborsRegressor(n_neighbors=5))
])

knn_reg_model.fit(X_train_reg, y_train_reg)
knn_reg_pred = knn_reg_model.predict(X_test_reg)

1.7. SVR

서포트 벡터 머신을 회귀에 적용한 모델이다.
복잡한 관계를 잘 잡을 수 있지만, 데이터가 많아질수록 학습 비용이 커질 수 있다.

svr_reg_model = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", SVR())
])

svr_reg_model.fit(X_train_reg, y_train_reg)
svr_reg_pred = svr_reg_model.predict(X_test_reg)

2. 분류 모델 학습 파트

분류는 정답이 숫자 연속값이 아니라 범주(label) 인 문제이다.
예를 들어 이메일이 스팸인지 아닌지, 꽃의 품종이 무엇인지, 고객이 이탈할지 말지 등을 예측할 때 분류 모델을 사용한다.

이번 예제에서는 iris 데이터셋을 사용해서 꽃의 품종을 예측해본다.

2.0. 데이터 준비

iris = load_iris(as_frame=True)
df_iris = iris.frame

X_clf = df_iris.drop("target", axis=1)
y_clf = df_iris["target"]

X_train_clf, X_test_clf, y_train_clf, y_test_clf = train_test_split(
    X_clf,
    y_clf,
    test_size=0.2,
    random_state=42,
    stratify=y_clf
)

iris 데이터셋은 이미 수치형 변수로 정리되어 있기 때문에 비교적 간단하게 사용할 수 있다.
분류 문제에서는 stratify=y를 넣어서 클래스 비율이 학습용과 테스트용에 비슷하게 유지되도록 하는 경우가 많다.

2.1. LogisticRegression

LogisticRegression은 이름에 회귀가 들어가지만 대표적인 분류 모델이다.
기본이 되는 선형 분류 모델로, 빠르고 해석도 비교적 쉬운 편이다.

log_clf_model = Pipeline([
    ("scaler", StandardScaler()),
    ("model", LogisticRegression(max_iter=1000))
])

log_clf_model.fit(X_train_clf, y_train_clf)
log_clf_pred = log_clf_model.predict(X_test_clf)

선형적으로 구분이 어느 정도 가능한 문제에서 좋은 출발점이 된다.

2.2. KNeighborsClassifier

KNeighborsClassifier는 가까운 샘플들의 다수결로 클래스를 예측하는 모델이다.
직관적이고 이해하기 쉽지만, 거리 기반이라 스케일링이 중요하다.

knn_clf_model = Pipeline([
    ("scaler", StandardScaler()),
    ("model", KNeighborsClassifier(n_neighbors=5))
])

knn_clf_model.fit(X_train_clf, y_train_clf)
knn_clf_pred = knn_clf_model.predict(X_test_clf)

데이터 구조가 비교적 단순할 때 좋은 성능을 내는 경우가 많다.

2.3. DecisionTreeClassifier

DecisionTreeClassifier는 질문을 반복하면서 데이터를 나누는 방식으로 클래스를 분류한다.
비선형 패턴을 반영할 수 있고, 규칙 기반이라 해석도 쉬운 편이다.

tree_clf_model = Pipeline([
    ("model", DecisionTreeClassifier(random_state=42))
])

tree_clf_model.fit(X_train_clf, y_train_clf)
tree_clf_pred = tree_clf_model.predict(X_test_clf)

깊이가 깊어지면 훈련 데이터에 과적합될 수 있으므로 주의가 필요하다.

2.4. RandomForestClassifier

RandomForestClassifier는 여러 개의 결정트리를 조합한 앙상블 분류 모델이다.
기본 성능이 안정적이고 실무에서도 자주 사용된다.

rf_clf_model = Pipeline([
    ("model", DecisionTreeClassifier(random_state=42))
])

rf_clf_model.fit(X_train_clf, y_train_clf)
rf_clf_model = tree_clf_model.predict(X_test_clf)

단일 트리보다 과적합이 덜하고, 중요한 변수를 함께 확인할 수 있다는 장점이 있다.

2.5. SVC

서포트 벡터 머신 기반 분류 모델이다.
결정 경계를 잘 찾는 편이고 성능이 좋은 경우가 많지만, 데이터가 커질수록 계산량이 증가할 수 있다.

svc_clf_model = Pipeline([
    ("scaler", StandardScaler()),
    ("model", SVC())
])

svc_clf_model.fit(X_train_clf, y_train_clf)
svc_clf_pred = svc_clf_model.predict(X_test_clf)

2.6. GradientBoostingClassifier

이전 모델의 오차를 보완해가며 순차적으로 학습하는 부스팅 계열 모델이다.
성능이 잘 나오는 경우가 많지만, 하이퍼파라미터에 민감할 수 있다.

gb_clf_model = Pipeline([
    ("model", GradientBoostingClassifier(random_state=42))
])

gb_clf_model.fit(X_train_clf, y_train_clf)
gb_clf_pred = gb_clf_model.predict(X_test_clf)

3. 교차검증

학습 데이터를 한 번만 나눠서 성능을 평가하면, 우연히 잘 나왔거나 우연히 낮게 나올 수 있다.
즉, train/test split 한 번만으로는 모델의 성능을 안정적으로 판단하기 어려울 수 있다.

이럴 때 사용하는 것이 교차검증(Cross Validation) 이다.
교차검증은 데이터를 여러 번 나눠서 반복적으로 학습하고 평가한 뒤 평균 성능을 확인하는 방식이다.

3.1. cross_val_scor

# 회귀 모델 교차검증
lr_cv_pipe = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", LinearRegression())
])

cv_scores_reg = cross_val_score(
    lr_cv_pipe,
    X_reg,
    y_reg,
    cv=5,
    scoring="r2"
)

print("회귀 교차검증 R2:", cv_scores_reg)
print("회귀 평균 R2:", cv_scores_reg.mean())

3.2. KFold와 StratifiedKFold

KFold는 데이터를 단순히 K개로 나눈다.

# 회귀 모델 교차검증
lr_cv_pipe = Pipeline([
    ("preprocessor", preprocessor_reg),
    ("model", LinearRegression())
])

cv_scores_reg = cross_val_score(
    lr_cv_pipe,
    X_reg,
    y_reg,
    cv=5,
    scoring="r2"
)

print("회귀 교차검증 R2:", cv_scores_reg)
print("회귀 평균 R2:", cv_scores_reg.mean())

StratifiedKFold는 클래스 비율을 유지하면서 나눈다.

분류 문제에서는 클래스 비율이 중요하기 때문에 StratifiedKFold가 자주 사용된다.

# 분류 모델 교차검증
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

rf_cv_clf_pipe = Pipeline([
    ("model", RandomForestClassifier(random_state=42))
])

cv_scores_clf = cross_val_score(
    rf_cv_clf_pipe,
    X_clf,
    y_clf,
    cv=skf,
    scoring="accuracy"
)

print("분류 교차검증 Accuracy:", cv_scores_clf)
print("분류 평균 Accuracy:", cv_scores_clf.mean())

4. 하이퍼파라미터 튜닝

모델에는 사람이 직접 설정해야 하는 값들이 있다.
예를 들어 트리의 최대 깊이, 랜덤포레스트의 트리 개수, KNN의 이웃 수 같은 값이 여기에 해당한다.
이런 값을 하이퍼파라미터라고 한다.

반면, 모델이 학습 과정에서 스스로 찾는 값은 학습 파라미터라고 볼 수 있다.
예를 들어 선형 회귀의 계수 값은 학습 파라미터이다.

4.1 GridSearchCV

GridSearchCV는 미리 정한 하이퍼파라미터 조합을 전부 탐색하는 방식이다.
후보 수가 많지 않을 때는 체계적으로 확인할 수 있다는 장점이 있다.

# 회귀 - GridSearchCV
param_grid_reg = {
    "model__n_estimators": [100, 200],
    "model__max_depth": [None, 3, 5, 10]
}

rf_reg_search = GridSearchCV(
    estimator=Pipeline([
        ("preprocessor", preprocessor_reg),
        ("model", RandomForestRegressor(random_state=42))
    ]),
    param_grid=param_grid_reg,
    cv=5,
    scoring="r2",
    n_jobs=-1
)

rf_reg_search.fit(X_train_reg, y_train_reg)

print("회귀 최적 파라미터:", rf_reg_search.best_params_)
print("회귀 최고 교차검증 점수:", rf_reg_search.best_score_)

4.2 RandomizedSearchCV

RandomizedSearchCV는 가능한 조합 전체를 다 보지 않고, 일부 조합을 무작위로 샘플링해서 탐색한다.
탐색 범위가 넓고 조합 수가 많을 때 더 효율적일 수 있다.

# 분류 - RandomizedSearchCV
param_dist_clf = {
    "model__n_estimators": [50, 100, 200, 300],
    "model__max_depth": [None, 3, 5, 10, 20],
    "model__min_samples_split": [2, 5, 10]
}

rf_clf_search = RandomizedSearchCV(
    estimator=Pipeline([
        ("model", RandomForestClassifier(random_state=42))
    ]),
    param_distributions=param_dist_clf,
    n_iter=10,
    cv=5,
    scoring="accuracy",
    random_state=42,
    n_jobs=-1
)

rf_clf_search.fit(X_train_clf, y_train_clf)

print("분류 최적 파라미터:", rf_clf_search.best_params_)
print("분류 최고 교차검증 점수:", rf_clf_search.best_score_)

5. 평가 지표 정리

5.1. 회귀 평가 지표 정리

회귀 문제는 예측값과 실제값이 얼마나 차이 나는지를 기준으로 성능을 평가한다.

MAE(Mean Absolute Error) 는 예측값과 실제값 차이의 절댓값 평균이다.

mae = mean_absolute_error(y_test_reg, lr_reg_pred)

오차를 직관적으로 이해하기 쉽다.
이상치의 영향이 MSE보다 덜하다.
작을수록 좋다.

MSE(Mean Squared Error) 는 오차를 제곱해서 평균낸 값이다.

mae = mean_absolute_error(y_test_reg, lr_reg_pred)

큰 오차에 더 큰 패널티를 준다.
이상치에 민감하다.
작을수록 좋다.

RMSE(Root Mean Squared Error) 는 MSE에 제곱근을 취한 값이다.

rmse = np.sqrt(mse)

다시 원래 단위로 해석할 수 있어서 직관적이다.
큰 오차를 더 민감하게 반영한다.
작을수록 좋다.

R² Score 는 모델이 데이터를 얼마나 잘 설명하는지를 보여주는 지표이다.

r2 = r2_score(y_test_reg, lr_reg_pred)

1에 가까울수록 좋다.
0이면 평균 수준의 예측과 비슷하다고 볼 수 있다.
음수가 나올 수도 있는데, 그 경우 평균보다도 못한 예측일 수 있다.
클수록 좋다.

5.2. 분류 평가 지표 정리

Accuracy 는 전체 예측 중 정답을 맞힌 비율이다.

acc = accuracy_score(y_test_clf, rf_clf_pred)

가장 직관적인 지표이다.
데이터가 균형 잡혀 있을 때는 유용하다.
클래스 불균형이 심하면 misleading할 수 있다.
클수록 좋다.

F1-score 는 Precision과 Recall의 균형을 함께 보는 지표이다.

f1 = f1_score(y_test_clf, rf_clf_pred, average="macro")

둘 중 하나만 높고 하나가 낮은 상황을 보완해서 볼 수 있다.
클래스 불균형 문제에서 자주 함께 확인한다.
클수록 좋다.

Confusion Matrix 는 실제 클래스와 예측 클래스의 조합을 표 형태로 보여준다.

cm = confusion_matrix(y_test_clf, rf_clf_pred)
print("Confusion Matrix:\n", cm)

print(classification_report(y_test_clf, rf_clf_pred))

어떤 클래스를 잘 맞추고, 어떤 클래스를 헷갈리는지 확인할 수 있다.
다중분류에서도 매우 유용하다.

분류 문제에서는 Accuracy만 보는 것보다 Precision, Recall, F1-score, Confusion Matrix까지 함께 보는 것이 훨씬 안전하다.

6. Feature Importance / Permutation Importance

모델을 학습한 뒤에는 단순히 성능만 보는 것이 아니라, 어떤 feature가 예측에 많이 기여했는지 확인하고 싶을 때가 있다.
이때 자주 사용하는 것이 Feature Importance와 Permutation Importance이다.

6.1. Feature Importance

Feature Importance는 주로 트리 계열 모델에서 많이 사용한다.
각 feature가 분할에 얼마나 기여했는지를 기준으로 중요도를 계산한다.

rf_importance_model = RandomForestClassifier(random_state=42)
rf_importance_model.fit(X_train_clf, y_train_clf)

feature_importance_df = pd.DataFrame({
    "feature": X_train_clf.columns,
    "importance": rf_importance_model.feature_importances_
}).sort_values("importance", ascending=False)

print(feature_importance_df)

이 값이 높을수록 모델이 해당 변수를 더 많이 참고했다는 뜻으로 해석할 수 있다.
다만 트리 기반 모델에 의존적이라는 점을 기억할 필요가 있다.

6.2. Permutation Importance

Permutation Importance는 특정 feature 값을 섞었을 때 모델 성능이 얼마나 떨어지는지를 보는 방식이다.
중요한 feature라면 값을 섞었을 때 성능 하락이 크게 나타난다.

perm_result = permutation_importance(
    rf_importance_model,
    X_test_clf,
    y_test_clf,
    n_repeats=10,
    random_state=42,
    scoring="accuracy"
)

perm_importance_df = pd.DataFrame({
    "feature": X_test_clf.columns,
    "importance_mean": perm_result.importances_mean
}).sort_values("importance_mean", ascending=False)

print(perm_importance_df)

이 방법은 특정 모델에 덜 종속적이어서 활용 범위가 더 넓다.

7. 모델 평가 시각화

7.1 회귀 시각화

회귀 문제에서는 숫자 지표만 보는 것보다 예측 결과를 시각적으로 확인하는 것이 훨씬 이해하기 쉽다.

같은 데이터셋이라도 모델마다 예측 방식이 다르기 때문에, 성능 비교표와 함께 그래프를 보면 어떤 모델이 더 안정적으로 예측하는지 빠르게 파악할 수 있다.

모델별 R² 비교 막대그래프

먼저 모델별 R² 비교 그래프를 그리면 전체적인 설명력을 한눈에 볼 수 있다.
R²가 높을수록 실제 데이터의 흐름을 더 잘 설명한다고 볼 수 있다.

plt.figure(figsize=(10, 5))
sns.barplot(data=reg_results_df, x="Model", y="R2")
plt.xticks(rotation=45)
plt.title("Regression Model R2 Comparison")
plt.tight_layout()
plt.show()

실제값 vs 예측값 산점도

실제값과 예측값 산점도도 자주 사용한다.
이 그래프에서 점들이 대각선 근처에 모일수록 예측이 잘된 것이다.
점들이 넓게 퍼져 있으면 실제값과 예측값 차이가 크다는 뜻이다.

plt.figure(figsize=(6, 6))
plt.scatter(y_test_reg, best_reg_pred, alpha=0.7)
plt.plot(
    [y_test_reg.min(), y_test_reg.max()],
    [y_test_reg.min(), y_test_reg.max()],
    linestyle="--"
)
plt.xlabel("Actual Tip")
plt.ylabel("Predicted Tip")
plt.title(f"Actual vs Predicted ({best_reg_name})")
plt.tight_layout()
plt.show()

잔차 시각화

잔차는 실제값에서 예측값을 뺀 값이며, 모델이 어디에서 얼마나 틀렸는지 보여준다.
잔차 분포가 0 근처에 고르게 모이면 비교적 안정적인 예측이라고 볼 수 있다.
반대로 특정 방향으로 치우치거나 이상하게 퍼져 있다면, 모델이 어떤 구간에서 지속적으로 과대예측 또는 과소예측하고 있을 가능성이 있다.

plt.figure(figsize=(8, 5))
plt.scatter(best_reg_pred, residuals, alpha=0.7)
plt.axhline(0, linestyle="--")
plt.xlabel("Predicted Value")
plt.ylabel("Residual")
plt.title(f"Residual Plot ({best_reg_name})")
plt.tight_layout()
plt.show()

7.2 분류 시각화

분류 문제에서는 단순히 Accuracy만 보는 것보다, 모델이 어떤 클래스를 잘 맞추고 어떤 클래스를 헷갈리는지를 함께 보는 것이 중요하다.

Accuracy 비교 막대그래프

plt.figure(figsize=(10, 5))
sns.barplot(data=clf_results_df, x="Model", y="Accuracy")
plt.xticks(rotation=45)
plt.title("Classification Model Accuracy Comparison")
plt.tight_layout()
plt.show()

Confusion Matrix heatmap

Confusion Matrix는 분류 문제에서 가장 대표적인 시각화이다.
실제 클래스와 예측 클래스의 조합을 표 형태로 보여주기 때문에, 어떤 클래스를 정확히 맞추고 어떤 클래스를 혼동하는지 바로 확인할 수 있다.
다중분류 문제인 iris 데이터셋에서도 각 품종이 얼마나 잘 분류되는지 직관적으로 볼 수 있다.

cm = confusion_matrix(y_test_clf, best_clf_pred)

plt.figure(figsize=(6, 5))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.title(f"Confusion Matrix ({best_clf_name})")
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.tight_layout()
plt.show()

이번 글에서는 회귀와 분류 문제를 나누어 대표적인 머신러닝 모델의 기본 사용법을 살펴보고, 교차검증과 하이퍼파라미터 튜닝, 평가 지표, 그리고 시각화 방법까지 함께 정리했다.

모델을 선택할때 해석이 쉬운 LinearRegression, LogisticRegression 같은 기본 모델로 시작하고, 이후 비선형 패턴이 의심되면 DecisionTree, RandomForest, GradientBoosting, SVC 등을 비교하는 방식이 일반적이다. 데이터 스케일에 민감한 KNN, SVC 계열은 스케일링 여부를 특히 신경 써야 한다.

머신러닝에서는 모델 하나만 학습해보는 것보다 여러 모델을 같은 기준으로 비교해보는 과정이 중요하다.
또한 성능 수치만 보는 데서 끝나지 않고, 실제 예측 결과와 오차, 클래스별 분류 결과, 변수 중요도까지 함께 확인해야 모델을 더 정확하게 이해할 수 있다.

ML - 데이터 전처리

bonggyulim — Sat, 4 Apr 2026 20:49:31 +0900

머신러닝에서 모델을 바꾸는 것만큼 중요한 것이 데이터 전처리다.
실제로 데이터를 다뤄보면 모델을 바로 학습하는 시간보다, 먼저 데이터를 확인하고 정리하고 가공하는 시간이 더 길다.

복잡한 수식 설명보다 실제로 어떻게 전처리를 하는지에 집중해서 정리했다.
예시는 seaborn의 tips 데이터셋을 사용했다.

1. 실습 준비

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler, MinMaxScaler

2. 데이터 불러오기

먼저 기본 데이터셋을 불러온다.

tips = sns.load_dataset("tips")
df = tips.copy()
df.head() # 데이터 앞부분 확인

3. 데이터 확인

전처리의 시작은 데이터를 확인하는 것이다.
컬럼 구성, 데이터 타입, 결측치 여부, 수치형 분포를 먼저 봐야 한다.

print("===== 데이터 정보 =====")
df.info()

# 수치형 컬럼의 기초 통계량 확인
print("===== 기초 통계량 =====")
df.describe()

# 컬럼명 확인
print("===== 컬럼 목록 =====")
df.columns

# 특정 컬럼 확인
df[["total_bill", "tip"]].head()

4. 결측치 확인과 처리

실무 데이터에서는 결측치가 자주 나온다.
기본 tips 데이터셋은 결측치가 거의 없기 때문에, 실습용으로 일부 값을 비워서 처리 과정을 확인해보겠다.

df.loc[0, "total_bill"] = np.nan
df.loc[3, "sex"] = np.nan
df.loc[5, "smoker"] = np.nan

4-1. 결측치 확인

isnull()은 결측치 여부를 확인하고, sum()을 붙이면 컬럼별 결측치 개수를 볼 수 있다.

df.isnull().sum()   # 각 열의 결측치 개수 확인

결측지 제거전

결측치 제거 후

4-2. 수치형 결측치 처리

fillna()는 비어 있는 값을 다른 값으로 채울 때 사용하는 메서드다.

# 수치형 컬럼은 평균이나 중앙값으로 채우는 경우가 많다
df["total_bill"] = df["total_bill"].fillna(df["total_bill"].mean())

4-3. 범주형 결측치 처리

# 문자형 컬럼은 최빈값으로 채우는 경우가 많다
df["sex"] = df["sex"].fillna(df["sex"].mode()[0])
df["smoker"] = df["smoker"].fillna(df["smoker"].mode()[0])

4-4. 결측치 제거

fillna() 대신, 경우에 따라서는 dropna()로 결측치가 포함된 행을 제거할 수도 있다.
다만 데이터 손실이 발생할 수 있으므로 신중히 사용해야 한다.

df_dropna = df.dropna()

5. 중복 데이터 확인과 제거

같은 데이터가 여러 번 들어 있으면 학습에 왜곡이 생길 수 있다.
그래서 중복 여부도 확인해보는 편이 좋다.

5-1. 중복 확인

df.duplicated().sum()

5-2. 중복 제거

df = df.drop_duplicates()

6. 이상치 확인과 제거

이상치는 다른 값들에 비해 너무 크거나 작은 값이다.
이상치를 그대로 두면 평균, 분산, 회귀 계수 등에 영향을 줄 수 있다.

이번 예제에서는 IQR 기준으로 total_bill의 이상치를 확인한 뒤, 전처리 과정 예시를 보여주기 위해 일부 이상치를 제거해보았다. 이상치라고 보이는 값이 모두 잘못된 데이터는 아니기 때문에, 단순히 수치 기준만으로 바로 삭제하기보다 도메인 의미와 모델 목적을 함께 고려해서 판단해야 한다.

6-1. 박스플롯으로 이상치 확인

# 박스플롯으로 total_bill의 이상치를 먼저 확인한다.
plt.figure(figsize=(8, 4))
sns.boxplot(x=df["total_bill"])
plt.title("total_bill Boxplot")
plt.show()

6-2. IQR 방식으로 이상치 찾기

quantile()은 분위수를 계산하는 메서드다.
IQR 방식은 이상치를 빠르게 확인할 때 많이 사용한다.

# total_bill 컬럼을 기준으로 IQR 방식으로 이상치를 찾는다.
Q1 = df["total_bill"].quantile(0.25)
Q3 = df["total_bill"].quantile(0.75)
IQR = Q3 - Q1

# 이상치 판단 경계값 설정
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 이상치만 따로 확인
outliers = df[(df["total_bill"] < lower_bound) | (df["total_bill"] > upper_bound)]
outliers.head()

6-3. 이상치 제거

이상치를 무조건 삭제하는 것이 정답은 아니다.
실제 중요한 이벤트일 수도 있으므로, 먼저 데이터 의미를 확인하는 것이 좋다.

df = df[(df["total_bill"] >= lower_bound) & (df["total_bill"] <= upper_bound)]
print("shape:", df.shape)

# 제거 후 다시 박스플롯 확인
plt.figure(figsize=(8, 4))
sns.boxplot(x=df["total_bill"])
plt.title("total_bill Boxplot After Outlier Removal")
plt.show()

제거 전 shape: (244, 7) -> 제거 후 shape: (235, 7)

7. 필요 없는 컬럼 제거

모든 컬럼이 항상 모델에 도움이 되는 것은 아니다.
식별자, 누수 가능성이 있는 값, 모델과 직접 관련 없는 값은 제거 대상이 될 수 있다.

예를 들어 불필요한 컬럼이 있다면 아래처럼 제거할 수 있다.

# 예시
# df = df.drop(columns=["id", "timestamp"])

8. 범주형 데이터 인코딩

문자열 형태의 범주형 컬럼은 많은 머신러닝 모델이 직접 처리하지 못하므로, 보통 숫자 형태로 변환한 뒤 사용한다.

8-1. 라벨 인코딩

라벨 인코딩은 범주형 값을 정수형으로 바꾸는 방식이다.
라벨 인코딩은 순서형 범주형 데이터에 더 적합하며, 분류 문제의 타깃값 y를 숫자로 바꿀 때도 자주 사용된다.
다만 입력값 X의 명목형 범주형 데이터에는 원-핫 인코딩이 더 적절한 경우가 많다.

# 라벨 인코딩은 범주형 값을 숫자로 바꾸는 방식이다.
# 원-핫 인코딩을 사용할 예정이므로, 여기서는 예시 확인용으로만 별도 복사본을 만들어 진행
df_label = df.copy()

le = LabelEncoder()
df_label["sex"] = le.fit_transform(df_label["sex"])
df_label["smoker"] = le.fit_transform(df_label["smoker"])
df_label["day"] = le.fit_transform(df_label["day"])
df_label["time"] = le.fit_transform(df_label["time"])

df_label.head()

8-2. 원-핫 인코딩

원-핫 인코딩은 주로 입력값 X의 범주형 변수를 변환할 때 사용한다.
회귀 모델, SVM, KNN처럼 문자열을 직접 처리하지 못하는 모델에서 자주 사용된다.

# 범주형 컬럼을 0/1 컬럼으로 바꾼다.
df = pd.get_dummies(
    df,
    columns=["sex", "smoker", "day", "time"],
    drop_first=True
)

get_dummies()는 범주형 컬럼을 여러 개의 0/1 컬럼으로 바꿔준다.

9. 입력값(X) / 타깃값(y) 분리

이제 예측 대상과 입력 데이터를 나눈다.
이번 예시에서는 tip을 예측 대상으로 두고, 나머지 컬럼을 입력값으로 사용한다.

X = df.drop(columns=["tip"])
y = df["tip"]

10. 다중공선성 확인 및 제거

전처리 단계에서는 feature들끼리 너무 비슷한 정보를 담고 있는지도 확인할 수 있다.
이런 경우를 다중공선성이라고 하고, 특히 선형 모델 계열에서 영향을 줄 수 있다.

10-1. 상관관계 히트맵 확인

# 수치형 컬럼끼리의 상관관계를 확인한다.
corr_matrix = X.corr()

plt.figure(figsize=(10, 8))
sns.heatmap(
    corr_matrix,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    linewidths=0.5
)
plt.title("Feature Correlation Heatmap")
plt.show()

10-2. 상관관계 높은 컬럼 찾기

10-2. 상관관계 높은 컬럼 찾기

# 상관관계 행렬의 상삼각 영역만 사용한다.
upper_triangle = corr_matrix.where(
    np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
)

# 절댓값 기준 0.8보다 큰 컬럼을 찾는다.
high_corr_cols = [
    column for column in upper_triangle.columns
    if any(upper_triangle[column].abs() > 0.8)
]

print("상관관계가 높은 컬럼:", high_corr_cols)

10-3. 상관관계 높은 컬럼 제거

X_reduced = X.drop(columns=high_corr_cols)
X_reduced.head()

상관관계가 높은 컬럼은 무조건 제거하는 것이 아니라,
모델 특성과 데이터 의미를 같이 보고 판단하는 것이 좋다.

11. 학습 데이터 / 테스트 데이터 분리

전처리 후에는 학습용 데이터와 테스트용 데이터를 나눈다.
모델은 학습용 데이터로 학습하고, 테스트 데이터로 성능을 확인한다.

X_train, X_test, y_train, y_test = train_test_split(
    X_reduced,
    y,
    test_size=0.2,
    random_state=42
)

12. 수치형 컬럼만 스케일링

스케일링은 컬럼마다 값의 범위가 크게 다를 때 이를 맞춰주는 작업이다.
예를 들어 어떤 컬럼은 값이 1~5 사이인데, 다른 컬럼은 1000~10000 사이일 수 있다.
이런 상태로 모델을 학습하면 큰 값을 가지는 컬럼이 더 큰 영향을 주는 경우가 있다.

특히 거리 기반 모델이나 선형 모델, 그리고 경사하강법 기반 학습에서는 스케일 차이가 성능과 학습 안정성에 영향을 줄 수 있다.
반면 트리 계열 모델은 보통 스케일링 영향을 크게 받지 않는다.

주의할점은 fit_transform()은 학습 데이터에만 적용하고, 테스트 데이터에는 transform()만 적용해야 한다는 점이다.

12-1. 수치형 컬럼 지정

numeric_cols = ["total_bill", "size"]

12-2. StandardScaler 적용

StandardScaler는 각 수치형 컬럼을 평균 0, 표준편차 1 기준으로 변환하는 방식이다.
이미지 픽셀값처럼 원래 범위가 분명한 데이터나, 입력값을 일정 구간으로 맞추고 싶은 경우에 자주 사용

X_train_standard = X_train.copy()
X_test_standard = X_test.copy()

standard_scaler = StandardScaler()

X_train_standard[numeric_cols] = standard_scaler.fit_transform(X_train_standard[numeric_cols])
X_test_standard[numeric_cols] = standard_scaler.transform(X_test_standard[numeric_cols])

X_train_standard.head()

12-3. MinMaxScaler 적용

MinMaxScaler는 각 수치형 컬럼의 값을 0과 1 사이 범위로 변환하는 방식이다.
로지스틱 회귀, 선형 회귀, SVM, KNN, PCA처럼 스케일에 민감한 모델에서 자주 사용

X_train_minmax = X_train.copy()
X_test_minmax = X_test.copy()

minmax_scaler = MinMaxScaler()

X_train_minmax[numeric_cols] = minmax_scaler.fit_transform(X_train_minmax[numeric_cols])
X_test_minmax[numeric_cols] = minmax_scaler.transform(X_test_minmax[numeric_cols])

X_train_minmax.head()

13. 데이터 확인 시 자주 사용하는 시각화 방법

전처리를 시작하기 전에는 단순히 head(), info(), describe()만 보는 것보다,
시각화를 통해 데이터 분포와 관계를 함께 확인하는 것이 훨씬 도움이 된다.

특히 시각화는 다음과 같은 상황에서 유용하다.

수치형 컬럼의 분포 확인
범주형 컬럼의 빈도 확인
이상치 확인
변수 간 관계 확인
상관관계 확인

이번에는 tips 데이터셋 기준으로 자주 사용하는 기본 시각화 방법을 정리해보겠다.

13-1. 히스토그램(Histogram)

히스토그램은 수치형 데이터가 어떤 구간에 많이 몰려 있는지 확인할 때 사용한다.
데이터가 한쪽으로 치우쳐 있는지, 대략적인 분포가 어떤지 파악할 수 있다.

plt.figure(figsize=(8, 4))
sns.histplot(df["total_bill"], kde=True)
plt.title("total_bill Distribution")
plt.show()

13-2. 카운트플롯(Countplot)

카운트플롯은 범주형 데이터의 개수를 시각적으로 확인할 때 사용한다.
각 범주가 얼마나 자주 등장하는지 한눈에 볼 수 있다.

plt.figure(figsize=(8, 4))
sns.countplot(x=df["day"])
plt.title("Count of day")
plt.show()

13-3. 박스플롯(Boxplot)

박스플롯은 수치형 데이터의 분포와 이상치를 함께 확인할 때 자주 사용한다.
사분위수 범위와 중앙값, 그리고 이상치로 의심되는 값을 한 번에 볼 수 있다.

13-4. 산점도(Scatterplot)

산점도는 두 수치형 변수 사이의 관계를 확인할 때 사용한다.
특정 변수끼리 함께 증가하는지, 감소하는지, 또는 뚜렷한 패턴이 있는지 확인할 수 있다.

전처리는 단순히 데이터를 정리하는 과정이 아니라,
모델이 학습하기 좋은 형태로 데이터를 바꾸고 불필요한 노이즈를 줄이는 과정이라는 점에서 매우 중요하다.

이번 글에서는 전처리 자체에 초점을 맞춰 흐름을 정리했고,
다음 글에서는 이렇게 준비한 데이터를 바탕으로 모델 학습 결과를 어떻게 평가하는지, 그리고 회귀 성능 지표를 어떻게 해석해야 하는지를 정리해볼 예정이다.

디자인패턴이란

bonggyulim — Sun, 29 Mar 2026 12:28:29 +0900

프로그램을 만들다 보면 비슷한 구조의 문제를 반복해서 만나게 된다.
객체를 어떻게 생성할지, 기능을 어떻게 유연하게 바꿀지, 객체들 사이의 의존성을 어떻게 줄일지 같은 문제들이다.

이런 반복되는 설계 문제에 대해 많이 사용되는 해법을 정리한 것이 디자인패턴(Design Pattern) 이다.
디자인패턴은 정답 코드가 아니라, 유지보수하기 좋은 구조를 만들기 위한 설계 방법이라고 볼 수 있다.

디자인패턴에는 어떤 것들이 있을까?

디자인패턴은 생성패턴, 구조패턴, 행위패턴 3가지 종류로 나눠서 본다.
이번 글에서는 Python 예시로 아래 중요 패턴 5가지를 정리해보겠다.

Singleton: 객체를 하나만 생성해서 공유
Factory Method: 객체 생성 책임을 분리
Strategy: 알고리즘/정책을 교체 가능하게 설계
Observer: 상태 변화를 여러 객체에 알림
Adapter: 인터페이스가 다른 객체를 연결

1. Singleton 패턴

Singleton 패턴은 인스턴스를 하나만 생성하도록 제한하는 패턴이다.
즉, 어떤 객체가 프로그램 전체에서 하나만 존재해야 할 때 사용한다.

# =========================
# 1. Singleton Pattern
# =========================
# 목적:
# - 인스턴스를 하나만 만들고 계속 재사용
# - 설정값, 로그 관리자 같은 전역 공용 객체에 사용

class Config:
    _instance = None  # 클래스 변수: 만들어진 인스턴스를 저장

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)	# 아직 객체가 없으면 한 번만 생성
            cls._instance.settings = {}        		# 이미 객체가 있으면 기존 객체를 그대로 반환
        return cls._instance


config1 = Config()
config2 = Config()

config1.settings["theme"] = "dark"

print(config1.settings)     # {'theme': 'dark'}
print(config2.settings)     # {'theme': 'dark'}

2. Factory Method 패턴

Factory Method 패턴은 객체 생성 책임을 별도의 메서드나 클래스에 맡기는 패턴이다.
객체를 직접 생성하지 않고 “필요한 객체를 대신 만들어주는 공장”을 두는 방식이다.

# =========================
# 2. Factory Method Pattern
# =========================
# 목적:
# - 객체 생성 책임을 따로 분리
# - 어떤 객체를 만들지 결정하는 로직을 한 곳에 모음

class EmailSender:
    def send(self, message):
        print(f"이메일 전송: {message}")


class SmsSender:
    def send(self, message):
        print(f"SMS 전송: {message}")


class NotificationFactory:
    @staticmethod
    def create(channel):
        # 생성 로직을 여기서 관리
        if channel == "email":
            return EmailSender()
        elif channel == "sms":
            return SmsSender()
        else:
            raise ValueError("지원하지 않는 채널")


sender = NotificationFactory.create("email")
sender.send("안녕하세요")

Factory를 사용하면 객체를 어떻게 생성할지를 숨길 수 있다.

클라이언트는 무엇이 필요한지만 말한다
실제 생성은 Factory가 담당한다

3. Strategy 패턴

Strategy 패턴은 같은 목적을 수행하는 여러 알고리즘을 각각 분리하고, 필요에 따라 교체해서 사용하는 패턴이다.

기능은 같지만 방식이 여러 개일 때 유용하다.

# =========================
# 3. Strategy Pattern
# =========================
# 목적:
# - 같은 기능을 여러 방식으로 처리
# - 상황에 따라 알고리즘/정책을 갈아끼움

class NormalDiscount:
    def apply(self, price):
        return price


class MemberDiscount:
    def apply(self, price):
        return price * 0.9


class VipDiscount:
    def apply(self, price):
        return price * 0.8


class PaymentService:
    def __init__(self, discount_strategy):
        # 어떤 할인 정책을 쓸지 외부에서 주입받음
        self.discount_strategy = discount_strategy

    def calculate_price(self, price):
        return self.discount_strategy.apply(price)


service1 = PaymentService(NormalDiscount())
service2 = PaymentService(MemberDiscount())
service3 = PaymentService(VipDiscount())

print(service1.calculate_price(10000))  # 10000
print(service2.calculate_price(10000))  # 9000.0
print(service3.calculate_price(10000))  # 8000.0

할인 정책이 일반, 회원, VIP로 나뉜다고 했을때 if-elif로 계속 처리하면 코드가 길어지고 수정도 어려워진다.
Strategy 패턴은 할인 정책별로 클래스를 따로 만들고, 필요한 정책을 주입받아 사용하게 만든다.

PPE Guard에서의 예시

PPE를 분석한다는 목적은 같지만, 입력 방식에 따라 처리 전략이 달랐다.

비디오는 세그먼트 단위 처리
웹캠은 실시간 이벤트 전송

둘 다 “PPE 탐지 + OCR + 결과 저장”이라는 큰 목적은 같지만, 내부 동작은 다르다.

4. Observer 패턴

Observer 패턴은 어떤 객체의 상태가 바뀌었을 때, 그 변화를 여러 객체에게 자동으로 알려주는 패턴이다.

# =========================
# 4. Observer Pattern
# =========================
# 목적:
# - 한 객체의 변화가 생기면 여러 객체에게 자동 알림
# - 구독 / 알림 구조

class EmailObserver:
    def update(self, message):
        print(f"[이메일 알림] {message}")


class SmsObserver:
    def update(self, message):
        print(f"[SMS 알림] {message}")


class NewsPublisher:
    def __init__(self):
        self.observers = []  # 구독자 목록

    def subscribe(self, observer):
        self.observers.append(observer)

    def notify(self, message):
        # 상태 변화가 생기면 모든 구독자에게 알림
        for observer in self.observers:
            observer.update(message)


publisher = NewsPublisher()			# 인스턴스 생성
publisher.subscribe(EmailObserver())		# 구독자 추가
publisher.subscribe(SmsObserver())

publisher.notify("새 뉴스가 등록되었습니다.")

NewsPublisher는 구독자 목록을 가지고 있고, 새 소식이 생기면 모든 구독자에게 알림을 보낸다.
이 구조의 장점은 발행자(Publisher)가 구독자의 구체적인 내부 동작을 몰라도 된다는 점이다.

5. Adapter 패턴

Adapter 패턴은 서로 다른 인터페이스를 가진 객체들을 연결해주는 패턴이다.
기존 코드가 기대하는 방식과 실제 외부 라이브러리의 방식이 다를 때 중간에서 맞춰준다.

# =========================
# 5. Adapter Pattern
# =========================
# 목적:
# - 인터페이스가 다른 기존 클래스를 현재 코드에 맞게 연결
# - 기존 코드 수정 없이 재사용 가능

class OldPrinter:
    def print_text(self, text):
        print(f"기존 프린터 출력: {text}")


class PrinterAdapter:
    def __init__(self, old_printer):
        self.old_printer = old_printer

    def print(self, message):
        # 현재 코드가 기대하는 print()를
        # 기존 클래스의 print_text()로 연결
        self.old_printer.print_text(message)


def client_code(printer):
    # 여기서는 print() 메서드가 있다고 가정
    printer.print("Hello Adapter")


old_printer = OldPrinter()
adapter = PrinterAdapter(old_printer)

client_code(adapter)

client_code()는 print() 메서드를 기대한다. 그런데 기존 프린터는 print_text()만 가지고 있다.
이때 Adapter가 중간에서 메서드 이름과 사용 방식을 맞춰준다. 그래서 기존 클래스를 수정하지 않고도 재사용할 수 있다.

PPE Guard에서의 예시

YOLO나 EasyOCR는 원래 자기들 방식의 API가 있지만 서비스 계층에서는 그런 외부 API를 직접 알 필요가 없다.

나중에 OCR 엔진을 바꾸더라도
서비스 로직 전체를 뜯어고치지 않고 Adapter 구현체만 바꾸면 된다.

결론

결국 디자인패턴은 단순히 개념을 외우기 위한 것이 아니라, 실제 프로젝트에서 기능을 분리하고 변경에 유연하게 대응하기 위한 설계 방식 이다.

특히 기능 단위로 개발해야 하는 프로젝트에서는 하나의 큰 로직에 모든 기능을 넣기보다,
역할을 나누고, 교체 가능한 구조로 만들고, 외부 의존성을 분리하는 방식이 더 효과적이다.
이런 구조는 기능 추가와 수정이 쉬울 뿐 아니라, 팀원들이 기능별로 나누어 개발한 뒤 다시 통합하는 과정에서도 유지보수성과 협업 효율을 높여준다.

결국 좋은 설계는 패턴 이름을 많이 아는 것이 아니라,
현재 프로젝트에 맞는 구조를 선택해 기능 단위 개발이 가능하고 확장 가능한 코드로 만드는 것이라고 생각한다.

RareBridge 프로젝트 회고

bonggyulim — Thu, 19 Mar 2026 20:06:30 +0900

이번 프로젝트는 RareBridge라는 이름으로 진행한 프로젝트로 사용자가 입력한 증상을 바탕으로 질환 정보를 탐색하는 서비스였다. 사용자는 증상을 텍스트나 이미지 형태로 입력할 수 있고, 시스템은 이를 HPO(Human Phenotype Ontology) 코드로 변환한 뒤 희귀질환 데이터를 검색한다. 이후 질환별 매칭 점수를 계산해 상위 5개 질환 후보와 질환명, ORPHA 코드, 설명, 일치도 등의 정보를 제공하는 것이 핵심 흐름이었다.

RareBridge 핵심 기능

사용자가 증상을 텍스트나 이미지 형태로 입력
입력된 증상을 HPO(Human Phenotype Ontology) 코드로 변환
변환된 HPO를 기반으로 희귀질환 데이터를 검색
질환별 매칭 점수(스코어링) 를 계산
상위 5개 질환 후보와 질환명, ORPHA 코드, 설명, 일치도 등을 제공

내가 맡은 역할

프로젝트에서 PM 역할을 맡았고, 단순히 일정 조율만 하는 것이 아니라 프로젝트의 전체 구조를 정리하고 팀이 개발을 진행할 수 있는 기반을 만드는 역할을 담당했다. 구체적으로는 아키텍처 설계, API 및 데이터 스키마 정의, 데이터베이스 설계, Orphanet 데이터셋 추가, 코드 리뷰, 프론트 배포를 맡아 진행했다.

프로젝트를 통해 얻은 점

프로젝트를 진행하면서 가장 크게 느낀 점은, 초기 아키텍처의 방향뿐 아니라 구현 기준까지 더 구체적으로 정해두었더라면 팀원들이 기능을 추가하거나 수정할 때 훨씬 수월했을 것이라는 점이다. 구조를 나누고 흐름을 정리하려고 하긴 했지만, 실제 개발이 진행되면서 어떤 로직을 어느 위치에서 관리해야 하는지, 새로운 기능이 들어왔을 때 어떤 구조로 확장해야 하는지를 자주 고민해야 했다. 또한 AI를 활용하는 프로젝트였기 때문에, 프롬프트와 응답 형식을 초기에 미리 정의해두었다면 코드 구조와 기능 흐름이 더 일관되고 깔끔하게 정리될 수 있었을 것이라고 느꼈다.

내가 생각하는 PM의 역할은 단순히 일정을 조율하는 것이 아니라, 팀원들이 자신의 역량을 최대한 발휘할 수 있도록 돕는 것이다. 프로젝트가 끝났을 때 결과물만 남는 것이 아니라, 팀원 모두가 한 단계 성장했다고 느낄 수 있게 만드는 것 또한 중요하다고 생각한다.

https://github.com/RareBridge/RareBridge

파이썬 기본 문법

bonggyulim — Thu, 19 Mar 2026 19:01:39 +0900

1. 출력과 변수

변수 선언

a = 10
name = "Python"
is_ok = True

파이썬은 자료형을 미리 선언하지 않아도 된다.

출력

print(a)
print(name)
print(a, name)

f-string

문자열 안에 변수를 넣을 때 자주 쓴다.

name = "봉규"
age = 27
print(f"이름은 {name}이고, 나이는 {age}살입니다.")

2. 기본 자료형

2-1. 숫자형

a = 10      # int
b = 3.14    # float

사칙연산:

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.333...
print(10 // 3)  # 3   -> 몫
print(10 % 3)   # 1   -> 나머지
print(10 ** 3)  # 1000 -> 거듭제곱

2-2. 문자열

s = "hello"
#   인덱스
#   0 1 2 3 4
#   h e l l o

인덱싱

print(s[0])   # h
print(s[-1])  # o  맨 끝

슬라이싱

# s[start:end:step]
print(s[0:2])  # he		2번 인덱스 전까지
print(s[:3])   # hel	
print(s[2:])   # llo	2번 인덱스부터 끝까지
print(s[::-1]) # olleh

문자열 자주 쓰는 함수

s = " hello python "

print(s.strip())       # 양쪽 공백 제거
print(s.upper())       # 대문자
print(s.lower())       # 소문자
print(s.replace("python", "java"))
print(s.split())       # 공백 기준 분리

문자열 합치기:

arr = ["a", "b", "c"]
print("".join(arr))    # abc

코테에서 join()은 매우 자주 나온다.

2-3. 불리언

flag = True
print(flag)  # True

비교 연산:

print(3 > 1)   # True
print(3 == 1)  # False
print(3 != 1)  # True

논리 연산:

print(True and False)
print(True or False)
print(not True)

3. 리스트

가장 많이 쓰는 자료형이다.

arr = [1, 2, 3, 4, 5]

접근

print(arr[0])
print(arr[-1]) # 뒤에서 부터 셈 -1, -2, -3 ...

추가 / 삭제

arr.append(6)      # 맨 뒤 추가
arr.insert(1, 10)  # 특정 위치에 삽입
arr.pop()          # 마지막 원소 제거
arr.remove(3)      # 값으로 제거

정렬

arr.sort()                  # 오름차순
arr.sort(reverse=True)      # 내림차순

정렬된 새 리스트 반환:

arr = [3, 1, 2]
new_arr = sorted(arr)
print(new_arr)   # [1, 2, 3]

뒤집기

arr.reverse()

개수 세기

arr = [1, 2, 2, 3]
print(arr.count(2))  # 2

리스트 컴프리헨션

코테에서 매우 자주 사용된다.

arr = [i for i in range(5)]
print(arr)  # [0, 1, 2, 3, 4]

조건 포함:

arr = [i for i in range(10) if i % 2 == 0]
print(arr)  # [0, 2, 4, 6, 8]

2차원 배열 생성:

graph = [[0] * 3 for _ in range(4)]

# [
# 	[0, 0, 0],
# 	[0, 0, 0],
# 	[0, 0, 0],
# 	[0, 0, 0]
# ]

주의:

graph = [[0] * 3] * 4

이 방식은 내부 리스트가 같은 객체를 참조해서 문제를 일으킬 수 있다.

4. 튜플

변경할 수 없는 자료형이다.

t = (1, 2, 3)

좌표나 값 묶음으로 많이 사용한다.

x, y = (3, 4)
print(x, y)

5. 딕셔너리

키-값 형태로 저장한다.

d = {"a": 1, "b": 2}
print(d["a"])  # 1

추가 / 수정

d["c"] = 3
d["a"] = 10

삭제

del d["b"]

자주 쓰는 함수

print(d.keys())
print(d.values())
print(d.items())
print(d.get("a"))      # 키가 없으면 None
print(d.get("x", 0))   # 기본값 0

빈도수 세기 패턴

arr = [1, 2, 2, 3, 3, 3]
count = {}

for x in arr:
    count[x] = count.get(x, 0) + 1

print(count)  # {1: 1, 2: 2, 3: 3}

코테에서 매우 중요하다.

6. 집합(set)

중복 제거와 빠른 탐색에 사용한다.

s = {1, 2, 3}

추가 / 삭제

s.add(4)
s.remove(2)

포함 여부 확인

print(3 in s)   # True

중복 제거

arr = [1, 2, 2, 3, 3]
arr = list(set(arr))
print(arr)

7. 조건문

x = 10

if x > 0:
    print("양수")
elif x == 0:
    print("0")
else:
    print("음수")

삼항 연산식:

a = 10
result = "짝수" if a % 2 == 0 else "홀수"
print(result)

8. 반복문

8-1. for문

for i in range(5):
    print(i)

range

range(5)        # 0 ~ 4
range(1, 5)     # 1 ~ 4
range(1, 10, 2) # 1, 3, 5, 7, 9

8-2. while문

i = 0
while i < 5:
    print(i)
    i += 1

8-3. enumerate

인덱스와 값을 같이 사용할 때 편하다.

arr = ["a", "b", "c"]

for idx, value in enumerate(arr):
    print(idx, value)

9. 함수

def add(a, b):
    return a + b

print(add(3, 4))

기본값:

def greet(name="guest"):
    print(f"hello, {name}")

여러 값 반환:

def calc(a, b):
    return a + b, a - b

x, y = calc(10, 3)
print(x, y)

10. 예외 처리

코테에서는 많이 쓰이지 않지만 기본은 알아두면 좋다.

try:
    x = int(input())
except:
    print("숫자를 입력하세요")

11. 코딩테스트 입력 처리

입력이 많을 때는 input()보다 sys.stdin.readline()이 빠르다.

import sys
input = sys.stdin.readline

n = int(input())
arr = list(map(int, input().split()))

문자열 개행 제거:

s = input().strip()

12. 코딩테스트에서 자주 쓰는 내장 함수

12-1. map

입력을 정수로 한 번에 변환할 때 자주 사용한다.

arr = list(map(int, input().split()))

12-2. sum

arr = [1, 2, 3, 4]
print(sum(arr))  # 10

12-3. min, max

arr = [5, 2, 8, 1]
print(min(arr))
print(max(arr))

12-4. sorted

arr = [3, 1, 2]
print(sorted(arr))
print(sorted(arr, reverse=True))

key 사용:

words = ["apple", "kiwi", "banana"]
print(sorted(words, key=len))

튜플 정렬:

arr = [(2, 3), (1, 5), (2, 1)]
print(sorted(arr))                 # 첫 번째 값 기준, 같으면 두 번째 값 기준
print(sorted(arr, key=lambda x: x[1]))

12-5. abs

print(abs(-5))  # 5

12-6. all / any

arr = [True, True, False]
print(all(arr))  # False
print(any(arr))  # True

12-7. zip

여러 리스트를 묶을 때 사용한다.

a = [1, 2, 3]
b = ["a", "b", "c"]

for x, y in zip(a, b):
    print(x, y)

12-8. eval

문자열을 코드처럼 실행해서 위험할 수 있으므로 코테에서는 거의 권장하지 않는다.
알아만 두고 남용하지 않는 것이 좋다.

13. 코딩테스트 필수 라이브러리

13-1. collections

파이썬 코테에서 가장 중요하다고 봐도 된다.

deque

양쪽에서 빠르게 삽입/삭제 가능하다.
BFS에서 거의 필수다.

from collections import deque

q = deque([1, 2, 3])
q.append(4)       # 오른쪽 추가
q.appendleft(0)   # 왼쪽 추가
q.pop()           # 오른쪽 제거
q.popleft()       # 왼쪽 제거

BFS 예시:

from collections import deque

q = deque()
q.append(1)

while q:
    x = q.popleft()
    print(x)

Counter

원소 개수를 자동으로 세어준다.

from collections import Counter

arr = ["a", "b", "a", "c", "a"]
counter = Counter(arr)

print(counter)           # Counter({'a': 3, 'b': 1, 'c': 1})
print(counter["a"])      # 3
print(counter.most_common(1))  # [('a', 3)]

defaultdict

키가 없어도 기본값으로 자동 생성된다.

from collections import defaultdict

d = defaultdict(int)
d["a"] += 1
print(d["a"])  # 1

리스트 기본값:

d = defaultdict(list)
d["x"].append(10)

13-2. itertools

순열, 조합 문제에서 자주 사용한다.

from itertools import permutations, combinations, product

permutations

순열

arr = [1, 2, 3]
print(list(permutations(arr, 2)))

combinations

조합

arr = [1, 2, 3]
print(list(combinations(arr, 2)))

product

중복 순열

arr = [1, 2, 3]
print(list(product(arr, repeat=2)))

13-3. heapq

우선순위 큐를 구현할 때 사용한다.
다익스트라, 최소 힙 문제에서 필수다.

import heapq

heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 2)

print(heapq.heappop(heap))  # 1
print(heapq.heappop(heap))  # 2

최소 힙만 기본 지원한다.

최대 힙처럼 사용:

import heapq

heap = []
heapq.heappush(heap, -3)
heapq.heappush(heap, -1)
heapq.heappush(heap, -2)

print(-heapq.heappop(heap))  # 3

13-4. math

수학 관련 문제에서 유용하다.

import math

print(math.sqrt(16))      # 제곱근
print(math.gcd(12, 18))   # 최대공약수
print(math.lcm(12, 18))   # 최소공배수
print(math.factorial(5))  # 팩토리얼
print(math.ceil(3.1))     # 올림
print(math.floor(3.9))    # 내림

13-5. bisect

이진 탐색을 쉽게 구현할 수 있다.

from bisect import bisect_left, bisect_right

arr = [1, 2, 4, 4, 4, 5, 6]

print(bisect_left(arr, 4))   # 2
print(bisect_right(arr, 4))  # 5

개수 구하기:

count = bisect_right(arr, 4) - bisect_left(arr, 4)
print(count)  # 3

14. 자주 나오는 문법 패턴

14-1. 리스트 초기화

visited = [False] * 10
dist = [0] * 10

14-2. 2차원 방향 탐색

DFS/BFS에서 자주 사용한다.

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

for i in range(4):
    nx = x + dx[i]
    ny = y + dy[i]

14-3. swap

a, b = b, a

14-4. 입력값 여러 개 받기

a, b = map(int, input().split())

14-5. 문자열을 리스트처럼 사용

s = "abcde"
for ch in s:
    print(ch)

14-6. 아스키 코드 변환

print(ord('A'))   # 65
print(chr(65))    # A

문자 변환 문제에서 자주 나온다.