코딩은 알지만 AI는 처음인 개발자를 위한 AI 입문 가이드

# Python 3.11 이상 설치 확인
python --version  # Python 3.11.x 이상이어야 해요

# 필수 라이브러리 설치
pip install numpy pandas scikit-learn matplotlib seaborn
pip install torch torchvision  # CPU 버전 (입문용으로 충분)
pip install jupyter notebook

import numpy as np
import pandas as pd

# 붓꽃(Iris) 데이터셋 불러오기 — AI 입문의 'Hello World'예요
from sklearn.datasets import load_iris

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target  # 0=setosa, 1=versicolor, 2=virginica

# 데이터 구조 파악 — 항상 먼저 해야 해요
print(df.head())          # 처음 5행
print(df.describe())      # 통계 요약
print(df['species'].value_counts())  # 클래스 분포 확인

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

X = df.drop('species', axis=1)
y = df['species']

# 훈련 데이터 80%, 테스트 데이터 20%로 나누기
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 모델 훈련
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"정확도: {accuracy:.2%}")  # 보통 95% 이상 나와요
print(classification_report(y_test, y_pred, target_names=iris.target_names))

import matplotlib.pyplot as plt

feature_importance = pd.Series(
    model.feature_importances_,
    index=iris.feature_names
).sort_values(ascending=False)

plt.figure(figsize=(8, 4))
feature_importance.plot(kind='bar', color='steelblue')
plt.title('어떤 특성이 분류에 중요했나요?')
plt.tight_layout()
plt.show()

from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

data = pd.DataFrame({
    'age': [25, 30, np.nan, 22, 35, np.nan],
    'salary': [50000, 60000, 55000, np.nan, 75000, 80000],
    'purchased': [0, 1, 1, 0, 1, 0]
})

imputer = SimpleImputer(strategy='mean')
X = data.drop('purchased', axis=1)
y = data['purchased']

X_imputed = imputer.fit_transform(X)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_imputed)

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

X = torch.tensor([[0,0],[0,1],[1,0],[1,1]], dtype=torch.float32)
y = torch.tensor([[0],[1],[1],[0]], dtype=torch.float32)

class XORNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(2, 4)
        self.output = nn.Linear(4, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.hidden(x))
        return self.sigmoid(self.output(x))

model = XORNet()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

for epoch in range(1000):
    pred = model(X)
    loss = criterion(pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 200 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

texts = [
    "이 제품 정말 좋아요", "최악이에요 환불할게요", "그냥 그래요",
    "강력 추천합니다", "다시는 안 사요", "배송 빨라서 좋았어요",
    "품질이 너무 별로예요", "만족스러워요"
]
labels = [1, 0, 2, 1, 0, 1, 0, 1]  # 1=긍정, 0=부정, 2=중립

pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', LogisticRegression(max_iter=200))
])

pipeline.fit(texts, labels)

new_texts = ["정말 마음에 들어요", "완전 실망이에요"]
preds = pipeline.predict(new_texts)
label_map = {1: "긍정", 0: "부정", 2: "중립"}
for text, pred in zip(new_texts, preds):
    print(f"'{text}' → {label_map[pred]}")

# 잘못된 방법 ❌
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # 전체 데이터로 fit
X_train, X_test = train_test_split(X_scaled)

# 올바른 방법 ✅
X_train, X_test = train_test_split(X)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)