[Python 100일 챌린지] Day 92 - scikit-learn 설치

게시 2025/05/31

Day 92 - scikit-learn 설치

By YonYonWare

21 분읽는 시간

[Python 100일 챌린지] Day 92 - scikit-learn 설치

드디어 첫 머신러닝 코드 실행! scikit-learn은 Python 머신러닝의 국민 라이브러리입니다. 설치하고 첫 예측 모델을 3분만에 만들어봅시다! “이게 머신러닝이구나!” 하는 순간을 경험하실 거예요.

(20분 완독 ⭐⭐)

🎯 오늘의 학습 목표

scikit-learn 설치하기
첫 번째 머신러닝 모델 실행하기
내장 데이터셋 사용하기

📚 사전 지식

Day 58: pip 패키지 설치
Day 66: Pandas DataFrame 기초
Day 91: 머신러닝이란?

🎯 학습 목표 1: scikit-learn 설치하기

💡 설치가 처음이라 막막하신가요? 괜찮습니다! 명령어 하나면 끝나요. 3분이면 충분합니다. 차근차근 따라오세요! 😊

scikit-learn이란?

Python 머신러닝의 표준 라이브러리

scikit-learn = 머신러닝 알고리즘 + 데이터 전처리 + 모델 평가

실생활 비유

scikit-learn = 요리 레시피북 📚

요리를 직접 만든다면:

🥘 재료 손질법 (데이터 전처리)
👨‍🍳 조리법 (머신러닝 알고리즘)
🍽️ 맛 평가법 (모델 평가)

이 모든 게 검증된 레시피로 정리되어 있어요! 처음부터 만들 필요 없이, 책에 나온 레시피를 따라하면 됩니다.

scikit-learn의 장점:

✅ 이미 만들어진 알고리즘 (바퀴를 재발명할 필요 없음)
✅ 일관된 사용법 (모든 모델이 .fit(), .predict() 사용)
✅ 잘 테스트된 코드 (전세계 개발자들이 검증)
✅ 풍부한 문서와 예제

설치 방법

방법 1: pip로 설치 (추천)

# 터미널 또는 명령 프롬프트에서 실행
pip install scikit-learn

방법 2: 특정 버전 설치

pip install scikit-learn==1.3.0

설치 확인

  
# 설치가 잘 됐는지 확인
import sklearn
print(sklearn.__version__)

출력 예시:

1.3.2

함께 설치되는 라이브러리

scikit-learn을 설치하면 자동으로 함께 설치됩니다:

  
import numpy as np       # 수치 계산
import pandas as pd      # 데이터 처리
import matplotlib.pyplot as plt  # 시각화
from sklearn import datasets     # 샘플 데이터

🎯 학습 목표 2: 첫 번째 머신러닝 모델 실행하기

3분 만에 만드는 첫 모델!

전체 코드 (복사해서 실행해보세요!)

  
# 1. 필요한 라이브러리 import
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# 2. 데이터 로드
iris = load_iris()
X = iris.data    # 특징 (꽃잎 길이, 너비 등)
y = iris.target  # 정답 (꽃 종류)

# 3. 훈련/테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 4. 모델 생성 및 학습
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# 5. 예측 및 정확도 확인
accuracy = model.score(X_test, y_test)
print(f"정확도: {accuracy * 100:.2f}%")

# 6. 새로운 데이터 예측해보기
new_flower = [[5.0, 3.5, 1.5, 0.2]]
prediction = model.predict(new_flower)
print(f"예측 결과: {iris.target_names[prediction][0]}")

출력:

정확도: 100.00%
예측 결과: setosa

코드 한 줄씩 이해하기

1단계: 데이터 준비

  
# Iris 꽃 데이터셋 로드 (유명한 샘플 데이터)
iris = load_iris()

# X: 입력 데이터 (특징)
# [꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비]
X = iris.data

# y: 정답 레이블
# 0=setosa, 1=versicolor, 2=virginica
y = iris.target

2단계: 데이터 분리

  
# 80%는 훈련용, 20%는 테스트용으로 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,      # 테스트 데이터 비율
    random_state=42     # 재현 가능하도록 시드 고정
)

print(f"훈련 데이터: {len(X_train)}개")
print(f"테스트 데이터: {len(X_test)}개")

출력:

훈련 데이터: 120개
테스트 데이터: 30개

3단계: 모델 학습

  
# 의사결정나무 모델 생성
model = DecisionTreeClassifier()

# 모델 학습
model.fit(X_train, y_train)
# 컴퓨터: "꽃잎이 2.5cm보다 작으면 setosa구나!"

4단계: 예측

  
# 테스트 데이터로 예측
predictions = model.predict(X_test)

# 처음 5개 예측 결과 확인
print("예측:", predictions[:5])
print("정답:", y_test[:5])

출력:

예측: [1 0 2 1 1]
정답: [1 0 2 1 1]

🎯 학습 목표 3: 내장 데이터셋 사용하기

scikit-learn의 샘플 데이터셋

연습용으로 제공되는 데이터셋들:

  
from sklearn import datasets

# 1. Iris (붓꽃 분류) - 가장 유명
iris = datasets.load_iris()
print("Iris 특징:", iris.feature_names)
print("Iris 클래스:", iris.target_names)

# 2. Wine (와인 분류)
wine = datasets.load_wine()
print("\nWine 특징:", wine.feature_names[:3])  # 처음 3개만

# 3. Digits (손글씨 숫자 인식)
digits = datasets.load_digits()
print("\nDigits 이미지 크기:", digits.images[0].shape)

출력:

Iris 특징: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Iris 클래스: ['setosa' 'versicolor' 'virginica']

Wine 특징: ['alcohol', 'malic_acid', 'ash']

Digits 이미지 크기: (8, 8)

Iris 데이터 자세히 보기

  
import pandas as pd

# DataFrame으로 변환
df = pd.DataFrame(
    data=iris.data,
    columns=iris.feature_names
)
df['species'] = iris.target

# 처음 5개 확인
print(df.head())

# 기본 통계
print("\n통계 정보:")
print(df.describe())

출력:

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  species
0                5.1               3.5                1.4               0.2        0
1                4.9               3.0                1.4               0.2        0
2                4.7               3.2                1.3               0.2        0
3                4.6               3.1                1.5               0.2        0
4                5.0               3.6                1.4               0.2        0

통계 정보:
       sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)    species
count         150.000000        150.000000         150.000000        150.000000  150.000000
mean            5.843333          3.057333           3.758000          1.199333    1.000000
std             0.828066          0.435866           1.765298          0.762238    0.819232
min             4.300000          2.000000           1.000000          0.100000    0.000000
25%             5.100000          2.800000           1.600000          0.300000    0.000000
50%             5.800000          3.000000           4.350000          1.300000    1.000000
75%             6.400000          3.300000           5.100000          1.800000    2.000000
max             7.900000          4.400000           6.900000          2.500000    2.000000

💻 실습 예제

예제 1: 와인 분류 모델 만들기

  
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# 1. 데이터 로드
wine = load_wine()
X = wine.data
y = wine.target

# 2. 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 3. KNN 모델 생성 및 학습
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)

# 4. 정확도 확인
accuracy = model.score(X_test, y_test)
print(f"와인 분류 정확도: {accuracy * 100:.2f}%")

# 5. 새로운 와인 예측
new_wine = X_test[0].reshape(1, -1)
prediction = model.predict(new_wine)
actual = y_test[0]

print(f"\n예측: {wine.target_names[prediction][0]}")
print(f"정답: {wine.target_names[actual]}")

출력:

와인 분류 정확도: 94.44%

예측: class_1
정답: class_1

예제 2: 손글씨 숫자 인식

  
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
import matplotlib.pyplot as plt

# 1. 데이터 로드
digits = load_digits()
X = digits.data
y = digits.target

# 2. 첫 번째 이미지 보기
plt.figure(figsize=(3, 3))
plt.imshow(digits.images[0], cmap='gray')
plt.title(f'Label: {digits.target[0]}')
plt.axis('off')
plt.savefig('first_digit.png', dpi=150, bbox_inches='tight')
print("첫 번째 숫자 이미지 저장: first_digit.png")

# 3. 모델 학습
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = SVC(kernel='linear')
model.fit(X_train, y_train)

# 4. 정확도
accuracy = model.score(X_test, y_test)
print(f"\n손글씨 인식 정확도: {accuracy * 100:.2f}%")

출력:

첫 번째 숫자 이미지 저장: first_digit.png

손글씨 인식 정확도: 98.61%

🎓 scikit-learn의 주요 모듈

모듈 구조

