📐 ML Fundamentals 완전 가이드

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# 1~2. 데이터 로드
df = pd.read_csv("customers.csv")
X, y = df.drop(columns=["churn"]), df["churn"]

# 3. 데이터 분리 먼저! (전처리 파라미터는 train에서만 학습)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)
scaler = StandardScaler().fit(X_train)          # train으로만 fit
X_train_s = scaler.transform(X_train)
X_test_s  = scaler.transform(X_test)             # test는 transform만

# 4. baseline 모델부터
model = LogisticRegression(max_iter=1000)
model.fit(X_train_s, y_train)

# 5. 평가
y_pred = model.predict(X_test_s)
print(classification_report(y_test, y_pred))

import torch
import torch.nn as nn

# ── 가장 단순한 MLP(다층 퍼셉트론) ────────────────
class SimpleMLP(nn.Module):
    def __init__(self, in_dim: int, hidden_dim: int, out_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, hidden_dim),
            nn.ReLU(),                      # 비선형 활성화 함수
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, out_dim),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)

model = SimpleMLP(in_dim=10, hidden_dim=32, out_dim=1)
x = torch.randn(4, 10)          # 배치 크기 4, 특성 10개
y_pred = model(x)               # forward pass — 순전파
print(y_pred.shape)             # torch.Size([4, 1])

# backward()를 호출하면 각 가중치의 gradient가 자동 계산됨(역전파)
loss = y_pred.sum()
loss.backward()

import torch.nn as nn
import torch.optim as optim

model     = SimpleMLP(in_dim=10, hidden_dim=32, out_dim=1)
criterion = nn.MSELoss()
optimizer = optim.AdamW(model.parameters(), lr=1e-3)

for epoch in range(100):
    optimizer.zero_grad()             # 이전 gradient 초기화
    y_pred = model(x_train)
    loss   = criterion(y_pred, y_train)
    loss.backward()                   # 역전파로 gradient 계산
    optimizer.step()                  # gradient 방향으로 가중치 업데이트

    if epoch % 20 == 0:
        print(f"epoch {epoch}: loss={loss.item():.4f}")

from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score

y_true = [1, 0, 1, 1, 0, 1, 0, 0]
y_pred = [1, 0, 0, 1, 0, 1, 1, 0]

tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
print(f"TP={tp} FP={fp} FN={fn} TN={tn}")
print(f"precision={precision_score(y_true, y_pred):.2f}")
print(f"recall={recall_score(y_true, y_pred):.2f}")
print(f"f1={f1_score(y_true, y_pred):.2f}")

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier

param_dist = {
    "n_estimators": [100, 200, 400],
    "max_depth": [None, 5, 10, 20],
    "min_samples_split": [2, 5, 10],
}

search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=20, cv=5, scoring="f1", random_state=42,
)
search.fit(X_train, y_train)
print(search.best_params_)