강의 자료 업데이트 및 용어집 정리

ai lecture/part_0_introduction.md

-# Part 0: 시작하며 - AI 서비스 개발, 첫걸음을 떼다
+# Part 0: 시작하며 - 12주 완성, AI 서비스 개발 마스터 과정
 
-안녕하세요! "AI Lecture" 시리즈에 오신 것을 환영합니다.
+안녕하세요! "AI 서비스 개발 12주 완성" 과정에 오신 것을 환영합니다.
 
-이 시리즈는 프로그래밍의 기초를 다지고, AI 모델을 활용하여 실제 동작하는 API 서버를 구축하는 여정을 함께합니다. 막연하게 느껴졌던 'AI 서비스 개발'을 구체적인 코드로 구현하며 자신감을 얻는 것을 목표로 합니다.
+AI 서비스를 만드는 것은 마치 **'스스로 생각하고 행동하는 기계'**를 조립하는 것과 같습니다. 처음에는 작은 부품(프로그래밍 기초)을 다루는 법부터 배우고, 점차 엔진(AI 모델)을 만들어 올리고, 마지막에는 멋진 차체(API 서버)를 씌워 실제 세상(인터넷)을 달리게 하는 것과 같죠.
 
-## 🏁 최종 목표: 나만의 AI API 서버 구축
+이 과정은 프로그래밍 기초부터 시작해, AI 모델을 활용한 고성능 API 서버를 구축하고, 최종적으로는 여러분만의 아이디어를 실현하는 캡스톤 프로젝트까지 완료하는 것을 목표로 합니다. 12주 동안 막연하게 느껴졌던 'AI 서비스 개발'의 모든 과정을 구체적인 코드로 구현하며, 현업에 바로 투입될 수 있는 실무 역량을 갖추게 될 것입니다.
 
-우리는 이 시리즈를 통해 **"붓꽃 품종을 예측하는 AI 모델이 내장된 API 서버"** 를 완성하게 될 것입니다. 사용자가 API에 붓꽃의 꽃잎, 꽃받침 정보를 보내면, 서버는 AI 모델을 통해 어떤 품종인지 예측하여 응답해주는 서비스입니다.
+## 🏁 최종 목표: 나만의 AI 서비스 포트폴리오 완성
+
+단순한 예제 완성을 넘어, 우리는 이 과정을 통해 **"실제 운영 가능한 수준의 AI 기반 API 서버"**를 구축하고, 이를 응용한 **"캡스톤 프로젝트"**를 완성하여 자신만의 포트폴리오를 만들게 됩니다.
+
+이는 마치 **'레시피만 따라 요리 하나를 만드는 것'**과 **'손님들이 언제든 찾아와 주문할 수 있는 식당 주방을 설계하는 것'**의 차이와 같습니다. 우리는 후자를 목표로 합니다. 언제든 요청에 응답하고, 안정적으로 서비스를 제공하는 '프로의 시스템'을 만드는 경험을 하게 될 것입니다.
 
 이 과정을 통해 여러분은 다음과 같은 결과물을 얻게 됩니다.
 
-- Python 프로그래밍에 대한 깊이 있는 이해
-- 실제 작동하는 FastAPI 기반의 API 서버
-- AI 모델을 서빙하고 활용하는 방법에 대한 실전 경험
-- Docker를 이용한 배포 및 운영의 기초 지식
+- **탄탄한 Python 프로그래밍 역량**: 기초 문법부터 객체 지향 설계까지 깊이 있는 이해
+- **고성능 AI API 서버**: FastAPI를 기반으로 한 비동기 API 서버 구축 및 운영 능력
+- **실전 머신러닝 모델링 경험**: 데이터 전처리, 모델 학습, 평가, 배포까지 전 과정 경험
+- **최신 DevOps 지식**: Docker를 이용한 컨테이너화 및 CI/CD 자동화 파이프라인 개념 이해
+- **나만의 포트폴리오**: 아이디어를 실제 서비스로 구현한 캡스톤 프로젝트 결과물
 
 ## 🙋‍♂️ 대상 독자
 
-이 강의는 다음과 같은 분들을 위해 만들어졌습니다.
+이 과정은 다음과 같은 분들을 위해 체계적으로 설계되었습니다.
 
-- 프로그래밍은 처음이지만 AI 서비스를 직접 만들어보고 싶은 입문자
-- Python 기본 문법은 알지만, 실제 프로젝트 경험이 부족한 학생 또는 주니어 개발자
-- AI 모델을 개발했지만, 이를 어떻게 서비스로 만들어야 할지 막막한 연구자
+- 프로그래밍은 처음이지만 AI 서비스를 직접 만들어보고 싶은 **입문자**
+- Python 기본 문법은 알지만, 실제 프로젝트 경험이 부족한 **학생 또는 주니어 개발자**
+- AI 모델은 개발했지만, 이를 어떻게 서비스로 만들어야 할지 막막한 **연구자 및 데이터 분석가**
 
-## 🗺️ 전체 커리큘럼 맵
+## 🗺️ 12주 학습 로드맵
 