graph TD
    A[sklearn] --> B[datasets<br/>샘플 데이터]
    A --> C[model_selection<br/>데이터 분리]
    A --> D[preprocessing<br/>전처리]
    A --> E[linear_model<br/>선형 모델]
    A --> F[tree<br/>의사결정나무]
    A --> G[ensemble<br/>앙상블]
    A --> H[metrics<br/>평가 지표]

    B --> B1[load_iris<br/>load_wine]
    C --> C1[train_test_split]
    D --> D1[StandardScaler<br/>LabelEncoder]
    E --> E1[LinearRegression<br/>LogisticRegression]

자주 사용하는 import 문

  
# 데이터 관련
from sklearn.datasets import load_iris, load_wine
from sklearn.model_selection import train_test_split

# 전처리
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder

# 모델
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# 평가
from sklearn.metrics import accuracy_score
from sklearn.metrics import mean_squared_error

🌟 머신러닝 워크플로우

표준 프로세스

  
# 1. 데이터 준비
from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target

# 2. 데이터 분리 (훈련/테스트)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. 모델 선택
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()

# 4. 모델 학습
model.fit(X_train, y_train)

# 5. 예측
predictions = model.predict(X_test)

# 6. 평가
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, predictions)
print(f"정확도: {accuracy * 100:.2f}%")

이 패턴을 외우세요! 모든 머신러닝이 이 순서입니다.

⚠️ 초보자 주의사항

주의 1: 데이터 분리는 필수

  
# ❌ 잘못된 방법: 같은 데이터로 훈련하고 테스트
model.fit(X, y)
accuracy = model.score(X, y)  # 100% 나와도 무의미!

# ✅ 올바른 방법: 분리해서 테스트
X_train, X_test, y_train, y_test = train_test_split(X, y)
model.fit(X_train, y_train)
accuracy = model.score(X_test, y_test)  # 의미 있는 결과

주의 2: random_state 설정

  
# random_state를 설정하지 않으면
# 실행할 때마다 결과가 달라집니다
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42  # 재현 가능하도록!
)

주의 3: 과적합 주의

  
# 훈련 정확도와 테스트 정확도 비교
train_acc = model.score(X_train, y_train)
test_acc = model.score(X_test, y_test)

print(f"훈련 정확도: {train_acc * 100:.2f}%")
print(f"테스트 정확도: {test_acc * 100:.2f}%")

# 훈련 100%, 테스트 60% → 과적합!
# 훈련 85%, 테스트 83% → 좋음!

📝 요약

scikit-learn: Python 머신러닝의 표준 라이브러리
설치: pip install scikit-learn
기본 워크플로우:
- 데이터 로드 → 분리 → 모델 생성 → 학습 → 예측 → 평가
내장 데이터셋: iris, wine, digits 등 연습용 데이터 제공
train_test_split: 데이터 분리는 필수!

🧪 연습 문제

문제 1: 완전한 분류 모델 만들기

아래 코드의 빈 칸을 채워 와인 분류 모델을 완성하세요.

  
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# 데이터 로드
wine = load_wine()
X = wine.____
y = wine.____

# 데이터 분리 (테스트 20%)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=____, random_state=42
)

# 모델 학습
model = DecisionTreeClassifier()
model.____(X_train, y_train)

# 정확도 출력
accuracy = model.____(X_test, y_test)
print(f"정확도: {accuracy * 100:.2f}%")

✅ 정답

  
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# 데이터 로드
wine = load_wine()
X = wine.data      # 특징 데이터
y = wine.target    # 레이블

# 데이터 분리 (테스트 20%)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 모델 학습
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# 정확도 출력
accuracy = model.score(X_test, y_test)
print(f"정확도: {accuracy * 100:.2f}%")

🤔 자주 묻는 질문 (FAQ)

Q1: pip install 시 에러가 납니다. 어떻게 하나요?

A: 가장 흔한 원인과 해결법입니다!

에러 1: pip: command not found

  
# Python 설치 확인
python --version

# pip 대신 python -m pip 사용
python -m pip install scikit-learn

에러 2: Permission denied

  
# Mac/Linux: 사용자 디렉토리에 설치
pip install --user scikit-learn

# 또는 가상환경 사용 (추천!)
python -m venv myenv
source myenv/bin/activate  # Windows: myenv\Scripts\activate
pip install scikit-learn

에러 3: Microsoft Visual C++ 14.0 is required (Windows)

해결: Visual Studio Build Tools 설치

