Commit 8675c176 authored by insun park's avatar insun park
Browse files

문서 업데이트

parent a59e2e71
This diff is collapsed.
# Part 5: AI 핵심 라이브러리 마스터하기 (5주차) # Part 5: AI 핵심 라이브러리 마스터하기
**⬅️ 이전 시간: [Part 4: 객체 지향 프로그래밍(OOP)](./part_4_object_oriented_programming.md)** | **➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)** **⬅️ 이전 시간: [Part 4: 객체 지향 프로그래밍(OOP)](./part_4_object_oriented_programming.md)**
**➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)**
--- ---
## 📜 실습 코드 바로가기
- **`part_5_ai_core_libraries.py`**: [바로가기](./source_code/part_5_ai_core_libraries.py)
- 본 파트에서 다루는 NumPy, Pandas, Matplotlib의 핵심 기능 예제 코드를 직접 실행하고 수정해볼 수 있습니다.
--- ## 1. 학습 목표 (Learning Objectives)
지난 4주간 우리는 파이썬이라는 언어 자체에 대한 이해와 객체 지향 설계 능력을 길렀습니다. 이제부터는 이 강력한 언어를 날개 삼아, 데이터의 세계를 본격적으로 탐험할 시간입니다. 이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
2부에서는 데이터 분석과 머신러닝 프로젝트의 실질적인 '주연' 배우들인 NumPy, Pandas, Scikit-learn 등의 핵심 라이브러리 사용법을 깊이 있게 학습합니다.
--- - NumPy `ndarray`를 생성하고, 벡터화 연산과 브로드캐스팅을 활용하여 고성능 수치 계산을 수행할 수 있습니다.
- Pandas `DataFrame`을 사용하여 CSV, Excel 등의 데이터를 불러오고, `loc`/`iloc`으로 원하는 데이터를 정밀하게 선택하고 필터링할 수 있습니다.
- `groupby`를 사용하여 데이터를 특정 기준으로 나누고, 각 그룹에 대한 집계(평균, 합계 등)를 효율적으로 계산할 수 있습니다.
- 여러 `DataFrame``merge``concat`을 사용해 비즈니스 목적에 맞게 결합할 수 있습니다.
- 데이터 분석 프로젝트에서 NumPy와 Pandas가 어떻게 상호작용하며 문제를 해결하는지 큰 그림을 이해합니다.
## 2. 핵심 키워드 (Keywords)
`NumPy`, `ndarray`, `Pandas`, `DataFrame`, `Series`, `Vectorization`, `Broadcasting`, `Indexing`, `Filtering`, `loc`, `iloc`, `groupby`, `merge`, `concat`, `pivot_table`
## 3. 도입: 데이터 과학자의 새로운 연장통 (Introduction)
## ⭐️ 2부의 시작: 핵심 라이브러리 관계도 (The Big Picture) 지난 4주간 우리는 파이썬이라는 언어와 객체 지향 설계 능력을 길렀습니다. 이제 이 강력한 언어를 날개 삼아, 데이터의 세계를 본격적으로 탐험할 시간입니다. 이번 주부터는 데이터 분석과 머신러닝 프로젝트의 실질적인 '주연 배우'들인 NumPy, Pandas 사용법을 깊이 있게 학습합니다.
본격적으로 각 라이브러리를 배우기 전에, 이들이 데이터 분석 및 머신러닝 프로젝트에서 어떻게 함께 사용되는지에 대한 전체적인 그림을 이해하는 것이 중요합니다. > [!TIP]
> 본 파트의 모든 예제 코드는 `source_code/part_5_ai_core_libraries.py` 파일에서 직접 실행해볼 수 있습니다.
### AI 프로젝트의 큰 그림: 라이브러리 관계도
각 라이브러리를 배우기 전에, 이들이 프로젝트에서 어떻게 함께 사용되는지 전체적인 그림을 이해하는 것이 중요합니다.
```mermaid ```mermaid
graph TD graph TD
...@@ -43,32 +55,28 @@ graph TD ...@@ -43,32 +55,28 @@ graph TD
B -->|"plt.plot(array)"| D B -->|"plt.plot(array)"| D
C -->|"결과 분석"| D C -->|"결과 분석"| D
``` ```
- **시작은 [Pandas](./glossary.md#pandas)**: 대부분의 프로젝트는 Pandas를 사용해 다양한 소스(CSV 등)로부터 데이터를 불러와 `DataFrame`으로 만드는 것에서 시작합니다.
- **계산을 위해 [NumPy](./glossary.md#numpy)로**: 정제된 데이터는 고성능 수치 계산을 위해 NumPy 배열(`ndarray`)로 변환되어 머신러닝 모델의 입력으로 준비됩니다.
- **[Scikit-learn](./glossary.md#scikit-learn)으로 모델링**: NumPy 배열로 변환된 데이터를 사용하여 Scikit-learn으로 모델을 학습하고 예측합니다.
- **모든 과정에서 시각화**: Pandas와 NumPy 데이터는 [Matplotlib/Seaborn](./glossary.md#matplotlib--seaborn)을 통해 시각화되어 데이터의 특징을 파악(EDA)하거나 모델의 성능을 분석하는 데 사용됩니다.
이 흐름을 염두에 두고 각 라이브러리를 학습하면, 지식이 파편적으로 남지 않고 하나의 큰 그림으로 연결될 것입니다. - **시작은 Pandas**: 대부분의 프로젝트는 Pandas `DataFrame`으로 데이터를 불러와 정제하는 것에서 시작합니다.
- **계산은 NumPy로**: 정제된 데이터는 고성능 수치 계산을 위해 NumPy 배열(`ndarray`)로 변환되어 머신러닝 모델의 입력으로 준비됩니다.
- **모델링은 Scikit-learn으로**: NumPy 배열을 사용하여 Scikit-learn으로 모델을 학습하고 예측합니다.
- **모든 과정은 Matplotlib으로 시각화**: 데이터의 특징을 파악(EDA)하거나 모델의 성능을 분석하는 데 사용됩니다.
이 흐름을 염두에 두면, 지식이 파편적으로 남지 않고 하나의 큰 그림으로 연결될 것입니다.
---
--- ---
# 1부: 데이터 과학자의 연장통 - NumPy & Pandas (5주차) ## 4. NumPy: 고성능 수치 계산의 초석
### 🎯 5주차 학습 목표 > **🎯 1일차 목표:** NumPy를 사용하여 고성능 과학 계산 및 다차원 배열을 다룹니다.
- **[NumPy](./glossary.md#numpy)**를 사용하여 고성능 과학 계산 및 다차원 배열을 다룹니다.
- **[Pandas](./glossary.md#pandas)**를 사용하여 표 형식의 데이터를 자유자재로 읽고, 선택하고, 필터링하고, 그룹화하고, 병합합니다.
--- **NumPy(Numerical Python)**는 파이썬에서 과학 계산을 위한 가장 기본적인 패키지입니다. `ndarray`라는 효율적인 다차원 배열 객체를 중심으로, 벡터, 행렬 등 고성능 수치 연산을 위한 방대한 함수들을 제공합니다.
## 1일차(월): NumPy - 고성능 수치 계산의 초석 > **💡 비유: NumPy 배열은 '계란판', 파이썬 리스트는 '장바구니'**
- **NumPy(Numerical Python)**: 파이썬에서 과학 계산을 위한 가장 기본적인 패키지. [`ndarray`](./glossary.md#ndarray)라는 효율적인 다차원 배열 객체를 중심으로, 벡터, 행렬 등 고성능 수치 연산을 위한 방대한 함수들을 제공합니다. > - **파이썬 리스트 ('장바구니')**: 뭐든 담을 수 있어 유연하지만, 내용물이 제각각이라 전체를 한 번에 계산하기는 어렵고 느립니다.
> - **NumPy 배열 ('계란판')**: 오직 한 종류(숫자)만 담을 수 있는 '계란판'과 같습니다. 모든 칸이 균일하고 규칙적이어서, '모든 계란에 도장 찍기' 같은 작업을 기계로 한 번에 처리할 수 있습니다. 이 **균일성** 덕분에 NumPy는 엄청나게 빠른 속도로 대규모 숫자 계산을 할 수 있습니다.
#### 💡 쉽게 이해하기: NumPy 배열은 '계란판', 파이썬 리스트는 '장바구니' ### 4-1. `ndarray` 생성 및 연산
> - **파이썬 리스트**: 뭐든 담을 수 있는 만능 '장바구니'입니다. 사과, 책, 신발 등 종류에 상관없이 담을 수 있어 유연하지만, 내용물이 제각각이라 전체를 한 번에 계산하기는 어렵고 느립니다.
> - **NumPy 배열**: 오직 한 종류(숫자)만 담을 수 있는 '계란판'과 같습니다. 모든 칸의 모양과 크기가 같아, '모든 계란에 도장 찍기' 같은 작업을 기계로 한 번에 처리할 수 있습니다. 이런 **균일성**과 **규칙성** 덕분에 NumPy는 엄청나게 빠른 속도로 숫자 계산을 할 수 있습니다. AI와 데이터 과학에서 대규모 데이터를 다룰 때 NumPy가 필수인 이유입니다.
### 1. `ndarray` 생성 및 연산
```python ```python
import numpy as np import numpy as np
...@@ -77,18 +85,19 @@ py_list = [[1, 2, 3], [4, 5, 6]] ...@@ -77,18 +85,19 @@ py_list = [[1, 2, 3], [4, 5, 6]]
np_array = np.array(py_list) np_array = np.array(py_list)
print("Shape:", np_array.shape) # (2, 3) print("Shape:", np_array.shape) # (2, 3)
# 배열 연산: for문 없이 모든 요소에 대해 한 번에 연산 # 벡터화(Vectorization) 연산: for문 없이 모든 요소에 대해 한 번에 연산
result = np_array * 2 + 1 result = np_array * 2 + 1
print("배열 연산 결과:\n", result) print("배열 연산 결과:\n", result)
# 브로드캐스팅: 서로 다른 크기의 배열 간에도 연산이 가능하도록 확장 # 브로드캐스팅(Broadcasting): 서로 다른 크기의 배열 간 연산
matrix = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3) matrix = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3)
vector = np.array([10, 20, 30]) # shape: (3,) vector = np.array([10, 20, 30]) # shape: (3,)
result_broadcast = matrix + vector result_broadcast = matrix + vector
print("브로드캐스팅 결과:\n", result_broadcast) print("브로드캐스팅 결과:\n", result_broadcast)
``` ```
### 2. 인덱싱과 슬라이싱 ### 4-2. 인덱싱과 슬라이싱
```python ```python
arr = np.arange(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] arr = np.arange(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
...@@ -102,10 +111,15 @@ print("짝수만 추출:", arr[arr % 2 == 0]) ...@@ -102,10 +111,15 @@ print("짝수만 추출:", arr[arr % 2 == 0])
``` ```
--- ---
## 2일차(화): Pandas - '슈퍼 엑셀' DataFrame의 등장
- **Pandas**: [`DataFrame`](./glossary.md#dataframe)(2차원 테이블)과 [`Series`](./glossary.md#series)(1차원 배열) 자료구조를 사용하여, 엑셀이나 DB 테이블처럼 데이터를 직관적으로 다루게 해주는 라이브러리. 데이터 전처리에 없어서는 안 될 필수 도구입니다.
### 1. `Series`와 `DataFrame` ## 5. Pandas: '슈퍼 엑셀' DataFrame 다루기
> **🎯 2-4일차 목표:** Pandas를 사용하여 표 형식의 데이터를 자유자재로 읽고, 선택하고, 필터링하고, 그룹화하고, 병합합니다.
**Pandas**`DataFrame`(2차원 테이블)과 `Series`(1차원 배열) 자료구조를 사용하여, 엑셀이나 DB 테이블처럼 데이터를 직관적으로 다루게 해주는 라이브러리입니다. 데이터 전처리에 없어서는 안 될 필수 도구입니다.
### 5-1. `Series`, `DataFrame` 생성 및 탐색
```python ```python
import pandas as pd import pandas as pd
...@@ -116,28 +130,14 @@ data = {'제품': ['사과', '바나나', '체리', '딸기'], ...@@ -116,28 +130,14 @@ data = {'제품': ['사과', '바나나', '체리', '딸기'],
df = pd.DataFrame(data) df = pd.DataFrame(data)
print("DataFrame:\n", df) print("DataFrame:\n", df)
# Series: DataFrame의 한 열 # 기본 탐색
prices = df['가격']
print("\nSeries (가격):\n", prices)
```
### 2. 데이터 읽고 쓰기 및 기본 탐색
```python
# df.to_csv("fruits.csv", index=False, encoding="utf-8-sig") # CSV 파일로 저장
# df_from_csv = pd.read_csv("fruits.csv") # CSV 파일 읽기
print("\n--- head() ---")
print(df.head()) # 맨 위 5개 행 print(df.head()) # 맨 위 5개 행
print("\n--- info() ---")
df.info() # 각 열의 정보와 결측치 확인 df.info() # 각 열의 정보와 결측치 확인
print("\n--- describe() ---")
print(df.describe()) # 숫자형 열의 기술 통계량 print(df.describe()) # 숫자형 열의 기술 통계량
``` ```
--- ### 5-2. 데이터 선택과 필터링 (`loc`, `iloc`)
## 3일차(수): Pandas - 데이터 선택과 필터링의 기술
### 1. `.loc` vs `.iloc`: 이름과 순서로 선택하기
> - **`.loc` (Label-based)**: 학생의 **'이름'**으로 자리를 찾는 방식 (`df.loc[행_이름, 열_이름]`) > - **`.loc` (Label-based)**: 학생의 **'이름'**으로 자리를 찾는 방식 (`df.loc[행_이름, 열_이름]`)
> - **`.iloc` (Integer-based)**: 학생이 앉아있는 **'자리 번호'**로 찾는 방식 (`df.iloc[행_번호, 열_번호]`) > - **`.iloc` (Integer-based)**: 학생이 앉아있는 **'자리 번호'**로 찾는 방식 (`df.iloc[행_번호, 열_번호]`)
...@@ -147,27 +147,21 @@ print(df.loc[1, ['제품', '재고']]) ...@@ -147,27 +147,21 @@ print(df.loc[1, ['제품', '재고']])
# iloc: 0번 행의 0, 2번 열 # iloc: 0번 행의 0, 2번 열
print(df.iloc[0, [0, 2]]) print(df.iloc[0, [0, 2]])
```
### 2. 조건으로 필터링하기 # 조건 필터링: 가격이 1000원 이상인 제품
```python
# 가격이 1000원 이상인 제품
print("\n가격 1000원 이상:\n", df[df['가격'] >= 1000]) print("\n가격 1000원 이상:\n", df[df['가격'] >= 1000])
# 가격 1000원 미만이고(and) 재고 10개 미만인 제품 # 복합 조건 필터링: 가격 1000원 미만이고(and) 재고 10개 미만인 제품
# & (and), | (or), ~ (not) # & (and), | (or), ~ (not)
print("\n가격 1000원 미만 AND 재고 10개 미만:\n", df[(df['가격'] < 1000) & (df['재고'] < 10)]) print("\n가격 1000원 미만 AND 재고 10개 미만:\n", df[(df['가격'] < 1000) & (df['재고'] < 10)])
``` ```
> 🚫 **`SettingWithCopyWarning` 주의!**: 값을 변경할 때는 `.loc`를 사용해 `df.loc[행조건, 열이름] = 값` 형태로 한 번에 접근해야 의도치 않은 오류를 막을 수 있습니다. 경고는 "원본을 바꿀지, 복사본을 바꿀지 애매하니 명확히 해달라"는 신호입니다. > 🚫 **`SettingWithCopyWarning` 주의!**: 값을 변경할 때는 `df.loc[행조건, 열이름] = 값` 형태로 한 번에 접근해야 의도치 않은 오류를 막을 수 있습니다.
--- ### 5-3. 데이터 분해와 조립 (`groupby`)
## 4일차(목): Pandas - 데이터 분해와 조립 (`groupby`)
`groupby()`는 데이터를 특정 기준으로 그룹화하여 각 그룹에 대한 집계(합계, 평균 등)를 수행하는 강력한 기능입니다.
#### 💡 쉽게 이해하기: `groupby`는 '반별 성적 평균 계산' (Split-Apply-Combine) > **💡 비유: `groupby`는 '반별 성적 평균 계산' (Split-Apply-Combine)**
> `groupby`는 '반별 성적을 계산하는 선생님'과 같습니다. > 1. **Split (나누기)**: 전체 학생 명단을 '1반', '2반'으로 나눕니다 (`df.groupby('반')`).
> 1. **Split (나누기)**: 전체 학생 명단을 '1반', '2반', '3반'으로 나눕니다 (`df.groupby('반')`). > 2. **Apply (적용하기)**: 각 반별로 '평균 점수 계산'을 수행합니다 (`.agg('mean')`).
> 2. **Apply (적용하기)**: 각 반별로 '평균 점수 계산'이라는 동일한 작업을 수행합니다 (`.agg('mean')`).
> 3. **Combine (합치기)**: 각 반의 평균 점수를 모아 하나의 최종 성적표로 합칩니다. > 3. **Combine (합치기)**: 각 반의 평균 점수를 모아 하나의 최종 성적표로 합칩니다.
```python ```python
...@@ -179,52 +173,81 @@ team_agg = df_player.groupby('팀')['득점'].agg(['sum', 'mean', 'count']) ...@@ -179,52 +173,81 @@ team_agg = df_player.groupby('팀')['득점'].agg(['sum', 'mean', 'count'])
print(team_agg) print(team_agg)
``` ```
--- ### 5-4. 데이터 병합과 연결 (`merge`, `concat`)
## 5일차(금): Pandas - 여러 데이터 합치고 모양 바꾸기
> - **`merge`**: '학생 명단'과 '도서관 대출 기록'을 '학번'이라는 공통 열을 기준으로 합치는 것 (SQL의 JOIN과 유사).
> - **`concat`**: '1반 학생 명단' 아래에 '2반 학생 명단'을 그대로 이어 붙이는 것.
### 1. 데이터 병합: `pd.merge()`
> `merge`는 '학생 명단'과 '도서관 대출 기록'을 '학번'이라는 공통 열을 기준으로 합쳐, 학생별 대출 정보를 만드는 것과 같습니다. (SQL의 JOIN과 유사)
```python ```python
import pandas as pd
df1 = pd.DataFrame({'id': ['A01', 'A02', 'A03'], '이름': ['김파이', '이판다', '박넘파']}) df1 = pd.DataFrame({'id': ['A01', 'A02', 'A03'], '이름': ['김파이', '이판다', '박넘파']})
df2 = pd.DataFrame({'id': ['A01', 'A02', 'A04'], '과목': ['수학', '영어', '과학']}) df2 = pd.DataFrame({'id': ['A01', 'A02', 'A04'], '과목': ['수학', '영어', '과학']})
# 공통 'id'를 기준으로 병합 (inner: 양쪽 모두에 id가 있는 경우만) # merge: 공통 'id'를 기준으로 병합 (left: df1의 모든 id 유지)
inner_join = pd.merge(df1, df2, on='id', how='inner')
print("Inner Join:\n", inner_join)
# df1을 기준으로 병합 (left: df1의 모든 id를 유지)
left_join = pd.merge(df1, df2, on='id', how='left') left_join = pd.merge(df1, df2, on='id', how='left')
print("\nLeft Join:\n", left_join) print("Left Join:\n", left_join)
df3 = pd.DataFrame({'이름': ['최사이'], '나이': [21]})
# concat: df1 아래에 df3을 이어 붙이기
concatenated_df = pd.concat([df1, df3], ignore_index=True)
print("\nConcatenated DataFrame:\n", concatenated_df)
``` ```
### 2. 데이터 연결: `pd.concat()` ---
> `concat`은 '1반 학생 명단' 아래에 '2반 학생 명단'을 그대로 이어 붙여 전체 학생 명단을 만드는 것과 같습니다.
## 6. 직접 해보기 (Hands-on Lab)
> **🎯 5일차 목표:** NumPy와 Pandas의 기술을 종합하여 실제적인 데이터 문제를 해결합니다.
아래는 어느 온라인 상점의 일자별 판매 데이터입니다. 이 데이터를 사용하여 아래의 질문에 답하는 코드를 작성해보세요.
```python ```python
df1 = pd.DataFrame({'이름': ['김파이', '이판다'], '나이': [20, 22]}) import pandas as pd
df2 = pd.DataFrame({'이름': ['박넘파', '최사이'], '나이': [25, 21]}) import numpy as np
concatenated_df = pd.concat([df1, df2], ignore_index=True) # 기존 인덱스 무시 data = {
print("\nConcatenated DataFrame:\n", concatenated_df) 'Date': ['2024-01-01', '2024-01-01', '2024-01-02', '2024-01-02', '2024-01-03', '2024-01-03'],
'Category': ['Electronics', 'Books', 'Electronics', 'Books', 'Electronics', 'Books'],
'Product': ['Laptop', 'Python Intro', 'Mouse', 'AI for All', 'Keyboard', 'Deep Learning'],
'Price_USD': [1200, 45, 25, 55, 75, 60],
'Quantity': [5, 10, 20, 8, 15, 12]
}
sales_df = pd.DataFrame(data)
``` ```
### 3. 데이터 재구조화: `pivot_table()` ### 문제 1: 매출 분석
> `pivot_table`은 '일자별, 상품별 판매 기록'이라는 긴 목록을 '일자는 행, 상품은 열, 값은 판매량'인 엑셀 보고서 형태로 바꾸는 것과 같습니다. 1. `Price_KRW` (원화 가격) 열을 새로 만드세요. 환율은 1 USD = 1300 KRW로 가정하고, NumPy를 이용해 한 번에 계산하세요.
```python 2. `Total_Sales_KRW` (총 판매액) 열을 만드세요. (`Price_KRW` * `Quantity`)
data = {'날짜': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02'], 3. 카테고리(`Category`)별 총 판매액 합계를 계산하세요 (`groupby` 사용).
'상품': ['사과', '바나나', '사과', '바나나'],
'판매량': [100, 80, 120, 90]}
df_sales = pd.DataFrame(data)
pivot = df_sales.pivot_table(index='날짜', columns='상품', values='판매량') ### 문제 2: 재고 관리
print("\nPivot Table:\n", pivot) 1. 현재 `sales_df`에는 없는 '재고(Stock)' 정보를 담은 아래 `stock_df`를 만드세요.
2. `sales_df``stock_df`를 상품명(`Product`)을 기준으로 합쳐(`merge`), 판매된 상품의 현재 재고를 함께 볼 수 있는 `report_df`를 생성하세요.
```python
stock_data = {
'Product': ['Laptop', 'Python Intro', 'Mouse', 'AI for All', 'Keyboard', 'Deep Learning', 'Monitor'],
'Stock': [50, 100, 150, 80, 120, 90, 40]
}
stock_df = pd.DataFrame(stock_data)
``` ```
--- ---
---
### 📚 5주차 마무리 및 다음 단계 ## 7. 되짚어보기 (Summary)
이번 주 우리는 데이터 과학의 양대 산맥인 **NumPy****Pandas**의 기본적인 사용법을 마스터했습니다. 이제 여러분은 대부분의 정형 데이터를 자유자재로 불러오고, 원하는 형태로 가공하고, 기본적인 통계를 파악할 수 있는 강력한 무기를 갖추게 되었습니다.
이번 주차에는 데이터 과학의 양대 산맥인 **NumPy****Pandas**를 마스터했습니다.
- **NumPy '계란판'**: 균일한 데이터(`ndarray`)를 빠르고 효율적으로 계산하는 방법을 배웠습니다.
- **Pandas '슈퍼 엑셀'**: 표 형태의 데이터(`DataFrame`)를 자유자재로 불러오고, 선택/필터링하고, `groupby`로 요약하고, `merge`/`concat`으로 합치는 강력한 데이터 전처리 기술을 익혔습니다.
- **큰 그림**: Pandas로 데이터를 준비하고, NumPy로 계산을 수행하는 데이터 분석의 핵심 흐름을 이해했습니다.
다음 시간에는 이어서 데이터를 시각적으로 탐색하는 **Matplotlib****Seaborn**을 배우고, 드디어 첫 **머신러닝 모델**을 만들어보는 흥미로운 여정을 시작합니다. 이제 여러분은 대부분의 정형 데이터를 원하는 형태로 가공하고, 기본적인 통계를 파악할 수 있는 강력한 무기를 갖추게 되었습니다.
## 8. 더 깊이 알아보기 (Further Reading)
- [Pandas 공식 10분 완성 튜토리얼](https://pandas.pydata.org/docs/user_guide/10min.html)
- [NumPy 공식 시작하기 가이드](https://numpy.org/doc/stable/user/absolute_beginners.html)
- [Chris Albon's Notes On pandas and NumPy](https://chrisalbon.com/): 특정 상황에 필요한 코드 스니펫을 찾기에 매우 유용한 사이트
---
**➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)** **➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)**
\ No newline at end of file
# Part 6: 머신러닝 모델링과 평가 (6주차) # Part 6: 머신러닝 모델링과 평가
**⬅️ 이전 시간: [Part 5: AI 핵심 라이브러리](./part_5_ai_core_libraries.md)** | **➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)** **⬅️ 이전 시간: [Part 5: AI 핵심 라이브러리](./part_5_ai_core_libraries.md)**
**➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**
--- ---
## 📜 실습 코드 바로가기
- **`part_6_machine_learning.py`**: [바로가기](./source_code/part_6_machine_learning.py)
- 본 파트에서 다루는 Matplotlib, Seaborn, Scikit-learn의 핵심 기능 예제 코드를 직접 실행하고 수정해볼 수 있습니다.
--- ## 1. 학습 목표 (Learning Objectives)
이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
- Matplotlib와 Seaborn을 사용하여 데이터의 분포, 관계, 추세를 시각화하고 인사이트를 도출할 수 있습니다.
- 지도학습, 훈련/테스트 데이터 분할의 개념을 설명할 수 있습니다.
- Scikit-learn의 `fit()`, `predict()` 인터페이스를 사용하여 머신러닝 모델을 훈련하고, 새로운 데이터에 대한 예측을 만들 수 있습니다.
- 피처 스케일링(StandardScaler, MinMaxScaler)과 같은 핵심 전처리 기법을 모델 성능 향상을 위해 적용할 수 있습니다.
- 데이터 불러오기부터 전처리, 훈련, 평가까지 이어지는 머신러닝의 전체 파이프라인을 코드로 구현할 수 있습니다.
## 2. 핵심 키워드 (Keywords)
`데이터 시각화`, `Matplotlib`, `Seaborn`, `Scikit-learn`, `지도학습(Supervised Learning)`, `훈련/테스트 분리(Train/Test Split)`, `데이터 전처리(Preprocessing)`, `피처 스케일링(Feature Scaling)`, `모델 평가(Evaluation)`, `정확도(Accuracy)`
## 3. 도입: 데이터에서 지혜를 캐내는 기술 (Introduction)
이전 파트에서 우리는 NumPy와 Pandas로 데이터를 자유자재로 다루는 법을 배웠습니다. 하지만 숫자로만 가득한 표는 우리에게 많은 것을 알려주지 않습니다. 이번 파트에서는 데이터에 '생명'을 불어넣는 두 가지 핵심 기술, **시각화****머신러닝**을 배웁니다.
### 🎯 6주차 학습 목표 - **시각화**는 데이터 속에 숨겨진 패턴과 이야기를 발견하는 '눈'이 되어줄 것입니다.
- **[Matplotlib](./glossary.md#matplotlib--seaborn)****[Seaborn](./glossary.md#matplotlib--seaborn)**으로 데이터를 시각화하여 인사이트를 발견합니다. - **머신러닝**은 그 패턴을 학습하여 미래를 예측하는 '두뇌' 역할을 합니다.
- **[Scikit-learn](./glossary.md#scikit-learn)을 사용하여 머신러닝의 기본 프로세스(학습, 예측, 평가)를 이해합니다.
- 모델 성능을 높이기 위한 핵심 데이터 전처리 기법을 학습합니다. Scikit-learn이라는 강력한 도구를 통해, 우리는 이 모든 과정을 직접 체험해볼 것입니다.
> [!TIP]
> 본 파트의 모든 예제 코드는 `source_code/part_6_machine_learning.py` 파일에서 직접 실행하고 수정해볼 수 있습니다.
--- ---
## 1-2일차(월-화): 데이터 시각화 - 그림으로 데이터 ## 4. 데이터 시각화: 그림으로 데이터와 대화하
데이터를 숫자로만 보는 것은 마치 숲을 보지 못하고 나무 하나하나만 보는 것과 같습니다. 시각화는 데이터 속에 숨겨진 패턴, 관계, 이상치를 한눈에 파악하게 해주는 강력한 도구입니다. > **🎯 1-2일차 목표:** Matplotlib와 Seaborn으로 데이터를 시각화하여 인사이트를 발견합니다.
- **[Matplotlib](./glossary.md#matplotlib--seaborn)**: 파이썬 시각화의 근간. 거의 모든 종류의 그래프를 그릴 수 있는 강력한 라이브러리. (비유: 하얀 도화지) 데이터를 숫자로만 보는 것은 숲을 보지 못하고 나무만 보는 것과 같습니다. 시각화는 데이터 속에 숨겨진 패턴, 관계, 이상치를 한눈에 파악하게 해주는 강력한 도구입니다.
- **[Seaborn](./glossary.md#matplotlib--seaborn)**: Matplotlib을 더 쉽고 예쁘게 사용할 수 있도록 만든 고수준 라이브러리. 통계적인 그래프 기능이 특화되어 있습니다. (비유: 밑그림과 색칠 도구가 갖춰진 스케치북)
#### 💡 쉽게 이해하기: 어떤 그래프를 언제 쓸까? - **Matplotlib**: 파이썬 시각화의 근간. 거의 모든 종류의 그래프를 그릴 수 있습니다. (비유: 하얀 도화지)
> - **선 그래프 (Line Plot)**: '시간'에 따른 주가 변화처럼, 연속적인 데이터의 '추세'를 볼 때 - **Seaborn**: Matplotlib을 더 쉽고 예쁘게 사용하도록 만든 고수준 라이브러리. 통계 기능이 특화되어 있습니다. (비유: 밑그림과 색칠 도구가 갖춰진 스케치북)
> - **막대 그래프 (Bar Plot)**: 반별 평균 키처럼, 여러 '그룹' 간의 값을 '비교'할 때
> - **산점도 (Scatter Plot)**: 공부 시간과 성적처럼, 두 변수 간의 '관계'나 '분포'를 볼 때
> - **히스토그램 (Histogram)**: 우리 반 학생들의 키 분포처럼, 특정 데이터 구간에 얼마나 많은 값이 있는지 '분포'를 볼 때
> - **히트맵 (Heatmap)**: 여러 변수들 간의 상관관계를 한눈에 '색상'으로 파악할 때
#### 4-1. 어떤 그래프를 언제 쓸까?
- **선 그래프 (Line Plot)**: 시간에 따른 주가 변화처럼, 연속적인 데이터의 **추세**를 볼 때
- **막대 그래프 (Bar Plot)**: 반별 평균 키처럼, 여러 그룹 간의 값을 **비교**할 때
- **산점도 (Scatter Plot)**: 공부 시간과 성적처럼, 두 변수 간의 **관계**나 분포를 볼 때
- **히스토그램 (Histogram)**: 우리 반 학생들의 키 분포처럼, 데이터의 **분포**를 볼 때
- **히트맵 (Heatmap)**: 여러 변수들 간의 상관관계를 한눈에 **색상**으로 파악할 때
#### 4-2. Seaborn 실전 예제
```python ```python
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import seaborn as sns import seaborn as sns
import pandas as pd
# Seaborn에 내장된 'tips' 데이터셋 사용 # Seaborn에 내장된 'tips' 데이터셋 사용
tips = sns.load_dataset("tips") tips = sns.load_dataset("tips")
# 1. 산점도: 총 식사 금액과 팁 사이의 관계 # 1. 산점도: 총 식사 금액과 팁 사이의 관계
plt.figure(figsize=(8, 6)) # 그래프 크기 조절 plt.figure(figsize=(8, 6))
sns.scatterplot(x="total_bill", y="tip", data=tips, hue="smoker", size="size") sns.scatterplot(x="total_bill", y="tip", data=tips, hue="smoker", size="size")
plt.title("Total Bill vs Tip Amount") plt.title("Total Bill vs Tip Amount")
plt.xlabel("Total Bill ($)") plt.xlabel("Total Bill ($)")
plt.ylabel("Tip ($)") plt.ylabel("Tip ($)")
plt.grid(True) plt.grid(True)
# plt.savefig("scatter_plot.png") # 그래프를 파일로 저장
plt.show() plt.show()
# 2. 막대 그래프: 요일별 평균 팁 # 2. 막대 그래프: 요일별 평균 팁
plt.figure(figsize=(8, 6)) plt.figure(figsize=(8, 6))
sns.barplot(x="day", y="tip", data=tips, errorbar=None) sns.barplot(x="day", y="tip", data=tips, errorbar=None) # errorbar=None은 신뢰구간 제거
plt.title("Average Tip by Day of the Week") plt.title("Average Tip by Day of the Week")
plt.xlabel("Day")
plt.ylabel("Average Tip ($)")
plt.show() plt.show()
``` ```
--- ---
## 3-4일차(수-목): 첫 머신러닝 모델 만들기
### 1. 머신러닝이란? ## 5. Scikit-learn으로 첫 머신러닝 모델 만들기
- **[지도학습](./glossary.md#지도학습-supervised-learning)**: **입력(문제)****정답**이 있는 데이터를 사용해, 문제와 정답 사이의 '패턴'을 기계에 학습시키는 방법.
> **🎯 3-4일차 목표:** Scikit-learn을 사용하여 머신러닝의 기본 프로세스(학습, 예측, 평가)를 이해합니다.
#### 💡 쉽게 이해하기: '훈련'과 '시험' ### 5-1. 머신러닝의 핵심: 훈련과 시험
> 머신러닝 모델 평가는 '공부'와 '시험' 과정과 같습니다. - **지도학습(Supervised Learning)**: **입력(문제)****정답**이 있는 데이터를 사용해, 문제와 정답 사이의 '패턴'을 기계에 학습시키는 방법입니다.
> - **[훈련 데이터](./glossary.md#훈련-데이터-vs-테스트-데이터) (교과서/모의고사)**: 모델이 학습하는 데 사용하는 데이터입니다.
> - **[테스트 데이터](./glossary.md#훈련-데이터-vs-테스트-데이터) (수능)**: 모델의 최종 성능을 평가하기 위해, 학습 과정에서 **전혀 사용하지 않은** 새로운 데이터입니다. > **💡 비유: 머신러닝은 '공부'와 '시험' 과정입니다.**
> - **훈련 데이터 (Training Data)**: 모델이 학습하는 데 사용하는 **'교과서/모의고사'**.
> - **테스트 데이터 (Test Data)**: 모델의 최종 성능을 평가하기 위해, 학습 과정에서 **전혀 사용하지 않은 새로운 '수능 문제'**.
> >
> 훈련 데이터로만 반복해서 시험 보면 100점이 나오겠지만, 진짜 실력이라고 할 수 없겠죠? 그래서 우리는 훈련/테스트 데이터를 엄격히 분리하여 모델의 **일반화 성능**(처음 보는 데이터에 대한 예측 능력)을 측정합니다. > 훈련 데이터로만 반복해서 시험 보면 100점이 나오겠지만, 진짜 실력이라고 할 수 없겠죠? 그래서 우리는 훈련/테스트 데이터를 엄격히 분리하여 모델의 **일반화 성능**(처음 보는 데이터에 대한 예측 능력)을 측정합니다.
### 2. Scikit-learn 기본 사용법 ### 5-2. Scikit-learn 기본 4단계 프로세스
[Scikit-learn](./glossary.md#scikit-learn)은 파이썬의 대표적인 머신러닝 라이브러리로, 다음과 같은 통일된 인터페이스를 제공합니다. Scikit-learn은 다음과 같은 통일된 인터페이스를 제공하여 누구나 쉽게 머신러닝 모델을 만들 수 있게 해줍니다.
1. **모델 객체 생성**: `model = ModelName()` 1. **모델 객체 생성**: `model = ModelName()`
2. **모델 학습**: `model.fit(X_train, y_train)` (훈련 데이터) 2. **모델 학습**: `model.fit(X_train, y_train)` (훈련 데이터로 공부)
3. **예측**: `predictions = model.predict(X_test)` (테스트 데이터) 3. **예측**: `predictions = model.predict(X_test)` (테스트 데이터로 시험)
4. **평가**: `score = accuracy_score(y_test, predictions)` 4. **평가**: `score = accuracy_score(y_test, predictions)` (채점)
```python ```python
from sklearn.model_selection import train_test_split from sklearn.model_selection import train_test_split
...@@ -100,28 +117,18 @@ model.fit(X_train, y_train) ...@@ -100,28 +117,18 @@ model.fit(X_train, y_train)
# 3. 예측 # 3. 예측
predictions = model.predict(X_test) predictions = model.predict(X_test)
print("예측값:", predictions)
# 4. 평가 (정확도) # 4. 평가 (정확도)
accuracy = accuracy_score(y_test, predictions) accuracy = accuracy_score(y_test, predictions)
print(f"정확도: {accuracy:.4f}") print(f"정확도: {accuracy:.4f}")
# 새로운 데이터 예측해보기
# 꽃받침 길이, 너비, 꽃잎 길이, 너비
new_data = np.array([[5.0, 3.5, 1.5, 0.2]]) # 'setosa' 품종으로 예상
new_prediction = model.predict(new_data)
print(f"새로운 데이터 예측 결과: {new_prediction[0]}")
``` ```
--- ### 5-3. 모델 성능을 높이는 데이터 전처리
## 5일차(금): 모델 성능 향상을 위한 데이터 전처리
모델의 성능은 알고리즘만큼이나 **'데이터의 품질'**에 크게 좌우됩니다. "Garbage In, Garbage Out" (쓰레기를 넣으면 쓰레기가 나온다) 라는 말이 있을 정도입니다. 모델의 성능은 알고리즘만큼이나 **'데이터의 품질'**에 크게 좌우됩니다. "Garbage In, Garbage Out" (쓰레기를 넣으면 쓰레기가 나온다) 라는 말이 있을 정도입니다.
- **결측치 처리**: 비어있는 값을 채우거나(평균, 중앙값 등) 해당 행/열을 제거합니다. - **피처 스케일링(Feature Scaling)**: 변수들의 단위를 맞춰줍니다. (예: 키(cm)와 몸무게(kg) -> 0~1 사이 값으로 표준화)
- **[피처 스케일링](./glossary.md#피처-스케일링feature-scaling)**: 변수들의 단위를 맞춰줍니다. (예: 키(cm)와 몸무게(kg) -> 0~1 사이 값으로 표준화) - **StandardScaler**: 평균 0, 표준편차 1로 변환. (분포가 정규분포에 가까울 때 효과적)
- **StandardScaler**: 평균 0, 표준편차 1로 변환. - **MinMaxScaler**: 최솟값 0, 최댓값 1로 변환. (모든 값을 0과 1 사이로 만들고 싶을 때)
- **MinMaxScaler**: 최솟값 0, 최댓값 1로 변환.
```python ```python
from sklearn.preprocessing import StandardScaler, MinMaxScaler from sklearn.preprocessing import StandardScaler, MinMaxScaler
...@@ -129,20 +136,49 @@ import numpy as np ...@@ -129,20 +136,49 @@ import numpy as np
data = np.array([[170, 70], [180, 85], [160, 55]], dtype=float) data = np.array([[170, 70], [180, 85], [160, 55]], dtype=float)
# StandardScaler
scaler_std = StandardScaler() scaler_std = StandardScaler()
scaled_std = scaler_std.fit_transform(data) scaled_std = scaler_std.fit_transform(data)
print("StandardScaler 결과:\n", scaled_std) print("StandardScaler 결과:\n", scaled_std)
# MinMaxScaler
scaler_minmax = MinMaxScaler() scaler_minmax = MinMaxScaler()
scaled_minmax = scaler_minmax.fit_transform(data) scaled_minmax = scaler_minmax.fit_transform(data)
print("\nMinMaxScaler 결과:\n", scaled_minmax) print("\nMinMaxScaler 결과:\n", scaled_minmax)
``` ```
### 📚 6주차 마무리 및 다음 단계 ---
이번 주 우리는 데이터를 시각적으로 탐색하고, Scikit-learn을 사용해 머신러닝의 전 과정을 직접 체험했습니다. 이제 여러분은 데이터를 분석하고 예측 모델을 만들 수 있는 기본적인 역량을 갖추었습니다.
## 6. 직접 해보기 (Hands-on Lab): 타이타닉 생존자 예측
다음 시간에는 드디어 **딥러닝**의 세계로 들어갑니다. **PyTorch**를 사용하여 인공 신경망을 직접 만들고, 컴퓨터 비전과 자연어 처리의 기초를 맛보는 흥미로운 여정이 시작됩니다. > **🎯 5일차 목표:** 데이터 전처리, 시각화, 모델링, 평가의 전 과정을 종합하여 문제를 해결합니다.
고전적인 '타이타닉' 데이터셋을 사용하여, 어떤 승객이 생존했을지 예측하는 모델을 만들어 봅시다.
### 문제:
1. Seaborn에서 `titanic` 데이터셋을 불러옵니다.
2. 간단한 탐색적 데이터 분석(EDA)을 수행하세요. (`survived``pclass`, `sex` 간의 관계를 막대 그래프로 시각화)
3. 모델링에 사용할 특성(`features`)으로 `pclass`, `sex`, `age`, `sibsp`, `parch`, `fare`를, 타겟(`target`)으로 `survived`를 선택하세요.
4. 결측치가 있는 `age` 열을 `age` 열의 **중앙값(median)**으로 채워주세요.
5. `sex` 열의 문자열('male', 'female')을 숫자(0, 1)로 변환해주세요.
6. 데이터를 훈련/테스트 세트로 분리하고 `StandardScaler`를 적용하여 스케일링하세요.
7. `DecisionTreeClassifier`로 모델을 학습시키고, 테스트 데이터에 대한 **정확도**를 계산하세요.
---
## 7. 되짚어보기 (Summary)
이번 주 우리는 데이터에서 패턴을 찾아 미래를 예측하는 머신러닝의 세계를 여행했습니다.
- **시각화는 눈**: Matplotlib와 Seaborn으로 데이터 속에 숨겨진 이야기를 보는 법을 배웠습니다.
- **머신러닝은 뇌**: Scikit-learn을 사용해 '훈련'과 '시험'이라는 과정을 거쳐 예측 모델을 만드는 법을 익혔습니다.
- **데이터는 생명**: "Garbage In, Garbage Out." 좋은 예측을 위해서는 결측치 처리, 피처 스케일링과 같은 데이터 전처리가 필수임을 이해했습니다.
이제 여러분은 데이터를 분석하고 예측 모델을 만들 수 있는 기본적인 역량을 갖추었습니다.
## 8. 더 깊이 알아보기 (Further Reading)
- [Scikit-learn 공식 예제 갤러리](https://scikit-learn.org/stable/auto_examples/index.html): 다양한 모델과 데이터셋에 대한 예제 코드의 보고
- [Seaborn 공식 튜토리얼](https://seaborn.pydata.org/tutorial.html): 더 아름답고 전문적인 시각화를 위한 가이드
- [Kaggle](https://www.kaggle.com/): 전 세계 데이터 과학자들이 모여 경쟁하는 플랫폼. 'Titanic'과 같은 다양한 입문용 프로젝트를 체험할 수 있습니다.
---
**➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)** **➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**
# Part 7: 딥러닝 기초와 PyTorch (7주차) # Part 7: 딥러닝 기초와 PyTorch
**⬅️ 이전 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)** | **➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)** **⬅️ 이전 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)**
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
--- ---
## 📜 실습 코드 바로가기
- **`part_7_deep_learning.py`**: [바로가기](./source_code/part_7_deep_learning.py)
- 본 파트에서 다루는 PyTorch의 핵심 기능 예제 코드를 직접 실행하고 수정해볼 수 있습니다.
--- ## 1. 학습 목표 (Learning Objectives)
### 🎯 7주차 학습 목표 이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
- **[PyTorch](./glossary.md#pytorch)**를 사용하여 간단한 딥러닝 모델을 직접 구현하고 학습시켜 봅니다.
- 인공 신경망의 기본 구성 요소(Linear Layer, Activation Function)를 이해합니다.
- 딥러닝 학습 과정(Forward/Backward Propagation, Optimizer)의 원리를 파악합니다.
--- - 딥러닝과 머신러닝의 차이점을 설명하고, PyTorch의 역할을 이해할 수 있습니다.
- PyTorch `Tensor`를 다루고, `nn.Module`을 상속받아 직접 인공 신경망 모델을 설계할 수 있습니다.
- 손실 함수, 옵티마이저의 역할을 이해하고, 딥러닝의 핵심인 학습 루프(Training Loop)를 구현할 수 있습니다.
- 순전파(Forward Propagation)와 역전파(Backward Propagation)의 기본 개념을 설명할 수 있습니다.
- `torchvision`을 사용하여 표준 데이터셋(MNIST)을 불러오고, 간단한 CNN 모델을 만들어 이미지 분류 문제를 해결할 수 있습니다.
## 2. 핵심 키워드 (Keywords)
## 1-3일차(월-수): PyTorch로 구현하는 딥러닝 첫걸음 `딥러닝(Deep Learning)`, `PyTorch`, `텐서(Tensor)`, `인공 신경망(ANN)`, `nn.Module`, `활성화 함수(Activation Function)`, `손실 함수(Loss Function)`, `옵티마이저(Optimizer)`, `순전파(Forward Propagation)`, `역전파(Backward Propagation)`, `에포크(Epoch)`, `CNN(Convolutional Neural Network)`
드디어 딥러닝의 세계에 입문합니다. 우리는 **PyTorch**라는 강력한 딥러닝 프레임워크를 사용하여 인공 신경망을 직접 만들어보겠습니다. ## 3. 도입: 모델을 직접 조립하는 즐거움, PyTorch (Introduction)
- **[PyTorch](./glossary.md#pytorch)**: 페이스북(메타)에서 개발한 딥러닝 프레임워크. 유연성과 직관적인 코드로 연구자와 개발자들에게 널리 사랑받고 있습니다. 드디어 딥러닝의 세계에 입문합니다. 지난 시간까지 우리는 Scikit-learn이라는 강력한 '완성품'을 사용했다면, 이제부터는 **PyTorch**라는 '조립 키트'를 사용하여 우리만의 모델을 직접 만들어 볼 것입니다.
> **💡 비유: PyTorch는 '레고 블록', Scikit-learn은 '완성된 장난감'**
> - **Scikit-learn**: '트럭', '비행기'처럼 이미 완성된 모델을 가져와 사용하는 **'완성품 장난감'**과 같습니다. 사용하기 편리하고 대부분의 정형 데이터 문제에 효과적입니다.
> - **PyTorch**: 다양한 모양의 **'레고 블록'**을 제공하여, 사용자가 원하는 어떤 복잡한 구조(신경망)라도 직접 조립할 수 있게 해줍니다. 이미지, 텍스트 등 비정형 데이터를 다루는 딥러닝에 필수적이며, 연구와 산업 현장에서 가장 널리 쓰이는 도구 중 하나입니다.
> [!TIP]
> 본 파트의 모든 예제 코드는 `source_code/part_7_deep_learning.py` 파일에서 직접 실행하고 수정해볼 수 있습니다.
---
#### 💡 쉽게 이해하기: PyTorch는 '레고 블록', Scikit-learn은 '완성된 장난감' ## 4. PyTorch 딥러닝의 기본 구성 요소
> - **Scikit-learn**: '트럭', '비행기'처럼 이미 완성된 모델을 가져와 사용하는 '완성품 장난감'과 같습니다. 사용하기 편리하고 대부분의 정형 데이터 문제에 효과적입니다.
> - **PyTorch**: 다양한 모양의 '레고 블록'을 제공하여, 사용자가 원하는 어떤 복잡한 구조(신경망)라도 직접 조립할 수 있게 해줍니다. 이미지, 텍스트 등 비정형 데이터를 다루는 딥러닝에 필수적입니다.
### 1. 딥러닝의 핵심, 텐서(Tensor) > **🎯 1-2일차 목표:** PyTorch의 텐서를 이해하고, 인공 신경망의 기본 구조를 코드로 구현합니다.
- **텐서**: PyTorch에서 데이터를 다루는 기본 단위. NumPy의 `ndarray`와 매우 유사하지만, GPU를 사용한 가속 연산이 가능하고 자동 미분(Autograd) 기능을 지원한다는 결정적인 차이가 있습니다.
### 2. 인공 신경망(Artificial Neural Network) 모델 만들기 ### 4-1. 딥러닝의 데이터, 텐서(Tensor)
PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래스를 정의합니다. - **텐서**: PyTorch에서 데이터를 다루는 기본 단위입니다. NumPy의 `ndarray`와 매우 유사하지만, 두 가지 결정적인 차이가 있습니다.
1. **GPU 가속**: `.to('cuda')` 코드 한 줄로 GPU를 사용한 초고속 연산이 가능합니다.
2. **자동 미분(Autograd)**: 딥러닝 학습의 핵심인 '역전파'를 위해 자동으로 미분값을 계산해줍니다.
### 4-2. 인공 신경망(ANN) 모델 만들기
PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래스(레고 조립 설명서)를 정의합니다.
- **`__init__(self)`**: 모델에 필요한 레고 블록들(레이어)을 정의하는 곳.
- **`forward(self, x)`**: 레고 블록들을 어떤 순서로 조립할지(데이터 흐름) 정의하는 곳.
```python ```python
import torch import torch
import torch.nn as nn import torch.nn as nn
# 모델 정의 # 모델 정의 (레고 조립 설명서)
class SimpleNet(nn.Module): class SimpleNet(nn.Module):
def __init__(self): # 1. 필요한 레고 블록 선언
def __init__(self, input_size, hidden_size, num_classes):
super(SimpleNet, self).__init__() super(SimpleNet, self).__init__()
# nn.Linear(input_features, output_features) self.fc1 = nn.Linear(input_size, hidden_size) # 완전 연결 계층
# 입력 특성 4개(붓꽃 데이터), 출력 클래스 3개(품종)
self.fc1 = nn.Linear(4, 50) # 첫 번째 완전 연결 계층
self.relu = nn.ReLU() # 활성화 함수 self.relu = nn.ReLU() # 활성화 함수
self.fc2 = nn.Linear(50, 3) # 두 번째 완전 연결 계층 self.fc2 = nn.Linear(hidden_size, num_classes)
# 2. 레고 블록 조립 순서 정의
def forward(self, x): def forward(self, x):
# 순전파: 데이터가 입력층부터 출력층까지 나아가는 과정 # 순전파: 데이터가 입력층부터 출력층까지 나아가는 과정
x = self.fc1(x) out = self.fc1(x)
x = self.relu(x) out = self.relu(out) # 💡 비선형성을 추가하여 모델의 표현력을 높임
x = self.fc2(x) out = self.fc2(out)
return x return out
model = SimpleNet() model = SimpleNet(input_size=784, hidden_size=500, num_classes=10) # MNIST 예시
print(model) print(model)
``` ```
> **활성화 함수(ReLU)는 왜 필요할까?**
> 선형 계층(`nn.Linear`)만 계속 쌓으면 결국 하나의 큰 선형 계층과 다를 바 없습니다. 활성화 함수는 여기에 '비선형성'이라는 마법을 더해, 복잡하고 구불구불한 데이터 패턴도 학습할 수 있게 해주는 필수 요소입니다.
---
## 5. 딥러닝 모델 학습 과정
> **🎯 3-4일차 목표:** 손실 함수, 옵티마이저의 개념을 이해하고 전체 학습 루프를 구현합니다.
### 5-1. 모델의 나침반과 조율사
- **손실 함수(Loss Function)**: 모델의 예측이 실제 정답과 얼마나 다른지를 측정하는 **'오차 측정기'**. (예: `nn.CrossEntropyLoss` - 분류 문제)
- **옵티마이저(Optimizer)**: 손실 함수가 계산한 오차를 기반으로, 모델의 파라미터(가중치)를 어느 방향으로 얼마나 업데이트할지 결정하는 **'조율사'**. (예: `torch.optim.Adam`)
### 5-2. 핵심 프로세스: 학습 루프(Training Loop)
딥러닝 모델 학습은 '에포크(Epoch)'라는 단위로 반복됩니다. 1 에포크는 전체 훈련 데이터를 한 번 모두 사용하는 것을 의미하며, 학습은 다음 4단계로 이루어집니다.
1. **`model(inputs)`**: 모델에 입력을 넣어 예측값(`outputs`)을 계산합니다 (**순전파**).
2. **`loss = criterion(outputs, labels)`**: 예측값과 실제 정답을 비교하여 오차(`loss`)를 계산합니다.
3. **`loss.backward()`**: 계산된 오차를 기반으로, 각 파라미터가 오차에 얼마나 기여했는지 미분값을 계산합니다 (**역전파**).
4. **`optimizer.step()`**: 계산된 미분값을 바탕으로 모델의 파라미터를 업데이트하여 오차를 줄이는 방향으로 나아갑니다.
> **💡 순전파와 역전파**
> - **순전파 (Forward)**: 내가 만든 레시피로 요리를 해서(모델 예측) 손님에게 내놓는 과정.
> - **역전파 (Backward)**: 손님의 피드백("너무 짜요!")을 듣고, 소금을 얼마나 많이 넣었는지, 간장을 얼마나 넣었는지 원인을 거슬러 올라가 분석하는 과정. `optimizer.step()`은 이 분석을 바탕으로 다음 요리에서는 소금을 덜 넣는 행동입니다.
--- ---
## 4-5일차(목-금): 딥러닝 모델 학습시키기
### 1. 손실 함수(Loss Function)와 옵티마이저(Optimizer) ## 6. 직접 해보기 (Hands-on Lab): MNIST 손글씨 분류
- **[손실 함수](./glossary.md#손실-함수loss-function)**: 모델의 예측이 실제 정답과 얼마나 다른지를 측정하는 '오차 측정기'. (예: `CrossEntropyLoss` - 분류 문제) > **🎯 5일차 목표:** PyTorch를 사용하여 딥러닝의 "Hello, World!"인 MNIST 손글씨 분류기를 직접 만듭니다.
- **[옵티마이저](./glossary.md#옵티마이저optimizer)**: 손실 함수가 계산한 오차를 기반으로, 모델의 파라미터(가중치)를 어느 방향으로 얼마나 업데이트할지 결정하는 '조율사'. (예: `Adam`, `SGD`)
### 2. 학습 루프(Training Loop) ### 문제:
딥러닝 모델 학습은 '에포크(Epoch)'라는 단위로 반복됩니다. 1 에포크는 전체 훈련 데이터를 한 번 모두 사용하는 것을 의미합니다. `torchvision`을 사용하여 MNIST 데이터셋을 불러오고, 간단한 CNN(합성곱 신경망) 모델을 구축하여 손글씨 숫자를 분류하는 전체 코드를 완성하세요.
```python ```python
# (데이터 로드 및 전처리는 Scikit-learn 예제와 유사하게 진행되었다고 가정) import torch
# X_train, y_train을 PyTorch 텐서로 변환 import torch.nn as nn
# X_train_tensor = torch.FloatTensor(X_train.values) import torchvision
# y_train_tensor = torch.LongTensor(pd.Categorical(y_train).codes) import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# criterion = nn.CrossEntropyLoss()
# optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # 1. 데이터셋 및 로더 준비
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
# epochs = 100 train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
# for epoch in range(epochs): test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform)
# # 1. 순전파 (Forward pass) train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
# outputs = model(X_train_tensor) test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
# loss = criterion(outputs, y_train_tensor)
# 2. CNN 모델 정의
# # 2. 역전파 및 가중치 업데이트 (Backward and optimize) class ConvNet(nn.Module):
# optimizer.zero_grad() # 이전 그래디언트 초기화 def __init__(self):
# loss.backward() # 그래디언트 계산 super(ConvNet, self).__init__()
# optimizer.step() # 파라미터 업데이트 self.layer1 = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2),
# if (epoch+1) % 10 == 0: nn.ReLU(),
# print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}') nn.MaxPool2d(kernel_size=2, stride=2))
self.layer2 = nn.Sequential(
nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2))
self.fc = nn.Linear(7*7*64, 10)
def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = out.reshape(out.size(0), -1) # Flatten
out = self.fc(out)
return out
# 3. 모델, 손실함수, 옵티마이저 설정
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = ConvNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 4. 학습 루프 구현
# for epoch ...
# for i, (images, labels) in enumerate(train_loader):
# - images, labels를 device로 이동
# - 순전파, 손실 계산, 역전파, 파라미터 업데이트 코드 작성
# 5. 평가 루프 구현
# with torch.no_grad():
# - test_loader에서 데이터를 가져와 예측
# - 전체 테스트 정확도 계산 및 출력 코드 작성
``` ```
위 코드는 개념 설명을 위한 것으로, 실제 실행 가능한 전체 코드는 `source_code/part_7_deep_learning.py`에서 확인해주세요.
### 📚 7주차 마무리 및 다음 단계 ---
이번 주 우리는 PyTorch를 사용하여 딥러닝의 기본 원리를 이해하고, 직접 신경망을 만들어 학습시키는 과정을 경험했습니다.
## 7. 되짚어보기 (Summary)
이번 주 우리는 PyTorch라는 '레고 블록'으로 딥러닝 모델을 직접 조립하는 방법을 배웠습니다.
다음 시간에는 지금까지 배운 머신러닝/딥러닝 지식을 바탕으로, 최근 가장 뜨거운 분야인 **거대 언어 모델(LLM)****LangChain**을 활용하여 간단한 챗봇 애플리케이션을 만들어보는 시간을 갖습니다. - **PyTorch의 구성요소**: GPU 연산이 가능한 `Tensor`와, `nn.Module`을 상속받아 만드는 우리만의 모델 구조를 이해했습니다.
- **딥러닝 학습 과정**: '오차 측정기'인 **손실 함수**와 '조율사'인 **옵티마이저**를 사용하여, **순전파 → 손실 계산 → 역전파 → 파라미터 업데이트**로 이어지는 학습 루프의 원리를 파악했습니다.
- **실전 경험**: MNIST 손글씨 분류 실습을 통해 이미지 데이터를 다루는 CNN 모델을 직접 구현하고 학습시키는 전 과정을 체험했습니다.
## 8. 더 깊이 알아보기 (Further Reading)
- [PyTorch 공식 60분 튜토리얼](https://tutorials.pytorch.kr/beginner/deep_learning_60min_blitz.html): PyTorch의 핵심 기능을 빠르게 훑어볼 수 있는 최고의 가이드
- [cs231n: Convolutional Neural Networks for Visual Recognition](https://cs231n.github.io/): 스탠포드 대학의 전설적인 딥러닝 강의. CNN의 원리를 깊이 있게 이해하고 싶다면 필독.
- [A Comprehensive Introduction to Torch.nn for Deep Learning](https://www.assemblyai.com/blog/a-comprehensive-introduction-to-torch-nn-for-deep-learning/): `torch.nn` 모듈에 대한 상세한 설명
---
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)** **➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
\ No newline at end of file
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment