Skip to content

GitLab

Commit 6971b361 authored by insun park's avatar insun park
Browse files

Update AI lecture materials: Integrate Machine Learning concepts and practical... 

Update AI lecture materials: Integrate Machine Learning concepts and practical applications into Part 6, emphasizing model building, evaluation, and data preprocessing techniques.
parent f909318d
Hide whitespace changes
Inline Side-by-side
2_services/ai_lecture/courses/05.5_linear_algebra_with_numpy/part_5.5_linear_algebra_with_numpy.md
View file @ 6971b361
......@@ -5,6 +5,31 @@
---
## 🗺️ 학습 로드맵: 왜 여기서 선형대수를 배우나요?
### 🎯 이번 파트의 목적
이제 AI 핵심 라이브러리(NumPy, Pandas, Matplotlib)를 마스터했으니, **머신러닝의 수학적 기초**를 다져보겠습니다. 선형대수는 AI의 "언어"라고 할 수 있습니다.
### 🔗 이전 파트와의 연결점
- **Part 5 (AI Core Libraries)**: NumPy 배열을 다루는 방법을 배웠습니다
- **이번 파트 (Linear Algebra)**: 그 NumPy 배열이 실제로는 **벡터와 행렬**이라는 것을 이해합니다
- **다음 파트 (Calculus)**: 선형대수 + 미적분 = 머신러닝의 완성
### 🚀 머신러닝에서의 활용 예시
- **이미지 처리**: 픽셀 데이터를 행렬로 표현하고 변환
- **추천 시스템**: 사용자-아이템 행렬을 분해하여 패턴 발견
- **신경망**: 가중치를 행렬로 표현하고 최적화
- **차원 축소**: PCA로 고차원 데이터를 저차원으로 압축
### 📈 학습 진행도
```
Part 5: AI Core Libraries ✅
Part 5.5: Linear Algebra 🔄 (현재)
Part 5.6: Calculus ⏳
Part 6: Machine Learning ⏳
```
---
> ## 🎯 학습 목표 (Learning Objectives)
>
......@@ -464,6 +489,49 @@ plt.show()
print("이미지 필터링 = 행렬 곱셈의 실제 활용")
print("각 픽셀 주변의 값들을 행렬(커널)로 가중 평균하여 새로운 픽셀 값 계산")
#### 🏢 Google - 이미지 검색 사례
Google의 이미지 검색 시스템은 선형대수를 어떻게 활용할까요?
```python
# Google 이미지 검색의 핵심: 특성 벡터와 유사도 계산
def google_image_search_simulation():
"""Google 이미지 검색 시뮬레이션"""
# 이미지 특성 벡터 (색상, 질감, 모양 등의 수치화된 특성)
image_features = {
'cat1.jpg': [0.8, 0.6, 0.9, 0.3, 0.7], # 고양이 이미지
'cat2.jpg': [0.7, 0.5, 0.8, 0.4, 0.6], # 다른 고양이
'dog1.jpg': [0.6, 0.8, 0.7, 0.5, 0.8], # 강아지 이미지
'car1.jpg': [0.2, 0.1, 0.3, 0.9, 0.4], # 자동차 이미지
'tree1.jpg': [0.4, 0.7, 0.5, 0.2, 0.9] # 나무 이미지
}
# 검색 쿼리: "고양이" 이미지 찾기
query_vector = np.array([0.8, 0.6, 0.9, 0.3, 0.7]) # 고양이 특성
print("Google 이미지 검색 시뮬레이션")
print("=" * 50)
# 각 이미지와의 유사도 계산 (코사인 유사도)
similarities = {}
for image_name, features in image_features.items():
similarity = np.dot(query_vector, features) / (np.linalg.norm(query_vector) * np.linalg.norm(features))
similarities[image_name] = similarity
# 유사도 순으로 정렬
sorted_results = sorted(similarities.items(), key=lambda x: x[1], reverse=True)
print("검색 결과 (유사도 순):")
for i, (image, sim) in enumerate(sorted_results, 1):
print(f"{i}. {image}: 유사도 {sim:.3f}")
print("\n선형대수 활용:")
print("- 이미지 특성 → 벡터로 표현")
print("- 유사도 계산 → 벡터 내적 활용")
print("- 검색 결과 정렬 → 수치 기반 순위 결정")
google_image_search_simulation()
```
### 4-2. 추천 시스템으로 이해하는 행렬 분해
......@@ -501,6 +569,75 @@ print(f"\n예측된 평점 행렬:\n{predicted.round(2)}")
# 원본과 예측 비교
print(f"\n원본 평점 (0은 누락):\n{ratings}")
print(f"예측 평점:\n{predicted.round(2)}")
#### 🏢 Netflix - 추천 시스템 사례
Netflix의 추천 시스템은 행렬 분해를 어떻게 활용할까요?
```python
# Netflix 추천 시스템 시뮬레이션
def netflix_recommendation_simulation():
"""Netflix 추천 시스템 시뮬레이션"""
# 사용자-영화 평점 행렬 (실제로는 수백만 명의 사용자와 수만 개의 영화)
ratings_matrix = np.array([
# 액션 로맨스 코미디 스릴러 SF
[5, 1, 2, 4, 5], # 사용자1 (액션/SF 선호)
[4, 2, 3, 5, 4], # 사용자2 (스릴러 선호)
[1, 5, 4, 2, 1], # 사용자3 (로맨스/코미디 선호)
[2, 4, 5, 1, 2], # 사용자4 (코미디 선호)
[3, 3, 3, 3, 3] # 사용자5 (중립적)
])
print("Netflix 추천 시스템 시뮬레이션")
print("=" * 50)
print("사용자-영화 평점 행렬:")
print(ratings_matrix)
# SVD를 통한 행렬 분해 (실제로는 더 복잡한 알고리즘 사용)
U, S, Vt = np.linalg.svd(ratings_matrix, full_matrices=False)
# 잠재 요인 수 (실제로는 하이퍼파라미터 튜닝으로 결정)
k = 2
# 차원 축소
U_k = U[:, :k]
S_k = np.diag(S[:k])
Vt_k = Vt[:k, :]
# 재구성된 평점 행렬
reconstructed = U_k @ S_k @ Vt_k
print(f"\n행렬 분해 결과 (k={k}):")
print("사용자 특성 행렬 (U):")
print(U_k.round(3))
print("\n특이값 행렬 (S):")
print(S_k.round(3))
print("\n영화 특성 행렬 (V^T):")
print(Vt_k.round(3))
print(f"\n재구성된 평점 행렬:")
print(reconstructed.round(2))
# 새로운 사용자에 대한 추천
new_user = np.array([4, 1, 2, 5, 4]) # 액션/스릴러 선호
print(f"\n새로운 사용자 평점: {new_user}")
# 사용자 특성 추출
user_features = new_user @ Vt_k.T @ np.linalg.inv(S_k)
print(f"사용자 특성: {user_features.round(3)}")
# 추천 점수 계산
recommendations = user_features @ S_k @ Vt_k
print(f"추천 점수: {recommendations.round(2)}")
print("\n선형대수 활용:")
print("- 사용자 취향 → 벡터로 표현")
print("- 영화 특성 → 벡터로 표현")
print("- 행렬 분해 → 잠재 요인 발견")
print("- 추천 점수 → 벡터 연산으로 계산")
netflix_recommendation_simulation()
```
```
---
......@@ -568,7 +705,107 @@ ax.set_title('나만의 벡터 클래스')
plt.show()
```
### 5-2. 간단한 신경망 가중치 시각화
#### 🎯 과제 1: 벡터 클래스 확장하기
기존 MyVector 클래스에 다음 메서드들을 추가해보세요:
```python
# 추가할 메서드들
def angle(self, other):
"""두 벡터 사이의 각도 계산 (라디안)"""
# TODO: 구현해보세요!
pass
def normalize(self):
"""단위 벡터로 정규화"""
# TODO: 구현해보세요!
pass
def cross(self, other):
"""외적 계산 (3D 벡터용)"""
# TODO: 구현해보세요!
pass
```
### 5-2. 행렬 변환 시각화 과제
```python
# 2D 변환 행렬 구현
class TransformationMatrix:
"""2D 변환 행렬 클래스"""
@staticmethod
def rotation(angle_degrees):
"""회전 변환 행렬"""
angle_rad = np.radians(angle_degrees)
return np.array([
[np.cos(angle_rad), -np.sin(angle_rad)],
[np.sin(angle_rad), np.cos(angle_rad)]
])
@staticmethod
def scaling(sx, sy):
"""크기 조절 변환 행렬"""
return np.array([[sx, 0], [0, sy]])
@staticmethod
def shear(sx, sy):
"""전단 변환 행렬"""
return np.array([[1, sx], [sy, 1]])
def visualize_transformations():
"""다양한 변환을 시각화"""
# 원본 점들 (사각형)
points = np.array([
[-1, -1], [1, -1], [1, 1], [-1, 1], [-1, -1]
])
# 변환들
transformations = {
'회전 45도': TransformationMatrix.rotation(45),
'X축 2배 확대': TransformationMatrix.scaling(2, 1),
'전단 변환': TransformationMatrix.shear(0.5, 0)
}
# 시각화
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
axes = axes.flatten()
# 원본
axes[0].plot(points[:, 0], points[:, 1], 'b-', linewidth=2)
axes[0].set_title('원본')
axes[0].set_xlim(-3, 3)
axes[0].set_ylim(-3, 3)
axes[0].grid(True, alpha=0.3)
axes[0].set_aspect('equal')
# 변환들
for i, (name, matrix) in enumerate(transformations.items()):
transformed_points = points @ matrix.T
axes[i+1].plot(transformed_points[:, 0], transformed_points[:, 1], 'r-', linewidth=2)
axes[i+1].set_title(name)
axes[i+1].set_xlim(-3, 3)
axes[i+1].set_ylim(-3, 3)
axes[i+1].grid(True, alpha=0.3)
axes[i+1].set_aspect('equal')
plt.tight_layout()
plt.show()
visualize_transformations()
```
#### 🎯 과제 2: 복합 변환 구현하기
여러 변환을 순서대로 적용하는 복합 변환을 구현해보세요:
```python
def composite_transformation():
"""복합 변환 구현"""
# TODO: 회전 + 확대 + 전단을 순서대로 적용하는 함수를 만들어보세요!
# 힌트: 행렬곱을 사용하여 변환들을 결합하세요
pass
```
### 5-3. 간단한 신경망 가중치 시각화
```python
# 간단한 신경망 가중치를 행렬로 이해하기
......@@ -610,6 +847,38 @@ W1, W2 = create_simple_network()
visualize_weights(W1, W2)
```
#### 🎯 과제 3: 신경망 순전파 구현하기
가중치 행렬을 사용하여 신경망의 순전파를 구현해보세요:
```python
def forward_propagation(input_data, W1, W2, b1, b2):
"""신경망 순전파"""
# TODO: 입력 데이터를 신경망에 통과시켜 출력을 계산하세요!
# 힌트: z1 = input @ W1 + b1, a1 = sigmoid(z1), z2 = a1 @ W2 + b2, output = sigmoid(z2)
pass
def sigmoid(x):
"""시그모이드 활성화 함수"""
return 1 / (1 + np.exp(-x))
```
### 5-4. 난이도별 실습 과제
#### 🟢 초급 과제: 기본 개념 이해 및 구현
1. **벡터 연산 계산기**: 두 벡터의 덧셈, 뺄셈, 내적, 외적을 계산하는 함수 구현
2. **행렬 기본 연산**: 행렬 덧셈, 곱셈, 전치를 구현하는 함수 작성
3. **단위 벡터 생성**: 주어진 방향의 단위 벡터를 생성하는 함수 구현
#### 🟡 중급 과제: 실제 데이터 적용
1. **이미지 회전**: NumPy 배열로 표현된 이미지를 행렬 변환으로 회전시키기
2. **데이터 정규화**: 데이터셋을 평균 0, 표준편차 1로 정규화하는 함수 구현
3. **거리 계산**: 여러 점들 간의 유클리드 거리를 행렬 연산으로 계산
#### 🔴 고급 과제: 창의적 활용 및 확장
1. **PCA 구현**: 고유값 분해를 사용하여 주성분 분석 직접 구현
2. **행렬 분해**: SVD를 사용하여 이미지 압축 알고리즘 구현
3. **신경망 시각화**: 가중치 행렬의 변화를 애니메이션으로 표현
---
<br>
......@@ -640,5 +909,65 @@ visualize_weights(W1, W2)
---
## ✅ Part 5.5 완료 체크리스트
### 🎯 달성 목표 확인
다음 항목들을 모두 완료했다면 선형대수의 핵심을 이해한 것입니다!
#### 📐 벡터 이해도
- [ ] 벡터를 화살표로 직관적 이해
- [ ] 벡터 덧셈의 기하학적 의미 설명 가능
- [ ] 벡터 내적이 유사도를 측정한다는 것 이해
- [ ] NumPy로 벡터 연산 구현 가능
#### 🎁 행렬 이해도
- [ ] 행렬을 데이터 변형기로 이해
- [ ] 행렬곱을 복합 변환으로 설명 가능
- [ ] 이미지 필터링에서 행렬이 어떻게 사용되는지 앎
- [ ] NumPy로 행렬 연산 구현 가능
#### 🧭 고유값과 고유벡터 이해도
- [ ] 고유벡터가 변하지 않는 특별한 방향이라는 것 이해
- [ ] PCA의 직관적 의미 이해
- [ ] 차원 축소의 필요성과 방법 이해
- [ ] 실제 데이터에 PCA 적용 가능
#### 🛠️ 실습 완료도
- [ ] 나만의 벡터 클래스 구현
- [ ] 행렬 변환 시각화 코드 작성
- [ ] 이미지 필터링 예제 실행
- [ ] 신경망 가중치 시각화 이해
### 🚀 다음 단계 준비 완료
- [ ] 미적분 학습을 위한 기초 수학 준비
- [ ] 기울기 하강법의 필요성 이해
- [ ] 최적화 문제에 대한 관심과 동기 부여
## 🎯 이제 할 수 있는 것들
### 🚀 즉시 활용 가능한 기술
- **이미지 필터링 알고리즘 구현**: 엣지 검출, 블러, 샤프닝 필터
- **간단한 추천 시스템 만들기**: 사용자-아이템 행렬 분해
- **데이터 차원 축소 (PCA) 적용**: 고차원 데이터를 저차원으로 압축
- **신경망 가중치 시각화**: 행렬로 표현된 가중치 분석
### 💼 포트폴리오 프로젝트 아이디어
- **얼굴 인식 시스템**: 선형대수 기반 특성 추출 및 유사도 계산
- **음악 추천 앱**: 행렬 분해를 활용한 사용자 취향 분석
- **이미지 스타일 변환**: 행렬 변환을 통한 이미지 처리
- **데이터 시각화 도구**: PCA를 활용한 다차원 데이터 시각화
### 🔬 실무 적용 예시
- **금융**: 포트폴리오 최적화, 위험 분석
- **의료**: 의료 이미지 처리, 환자 데이터 분석
- **게임**: 3D 그래픽 변환, 물리 시뮬레이션
- **마케팅**: 고객 세분화, 추천 시스템
> **💡 체크리스트 완료 후**:
> 80% 이상 완료했다면 다음 파트(Part 5.6: 미적분)로 진행하세요!
> 미완료 항목이 있다면 해당 섹션을 다시 학습하고 실습해보세요.
---
**⬅️ 이전 시간: [Part 5: AI 핵심 라이브러리](../05_ai_core_libraries/part_5_ai_core_libraries.md)**
**➡️ 다음 시간: [Part 5.6: 머신러닝/딥러닝을 위한 미적분](../05.6_calculus_for_ml/part_5.6_calculus_for_ml.md)**
\ No newline at end of file
2_services/ai_lecture/courses/05.6_calculus_for_ml/part_5.6_calculus_for_ml.md
View file @ 6971b361
......@@ -10,6 +10,38 @@
---
## 🗺️ 학습 로드맵: 선형대수 + 미적분 = 머신러닝의 완성
### 🎯 이번 파트의 목적
선형대수를 통해 **"무엇을 최적화할 것인가?"**를 배웠다면, 이제 미적분을 통해 **"어떻게 최적화할 것인가?"**를 배워보겠습니다. 기울기 하강법은 모든 머신러닝 모델의 핵심입니다.
### 🔗 이전 파트와의 연결점
- **Part 5.5 (Linear Algebra)**: 벡터와 행렬로 데이터를 표현하고 변환하는 방법을 배웠습니다
- **이번 파트 (Calculus)**: 그 변환된 데이터를 **최적화**하는 방법을 배웁니다
- **다음 파트 (Machine Learning)**: 선형대수 + 미적분을 결합하여 실제 AI 모델을 만듭니다
### 🚀 기울기 하강법과 미적분의 연결점
- **미분**: 함수의 기울기를 계산하여 어느 방향으로 가야 할지 결정
- **기울기 하강법**: 미분값을 이용해 최적의 파라미터를 찾아가는 과정
- **편미분**: 여러 변수가 있을 때 각각의 기울기를 계산
- **연쇄법칙**: 신경망에서 오차를 뒤로 전파하는 핵심 원리
### 📈 학습 진행도
```
Part 5: AI Core Libraries ✅
Part 5.5: Linear Algebra ✅
Part 5.6: Calculus 🔄 (현재)
Part 6: Machine Learning ⏳
```
### 🎯 이제 할 수 있는 것들
- **신경망 가중치 최적화**: 기울기 하강법으로 모델 학습
- **함수 최적화**: 복잡한 함수의 최솟값/최댓값 찾기
- **변화율 분석**: 데이터의 변화 패턴 분석
- **자동 미분**: PyTorch, TensorFlow의 핵심 기능 이해
---
<br>
> ## 🎯 학습 목표 (Learning Objectives)
......@@ -757,6 +789,100 @@ def compare_optimizers():
compare_optimizers()
```
### 5-3. 실습: 직접 해보기 🛠️
#### 🎯 과제 1: 미분 계산기 구현하기
다양한 함수의 미분을 계산하는 클래스를 구현해보세요:
```python
class DerivativeCalculator:
"""미분 계산기 클래스"""
def __init__(self, h=1e-6):
self.h = h
def numerical_derivative(self, func, x):
"""수치 미분"""
# TODO: 수치 미분 공식을 사용하여 미분값을 계산하세요!
# 힌트: f'(x) ≈ (f(x+h) - f(x-h)) / (2h)
pass
def analytical_derivative(self, func_name, x):
"""해석적 미분 (기본 함수들)"""
# TODO: 기본 함수들의 해석적 미분을 구현하세요!
# 지원할 함수: 'x^2', 'sin(x)', 'cos(x)', 'exp(x)', 'log(x)'
pass
def compare_methods(self, func, x, func_name=None):
"""수치 미분과 해석적 미분 비교"""
numerical = self.numerical_derivative(func, x)
analytical = self.analytical_derivative(func_name, x) if func_name else None
print(f"x = {x}에서의 미분값:")
print(f" 수치 미분: {numerical:.6f}")
if analytical is not None:
print(f" 해석적 미분: {analytical:.6f}")
print(f" 오차: {abs(numerical - analytical):.2e}")
```
#### 🎯 과제 2: 기울기 하강법 시각화 도구
기울기 하강법의 과정을 애니메이션으로 시각화하는 도구를 만들어보세요:
```python
def animated_gradient_descent(func, gradient, x0, learning_rate=0.1, epochs=100):
"""애니메이션 기울기 하강법"""
import matplotlib.animation as animation
# TODO: 기울기 하강법 과정을 애니메이션으로 표현하세요!
# 힌트: matplotlib.animation.FuncAnimation을 사용하여 실시간으로 최적화 과정을 보여주세요
pass
def plot_optimization_landscape(func, x_range, y_range, optimizer_history):
"""최적화 경관을 3D로 시각화"""
# TODO: 3D 그래프로 목적 함수의 표면과 최적화 경로를 그려보세요!
# 힌트: ax.plot_surface()와 ax.plot()을 사용하세요
pass
```
#### 🎯 과제 3: 다변수 함수 최적화
여러 변수를 가진 함수의 최적화를 구현해보세요:
```python
def multivariate_gradient_descent(objective_func, gradient_func, x0, learning_rate=0.01, epochs=1000):
"""다변수 함수의 기울기 하강법"""
# TODO: 다변수 함수의 기울기 하강법을 구현하세요!
# 힌트: 각 변수에 대해 편미분을 계산하고 동시에 업데이트하세요
pass
def rosenbrock_function(x, y):
"""Rosenbrock 함수 (최적화 테스트용)"""
return (1 - x)**2 + 100 * (y - x**2)**2
def rosenbrock_gradient(x, y):
"""Rosenbrock 함수의 그래디언트"""
# TODO: Rosenbrock 함수의 편미분을 계산하세요!
# ∂f/∂x = -2(1-x) - 400x(y-x²)
# ∂f/∂y = 200(y-x²)
pass
```
### 5-4. 난이도별 실습 과제
#### 🟢 초급 과제: 기본 개념 이해 및 구현
1. **미분 계산기**: 다양한 함수의 수치 미분을 계산하는 함수 구현
2. **기울기 시각화**: 함수와 그 미분을 동시에 그래프로 표현
3. **단순 최적화**: 1변수 함수의 최솟값을 기울기 하강법으로 찾기
#### 🟡 중급 과제: 실제 데이터 적용
1. **선형 회귀 구현**: 실제 데이터셋으로 선형 회귀 모델 학습
2. **학습률 스케줄링**: 다양한 학습률 스케줄링 기법 구현 및 비교
3. **조기 종료**: 과적합을 방지하는 조기 종료 기법 구현
#### 🔴 고급 과제: 창의적 활용 및 확장
1. **신경망 역전파**: 간단한 신경망의 역전파 알고리즘 직접 구현
2. **적응적 최적화**: Adam, RMSprop 등 고급 최적화 알고리즘 구현
3. **제약 최적화**: 라그랑주 승수법을 사용한 제약 조건이 있는 최적화
---
<br>
......@@ -787,5 +913,65 @@ compare_optimizers()
---
## ✅ Part 5.6 완료 체크리스트
### 🎯 달성 목표 확인
다음 항목들을 모두 완료했다면 미적분의 핵심을 이해한 것입니다!
#### 📈 미분 이해도
- [ ] 미분의 기하학적 의미 이해
- [ ] 순간 변화율의 직관적 개념 파악
- [ ] 수치 미분과 해석적 미분의 차이 이해
- [ ] Python으로 미분 계산 구현 가능
#### 🏔️ 기울기 하강법 이해도
- [ ] 기울기 하강법의 원리 이해
- [ ] 학습률의 역할과 중요성 이해
- [ ] 다양한 최적화 알고리즘 비교 가능
- [ ] 실제 함수 최적화 문제 해결 능력
#### 🔧 편미분과 연쇄법칙 이해도
- [ ] 다변수 함수의 편미분 개념 이해
- [ ] 연쇄법칙의 직관적 의미 파악
- [ ] 신경망에서 역전파의 원리 이해
- [ ] 그래디언트 계산 구현 가능
#### 🛠️ 실습 완료도
- [ ] 미분 계산기 구현
- [ ] 기울기 하강법 시각화 코드 작성
- [ ] 선형 회귀 모델 구현
- [ ] 간단한 신경망 역전파 구현
### 🚀 다음 단계 준비 완료
- [ ] 머신러닝 모델 설계 능력
- [ ] 데이터 전처리와 모델 평가 방법 이해
- [ ] 실제 프로젝트 구현에 대한 동기 부여
## 🎯 이제 할 수 있는 것들
### 🚀 즉시 활용 가능한 기술
- **신경망 가중치 최적화**: 기울기 하강법으로 모델 학습
- **함수 최적화 알고리즘 구현**: 복잡한 함수의 최솟값/최댓값 찾기
- **변화율 기반 데이터 분석**: 데이터의 변화 패턴 분석
- **자동 미분을 활용한 모델 학습**: PyTorch, TensorFlow의 핵심 기능 이해
### 💼 포트폴리오 프로젝트 아이디어
- **자동 미분을 활용한 신경망 구현**: 역전파 알고리즘 직접 구현
- **최적화 알고리즘 비교 분석**: 다양한 최적화 기법 성능 비교
- **실시간 데이터 변화율 모니터링 시스템**: 센서 데이터 분석
- **함수 근사화 도구**: 복잡한 함수를 단순한 함수로 근사
### 🔬 실무 적용 예시
- **금융**: 포트폴리오 최적화, 리스크 관리
- **의료**: 약물 투여량 최적화, 진단 모델 학습
- **제조업**: 생산 공정 최적화, 품질 관리
- **물류**: 경로 최적화, 재고 관리
> **💡 체크리스트 완료 후**:
> 80% 이상 완료했다면 다음 파트(Part 6: 머신러닝)로 진행하세요!
> 미완료 항목이 있다면 해당 섹션을 다시 학습하고 실습해보세요.
---
**⬅️ 이전 시간: [Part 5.5: NumPy로 배우는 선형대수학](../05.5_linear_algebra_with_numpy/part_5.5_linear_algebra_with_numpy.md)**
**➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](../06_machine_learning/part_6_machine_learning.md)**
\ No newline at end of file
2_services/ai_lecture/courses/06_machine_learning/part_6_machine_learning.md
View file @ 6971b361
......@@ -5,6 +5,40 @@
---
## 🗺️ 학습 로드맵: 이제 실제 AI 모델을 만들어봅시다!
### 🎯 이번 파트의 목적
이제 선형대수와 미적분의 기초를 다졌으니, **실제 머신러닝 모델을 만들어보겠습니다!** 이전 파트들의 모든 지식이 하나로 합쳐지는 순간입니다.
### 🔗 이전 파트들의 지식이 어떻게 활용되는지
- **Part 5 (AI Core Libraries)**: NumPy, Pandas로 데이터를 다루고 전처리
- **Part 5.5 (Linear Algebra)**: 벡터와 행렬로 데이터를 표현하고 변환
- **Part 5.6 (Calculus)**: 기울기 하강법으로 모델을 최적화
- **이번 파트 (Machine Learning)**: 모든 것을 결합하여 실제 예측 모델 구축
### 🚀 머신러닝의 핵심 구성 요소
- **데이터 시각화**: Matplotlib, Seaborn으로 패턴 발견
- **지도학습**: 정답이 있는 데이터로 패턴 학습
- **모델 평가**: 훈련/테스트 분리로 일반화 성능 측정
- **전처리**: 피처 스케일링으로 모델 성능 향상
### 📈 학습 진행도
```
Part 5: AI Core Libraries ✅
Part 5.5: Linear Algebra ✅
Part 5.6: Calculus ✅
Part 6: Machine Learning 🔄 (현재)
Part 7: Deep Learning ⏳
```
### 🎯 이제 할 수 있는 것들
- **실제 예측 모델 구축**: 집값 예측, 고객 이탈 예측 등
- **데이터 기반 의사결정**: 시각화를 통한 인사이트 도출
- **모델 성능 최적화**: 하이퍼파라미터 튜닝, 앙상블 기법
- **실무 프로젝트**: 전체 머신러닝 파이프라인 구축
---
<br>
> ## 1. 학습 목표 (Learning Objectives)
......@@ -520,5 +554,71 @@ print("---------------------------------------")
---
## ✅ Part 6 완료 체크리스트
### 🎯 달성 목표 확인
다음 항목들을 모두 완료했다면 머신러닝의 핵심을 이해한 것입니다!
#### 📊 데이터 시각화 능력
- [ ] Matplotlib와 Seaborn으로 다양한 그래프 생성
- [ ] 데이터의 분포, 관계, 추세를 시각화하여 인사이트 도출
- [ ] 적절한 그래프 유형 선택 (산점도, 히스토그램, 히트맵 등)
- [ ] 시각화를 통한 데이터 품질 문제 발견
#### 🤖 머신러닝 모델링 능력
- [ ] 지도학습의 개념과 훈련/테스트 분할 이해
- [ ] Scikit-learn의 fit(), predict() 인터페이스 활용
- [ ] 다양한 분류 모델 (로지스틱 회귀, 결정 트리, 랜덤 포레스트) 구현
- [ ] 모델 성능 평가 지표 (정확도, 정밀도, 재현율) 이해
#### 🔧 데이터 전처리 능력
- [ ] 피처 스케일링 (StandardScaler, MinMaxScaler) 적용
- [ ] 결측치 처리 및 범주형 변수 인코딩
- [ ] 데이터 누수 방지를 위한 전처리 순서 이해
- [ ] Pipeline을 활용한 전처리 자동화
#### 📈 실무 프로젝트 능력
- [ ] 전체 머신러닝 파이프라인 구축
- [ ] 여러 모델의 성능 비교 및 분석
- [ ] 과적합/과소적합 문제 진단 및 해결
- [ ] 실제 비즈니스 문제에 머신러닝 적용
### 🚀 다음 단계 준비 완료
- [ ] 딥러닝 학습을 위한 기초 준비
- [ ] 신경망 구조와 역전파 이해
- [ ] PyTorch 프레임워크 학습 동기 부여
## 🎯 이제 할 수 있는 것들
### 🚀 즉시 활용 가능한 기술
- **실제 예측 모델 구축**: 집값 예측, 고객 이탈 예측, 스팸 메일 분류
- **데이터 기반 의사결정**: 시각화를 통한 인사이트 도출 및 비즈니스 분석
- **모델 성능 최적화**: 하이퍼파라미터 튜닝, 앙상블 기법 적용
- **실무 머신러닝 파이프라인**: 데이터 전처리부터 모델 배포까지 전체 과정
### 💼 포트폴리오 프로젝트 아이디어
- **부동산 가격 예측 시스템**: 다양한 특성을 활용한 집값 예측 모델
- **고객 이탈 예측 대시보드**: 시각화와 머신러닝을 결합한 분석 도구
- **신용카드 사기 탐지 시스템**: 이상 탐지 알고리즘 구현
- **추천 시스템**: 협업 필터링과 콘텐츠 기반 필터링 결합
### 🔬 실무 적용 예시
- **금융**: 신용 평가, 리스크 관리, 포트폴리오 최적화
- **의료**: 질병 진단, 약물 효과 예측, 환자 결과 예측
- **마케팅**: 고객 세분화, 캠페인 효과 예측, 가격 최적화
- **제조업**: 품질 관리, 예측 정비, 공정 최적화
### 📋 캡스톤 프로젝트 완료도
- [ ] 모델 성능 비교 실험 수행
- [ ] Pipeline을 활용한 전처리 자동화
- [ ] 결과 분석 및 보고서 작성
- [ ] 실무 적용 가능한 인사이트 도출
> **💡 체크리스트 완료 후**:
> 80% 이상 완료했다면 다음 파트(Part 7: 딥러닝)로 진행하세요!
> 미완료 항목이 있다면 해당 섹션을 다시 학습하고 실습해보세요.
---
**⬅️ 이전 시간: [Part 5.6: 머신러닝/딥러닝을 위한 미적분](../05.6_calculus_for_ml/part_5.6_calculus_for_ml.md)**
**➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](../07_deep_learning/part_7_deep_learning.md)**
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