-우리는 다음과 같은 순서로 학습을 진행합니다.
+우리는 12주 동안 다음의 로드맵에 따라 체계적으로 학습을 진행합니다. 이 로드맵은 AI 서비스 개발이라는 보물섬을 찾아가는 **'친절한 안내 지도'**입니다. 각 주차별 목표를 따라 한 걸음씩 나아가다 보면, 어느새 유능한 개발자로 성장한 자신을 발견하게 될 것입니다.
 
 ```mermaid
 graph TD
-    A[Part 0: 시작하며] --> B[Part 1: AI 개발 환경 준비];
-    B --> C[Part 2: Python 핵심 문법];
-    C --> D[Part 3: Python 자료구조];
-    D --> E[Part 4: 객체 지향 프로그래밍];
-    E --> F[Part 5: AI 핵심 라이브러리];
-    F --> G[Part 6: FastAPI로 모델 서빙하기];
-    G --> H[Part 7: 프로덕션 수준의 API 만들기];
-    H --> I[Part 8: 전문가로 가는 길];
-
-    subgraph "기초 다지기"
-        B
-        C
-        D
-        E
+    subgraph "1부: 파이썬 기초 다지기 (1-4주)"
+        W1["<a href='part_1_ai_development_environment.md'><b>1주차</b>: 과정 소개 및<br/>개발 환경 설정</a>"]
+        W2["<a href='part_2_python_core_syntax.md'><b>2주차</b>: 파이썬 핵심 문법</a>"]
+        W3["<a href='part_3_python_collections.md'><b>3주차</b>: 파이썬 컬렉션 심화</a>"]
+        W4["<a href='part_4_object_oriented_programming.md'><b>4.주차</b>: 객체 지향 프로그래밍 (OOP)</a>"]
     end
 
-    subgraph "AI 모델 활용 및 API 개발"
-        F
-        G
-        H
+    subgraph "2부: AI 모델 개발 및 API 서버 구축 (5-9주)"
+        W5["<a href='part_5_ai_core_libraries.md'><b>5주차</b>: 핵심 라이브러리<br/>(NumPy & Pandas)</a>"]
+        W6["<a href='part_6_machine_learning.md'><b>6주차</b>: 머신러닝 완전 정복<br/>(회귀, 분류, 군집, 튜닝)</a>"]
+        W7["<a href='part_7_deep_learning.md'><b>7주차</b>: 딥러닝 첫걸음<br/>(DNN, CNN, RNN, Transformer)</a>"]
+        W8["<a href='part_8_model_serving_with_fastapi.md'><b>8주차</b>: FastAPI를 이용한<br/>모델 서빙(API)</a>"]
+        W9["<a href='part_9_production_ready_api.md'><b>9주차</b>: API 서버 고도화 및<br/>Docker 패키징</a>"]
     end
 
-    subgraph "심화"
-        I
+    subgraph "3부: 심화 학습 및 캡스톤 프로젝트 (10-12주)"
+        W10["<a href='part_10_expert_path.md'><b>10주차</b>: 전문가 과정 소개 (MLOps)</a>"]
+        W11["<a href='part_11_capstone_project_guide.md'><b>11주차</b>: 캡스톤 프로젝트 (Phase 1)</a>"]
+        W12["<a href='part_11_capstone_project_guide.md'><b>12주차</b>: 캡스톤 프로젝트 (Phase 2) 및<br/>마무리</a>"]
     end
+
+    W1 --> W2 --> W3 --> W4 --> W5 --> W6 --> W7 --> W8 --> W9 --> W10 --> W11 --> W12
 ```
 
