나이브 베이즈(Naive Bayes): 베이즈 정리로 분류하는 확률적 접근

P(스팸 | "무료") = P("무료" | 스팸) × P(스팸) / P("무료")

p_spam = 0.3
p_free_given_spam = 0.8
p_free = 0.35

p_spam_given_free = (p_free_given_spam * p_spam) / p_free
print(f"P(스팸 | '무료') = {p_spam_given_free:.4f}")
# P(스팸 | '무료') = 0.6857

P(스팸 | "무료", "이벤트", "당첨") = P("무료", "이벤트", "당첨" | 스팸) × P(스팸) / P("무료", "이벤트", "당첨")

P(x₁, x₂, ..., xₙ | C) = P(x₁|C) × P(x₂|C) × ... × P(xₙ|C)

# 나이브 가정 적용
p_free_given_spam = 0.8
p_event_given_spam = 0.6
p_win_given_spam = 0.7
p_spam = 0.3

# 결합 확률 = 개별 확률의 곱 (나이브 가정)
likelihood = p_free_given_spam * p_event_given_spam * p_win_given_spam
numerator = likelihood * p_spam

print(f"P('무료','이벤트','당첨' | 스팸) ≈ {likelihood:.4f}")
print(f"분자 = {numerator:.4f}")
# P('무료','이벤트','당첨' | 스팸) ≈ 0.3360
# 분자 = 0.1008

P(xⱼ | C=k) = (1 / √(2π σₖⱼ²)) × exp(-(xⱼ - μₖⱼ)² / (2σₖⱼ²))

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report

# 데이터 로드
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)

# Gaussian Naive Bayes — 스케일링 불필요
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred = gnb.predict(X_test)

print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")
print(f"\n클래스별 평균:\n{gnb.theta_.round(2)}")
print(f"\n클래스별 분산:\n{gnb.var_.round(2)}")

정확도: 0.9778

클래스별 평균:
[[4.99 3.39 1.47 0.24]
 [5.94 2.78 4.22 1.31]
 [6.59 2.97 5.58 2.03]]

클래스별 분산:
[[0.11 0.13 0.03 0.01]
 [0.28 0.1  0.21 0.04]
 [0.44 0.1  0.32 0.07]]

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

# 로지스틱 회귀 (스케일링 필수)
pipe_lr = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(max_iter=1000))
])
pipe_lr.fit(X_train, y_train)
y_pred_lr = pipe_lr.predict(X_test)

print(f"Gaussian NB 정확도:   {accuracy_score(y_test, y_pred):.4f}")
print(f"Logistic Regression: {accuracy_score(y_test, y_pred_lr):.4f}")

Gaussian NB 정확도:   0.9778
Logistic Regression: 1.0000

from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# 4개 카테고리만 사용
categories = ['alt.atheism', 'sci.space', 'comp.graphics', 'rec.sport.baseball']

train_data = fetch_20newsgroups(subset='train', categories=categories, random_state=42)
test_data = fetch_20newsgroups(subset='test', categories=categories, random_state=42)

# 파이프라인: 단어 벡터화 → Multinomial NB
pipe_mnb = Pipeline([
    ('vectorizer', CountVectorizer(stop_words='english', max_features=10000)),
    ('clf', MultinomialNB(alpha=1.0))
])

pipe_mnb.fit(train_data.data, train_data.target)
y_pred = pipe_mnb.predict(test_data.data)

print(f"정확도: {accuracy_score(test_data.target, y_pred):.4f}")
print(f"학습 데이터: {len(train_data.data)}개")
print(f"테스트 데이터: {len(test_data.data)}개")
print(f"어휘 수: {len(pipe_mnb['vectorizer'].vocabulary_)}개")

정확도: 0.9335
학습 데이터: 2354개
테스트 데이터: 1568개
어휘 수: 10000개

import numpy as np

vectorizer = pipe_mnb['vectorizer']
clf = pipe_mnb['clf']
feature_names = vectorizer.get_feature_names_out()

# 각 카테고리에서 가장 영향력 있는 단어 top 5
for i, category in enumerate(categories):
    top_indices = clf.feature_log_prob_[i].argsort()[-5:][::-1]
    top_words = [feature_names[j] for j in top_indices]
    print(f"{category}: {', '.join(top_words)}")

alt.atheism: god, people, don, think, just
sci.space: space, nasa, orbit, launch, earth
comp.graphics: graphics, image, files, program, computer
rec.sport.baseball: game, team, baseball, year, games

from sklearn.linear_model import LogisticRegression
import time

# Multinomial NB
start = time.time()
pipe_mnb.fit(train_data.data, train_data.target)
nb_time = time.time() - start
nb_acc = accuracy_score(test_data.target, pipe_mnb.predict(test_data.data))

# Logistic Regression
pipe_lr = Pipeline([
    ('vectorizer', CountVectorizer(stop_words='english', max_features=10000)),
    ('clf', LogisticRegression(max_iter=1000, C=1.0))
])

start = time.time()
pipe_lr.fit(train_data.data, train_data.target)
lr_time = time.time() - start
lr_acc = accuracy_score(test_data.target, pipe_lr.predict(test_data.data))

print(f"Multinomial NB  — 정확도: {nb_acc:.4f}, 학습 시간: {nb_time:.4f}초")
print(f"Logistic Reg.   — 정확도: {lr_acc:.4f}, 학습 시간: {lr_time:.4f}초")

Multinomial NB  — 정확도: 0.9335, 학습 시간: 0.0089초
Logistic Reg.   — 정확도: 0.9503, 학습 시간: 0.4521초