Q2: scikit-learn과 sklearn, 뭐가 맞나요?

A: 둘 다 맞습니다! 😊

  
# 설치할 때는 scikit-learn
pip install scikit-learn

# import 할 때는 sklearn
import sklearn
from sklearn.tree import DecisionTreeClassifier

왜 다르냐고요?

패키지 이름: scikit-learn (하이픈 포함)
Python 모듈 이름: sklearn (하이픈 불가능)

처음엔 헷갈리지만 금방 익숙해져요!

Q3: TensorFlow, PyTorch랑 뭐가 다른가요?

A: 목적과 난이도가 다릅니다!

라이브러리	주요 용도	난이도	추천 대상
scikit-learn	전통적 ML (회귀, 분류, 클러스터링)	⭐ 쉬움	입문자
TensorFlow	딥러닝, 신경망	⭐⭐⭐ 어려움	전문가
PyTorch	딥러닝, 연구용	⭐⭐⭐ 어려움	연구자

예시로 이해하기:

  
# scikit-learn - 간단한 분류
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
model.fit(X, y)  # 끝!

# TensorFlow - 복잡한 신경망
import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
# ... 더 많은 코드 ...

💡 추천: 입문자는 scikit-learn으로 시작 → 나중에 TensorFlow/PyTorch

Q4: 수학을 잘 못하는데 scikit-learn 쓸 수 있나요?

A: 100% 가능합니다! 😊

scikit-learn의 철학: “복잡한 수학은 라이브러리가 알아서!”

  
# 여러분이 할 일
model = DecisionTreeClassifier()  # 모델 선택
model.fit(X_train, y_train)       # 학습
predictions = model.predict(X_test)  # 예측

# 뒤에서 scikit-learn이 하는 일
# - 수백 줄의 수학 공식 계산
# - 최적화 알고리즘 실행
# - 메모리 효율적 처리

필요한 것:

✅ Python 기본 문법 (Day 1-90에서 배운 내용)
✅ 데이터 구조 이해 (리스트, DataFrame)
❌ 미적분, 선형대수 (필요 없음!)

나중에 공부하면 좋은 것 (선택):

각 알고리즘이 어떻게 작동하는지
하이퍼파라미터 튜닝 원리

Q5: 데이터가 얼마나 있어야 하나요?

A: 생각보다 적어도 됩니다!

일반적인 가이드:

  
# 최소한의 데이터
- 간단한 문제: 100-1000개
- 복잡한 문제: 1000-10000개
- 이미지 인식: 10000개 이상

# 오늘 배운 Iris 데이터
print(len(iris.data))  # 150개
# 이것만으로도 정확도 100%! (간단한 문제라서)

적은 데이터로 시작하는 팁:

데이터 증강: 기존 데이터를 변형해서 늘리기
전이 학습: 미리 학습된 모델 활용
Cross-validation: 데이터를 여러 번 재사용

💡 현실 조언:

일단 가진 데이터로 시작하세요!
모델 학습 → 결과 확인 → 더 필요하면 데이터 추가
“완벽한 데이터”를 기다리다 시작 못 하는 게 최악입니다

Q6: 첫 모델 정확도가 낮아요. 정상인가요?

A: 완전히 정상입니다! 👍

실제 개발 과정:

1차 시도: 정확도 60% → "음... 뭔가 부족해"
2차 시도: 데이터 전처리 추가 → 75%
3차 시도: 다른 알고리즘 시도 → 82%
4차 시도: 하이퍼파라미터 튜닝 → 88%
5차 시도: 특징 엔지니어링 → 92%

처음부터 90% 넘는 경우:

✅ 데이터가 매우 간단함 (Iris 같은 예제)
⚠️ 데이터 누수 (학습/테스트 분리 실수)
⚠️ 과적합

첫 모델의 목표:

정확도 100% ❌
제대로 작동하는 baseline ✅

Day 93-96에서 성능 개선 방법을 배웁니다!

📚 다음 학습

Day 93: 데이터 전처리 기초 ⭐⭐⭐

내일은 머신러닝의 가장 중요한 단계인 데이터 전처리를 배웁니다. 실제 데이터는 지저분해요!

“최고의 머신러닝 모델보다 깨끗한 데이터가 더 중요합니다!” 🚀

Day 92/100 Phase 10: AI/ML 입문 #100DaysOfPython

Python100일챌린지, Python100일챌린지-Phase10