-## 🎓 필요한 선수 지식
+## 🚀 AI의 미래: 에이전트 워크플로우 (The Future of AI: Agentic Workflows)
+
+최근 AI 분야의 가장 뜨거운 화두는 바로 **'AI 에이전트'**입니다. 스탠포드 대학의 앤드류 응(Andrew Ng) 교수는 AI의 미래가 에이전트에 달려있다고 강조합니다.
+
+> **💡 AI 에이전트란?**
+>
+> 단순히 주어진 질문에 한 번 답하고 끝나는 것이 아니라, 목표를 달성하기 위해 **스스로 계획을 세우고, 도구를 사용하며, 스스로 피드백하고 수정하는 과정을 반복**하는 지능형 시스템을 말합니다.
+>
+> 이는 마치 우리가 복잡한 문제를 해결하기 위해 여러 번 생각하고, 자료를 찾아보고, 계획을 수정하는 과정과 유사합니다. 이러한 **에이전틱 워크플로우(Agentic Workflow)**는 기존 모델보다 훨씬 더 뛰어난 문제 해결 능력을 보여줍니다.
+>
+> (참고: [Agents: The Future of AI, Explained by Dr. Andrew Ng](https://medium.com/@honeyricky1m3/agents-the-future-of-ai-explained-by-dr-andrew-ng-9be4675a6079))
+
+본 과정의 후반부에서는 이러한 최신 트렌드를 맛보고, 여러분이 만든 AI 모델을 어떻게 더 똑똑한 '에이전트'로 발전시킬 수 있을지에 대한 아이디어를 얻게 될 것입니다.
+
+## ❓ 자주 묻는 질문 (Q&A)
+
+**Q1: 정말 프로그래밍을 하나도 몰라도 따라갈 수 있나요?**
+> A1: 네, 가능합니다. 본 과정의 1부(1-4주차)는 비전공자 및 입문자를 위해 파이썬 기초를 매우 상세하게 다룹니다. 열정과 꾸준함만 있다면 누구나 과정을 완주할 수 있습니다.
+
+**Q2: 과정에서 사용하는 주요 기술은 무엇인가요?**
+> A2: <a href="glossary.md#python">Python</a>, <a href="glossary.md#numpy">NumPy</a>, <a href="glossary.md#pandas">Pandas</a>, <a href="glossary.md#scikit-learn">Scikit-learn</a>, <a href="glossary.md#fastapi">FastAPI</a>, <a href="glossary.md#docker">Docker</a> 등 현재 AI 서비스 개발 현업에서 가장 널리 사용되는 기술 스택을 중심으로 학습합니다.
+
+**Q3: 개인 노트북 사양이 많이 좋아야 하나요?**
+> A3: 기본적인 코딩은 일반적인 노트북으로 충분합니다. 모델 학습 등 높은 사양이 필요한 경우, 무료로 사용할 수 있는 <a href="glossary.md#google-colab">Google Colab</a>을 활용하는 방법을 안내해 드리므로 걱정하지 않으셔도 됩니다.
 
-본격적인 학습에 앞서, 특별한 선수 지식은 필요하지 않습니다. 모든 과정을 하나하나 차근차근 설명합니다. 다만, 컴퓨터를 다루는 데 기본적인 지식이 있고, 배우고자 하는 열정과 꾸준함이 있다면 충분합니다!
+**Q4: 캡스톤 프로젝트는 어떻게 진행되나요?**
+> A4: 11-12주차에 진행되며, 수강생들이 직접 주제를 선정하고 기획, 개발, 발표까지 진행합니다. 이 과정에서 멘토링을 통해 프로젝트가 올바른 방향으로 나아갈 수 있도록 적극적으로 지원합니다. 자세한 내용은 <a href="part_11_capstone_project_guide.md">캡스톤 프로젝트 가이드</a>를 참고하세요.
 
 ---
 
-자, 이제 모든 준비가 끝났습니다. 다음 파트에서는 본격적인 개발을 위해 필요한 프로그램들을 설치하고 환경을 설정해보겠습니다.
+자, 이제 12주간의 여정을 시작할 준비가 되셨나요?
+다음 시간에는 본격적인 개발을 위해 여러분의 컴퓨터에 개발 환경을 설정하는 방법을 알아보겠습니다.
 
 **➡️ 다음 시간: [Part 1: AI 개발 환경 준비](part_1_ai_development_environment.md)** 
\ No newline at end of file

ai lecture/part_11_capstone_project_guide.md

+# Part 11: 캡스톤 프로젝트 가이드
+
+**⬅️ 이전 시간: [Part 10: 전문가로 가는 길](./part_10_expert_path.md)**
+
+AI 전문가 양성 과정의 마지막 단계인 캡스톤 프로젝트를 성공적으로 완수하기 위한 가이드입니다.
+
+---
+
+### 1. 프로젝트 개요
+
+캡스톤 프로젝트는 과정에서 배운 AI 기술과 지식을 총동원하여 실제 문제를 해결하는 실전 경험을 쌓는 것을 목표로 합니다. 팀을 구성하여 아이디어를 기획하고, 데이터 수집, 모델링, 개발, 그리고 최종 발표까지 프로젝트의 전 과정을 직접 수행하게 됩니다.
+
+### 2. 프로젝트 주제 예시
+
+아래 예시를 참고하여 창의적이고 실용적인 프로젝트 주제를 선정해 보세요.
+
+- **AI 챗봇 개발**: 특정 도메인(e.g., 법률, 의료, 쇼핑)의 정보를 제공하거나 상담해주는 챗봇
+- **이미지 분류/객체 탐지 서비스**: 특정 종류의 이미지를 분류하거나(e.g., 식물, 동물 종 식별), 이미지 내의 객체를 탐지하는(e.g., CCTV 영상 분석) 서비스
+- **[RAG(Retrieval-Augmented Generation)](./glossary.md#rag-retrieval-augmented-generation) 기반 Q&A 시스템**: 전문 문서나 내부 자료를 기반으로 사용자의 질문에 정확하게 답변하는 시스템
+- **추천 시스템**: 사용자 행동 데이터를 기반으로 상품, 콘텐츠, 또는 서비스를 추천하는 시스템
+- **데이터 시각화 대시보드**: 복잡한 데이터를 수집/분석하여 의미 있는 인사이트를 제공하는 인터랙티브 대시보드
+
+### 3. 팀 구성 가이드라인
+
+- **팀 규모**: 3~4인으로 구성하는 것을 권장합니다.
+- **역할 분담**: 팀 내에서 기획, 데이터 분석, 모델링, 백엔드/프론트엔드 개발 등 역할을 분담하여 효율적으로 협업하는 것이 중요합니다.
+- **팀워크**: 정기적인 회의와 명확한 의사소통을 통해 프로젝트 진행 상황을 공유하고 문제를 함께 해결해 나가세요.
+
+### 4. 주차별 마일스톤
+
+| 주차 | 주요 활동 | 상세 내용 |
+| :--: | :--- | :--- |
+| **1주차** | **기획 및 데이터 수집** | - 아이디어 구체화 및 최종 주제 선정<br/>- 필요 데이터 정의 및 수집/가공 계획 수립<br/>- 개발 환경 설정 및 역할 분담 |
+| **2주차** | **핵심 기능 모델링 및 개발** | - 데이터 전처리 및 분석<br/>- 핵심 AI 모델 설계, 학습 및 평가<br/>- 서비스 프로토타입 개발 |
+| **3주차** | **최종 개발, 발표 및 코드 리뷰** | - 모델 성능 개선 및 서비스 기능 고도화<br/>- 최종 발표 자료(PPT) 및 데모 영상 제작<br/>- Github 레포지토리 정리 및 동료 코드 리뷰 |
+
+### 5. 최종 결과물
+
+- **발표 자료 (PPT)**: 프로젝트의 목표, 과정, 결과, 그리고 배운 점을 명확하게 정리하여 발표합니다.
+- **Github 레포지토리**: 모든 소스코드, 데이터(혹은 데이터 설명), 실행 방법이 포함된 README 파일을 포함해야 합니다.
+- **데모 영상**: 서비스의 핵심 기능을 시연하는 3~5분 내외의 영상입니다.
+
+### 6. 평가 기준
+
+| 평가 항목 | 세부 내용 | 배점 |
+| :--- | :--- | :--: |
+| **기술 구현의 완성도** | AI 모델의 성능, 서비스의 안정성 및 기능의 완성도 | 40 |
+| **아이디어의 창의성 및 실용성** | 문제 해결 방식의 독창성과 실제 활용 가능성 | 30 |
+| **프로젝트 관리 및 협업** | 마일스톤 준수, 역할 분담, Github 활용 등 협업 과정 | 20 |
+| **최종 발표 및 전달력** | 프로젝트 결과물을 명확하고 논리적으로 설명하는 능력 | 10 |
+
+---
+
+캡스톤 프로젝트를 통해 여러분의 가능성을 마음껏 펼치시길 바랍니다! 
\ No newline at end of file

ai lecture/part_6_machine_learning.md

+# Part 6: 머신러닝 모델링과 평가 (6주차)
+
+**⬅️ 이전 시간: [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의 핵심 기능 예제 코드를 직접 실행하고 수정해볼 수 있습니다.
+
+---
+
+### 🎯 6주차 학습 목표
+- **[Matplotlib](./glossary.md#matplotlib--seaborn)**과 **[Seaborn](./glossary.md#matplotlib--seaborn)**으로 데이터를 시각화하여 인사이트를 발견합니다.
+- **[Scikit-learn](./glossary.md#scikit-learn)을 사용하여 머신러닝의 기본 프로세스(학습, 예측, 평가)를 이해합니다.
+- 모델 성능을 높이기 위한 핵심 데이터 전처리 기법을 학습합니다.
+
+---
+
+## 1-2일차(월-화): 데이터 시각화 - 그림으로 데이터 보기
+
+데이터를 숫자로만 보는 것은 마치 숲을 보지 못하고 나무 하나하나만 보는 것과 같습니다. 시각화는 데이터 속에 숨겨진 패턴, 관계, 이상치를 한눈에 파악하게 해주는 강력한 도구입니다.
+
+- **[Matplotlib](./glossary.md#matplotlib--seaborn)**: 파이썬 시각화의 근간. 거의 모든 종류의 그래프를 그릴 수 있는 강력한 라이브러리. (비유: 하얀 도화지)
+- **[Seaborn](./glossary.md#matplotlib--seaborn)**: Matplotlib을 더 쉽고 예쁘게 사용할 수 있도록 만든 고수준 라이브러리. 통계적인 그래프 기능이 특화되어 있습니다. (비유: 밑그림과 색칠 도구가 갖춰진 스케치북)
+
+#### 💡 쉽게 이해하기: 어떤 그래프를 언제 쓸까?
+> - **선 그래프 (Line Plot)**: '시간'에 따른 주가 변화처럼, 연속적인 데이터의 '추세'를 볼 때
+> - **막대 그래프 (Bar Plot)**: 반별 평균 키처럼, 여러 '그룹' 간의 값을 '비교'할 때
+> - **산점도 (Scatter Plot)**: 공부 시간과 성적처럼, 두 변수 간의 '관계'나 '분포'를 볼 때
+> - **히스토그램 (Histogram)**: 우리 반 학생들의 키 분포처럼, 특정 데이터 구간에 얼마나 많은 값이 있는지 '분포'를 볼 때
+> - **히트맵 (Heatmap)**: 여러 변수들 간의 상관관계를 한눈에 '색상'으로 파악할 때
+
+```python
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+
+# Seaborn에 내장된 'tips' 데이터셋 사용
+tips = sns.load_dataset("tips")
+
+# 1. 산점도: 총 식사 금액과 팁 사이의 관계
+plt.figure(figsize=(8, 6)) # 그래프 크기 조절
+sns.scatterplot(x="total_bill", y="tip", data=tips, hue="smoker", size="size")
+plt.title("Total Bill vs Tip Amount")
+plt.xlabel("Total Bill ($)")
+plt.ylabel("Tip ($)")
+plt.grid(True)
+# plt.savefig("scatter_plot.png") # 그래프를 파일로 저장
+plt.show()
+
+
+# 2. 막대 그래프: 요일별 평균 팁
+plt.figure(figsize=(8, 6))
+sns.barplot(x="day", y="tip", data=tips, errorbar=None)
+plt.title("Average Tip by Day of the Week")
+plt.xlabel("Day")
+plt.ylabel("Average Tip ($)")
+plt.show()
+```
+
+---
+## 3-4일차(수-목): 첫 머신러닝 모델 만들기
+
+### 1. 머신러닝이란?
+- **[지도학습](./glossary.md#지도학습-supervised-learning)**: **입력(문제)**과 **정답**이 있는 데이터를 사용해, 문제와 정답 사이의 '패턴'을 기계에 학습시키는 방법.
+
+#### 💡 쉽게 이해하기: '훈련'과 '시험'
+> 머신러닝 모델 평가는 '공부'와 '시험' 과정과 같습니다.
+> - **[훈련 데이터](./glossary.md#훈련-데이터-vs-테스트-데이터) (교과서/모의고사)**: 모델이 학습하는 데 사용하는 데이터입니다.
+> - **[테스트 데이터](./glossary.md#훈련-데이터-vs-테스트-데이터) (수능)**: 모델의 최종 성능을 평가하기 위해, 학습 과정에서 **전혀 사용하지 않은** 새로운 데이터입니다.
+>
+> 훈련 데이터로만 반복해서 시험 보면 100점이 나오겠지만, 진짜 실력이라고 할 수 없겠죠? 그래서 우리는 훈련/테스트 데이터를 엄격히 분리하여 모델의 **일반화 성능**(처음 보는 데이터에 대한 예측 능력)을 측정합니다.
+
+### 2. Scikit-learn 기본 사용법
+[Scikit-learn](./glossary.md#scikit-learn)은 파이썬의 대표적인 머신러닝 라이브러리로, 다음과 같은 통일된 인터페이스를 제공합니다.
+
+1.  **모델 객체 생성**: `model = ModelName()`
+2.  **모델 학습**: `model.fit(X_train, y_train)` (훈련 데이터)
+3.  **예측**: `predictions = model.predict(X_test)` (테스트 데이터)
+4.  **평가**: `score = accuracy_score(y_test, predictions)`
+
+```python
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+import seaborn as sns
+import numpy as np
+
+# 데이터 로드 (붓꽃 데이터)
+iris = sns.load_dataset("iris")
+X, y = iris.drop("species", axis=1), iris["species"]
+
+# 1. 데이터 분리 (훈련 80%, 테스트 20%)
+# stratify=y : 훈련/테스트 데이터의 클래스 비율을 원본과 동일하게 유지
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
+
+# 2. 모델 생성 및 학습
+model = DecisionTreeClassifier(random_state=42)
+model.fit(X_train, y_train)
+
+# 3. 예측
+predictions = model.predict(X_test)
+print("예측값:", predictions)
+
+# 4. 평가 (정확도)
+accuracy = accuracy_score(y_test, predictions)
+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일차(금): 모델 성능 향상을 위한 데이터 전처리
+
+모델의 성능은 알고리즘만큼이나 **'데이터의 품질'**에 크게 좌우됩니다. "Garbage In, Garbage Out" (쓰레기를 넣으면 쓰레기가 나온다) 라는 말이 있을 정도입니다.
+
+- **결측치 처리**: 비어있는 값을 채우거나(평균, 중앙값 등) 해당 행/열을 제거합니다.
+- **[피처 스케일링](./glossary.md#피처-스케일링feature-scaling)**: 변수들의 단위를 맞춰줍니다. (예: 키(cm)와 몸무게(kg) -> 0~1 사이 값으로 표준화)
+    - **StandardScaler**: 평균 0, 표준편차 1로 변환.
+    - **MinMaxScaler**: 최솟값 0, 최댓값 1로 변환.
+
+```python
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+import numpy as np
+
+data = np.array([[170, 70], [180, 85], [160, 55]], dtype=float)
+
+# StandardScaler
+scaler_std = StandardScaler()
+scaled_std = scaler_std.fit_transform(data)
+print("StandardScaler 결과:\n", scaled_std)
+
+# MinMaxScaler
+scaler_minmax = MinMaxScaler()
+scaled_minmax = scaler_minmax.fit_transform(data)
+print("\nMinMaxScaler 결과:\n", scaled_minmax)
+```
+
+### 📚 6주차 마무리 및 다음 단계
+이번 주 우리는 데이터를 시각적으로 탐색하고, Scikit-learn을 사용해 머신러닝의 전 과정을 직접 체험했습니다. 이제 여러분은 데이터를 분석하고 예측 모델을 만들 수 있는 기본적인 역량을 갖추었습니다.
+
+다음 시간에는 드디어 **딥러닝**의 세계로 들어갑니다. **PyTorch**를 사용하여 인공 신경망을 직접 만들고, 컴퓨터 비전과 자연어 처리의 기초를 맛보는 흥미로운 여정이 시작됩니다.
+
+**➡️ 다음 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**

ai lecture/part_6_model_serving_with_fastapi.md

-# Part 6: AI 모델 서비스화 기초 (FastAPI)
-
----
-
-### 💡 지난 시간 복습
-
-[Part 5: AI 개발 핵심 라이브러리](part_5_ai_core_libraries.md)에서는 NumPy, Pandas, Scikit-learn 등을 사용하여 데이터를 처리하고, 붓꽃 품종 예측 모델을 학습시킨 후 `iris_model.pkl` 파일로 저장했습니다. 이제 우리는 예측 모델이라는 결과물을 손에 쥐게 되었습니다.
-
----
-
-학습된 AI 모델은 그 자체로는 가치를 창출하기 어렵습니다. API(Application Programming Interface)를 통해 다른 서비스와 연동되고, 실제 사용자의 요청을 처리할 수 있을 때 비로소 가치를 갖게 됩니다. 이 섹션에서는 **Part 5에서 학습하고 저장한 Scikit-learn 모델(`iris_model.pkl`)**을 빠르고 안정적인 API로 만드는 방법을 소개합니다.
-
-이를 위해 **FastAPI**라는 현대적인 고성능 웹 프레임워크를 사용합니다. FastAPI는 Python 3.7+의 타입 힌트(Type Hint)에 기반하여, 코드 작성과 동시에 데이터 유효성 검사, 자동 API 문서 생성을 지원하여 개발 생산성을 획기적으로 높여줍니다.
-
----
-
-## 1. 왜 FastAPI를 사용하는가?
-
-- **고성능**: 비동기(Asynchronous) 웹 요청을 지원하는 `ASGI`(Asynchronous Server Gateway Interface) 기반으로 만들어져, Node.js나 Go에 버금가는 매우 빠른 성능을 보여줍니다.
-- **빠른 개발 속도**: 타입 힌트를 기반으로 코드를 작성하면, FastAPI가 입력 데이터의 유효성을 자동으로 검사해주므로 개발자가 직접 검증 코드를 작성하는 수고를 덜어줍니다.
-- **자동 대화형 문서**: 코드만 작성하면 OpenAPI(Swagger UI)와 ReDoc 형태의 대화형 API 문서를 자동으로 생성해줍니다. 이를 통해 프론트엔드 개발자나 API 사용자가 별도의 문서 없이도 API를 쉽게 테스트하고 이해할 수 있습니다.
-- **간편함과 표준 준수**: 배우기 쉽고 사용하기 간편하며, OpenAPI, JSON Schema 등 웹 표준을 철저히 준수합니다.
-
----
-
-## 2. API 서버 구축 단계별 예제
-
-> **사전 준비**: 아래 명령어를 터미널에 입력하여 필요한 라이브러리들을 설치해야 합니다. `uvicorn`은 FastAPI 애플리케이션을 실행시켜주는 경량 ASGI 서버입니다.  
-> **`Part 5`에서 생성된 `iris_model.pkl` 파일이 지금 만들 `main.py` 파일과 같은 디렉토리에 있어야 합니다.**
-
-```bash
-pip install fastapi "uvicorn[standard]" scikit-learn joblib numpy
-```
-
-### 2.1. 기본 FastAPI 앱 만들기 (`main.py`)
-
-아래 코드를 `main.py` 라는 이름의 파일로 저장하세요.
-
-```python
-# main.py
-from fastapi import FastAPI, HTTPException, Request
-from pydantic import BaseModel
-from typing import List
-import joblib
-import numpy as np
-from contextlib import asynccontextmanager
-
-# -------------------------------------------------------------------
-# 1. 모델 로딩 및 리소스 관리를 위한 Lifespan 이벤트 핸들러 정의
-# -------------------------------------------------------------------
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # 애플리케이션 시작 시 실행될 코드
-    print("--- 서버 시작: 모델을 로드합니다. ---")
-    try:
-        # 모델을 로드하여 app.state에 저장
-        app.state.model = joblib.load("iris_model.pkl")
-        # 모델이 예측할 클래스(품종)의 실제 이름 정보도 함께 저장
-        app.state.iris_target_names = {0: 'setosa', 1: 'versicolor', 2: 'virginica'}
-        print("--- 모델 로드 성공 ---")
-    except FileNotFoundError:
-        print("!!! 모델 파일(iris_model.pkl)을 찾을 수 없습니다. !!!")
-        app.state.model = None
-    
-    yield # 여기에서 애플리케이션이 실행됨
-
-    # 애플리케이션 종료 시 실행될 코드
-    print("--- 서버 종료: 리소스를 정리합니다. ---")
-    # 필요한 경우 리소스 정리 로직 추가 (예: DB 연결 해제 등)
-    app.state.clear()
-
-
-# 2. FastAPI 애플리케이션 인스턴스 생성 및 Lifespan 연결
-app = FastAPI(
-    title="붓꽃 품종 예측 API", 
-    description="Scikit-learn 모델을 이용한 붓꽃 품종 예측 API입니다.",
-    lifespan=lifespan
-)
-
-# 3. 입력 데이터의 형식을 Pydantic 모델로 정의
-class IrisFeatures(BaseModel):
-    features: List[float]
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "features": [5.1, 3.5, 1.4, 0.2] # setosa 품종의 실제 데이터
-            }
-        }
-
-# 4. API 엔드포인트(Endpoint) 정의
-@app.get("/")
-def read_root():
-    """API의 루트 경로로, 간단한 환영 메시지를 반환합니다."""
-    return {"message": "붓꽃 품종 예측 API에 오신 것을 환영합니다!"}
-
-@app.post("/predict")
-def predict_iris(request: Request, data: IrisFeatures):
-    """
-    붓꽃의 특징(features) 4개를 입력받아 품종을 예측하고 결과를 반환합니다.
-    - **data**: `IrisFeatures` Pydantic 모델 형식의 요청 Body
-    """
-    # Lifespan에서 로드한 모델 객체를 가져옴
-    model = request.app.state.model
-    iris_target_names = request.app.state.iris_target_names
-
-    if model is None:
-        raise HTTPException(status_code=503, detail="모델이 로드되지 않았습니다. 서버 로그를 확인하세요.")
-        
-    if len(data.features) != 4:
-        raise HTTPException(status_code=400, detail="입력 피처는 4개여야 합니다. (sepal length, sepal width, petal length, petal width)")
-    
-    try:
-        model_input = np.array(data.features).reshape(1, -1)
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"입력 데이터 변환 중 오류 발생: {e}")
-
-    prediction_idx = model.predict(model_input)[0]
-    prediction_proba = model.predict_proba(model_input)[0]
-
-    class_name = iris_target_names.get(int(prediction_idx), "Unknown")
-    confidence = prediction_proba[int(prediction_idx)]
-
-    return {
-        "input_features": data.features,
-        "predicted_class_id": int(prediction_idx),
-        "predicted_class_name": class_name,
-        "confidence": float(confidence)
-    }
-```
-
-### 2.2. API 서버 실행 및 테스트
-
-1.  **서버 실행**:
-    터미널을 열고 `main.py` 파일이 있는 디렉토리에서 아래 명령어를 실행합니다.
-
-    ```bash
-    uvicorn main:app --reload
-    ```
-    - `main`: `main.py` 파일을 의미합니다.
-    - `app`: `main.py` 파일 안에서 `app = FastAPI()`로 생성한 FastAPI 인스턴스 객체를 의미합니다.
-    - `--reload`: 코드가 변경될 때마다 서버를 자동으로 재시작해주는 개발용 옵션입니다.
-
-2.  **자동 생성된 API 문서 확인**:
-    서버가 성공적으로 실행되면 (`Application startup complete.`), 웹 브라우저를 열고 다음 두 주소 중 하나로 접속합니다.
-
-    - **Swagger UI**: http://127.0.0.1:8000/docs
-    - **ReDoc**: http://127.0.0.1:8000/redoc
-
-    <p align="center">
-      <img src="https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png" alt="FastAPI Swagger UI" width="700"/>
-    </p>
-
-3.  **API 테스트**:
-    - Swagger UI 화면에서 `/predict` 엔드포인트를 클릭하여 펼칩니다.
-    - 오른쪽 위에 있는 `Try it out` 버튼을 클릭합니다.
-    - `Request body`에 예시로 있는 JSON 데이터를 그대로 두거나 다른 값으로 수정합니다.
-      ```json
-      {
-        "features": [6.7, 3.0, 5.2, 2.3] // virginica 품종의 데이터
-      }
-      ```
-    - `Execute` 버튼을 누르면 API 서버로 요청이 전송되고, 그 아래 `Response body`에서 예측 결과를 확인할 수 있습니다.
-
----
-
-### ✅ 정리 및 다음 단계
-
-이번 파트에서는 **FastAPI**를 사용하여, Part 5에서 만든 `iris_model.pkl` 머신러닝 모델을 **실시간으로 예측 결과를 제공하는 API 서버**로 만드는 과정을 실습했습니다.
-
-- **FastAPI**: 높은 성능과 빠른 개발 속도, 자동 문서 생성 기능을 갖춘 현대적인 웹 프레임워크
-- **`lifespan`**: 서버 시작/종료 시 모델 로딩과 같은 초기화/정리 작업을 수행
-- **Pydantic**: API의 입출력 데이터 형식을 명확하게 정의하고 자동으로 유효성 검사
-- **Uvicorn**: FastAPI 애플리케이션을 실행하는 ASGI 서버
-
-이제 여러분은 학습된 모델을 실제 서비스로 만들 수 있는 첫걸음을 떼었습니다. 하지만 현재의 코드는 모든 로직이 `main.py` 단일 파일에 집중되어 있어, 기능이 복잡해질수록 유지보수가 어려워지는 한계가 있습니다.
-
-**➡️ 다음 시간: [Part 7: 실전형 AI API 서버 구축](part_7_production_ready_api.md)**
-
-다음 시간에는 단일 파일 구조를 벗어나, 실제 프로덕션 환경에서도 통용되는 **체계적인 프로젝트 구조**로 API 서버를 리팩토링합니다. **라우터 분리, 데이터베이스 연동, 설정 관리** 등 더 견고하고 확장 가능한 서버를 만드는 방법을 배우게 될 것입니다. 
\ No newline at end of file

ai lecture/part_7_deep_learning.md

+# Part 7: 딥러닝 기초와 PyTorch (7주차)
+
+**⬅️ 이전 시간: [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의 핵심 기능 예제 코드를 직접 실행하고 수정해볼 수 있습니다.
+
+---
+
+### 🎯 7주차 학습 목표
+- **[PyTorch](./glossary.md#pytorch)**를 사용하여 간단한 딥러닝 모델을 직접 구현하고 학습시켜 봅니다.
+- 인공 신경망의 기본 구성 요소(Linear Layer, Activation Function)를 이해합니다.
+- 딥러닝 학습 과정(Forward/Backward Propagation, Optimizer)의 원리를 파악합니다.
+
+---
+
+## 1-3일차(월-수): PyTorch로 구현하는 딥러닝 첫걸음
+
+드디어 딥러닝의 세계에 입문합니다. 우리는 **PyTorch**라는 강력한 딥러닝 프레임워크를 사용하여 인공 신경망을 직접 만들어보겠습니다.
+
+- **[PyTorch](./glossary.md#pytorch)**: 페이스북(메타)에서 개발한 딥러닝 프레임워크. 유연성과 직관적인 코드로 연구자와 개발자들에게 널리 사랑받고 있습니다.
+
+#### 💡 쉽게 이해하기: PyTorch는 '레고 블록', Scikit-learn은 '완성된 장난감'
+> - **Scikit-learn**: '트럭', '비행기'처럼 이미 완성된 모델을 가져와 사용하는 '완성품 장난감'과 같습니다. 사용하기 편리하고 대부분의 정형 데이터 문제에 효과적입니다.
+> - **PyTorch**: 다양한 모양의 '레고 블록'을 제공하여, 사용자가 원하는 어떤 복잡한 구조(신경망)라도 직접 조립할 수 있게 해줍니다. 이미지, 텍스트 등 비정형 데이터를 다루는 딥러닝에 필수적입니다.
+
+### 1. 딥러닝의 핵심, 텐서(Tensor)
+- **텐서**: PyTorch에서 데이터를 다루는 기본 단위. NumPy의 `ndarray`와 매우 유사하지만, GPU를 사용한 가속 연산이 가능하고 자동 미분(Autograd) 기능을 지원한다는 결정적인 차이가 있습니다.
+
+### 2. 인공 신경망(Artificial Neural Network) 모델 만들기
+PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래스를 정의합니다.
+
+```python
+import torch
+import torch.nn as nn
+
+# 모델 정의
+class SimpleNet(nn.Module):
+    def __init__(self):
+        super(SimpleNet, self).__init__()
+        # nn.Linear(input_features, output_features)
+        # 입력 특성 4개(붓꽃 데이터), 출력 클래스 3개(품종)
+        self.fc1 = nn.Linear(4, 50) # 첫 번째 완전 연결 계층
+        self.relu = nn.ReLU()       # 활성화 함수
+        self.fc2 = nn.Linear(50, 3) # 두 번째 완전 연결 계층
+
+    def forward(self, x):
+        # 순전파: 데이터가 입력층부터 출력층까지 나아가는 과정
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.fc2(x)
+        return x
+
+model = SimpleNet()
+print(model)
+```
+
+---
+## 4-5일차(목-금): 딥러닝 모델 학습시키기
+
+### 1. 손실 함수(Loss Function)와 옵티마이저(Optimizer)
+- **[손실 함수](./glossary.md#손실-함수loss-function)**: 모델의 예측이 실제 정답과 얼마나 다른지를 측정하는 '오차 측정기'. (예: `CrossEntropyLoss` - 분류 문제)
+- **[옵티마이저](./glossary.md#옵티마이저optimizer)**: 손실 함수가 계산한 오차를 기반으로, 모델의 파라미터(가중치)를 어느 방향으로 얼마나 업데이트할지 결정하는 '조율사'. (예: `Adam`, `SGD`)
+
+### 2. 학습 루프(Training Loop)
+딥러닝 모델 학습은 '에포크(Epoch)'라는 단위로 반복됩니다. 1 에포크는 전체 훈련 데이터를 한 번 모두 사용하는 것을 의미합니다.
+
+```python
+# (데이터 로드 및 전처리는 Scikit-learn 예제와 유사하게 진행되었다고 가정)
+# X_train, y_train을 PyTorch 텐서로 변환
+# X_train_tensor = torch.FloatTensor(X_train.values)
+# y_train_tensor = torch.LongTensor(pd.Categorical(y_train).codes)
+
+# criterion = nn.CrossEntropyLoss()
+# optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+
+# epochs = 100
+# for epoch in range(epochs):
+#     # 1. 순전파 (Forward pass)
+#     outputs = model(X_train_tensor)
+#     loss = criterion(outputs, y_train_tensor)
+
+#     # 2. 역전파 및 가중치 업데이트 (Backward and optimize)
+#     optimizer.zero_grad() # 이전 그래디언트 초기화
+#     loss.backward()       # 그래디언트 계산
+#     optimizer.step()        # 파라미터 업데이트
+
+#     if (epoch+1) % 10 == 0:
+#         print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
+```
+위 코드는 개념 설명을 위한 것으로, 실제 실행 가능한 전체 코드는 `source_code/part_7_deep_learning.py`에서 확인해주세요.
+
+### 📚 7주차 마무리 및 다음 단계
+이번 주 우리는 PyTorch를 사용하여 딥러닝의 기본 원리를 이해하고, 직접 신경망을 만들어 학습시키는 과정을 경험했습니다.
+
+다음 시간에는 지금까지 배운 머신러닝/딥러닝 지식을 바탕으로, 최근 가장 뜨거운 분야인 **거대 언어 모델(LLM)**과 **LangChain**을 활용하여 간단한 챗봇 애플리케이션을 만들어보는 시간을 갖습니다.
+
+**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)** 
\ No newline at end of file