1차 강의(데이터분석 및 MLOps) 모듈별 강의안 초안

산출물 개요

SKALA 3기 ‘데이터분석 및 MLOps’ 교과목(총 136시간)의 각 모듈별 강의안 초안

학습목표(ABCD) 기반 재구성

이론(40%) + 실습(50-60%) + 과제(10%) 비중 배분

슬라이드 개수 추정 및 세부 강의 계획

Module 1: 데이터 분석을 위한 Python 이해 (24시간)

학습 결과

학생은 Python 3.7+ 타입 힌트와 비동기 프로그래밍을 이용하여 AI-native 데이터분석 코드를 작성할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

Python 기초 및 AI Native 패러다임: 2h
타입 힌트(Type Hints) 체계: 2.5h
비동기 프로그래밍(async/await): 2.5h
Python 환경설정(venv/poetry/conda): 1.5h
Pydantic 데이터 검증: 1.1h

실습 (50% = 12시간)

실습 1: 가상환경 구축 및 패키지 관리: 2h (초급, 데이터셋 없음)
실습 2: 타입 힌트 적용한 데이터 처리 함수 작성: 3h (중급)
실습 3: async/await로 다중 파일 I/O 처리: 3h (중급)
실습 4: Pydantic으로 JSON 데이터 검증 API 구축: 4h (중급)

과제 (10% = 2.4시간)

과제 1: AI Native 환경에서 타입안전 데이터 처리 코드 작성: 2.4h (평가 기준: 타입 커버리지 90% 이상, 비동기 처리 로직 정확성)

세부 강의 계획

Objective 1-1: Python 타입 힌트(Type Hints) 이해 및 적용

강의 포인트:

정적 타입 vs 동적 타입의 장단점
Python 타입 힌트 발전사 (PEP 484, 526, 585, 604)
기본 타입·제네릭·유니온·프로토콜의 문법과 용도
IDE 자동완성·검증·리팩토링의 이점
FastAPI와의 통합

슬라이드 구성 (8장):

슬라이드 1: Python 타입 시스템 진화 (그래프: 타입 안전성 vs 유연성)
슬라이드 2-3: 기본 타입 문법 (int, str, List, Dict, Optional 등)
슬라이드 4-5: 제네릭·유니온·프로토콜 심화
슬라이드 6: IDE 지원 (PyCharm/VSCode 데모)
슬라이드 7: FastAPI 예제 (자동 문서화)
슬라이드 8: 실전 체크리스트

실습 (3시간):

난이도: 중급
시간: 180분
데이터: 샘플 CSV 파일 (users.csv, 1,000행)
단계별 진행:
1. CSV 읽기 함수에 타입 힌트 추가 (30분)
2. dataclass/TypedDict로 데이터 구조화 (45분)
3. 복잡한 타입(nested generic) 정의 (45분)
4. PyCharm에서 타입 검증 및 자동 완성 테스트 (60분)
예상 결과: 모든 함수에 def → return 까지 타입 명시, IDE 지원 활용

평가 기준 (루브릭):

기준	만점	설명
타입 커버리지	40	함수 파라미터 · 반환값 · 지역변수 모두 타입 명시 (90% 이상 = 40점)
정확성	30	타입 체커(mypy) 통과 시 30점 만점, 위반 시 10점 감점/건
가독성	20	Union 대신 `\|` 사용, Optional 올바른 적용 (코드 리뷰)
IDE 활용	10	자동 완성·리팩토링 활용 증거 (스크린샷 제출)

학생 오류 & 대응:

오류 1: List[int] vs list[int] 혼동 (Python 3.9+ 문법 차이)
- 대응: 버전 확인 후 표준 문법으로 통일
오류 2: Any 남용
- 대응: “Any를 쓰면 타입 힌트 의미 없음” 강조, 구체적 타입 권유

Objective 1-2: 비동기 프로그래밍(async/await) 이해

강의 포인트:

동기 vs 비동기 · I/O 바운드 작업 개념
asyncio 라이브러리 핵심 (Event Loop, Task, coroutine)
async/await 문법과 동시성 패턴
성능 비교 (동기 대비 2-3배 처리량 증가)

슬라이드 구성 (7장):

슬라이드 1: 동기/비동기 타임라인 (다이어그램)
슬라이드 2: asyncio 아키텍처 (Event Loop 개념도)
슬라이드 3: async/await 기본 문법
슬라이드 4-5: asyncio.gather, asyncio.create_task 패턴
슬라이드 6: 성능 벤치마크 (동기 vs 비동기 I/O)
슬라이드 7: 실전 팁 (디버깅, 예외 처리)

실습 (3시간):

난이도: 중급
시간: 180분
데이터: URL 리스트 (100개 웹사이트)
단계별 진행:
1. 동기 방식: for 루프로 100개 URL 다운로드 (30분, ~30초 소요)
2. 비동기 방식: asyncio.gather로 동시 다운로드 (45분, ~5초 소요)
3. asyncio.create_task로 개별 제어 (45분)
4. 에러 처리 & timeout 추가 (60분)
예상 결과: 동기 대비 최소 5배 이상 성능 개선 증명

평가 기준 (루브릭):

기준	만점	설명
async/await 문법 정확성	35	Task 생성 · gather 호출 · 에러 처리 모두 정상 동작
성능 개선	35	동기 대비 2배 이상 처리량 증가 (벤치마크 제출)
코드 읽기	20	일반적인 async 패턴 이해도 확인 (peer review)
문서화	10	코드 주석 · 성능 분석 보고

학생 오류 & 대응:

오류 1: await 빠뜨림 (Task 생성은 되었으나 대기 없음)
- 대응: “await 없으면 백그라운드에서 실행만 되고 결과 못 받음” 설명
오류 2: asyncio.run() 중복 호출 (Event Loop 충돌)
- 대응: Jupyter 환경에서는 nest-asyncio 필요함을 강조

Objective 1-3: Python 환경설정 자동화

강의 포인트:

venv·virtualenv·pipenv·poetry·conda 5가지 도구 비교
의존성 관리 (requirements.txt vs pyproject.toml)
환경 재현성(reproducibility) 원칙
CI/CD 환경에서의 환경설정

슬라이드 구성 (6장):

슬라이드 1: 5가지 도구 비교 표 (기능·성능·학습곡선)
슬라이드 2-3: venv + poetry (추천 조합) 상세
슬라이드 4: requirements.txt → pyproject.toml 마이그레이션
슬라이드 5: Docker와의 통합 (다음 모듈 미리보기)
슬라이드 6: 트러블슈팅 (버전 충돌, 플랫폼별 차이)

실습 (2시간):

난이도: 초급
시간: 120분
데이터: 없음 (순수 환경설정)
단계별 진행:
1. poetry init으로 프로젝트 생성 (20분)
2. pandas·numpy·scikit-learn 설치 (20분)
3. pyproject.toml 수정 (버전 고정) (20분)
4. 팀원 환경 재현 (poetry install) (20분)
5. Docker와 통합 (40분)
예상 결과: 팀원이 1회 명령으로 동일 환경 복제 가능

평가 기준 (루브릭):

기준	만점	설명
pyproject.toml 완성도	40	필수 의존성 · 개발용 의존성 · 버전 명시
환경 재현 성공	40	타 컴퓨터에서 poetry install 후 모든 import 성공
Dockerfile 통합	20	선택사항, 가산점

Objective 1-4: Pydantic을 이용한 데이터 검증

강의 포인트:

데이터 검증의 필요성 (API 입출력, DB 직렬화)
Pydantic BaseModel 기본
Field·Validator·root_validator 심화
FastAPI 자동 통합

슬라이드 구성 (7장):

슬라이드 1: 데이터 검증이 필요한 이유 (사례)
슬라이드 2-3: BaseModel 기본 문법
슬라이드 4-5: Field·Validator·Config 심화
슬라이드 6: FastAPI와의 통합 (자동 API 문서화)
슬라이드 7: 성능·확장성 고려사항

실습 (4시간):

난이도: 중급
시간: 240분
데이터: 사용자 등록 JSON 샘플 (100개 레코드)
단계별 진행:
1. User 모델 정의 (id, name, email, age) (40분)
2. 필드별 검증 규칙 추가 (Field 사용) (60분)
3. 커스텀 Validator 작성 (이메일, 전화번호) (60분)
4. FastAPI 엔드포인트 작성 및 테스트 (80분)
예상 결과: 유효하지 않은 JSON 입력 자동 거절, Swagger 문서 자동 생성

평가 기준 (루브릭):

기준	만점	설명
모델 정의	30	필수·선택 필드 · 타입 · 기본값 정확
검증 규칙	35	Field 제약 · Validator 로직 정확
FastAPI 통합	25	엔드포인트 동작 · Swagger 문서 완성도
문서화	10	모델·검증 규칙 설명 주석

참고 자료

유의사항

선행 학습 필수: Phase 1 프로그래밍 기초 (Git, IDE 환경설정, Python 문법 기초)
일반적 오류 및 대응책:
- 타입 힌트를 “선택사항”으로 생각하는 학생 → “ML 팀 코드는 타입 힌트 필수”로 강조
- async/await와 threading 혼동 → 명확한 구분 (GIL, CPU vs I/O bound)
- 환경 오염(다른 버전 패키지 남음) → poetry.lock 파일의 중요성 강조
다음 모듈과의 연계:
- Module 2: 여기서 배운 타입 힌트·pandas 기초를 EDA 실습에 적용
- Module 4: FastAPI는 Module 4에서 심화, 여기서는 기초만

강의 슬라이드 추정

총 슬라이드 수: 약 28장 (1시간당 ~1.2장)
- 1-1: 8장
- 1-2: 7장
- 1-3: 6장
- 1-4: 7장

Next Action

Module 2 강의안 초안 작성 진행
각 모듈별 대표 실습 자료 (코드 템플릿, 데이터셋) 준비

Module 2: 데이터 분석 개요 및 기초통계 (24시간)

학습 결과

학생은 pandas·matplotlib·seaborn을 이용하여 실제 데이터셋(11,000+ 행)에 대해 EDA를 독립적으로 수행할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

EDA 개요 및 8단계 프로세스: 2h
pandas 기초 (선택·필터링·그룹화): 2.5h
기초 통계 및 분포 (평균·분산·이상치): 2.5h
데이터 시각화 3계층 설계: 1.5h
데이터 품질 관리(결측치·중복·이상치): 1.1h

실습 (50% = 12시간)

실습 1: pandas로 11,000행 데이터셋 탐색: 3h (초급~중급)
실습 2: 이상치 탐지(IQR 기법) 및 처리: 2.5h (중급)
실습 3: 시각화 3계층(단변량→이변량→다변량): 3.5h (중급)
실습 4: 통계 가설 검정(t-test, chi-square): 3h (중급)

과제 (10% = 2.4시간)

과제 1: 신규 데이터셋에 대한 EDA 리포트(8단계 완료): 2.4h

세부 강의 계획

Objective 2-1: EDA(Exploratory Data Analysis) 프로세스 이해 및 실행

강의 포인트:

EDA의 목적 (데이터 이해 → 가설 → 모델 설계)
8단계 표준 프로세스 (데이터 로드→타입 확인→결측치→통계→분포→상관성→시각화→가설)
각 단계별 도구 (pandas, numpy, scipy, matplotlib)
EDA 리포트 작성법

슬라이드 구성 (8장):

슬라이드 1: EDA의 역할 (ELT 파이프라인에서의 위치)
슬라이드 2: 8단계 프로세스 플로우차트
슬라이드 3-4: 단계 1-4 (데이터 로드 ~ 통계 요약)
슬라이드 5-6: 단계 5-7 (분포 · 상관성 · 시각화)
슬라이드 7: 가설 도출 및 문서화
슬라이드 8: 체크리스트

실습 (3시간):

난이도: 초급~중급
시간: 180분
데이터: Titanic 데이터셋 (891행, 11 컬럼) 또는 주택 가격 데이터(11,000+ 행)
단계별 진행:
1. 데이터 로드 및 기본 정보 확인 (.shape, .info(), .describe()) (30분)
2. 결측치 패턴 분석 (30분)
3. 수치형·범주형 컬럼별 기초 통계 (30분)
4. 분포 시각화 (히스토그램, 박스플롯) (30분)
5. 상관성 분석 (30분)
예상 결과: 모든 8단계 체크리스트 완료, 가설 3개 이상 도출

평가 기준 (루브릭):

기준	만점	설명
프로세스 완성도	50	8단계 모두 실행, 누락 시 10점 감점/단계
코드 품질	30	pandas 명령어 활용 능숙도, 주석 완성도
가설 도출	20	데이터 기반 합리적 가설 3개 이상

Objective 2-2: 데이터 품질 문제 탐지 및 처리(결측치·중복·이상치)

강의 포인트:

결측치(Missing Values) 원인 · 탐지 · 처리 전략
중복 레코드 탐지 및 제거
이상치(Outlier) 탐지 방법 (IQR, Z-score, Isolation Forest)
처리 방식 선택 (제거 vs 대체 vs 변환)

슬라이드 구성 (7장):

슬라이드 1: 데이터 품질 문제의 영향 (모델 성능 사례)
슬라이드 2-3: 결측치 분석 및 처리 (MCAR, MAR, MNAR)
슬라이드 4: 중복 탐지 및 제거
슬라이드 5-6: 이상치 탐지 (IQR, Z-score 공식)
슬라이드 7: 의사결정 플로우(처리 방식 선택)

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: 결측치·이상치 포함 실제 데이터셋(2,000행)
단계별 진행:
1. 결측치 패턴 시각화 (30분)
2. 결측치 처리: 삭제 vs KNN 대체 비교 (40분)
3. 이상치 탐지: IQR 기법 적용 (40분)
4. 이상치 처리 전후 모델 성능 비교 (40분)
예상 결과: 90% 정확도로 이상치 식별, 처리 전후 통계 비교표

평가 기준 (루브릭):

기준	만점	설명
탐지 정확도	40	이상치 90% 이상 탐지 (IQR 또는 Z-score)
처리 논리	35	결측치 · 중복 처리 방식 정당화 (보고서)
코드 효율성	15	pandas 벡터화 활용, 반복문 최소화
문서화	10	처리 과정 설명, 통계 변화 기록

학생 오류 & 대응:

오류 1: 이상치를 무조건 제거 → “도메인 지식과 비즈니스 문맥 고려 필수” 강조
오류 2: 결측치 평균값 대체 후 통계 왜곡 → 대체 전후 비교 분석 필수

Objective 2-3: 데이터 시각화 3계층 설계

강의 포인트:

시각화의 목적 (탐색 vs 설득)
3계층 설계: 단변량(분포) → 이변량(관계) → 다변량(패턴)
차트 선택 기준 (데이터 타입 × 목적)
matplotlib vs seaborn 사용 분기

슬라이드 구성 (8장):

슬라이드 1: 시각화 디자인 원칙 (Tufte, few/many)
슬라이드 2-3: 단변량 시각화 (히스토그램, 박스플롯, 바이올린)
슬라이드 4-5: 이변량 시각화 (산점도, 히트맵, 조건부 분포)
슬라이드 6: 다변량 시각화 (면분할, 크기/색상 인코딩)
슬라이드 7: 차트 선택 의사결정 트리
슬라이드 8: 포트폴리오 사례

실습 (3.5시간):

난이도: 중급
시간: 210분
데이터: 주택 가격 데이터(11,000+ 행, 80개 컬럼)
단계별 진행:
1. 단변량: 5개 핵심 컬럼 분포 시각화 (45분)
2. 이변량: 가격과 주요 특성(면적, 방수, 위치) 관계 분석 (60분)
3. 다변량: 3-4개 컬럼 동시 표현 (면분할, 크기/색상) (60분)
4. Seaborn 스타일 개선 및 저장 (45분)
예상 결과: 12장 이상의 고품질 시각화, 각 차트에 인사이트 주석

평가 기준 (루브릭):

기준	만점	설명
차트 다양성	30	3계층 모두 표현, 최소 8종류 차트
시각화 품질	30	레이아웃 · 색상 · 폰트 · 범례 완성도
인사이트 도출	25	각 차트에서 의미 있는 발견 1개 이상
문서화	15	차트 제목 · 축 레이블 · 출처 명시

참고 자료

유의사항

선행 학습 필수: Module 1 Python 기초 · 타입 힌트
일반적 오류 및 대응책:
- pandas 불명확한 사용 (copy vs view) → .copy() 명시 권유
- 시각화 과다 (차트 100개 생성) → “이상치 3개가 인사이트 100개보다 낫다” 철학 강조
- 결측치 무시 → 명시적 처리 기록 필수
다음 모듈과의 연계:
- Module 3: 전처리된 데이터로 모델링 시작
- Module 5: EDA 기술을 Feature Engineering에 적용

강의 슬라이드 추정

총 슬라이드 수: 약 23장 (1시간당 ~0.96장)
- 2-1: 8장
- 2-2: 7장
- 2-3: 8장

Next Action

실습 데이터셋 확정 (Kaggle vs 정부 공개 데이터)
Module 3 강의안 초안 작성 진행

Module 3: 머신러닝 및 딥러닝 이해 (24시간)

학습 결과

학생은 Decision Tree·Ensemble·신경망의 동작 원리를 이해하고 scikit-learn·TensorFlow로 구현할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

머신러닝 기초 (지도학습 vs 비지도학습): 1.5h
Decision Tree 및 분할 기준(Gini, Entropy): 2h
Ensemble 방법 (Random Forest, Gradient Boosting, XGBoost): 2.5h
신경망 기초 (Forward Pass, Backpropagation): 2h
깊은 신경망 (활성화함수, 정규화): 1.6h

실습 (60% = 14.4시간)

실습 1: Decision Tree 시각화 및 과적합 분석: 2.5h (중급)
실습 2: Random Forest vs Gradient Boosting 비교: 3h (중급)
실습 3: 신경망 구현(NumPy or TensorFlow): 4.5h (고급)
실습 4: 모듈 2 데이터로 모델 학습 및 평가: 4.4h (중급)

과제 (10% = 2.4시간)

과제 1: 5-fold 교차검증 AUC ≥ 0.85 달성: 2.4h

세부 강의 계획

Objective 3-1: Decision Tree의 분할 기준 이해

강의 포인트:

Decision Tree의 개념 및 구조
Gini Index vs Entropy 수식 및 계산
정보 이득(Information Gain) 개념
과적합 및 제어(max_depth, min_samples_split)

슬라이드 구성 (8장):

슬라이드 1: Decision Tree 개요 (트리 구조 시각화)
슬라이드 2-3: Gini Index 공식 · 예시 계산
슬라이드 4-5: Entropy · Information Gain 공식
슬라이드 6: 과적합 사례 및 제어 방법
슬라이드 7: scikit-learn 실전 예제
슬라이드 8: 해석성 (Feature Importance)

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: 분류 데이터셋(Iris 또는 의료 진단 데이터, 500행)
단계별 진행:
1. Decision Tree 구축 (기본 파라미터) (30분)
2. 트리 시각화 (graphviz 사용) (30분)
3. Gini vs Entropy 비교 (결과 차이) (30분)
4. 과적합 분석: max_depth 변화에 따른 성능 (60분)
예상 결과: 손으로 트리 분할 과정을 설명 가능, 과적합/과소적합 개념 이해

평가 기준 (루브릭):

기준	만점	설명
Gini/Entropy 이해	35	공식 유도 · 계산 정확도
트리 시각화	30	graphviz 출력 가능, 각 노드 기준 이해
과적합 분석	25	max_depth별 정확도 곡선 그래프 제출
코드 품질	10	pandas · scikit-learn 활용 능숙도

학생 오류 & 대응:

오류 1: Gini와 Entropy 선택의 차이 모름 → “대부분 비슷한 결과, Gini가 계산 빠름” 강조
오류 2: 깊은 트리(깊이 제한 없음)로 100% 정확도 달성 → 테스트셋에서 성능 확인 강조

Objective 3-2: Ensemble 방법 비교(Random Forest vs Gradient Boosting)

강의 포인트:

Bagging vs Boosting 개념
Random Forest (병렬, 분산 감소)
Gradient Boosting & XGBoost (순차, 편향 감소)
성능·과적합·해석성 관점 비교
하이퍼파라미터 선택 기준

슬라이드 구성 (9장):

슬라이드 1-2: Ensemble의 필요성 (약한 학습기 → 강한 학습기)
슬라이드 3: Bagging 개념 (부트스트랩)
슬라이드 4: Random Forest 알고리즘
슬라이드 5: Boosting 개념 (에러 누적)
슬라이드 6-7: Gradient Boosting · XGBoost 상세
슬라이드 8: 비교표 (성능·속도·해석성)
슬라이드 9: 선택 의사결정 플로우

실습 (3시간):

난이도: 중급
시간: 180분
데이터: Kaggle 분류 문제(5,000행, 20개 특성)
단계별 진행:
1. 같은 데이터에 Random Forest 학습 (40분)
2. Gradient Boosting 학습 (40분)
3. XGBoost 학습 (40분)
4. 3개 모델 비교: 정확도 · AUC · 학습 시간 · Feature Importance (60분)
예상 결과: 성능·해석성·속도 관점 비교 리포트 작성

평가 기준 (루브릭):

기준	만점	설명
모델 구현	30	3개 모델 모두 정상 학습
성능 분석	35	정확도 · AUC · 학습 시간 비교표 + 해석
선택 정당화	25	”이 데이터에는 X 모델이 최적”인 이유 기술
코드 정리	10	3개 모델 코드 DRY 원칙 준수

학생 오류 & 대응:

오류 1: “XGBoost가 항상 최고 성능” 가정 → “데이터 크기, 시간 제약 등 고려 필수”
오류 2: 기본 하이퍼파라미터로 비교 → GridSearchCV 동일 조건 강조

Objective 3-3: 신경망의 Forward Pass & Backpropagation

강의 포인트:

신경망 구조 (층, 뉴런, 가중치, 편향)
Forward Pass 수식 (선형변환 + 활성화함수)
Chain Rule 기반 Backpropagation 유도
가중치 업데이트 (경사 하강법)
실전 활성화함수 (ReLU, Sigmoid, Softmax)

슬라이드 구성 (10장):

슬라이드 1: 신경망 개요 (뉴런 모델)
슬라이드 2-3: 2-4-2 신경망 구조 및 Forward Pass 수식
슬라이드 4-5: Chain Rule (다변함수 미분)
슬라이드 6-7: Backpropagation 수식 유도 (L1, L2 노드)
슬라이드 8: 활성화함수 미분 (ReLU, Sigmoid, Softmax)
슬라이드 9: 경사 하강법 시각화
슬라이드 10: 수치 검증 (Gradient Checking)

실습 (4.5시간):

난이도: 고급
시간: 270분
데이터: MNIST 또는 간단한 분류 데이터(3,000행, 10 특성)
단계별 진행:
1. NumPy로 신경망 Forward Pass 구현 (60분)
2. Backpropagation 구현 (90분)
3. 경사 하강법 최적화 (60분)
4. TensorFlow/PyTorch로 검증 (60분)
예상 결과: NumPy 구현이 TensorFlow와 같은 결과 도출, Gradient Checking 통과

평가 기준 (루브릭):

기준	만점	설명
Forward Pass 정확성	25	행렬 계산 오류 없음, 모양 일치
Backpropagation 유도	40	수식 유도 논리 정확, Chain Rule 적용 정확
코드 구현	25	NumPy로 구현 가능, 효율성 고려
검증	10	Gradient Checking 또는 TensorFlow 검증

학생 오류 & 대응:

오류 1: Backpropagation = 모델이 역방향으로 실행 → “단지 그래디언트 계산 방법”임을 명확히
오류 2: Chain Rule 적용 실수 (미분 순서 혼동) → 체인 규칙 예시 반복

Objective 3-4: scikit-learn/TensorFlow로 분류 모델 학습

강의 포인트:

scikit-learn MLPClassifier 기본 사용법
TensorFlow/Keras Sequential API
모델 구축 → 컴파일 → 훈련 → 평가 파이프라인
하이퍼파라미터 선택 (은닉층 크기, 학습률, 에포크)
조기 종료(Early Stopping) 및 검증

슬라이드 구성 (7장):

슬라이드 1: scikit-learn vs TensorFlow 선택 기준
슬라이드 2: MLPClassifier 사용법
슬라이드 3-4: Keras Sequential API (모델 구축)
슬라이드 5: 손실함수 · 최적화기 · 평가 지표 선택
슬라이드 6: 조기 종료 및 정규화(Dropout, L2)
슬라이드 7: 5-fold 교차검증

실습 (4.4시간):

난이도: 중급
시간: 264분
데이터: Module 2에서 전처리한 데이터
단계별 진행:
1. scikit-learn MLPClassifier로 학습 (60분)
2. TensorFlow Sequential 모델 구축 (60분)
3. 하이퍼파라미터 튜닝 (GridSearchCV) (80분)
4. 5-fold 교차검증 및 AUC 측정 (64분)
예상 결과: AUC ≥ 0.85 달성, 훈련 곡선 제시(과적합 분석)

평가 기준 (루브릭):

기준	만점	설명
모델 성능	40	5-fold 교차검증 AUC ≥ 0.85
코드 완성도	30	scikit-learn + TensorFlow 모두 구현, 전처리 포함
하이퍼파라미터	20	최적화 과정 및 선택 이유 기술
문서화	10	모델 구조 · 성능 지표 설명

참고 자료

유의사항

선행 학습 필수: Module 1-2 (Python, pandas, 기초통계)
일반적 오류 및 대응책:
- Ensemble 모델도 과적합 가능 → 검증셋으로 성능 확인 강조
- 신경망 초기화 영향 → 동일 데이터에서 여러 번 학습해 분산 확인
- 깊은 신경망(100+층)에서 그래디언트 소실 → Batch Normalization 미리보기
다음 모듈과의 연계:
- Module 4: 여기서 학습한 모델을 FastAPI로 서빙
- Module 5: 하이퍼파라미터 최적화 심화 · Feature Engineering

강의 슬라이드 추정

총 슬라이드 수: 약 42장 (1시간당 1.75장)
- 3-1: 8장
- 3-2: 9장
- 3-3: 10장
- 3-4: 7장 + 알고리즘 복잡도 비교 1장

Next Action

Module 4, 5, 6 강의안 초안 작성
실습용 데이터셋 및 Jupyter 노트북 템플릿 준비

Module 4: 모델 서빙을 위한 Python 심화, FastAPI (16시간)

학습 결과

학생은 FastAPI + Docker를 이용하여 머신러닝 모델을 REST API로 배포할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 6.4시간)

FastAPI 프레임워크 기초: 1.5h
RESTful API 설계 원칙: 1h
Pydantic 입출력 검증(복습 + 심화): 1h
Docker 컨테이너화 개념: 1h
배포 환경 및 성능 최적화: 0.9h

실습 (60% = 9.6시간)

실습 1: FastAPI 기본(GET, POST 엔드포인트): 2h (중급)
실습 2: 머신러닝 모델 감싸기(Module 3 모델 활용): 2.5h (중급)
실습 3: Dockerfile 작성 및 이미지 빌드: 2.5h (중급)
실습 4: Docker 컨테이너 실행 및 테스트: 2.6h (중급)

과제 (10% = 1.6시간)

과제 1: 모델 + API + Docker 통합 서빙: 1.6h

세부 강의 계획

Objective 4-1: FastAPI 프레임워크 및 엔드포인트 구현

강의 포인트:

FastAPI의 장점 (빠른 성능, 자동 문서화, 타입 검증)
기본 구조 (app 생성, 라우트 정의)
GET/POST/PUT/DELETE 엔드포인트
경로 파라미터 · 쿼리 파라미터 · 요청 본문
자동 문서화 (Swagger, ReDoc)

슬라이드 구성 (8장):

슬라이드 1: FastAPI 소개 (Flask/Django와 비교)
슬라이드 2-3: 기본 구조 (app, @app.get, @app.post)
슬라이드 4: 경로/쿼리/본문 파라미터
슬라이드 5-6: Pydantic 모델 활용 (입력 검증, 응답 스키마)
슬라이드 7: 자동 API 문서화 (Swagger)
슬라이드 8: 상태 코드 · 예외 처리

실습 (2시간):

난이도: 중급
시간: 120분
데이터: 없음 (순수 API 구현)
단계별 진행:
1. FastAPI 앱 초기화 (10분)
2. GET 엔드포인트 3개 (사용자 조회, 목록, 상세) (30분)
3. POST 엔드포인트 (데이터 생성 + Pydantic 검증) (40분)
4. Swagger 문서 확인 및 curl/Postman으로 테스트 (40분)
예상 결과: 5개 이상 엔드포인트 구현, Swagger에서 자동 테스트 가능

평가 기준 (루브릭):

기준	만점	설명
엔드포인트 구현	35	GET/POST/DELETE 포함, 모든 엔드포인트 정상 동작
Pydantic 검증	30	요청 데이터 타입·필드 검증, 오류 응답 명확
문서화	20	Swagger UI에서 모든 엔드포인트 설명 표시
코드 구조	15	라우터 분리(router.py), 모델 분리

Objective 4-2: Docker 이미지 작성 및 레이어 최적화

강의 포인트:

Dockerfile 기본 문법 (FROM, RUN, COPY, CMD)
레이어 캐싱의 중요성
다단계 빌드(Multi-stage build)로 이미지 크기 최소화
의존성 관리 (requirements.txt vs poetry)
빌드 컨텍스트 최적화

슬라이드 구성 (7장):

슬라이드 1: Docker 개념 (컨테이너 vs 가상머신)
슬라이드 2-3: Dockerfile 명령어 상세 (FROM, RUN, COPY 등)
슬라이드 4: 레이어 캐싱 원칙 (명령어 순서 최적화)
슬라이드 5-6: 다단계 빌드 (개발 vs 프로덕션)
슬라이드 7: .dockerignore 및 빌드 성능 측정

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: Module 4 실습 1의 FastAPI 앱
단계별 진행:
1. 기본 Dockerfile 작성 (40분)
2. 빌드 및 성능 측정 (빌드 시간, 이미지 크기) (30분)
3. 레이어 캐싱 최적화 (의존성 먼저 설치) (40분)
4. 다단계 빌드로 재작성 (크기 감소) (40분)
예상 결과: 빌드 시간 < 30초(캐시 히트 시), 이미지 크기 < 200MB

평가 기준 (루브릭):

기준	만점	설명
Dockerfile 정확성	35	문법 오류 없음, 앱 정상 실행
캐싱 최적화	35	코드 변경 시 빌드 시간 < 30초 달성
이미지 크기	20	다단계 빌드 또는 alpine 베이스로 < 300MB
문서화	10	Dockerfile 주석, 빌드 지침 명시

학생 오류 & 대응:

오류 1: RUN pip install 매 명령마다 (레이어 증가) → RUN 명령 통합 강조
오류 2: COPY . . (모든 파일 복사, 캐시 무효화) → .dockerignore 활용

Objective 4-3: 컨테이너 배포 및 헬스체크

강의 포인트:

docker run / docker ps / docker logs 기본 명령
포트 바인딩 및 환경변수 전달
헬스체크 엔드포인트 구현
자동 재시작 정책
로깅 및 모니터링

슬라이드 구성 (6장):

슬라이드 1: Docker CLI 기본 (run, ps, logs, stop)
슬라이드 2: 포트 바인딩 및 네트워킹
슬라이드 3-4: 헬스체크 (HEALTHCHECK, /health 엔드포인트)
슬라이드 5: 자동 재시작 정책 (—restart)
슬라이드 6: 로그 수집 및 모니터링

실습 (2.6시간):

난이도: 중급
시간: 156분
데이터: Module 4 실습 3의 Docker 이미지
단계별 진행:
1. FastAPI에 /health 엔드포인트 추가 (30분)
2. Dockerfile에 HEALTHCHECK 추가 (30분)
3. docker run으로 컨테이너 실행 및 포트 확인 (40분)
4. 컨테이너 내부 문제 발생 시 자동 재시작 시뮬레이션 (56분)
예상 결과: 컨테이너 크래시 자동 감지 및 재시작 확인, 로그 수집

평가 기준 (루브릭):

기준	만점	설명
헬스체크 구현	40	/health 엔드포인트 동작, 상태 코드 정확
자동 재시작	35	컨테이너 재시작 정책 설정 및 확인
포트 바인딩	15	정확한 포트 맵핑, 외부에서 접근 가능
문서화	10	docker run 정확한 명령, 설명 명시

참고 자료

유의사항

선행 학습 필수: Module 1 Python 기초, Module 3 모델 학습
일반적 오류 및 대응책:
- Dockerfile CMD vs ENTRYPOINT 혼동 → 명확한 차이 설명(명령 vs 컨테이너 프로세스)
- Docker 볼륨 미사용으로 데이터 손실 → 프로덕션에서는 외부 DB 필수 강조
- 기본 포트 사용 충돌 → 포트 맵핑 개념 정확히
다음 모듈과의 연계:
- Module 5: 이 FastAPI를 모델 최적화와 함께 운영
- Module 6: Docker Compose로 다중 서비스 통합

강의 슬라이드 추정

총 슬라이드 수: 약 27장 (1시간당 1.69장)
- 4-1: 8장
- 4-2: 7장
- 4-3: 6장 + Docker 명령 치트시트 1장

Next Action

Module 5, 6, 7 강의안 초안 작성
FastAPI 실습 코드 템플릿 준비

Module 5: 모델 개발 및 최적화 (16시간)

학습 결과

학생은 scikit-learn 파이프라인으로 데이터 누수를 방지한 ML 모델을 개발하고 배포할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 6.4시간)

머신러닝 파이프라인 개념: 1h
Feature Engineering 기초: 1.5h
sklearn Pipeline 및 ColumnTransformer: 1.5h
하이퍼파라미터 최적화(GridSearchCV, RandomSearchCV): 1.2h
데이터 누수 방지: 0.2h

실습 (60% = 9.6시간)

실습 1: Feature Engineering (수치형·범주형 변환): 2.5h (중급)
실습 2: sklearn Pipeline 구축: 2.5h (중급)
실습 3: GridSearchCV로 하이퍼파라미터 최적화: 2.5h (중급)
실습 4: 데이터 누수 탐지 및 개선: 2.1h (중급)

과제 (10% = 1.6시간)

과제 1: End-to-end Pipeline (전처리→모델→평가) 구축: 1.6h

세부 강의 계획

Objective 5-1: sklearn Pipeline과 ColumnTransformer 이해

강의 포인트:

ML 파이프라인의 필요성 (재현성, 실수 방지)
sklearn Pipeline 구조 (fit_transform vs transform)
ColumnTransformer (혼합 자료형 처리)
커스텀 변환자(Custom Transformer) 작성
Pipeline 저장 및 재사용(joblib)

슬라이드 구성 (8장):

슬라이드 1: 파이프라인이 필요한 이유
슬라이드 2-3: Pipeline 기본 (단계 추가, fit, predict)
슬라이드 4-5: ColumnTransformer (수치형/범주형 분리)
슬라이드 6: 커스텀 변환자 (BaseEstimator, TransformerMixin)
슬라이드 7-8: 파이프라인 시각화 및 저장/로드

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: 혼합 자료형 데이터셋(5,000행, 10개 컬럼: 수치형 5개 + 범주형 5개)
단계별 진행:
1. 수치형 전처리: 정규화(StandardScaler) + 다항 특성 (30분)
2. 범주형 전처리: 인코딩(OneHotEncoder) (30분)
3. ColumnTransformer로 통합 (40분)
4. Pipeline에 모델 추가 및 저장 (50분)
예상 결과: 수치형·범주형 모두 정확히 처리, Pipeline 파일 저장/로드 가능

평가 기준 (루브릭):

기준	만점	설명
ColumnTransformer 정확성	35	수치형·범주형 각각 정확한 변환
Pipeline 구축	35	전처리→모델 단계 통합, fit/predict 정상 동작
재현성	20	Pipeline 저장 후 재로드하여 동일 결과
코드 정리	10	DRY 원칙, 가독성

Objective 5-2: 하이퍼파라미터 최적화(GridSearchCV)

강의 포인트:

하이퍼파라미터 vs 학습 파라미터
GridSearchCV 기본 (전수 탐색)
RandomSearchCV (샘플링)
교차검증과의 조합
최적화 과정 시각화

슬라이드 구성 (7장):

슬라이드 1: 하이퍼파라미터의 역할
슬라이드 2-3: GridSearchCV 사용법 (param_grid, cv, scoring)
슬라이드 4: RandomSearchCV (계산량 vs 탐색 범위)
슬라이드 5-6: 최적화 결과 분석 (best_params_, best_score_)
슬라이드 7: 계산량 최적화 (병렬화, early stopping)

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: Module 5 실습 1의 전처리 데이터
단계별 진행:
1. GridSearchCV로 모델 파라미터 탐색 (80분)
  - 탐색 범위: 예) Random Forest: n_estimators [50, 100, 200], max_depth [5, 10, 15]
2. 결과 분석 및 최고 성능 조합 확인 (30분)
3. RandomSearchCV로 더 넓은 범위 탐색 (40분)
예상 결과: 최적 파라미터 조합 발견, 성능 10% 이상 개선 증명

평가 기준 (루브릭):

기준	만점	설명
탐색 범위 설정	30	합리적 범위, 계산 시간 고려
GridSearchCV 구현	35	cv, scoring, n_jobs 올바르게 설정
결과 분석	25	최고 성능 파라미터 명확, 성능 개선 수치 기록
코드 효율성	10	병렬화(n_jobs=-1) 활용

학생 오류 & 대응:

오류 1: 파라미터 범위를 너무 많이 설정 (시간 폭증) → 계산량 추정식 제시
오류 2: 훈련셋만으로 최적화 → 교차검증 필수 강조

Objective 5-3: 데이터 누수(Data Leakage) 방지

강의 포인트:

데이터 누수의 정의 및 종류
전형적인 누수 패턴 (fit_transform 순서, 시계열 처리)
sklearn Pipeline의 자동 방지 기제
탐지 방법 (훈련/테스트 성능 격차)

슬라이드 구성 (6장):

슬라이드 1: 데이터 누수란 무엇인가
슬라이드 2-3: 전형적인 누수 패턴 (3가지 사례)
슬라이드 4: Pipeline이 누수를 방지하는 방식
슬라이드 5: 시계열 데이터 처리 (TimeSeriesSplit)
슬라이드 6: 누수 탐지 체크리스트

실습 (2.1시간):

난이도: 중급
시간: 126분
데이터: 의도적으로 누수가 포함된 데이터셋(2,000행)
단계별 진행:
1. 나쁜 예시: 전체 데이터로 정규화 후 분할 (30분)
2. 모델 성능 평가: 훈련셋 95%, 테스트셋 52% (성능 격차 증명) (30분)
3. 좋은 예시: Pipeline으로 올바르게 분할 후 정규화 (40분)
4. 성능 재평가: 훈련셋 85%, 테스트셋 83% (격차 감소) (26분)
예상 결과: 누수 전후 성능 격차 명확히 이해

평가 기준 (루브릭):

기준	만점	설명
누수 패턴 이해	40	3가지 누수 원인 모두 설명 가능
탐지 능력	30	나쁜 코드에서 누수 식별 가능
Pipeline 올바른 사용	25	fit_transform vs transform 정확 사용
문서화	5	누수와 성능 격차 관계 기술

학생 오류 & 대응:

오류 1: “Pipeline이 자동으로 방지해주니까 안심” → “직접 검증 필수(훈련/테스트 성능 비교)”
오류 2: 시계열 데이터에 일반 train_test_split 사용 → TimeSeriesSplit 강조

참고 자료

유의사항

선행 학습 필수: Module 1-2 (Python, pandas), Module 3 (모델 알고리즘)
일반적 오류 및 대응책:
- ColumnTransformer의 remainder=‘drop’으로 특성 손실 → ‘passthrough’ 권유
- GridSearchCV 결과 해석 오류 → best_score_가 교차검증 점수임을 강조
- 시계열 데이터 누수 → TimeSeriesSplit 필수 강조
다음 모듈과의 연계:
- Module 6: 이 Pipeline을 프로덕션 환경에 배포
- Module 7: Mini-project에서 end-to-end 적용

강의 슬라이드 추정

총 슬라이드 수: 약 21장 (1시간당 1.31장)
- 5-1: 8장
- 5-2: 7장
- 5-3: 6장

Next Action

Module 6, 7 강의안 초안 작성

Module 6: MLOps 구성 및 모델 서빙 (16시간)

학습 결과

학생은 FastAPI + Docker + Traefik으로 프로덕션 수준의 ML 서비스를 배포할 수 있다.

강의 구성 (시간 배분)

이론 (40% = 6.4시간)

MLOps 파이프라인 개요: 1h
Docker Compose를 이용한 다중 서비스 구성: 1.5h
리버스 프록시(Traefik) 및 SSL: 1.5h
구조화된 로깅: 0.9h
모니터링 및 알림 기초: 0.5h

실습 (60% = 9.6시간)

실습 1: Docker Compose 다중 서비스(API + DB): 2.5h (중급)
실습 2: Traefik 리버스 프록시 설정: 2.5h (중급)
실습 3: Let’s Encrypt SSL 자동 발급: 2h (중급)
실습 4: 구조화된 로깅 구현: 2.6h (중급)

과제 (10% = 1.6시간)

과제 1: 완전한 MLOps 스택 배포(Traefik + FastAPI + DB + SSL): 1.6h

세부 강의 계획

Objective 6-1: Docker Compose로 다중 서비스 통합

강의 포인트:

Docker Compose 기본 (docker-compose.yml)
서비스 정의 (image, build, ports, environment)
의존성 관리 (depends_on, wait-for 스크립트)
헬스체크와 순서 보장
네트워킹 및 볼륨

슬라이드 구성 (8장):

슬라이드 1: Docker Compose의 필요성 (여러 컨테이너 관리)
슬라이드 2-3: YAML 문법 및 서비스 정의
슬라이드 4: depends_on과 헬스체크
슬라이드 5-6: 환경변수 · 포트 맵핑 · 볼륨
슬라이드 7: 네트워크 설정 (서비스 간 통신)
슬라이드 8: 자주 쓰는 명령 (up, down, logs, ps)

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: Module 4 FastAPI 앱 + PostgreSQL
단계별 진행:
1. docker-compose.yml 작성 (FastAPI + PostgreSQL) (40분)
2. depends_on과 헬스체크 추가 (40분)
3. 환경변수로 DB 연결 설정 (30분)
4. docker-compose up 및 서비스 통신 확인 (40분)
예상 결과: 한 번의 ‘docker-compose up’으로 모든 서비스 자동 시작, API에서 DB 조회 가능

평가 기준 (루브릭):

기준	만점	설명
YAML 문법	30	오류 없음, 모든 서비스 정상 시작
의존성 관리	35	depends_on + 헬스체크로 시작 순서 보장
환경 설정	20	환경변수로 설정 외부화
문서화	15	docker-compose 명령 설명, 서비스 다이어그램

Objective 6-2: Traefik 리버스 프록시 및 SSL

강의 포인트:

리버스 프록시의 역할 (라우팅, 로드밸런싱, SSL)
Traefik 설정 파일 (traefik.yml, dynamic.yml)
라우터 및 서비스 정의 (Docker provider)
Let’s Encrypt와의 통합
HTTPS 자동 리다이렉트

슬라이드 구성 (8장):

슬라이드 1: 리버스 프록시의 역할
슬라이드 2-3: Traefik 아키텍처 (static config, dynamic config)
슬라이드 4-5: Docker provider를 통한 자동 디스커버리
슬라이드 6-7: Let’s Encrypt SSL 설정
슬라이드 8: HTTPS 리다이렉트 및 보안

실습 (2.5시간):

난이도: 중급
시간: 150분
데이터: 실제 도메인 + 공인 IP (또는 로컬 테스트)
단계별 진행:
1. Traefik 설정 파일 작성 (40분)
2. Docker Compose에 Traefik 추가 (30분)
3. FastAPI에 라우터 레이블 추가 (30분)
4. Let’s Encrypt 자동 발급 테스트 (50분)
예상 결과: HTTP 요청이 자동으로 HTTPS로 리다이렉트, SSL 인증서 자동 갱신

평가 기준 (루브릭):

기준	만점	설명
Traefik 설정	35	static/dynamic config 정확
라우팅	30	Docker provider 자동 디스커버리 동작
SSL 설정	25	Let’s Encrypt 자동 발급, HTTPS 동작
문서화	10	설정 원리 · 인증서 갱신 주기 설명

학생 오류 & 대응:

오류 1: Traefik 라우터 레이블 오타 → 정확한 레이블 형식 강조(traefik.http.routers.xxx)
오류 2: Let’s Encrypt 인증 실패(도메인 오류) → DNS 설정 확인 필수

Objective 6-3: 구조화된 로깅 및 모니터링

강의 포인트:

로깅의 중요성 (디버깅, 모니터링, 감사)
JSON 구조화된 로그 포맷
FastAPI 미들웨어로 요청/응답 로깅
로그 수집 (stdout → 파일/클라우드)
기초 모니터링(응답 시간, 에러율)

슬라이드 구성 (7장):

슬라이드 1: 로깅의 필요성 (프로덕션 문제 대응)
슬라이드 2-3: JSON 구조화 로그 (레벨, 타임스탬프, 컨텍스트)
슬라이드 4-5: FastAPI 미들웨어 (요청 처리 시간, 상태 코드)
슬라이드 6: 로그 수집 (python logging, structlog 등)
슬라이드 7: 기초 메트릭 (응답 시간 분포, 에러 추적)

실습 (2.6시간):

난이도: 중급
시간: 156분
데이터: Module 6 실습 1의 Docker Compose 환경
단계별 진행:
1. structlog로 JSON 로깅 설정 (40분)
2. FastAPI 미들웨어 작성 (요청/응답 로깅) (40분)
3. 컨테이너 로그 수집 및 확인 (40분)
4. 기초 메트릭 계산 (응답 시간 분포, 에러율) (36분)
예상 결과: 모든 API 요청의 요청/응답 시간·상태코드·에러 메시지가 JSON으로 로깅됨

평가 기준 (루브릭):

기준	만점	설명
JSON 로깅 형식	35	모든 필수 필드(타임스탬프, 레벨, 메시지) 포함
미들웨어 구현	35	요청 시간, 응답 시간, 상태 코드 기록
로그 수집	20	docker logs로 모든 로그 확인 가능
메트릭 분석	10	응답 시간 분포, 에러율 계산

참고 자료

유의사항

선행 학습 필수: Module 4 (FastAPI, Docker), Module 5 (모델 개발)
일반적 오류 및 대응책:
- Traefik 라우터 레이블과 서비스명 불일치 → 정확한 레이블 형식 강조
- Let’s Encrypt 인증 실패 → DNS 설정(A 레코드), 방화벽 80/443 포트 개방 확인
- 로그 파일 크기 증가 → 로그 로테이션 설정 필수(logrotate 또는 docker log driver)
다음 모듈과의 연계:
- Module 7: 이 MLOps 스택으로 Mini-project 배포

강의 슬라이드 추정

총 슬라이드 수: 약 23장 (1시간당 1.44장)
- 6-1: 8장
- 6-2: 8장
- 6-3: 7장

Next Action

Module 7 강의안 초안 작성
Traefik 설정 템플릿 및 docker-compose 샘플 준비

Module 7: 데이터 분석 Mini-project (16시간)

학습 결과

학생은 모듈 1-6을 통합하여 데이터 수집→정제→분석→모델 배포까지 end-to-end 파이프라인을 완성할 수 있다.

강의 구성 (시간 배분)

이론 (20% = 3.2시간)

CRISP-DM 워크플로우 개요: 1h
데이터셋 선택 기준: 0.8h
프로젝트 관리 및 버전 관리(Git): 0.8h
평가 기준 및 리포팅: 0.6h

프로젝트 (70% = 11.2시간)

단계 1: 데이터셋 선택 및 EDA: 2h (실습)
단계 2: Feature Engineering 및 모델 개발: 3h (실습)
단계 3: 모델 최적화 및 평가: 2h (실습)
단계 4: FastAPI 서빙 구현: 2h (실습)
단계 5: Docker 배포 및 테스트: 2.2h (실습)

리포팅 및 평가 (10% = 1.6시간)

단계 6: GitHub 리포지토리 구축 및 문서작성: 1.6h

세부 프로젝트 계획

단계 1: 데이터셋 선택 및 EDA

목표: 분석할 공개 데이터셋을 선정하고 모듈 2의 EDA 기법 적용

제약 사항:

행 수: 최소 1,000행 이상
컬럼 수: 최소 10개 이상
결측치·이상치 포함되어야 함 (EDA 의미)
분류 또는 회귀 문제로 명확히 정의 가능해야 함

권장 데이터셋:

Kaggle: House Prices, Titanic (분류), 의료 데이터
정부 공공데이터포털: 공공 의료, 환경, 교육 데이터
UCI Machine Learning Repository

평가 기준:

항목	만점	설명
데이터셋 적절성	20	요구사항 충족, 도메인 이해도
EDA 완성도	50	모듈 2 8단계 체크리스트 모두 완료
가설 도출	20	데이터 기반 가설 3개 이상
시각화 품질	10	12장 이상, 고품질 차트

단계 2-3: Feature Engineering, 모델 개발 & 최적화

목표: 모듈 3-5의 기법을 적용하여 모델 성능 최대화

프로세스:

Feature Engineering (수치형·범주형 변환, 파생 특성)
sklearn Pipeline 구축 (ColumnTransformer + 모델)
3가지 모델 비교 (Decision Tree, Random Forest, Gradient Boosting)
GridSearchCV로 하이퍼파라미터 최적화
교차검증(5-fold) 성능 평가

성능 목표:

분류 문제: 교차검증 AUC ≥ 0.80
회귀 문제: 교차검증 R² ≥ 0.75

평가 기준:

항목	만점	설명
Pipeline 정확성	30	데이터 누수 없음, 전처리 적절
모델 성능	30	목표 성능 달성(AUC ≥ 0.80 등)
하이퍼파라미터 튜닝	25	GridSearchCV 실행, 결과 분석
문서화	15	Feature 설명, 모델 선택 이유

단계 4: FastAPI 서빙 구현

목표: 훈련된 모델을 REST API로 래핑

구현 사항:

Pydantic 입력 스키마 정의 (입력 특성)
모델 로드 및 예측 함수
/predict 엔드포인트 구현
Swagger 자동 문서화 확인

테스트:

curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"feature1": 10, "feature2": 20, ...}'

평가 기준:

항목	만점	설명
엔드포인트 구현	40	/predict 정상 동작, 예측값 반환
Pydantic 검증	30	입력 데이터 타입·범위 검증
Swagger 문서	20	자동 생성, 입출력 스키마 명확
코드 구조	10	모델 로드, predict 함수 분리

단계 5: Docker 배포 및 테스트

목표: 모델 + API를 Docker로 컨테이너화하여 배포

구현 사항:

Dockerfile 작성 (FastAPI 앱)
docker-compose.yml (필요시 DB 추가)
모델 파일 포함(joblib)
헬스체크 엔드포인트

테스트 환경:

로컬: docker-compose up 후 API 호출 성공 확인
클라우드(선택): AWS EC2 / GCP Compute Engine에 배포

평가 기준:

항목	만점	설명
Dockerfile 정확성	35	문법 오류 없음, 이미지 빌드 성공
컨테이너 배포	35	docker-compose up 성공, API 호출 가능
클라우드 배포	20	AWS/GCP 배포 성공(선택 가산)
문서화	10	docker-compose 설명, 배포 가이드

단계 6: GitHub 리포지토리 및 문서작성

목표: 프로젝트를 공개 가능한 수준으로 정리

필수 요소:

README.md
- 프로젝트 개요
- 설치 방법 (pip install -r requirements.txt)
- 실행 방법 (python train.py, python app.py)
- 모델 성능 (교차검증 점수)
- 구조(폴더/파일 설명)
requirements.txt 또는 pyproject.toml
- 정확한 버전 명시

코드 구조:

project-repo/
├── README.md
├── requirements.txt
├── data/
│   ├── raw/
│   └── processed/
├── notebooks/
│   ├── 01_eda.ipynb
│   ├── 02_model_training.ipynb
├── src/
│   ├── preprocessing.py
│   ├── model.py
│   ├── app.py (FastAPI)
├── Dockerfile
├── docker-compose.yml
└── .gitignore

주요 파일 설명:
- notebooks/01_eda.ipynb: EDA 과정 (출력 결과 포함)
- notebooks/02_model_training.ipynb: 모델 학습 및 평가
- src/preprocessing.py: 데이터 전처리 파이프라인
- src/model.py: 모델 정의 및 저장/로드
- src/app.py: FastAPI 앱
- .gitignore: 데이터, 모델 파일 제외

평가 기준:

항목	만점	설명
README 완성도	30	명확한 설명, 설치/실행 지침
코드 구조	30	폴더 구성 논리적, 파일 명명 명확
문서화	25	주석, docstring, 주요 파일 설명
재현성	15	타 컴퓨터에서 5분 내 실행 가능

프로젝트 주제 제시(3개 안)

선택지 1: 주택 가격 예측 (회귀)

데이터: Kaggle House Prices Dataset (1,460행 × 80 특성)
목표: 주택 가격 예측
난이도: 중급
학습 포인트: 범주형/수치형 혼합, 특이값 처리, 회귀 모델

선택지 2: 고객 이탈 예측 (분류)

데이터: Kaggle Churn Dataset (7,043행 × 21 특성)
목표: 이동통신사 고객 이탈 여부 예측
난이도: 중급
학습 포인트: 불균형 데이터, 분류 모델, 비즈니스 해석

선택지 3: 의료 진단 (분류)

데이터: UCI Breast Cancer Dataset (569행 × 30 특성) 또는 정부 공공데이터
목표: 질병 진단 예측
난이도: 중급~고급
학습 포인트: 의료 데이터 윤리, 특성 스케일링 중요성

참고 자료

유의사항

선행 학습 필수: Module 1-6 모든 내용
일반적 오류 및 대응책:
- 데이터셋 너무 크거나 복잡 선택 → “처음에는 간단한 데이터셋”부터 시작 권유
- EDA 없이 바로 모델링 → “탐색 없이는 성공 없음” 강조
- 모델 파일 commit → .gitignore에 *.pkl, *.joblib 추가 필수
평가 방식:
- 단계별 제출(1-3주) → 중간 피드백 제공
- 최종 평가: GitHub 리포지토리 + 문서 완성도
- 추가점: 클라우드 배포 성공, Dockerfile 최적화, 모니터링 추가

강의 슬라이드 추정

총 슬라이드 수: 약 15장 (1시간당 0.94장, 프로젝트 중심)
- CRISP-DM 개요: 5장
- 데이터셋 선택 및 예시: 4장
- 평가 기준 상세: 4장
- GitHub 베스트 프랙티스: 2장

프로젝트 타임라인

주차	마일스톤	산출물
1	데이터셋 선택 + EDA	EDA 리포트 (Jupyter)
2	모델 개발 + 최적화	훈련된 모델 (pickle)
3	FastAPI 구현 + 배포	Docker 이미지
4	문서화 + 제출	GitHub 리포지토리

종합 강의안 개요 및 통계

전체 모듈별 강의 슬라이드 수

모듈	시간	슬라이드 수	비고
M1	24h	28장	이론 40% + 실습 50%
M2	24h	23장	이론 40% + 실습 50%
M3	24h	42장	이론 40% + 실습 60% (알고리즘 복잡도)
M4	16h	27장	이론 40% + 실습 60%
M5	16h	21장	이론 40% + 실습 60%
M6	16h	23장	이론 40% + 실습 60%
M7	16h	15장	이론 20% + 프로젝트 70%
합계	136h	179장	1시간당 평균 1.31장

강의안 품질 체크리스트

각 모듈별 명확한 학습 결과(ABCD) 정의
이론·실습·과제 비율 균형(기본 40-50-10, 심화 40-60-10)
각 Objective별 구체적 강의 포인트 및 슬라이드 구성
실습별 난이도·시간·데이터·단계별 진행 상세 기술
루브릭을 통한 명확한 평가 기준
학생 오류 3가지 이상 및 대응책
선행 학습·다음 모듈과의 연계 명시
참고 자료 출처 링크(wiki 페이지)

종합 추천사항 및 우선순위

Phase 1: 강의안 초안 검토 및 수정 (4월 26-28일)

각 모듈별 강의안 초안 내용 검토
슬라이드 개수 조정 (과다/부족 검토)
실습 난이도 조정 (학생 수준에 맞춤)

Phase 2: 실습 자료 준비 (4월 29일~5월 10일)

각 모듈별 실습 코드 템플릿 작성 (Jupyter 노트북)
데이터셋 확정 (Kaggle vs 정부 공공데이터 vs 직접 생성)
실습 가이드 문서 작성

Phase 3: 강의 슬라이드 제작 (5월 11일~30일)

강의안을 기반으로 실제 슬라이드 제작 (PowerPoint/Google Slides)
수식·코드 예제 추가
비주얼 다이어그램 작성

Phase 4: 평가 기준 및 루브릭 최종화 (5월 31일~6월 10일)

루브릭 수정 (점수 조정)
채점 가이드 작성
예시 답안 작성

Next Steps

✅ 강의안 초안 완성 (본 문서)
⏳ 각 모듈별 대표 실습 상세 기술 추가 (별도 문서)
⏳ 슬라이드 템플릿 및 예제 제작 시작
⏳ 학생 피드백 반영 루프 구축 (강의 시작 후)

JYP Garden Internal

탐색기

1차 강의(데이터분석 및 MLOps) 모듈별 강의안 초안

1차 강의(데이터분석 및 MLOps) 모듈별 강의안 초안

Module 1: 데이터 분석을 위한 Python 이해 (24시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

실습 (50% = 12시간)

과제 (10% = 2.4시간)

세부 강의 계획

Objective 1-1: Python 타입 힌트(Type Hints) 이해 및 적용

Objective 1-2: 비동기 프로그래밍(async/await) 이해

Objective 1-3: Python 환경설정 자동화

Objective 1-4: Pydantic을 이용한 데이터 검증

참고 자료

유의사항

강의 슬라이드 추정

Next Action

Module 2: 데이터 분석 개요 및 기초통계 (24시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

실습 (50% = 12시간)

과제 (10% = 2.4시간)

세부 강의 계획

Objective 2-1: EDA(Exploratory Data Analysis) 프로세스 이해 및 실행

Objective 2-2: 데이터 품질 문제 탐지 및 처리(결측치·중복·이상치)

Objective 2-3: 데이터 시각화 3계층 설계

참고 자료

유의사항

강의 슬라이드 추정

Next Action

Module 3: 머신러닝 및 딥러닝 이해 (24시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 9.6시간)

실습 (60% = 14.4시간)

과제 (10% = 2.4시간)

세부 강의 계획

Objective 3-1: Decision Tree의 분할 기준 이해

Objective 3-2: Ensemble 방법 비교(Random Forest vs Gradient Boosting)

Objective 3-3: 신경망의 Forward Pass & Backpropagation

Objective 3-4: scikit-learn/TensorFlow로 분류 모델 학습

참고 자료

유의사항

강의 슬라이드 추정

Next Action

Module 4: 모델 서빙을 위한 Python 심화, FastAPI (16시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 6.4시간)

실습 (60% = 9.6시간)

과제 (10% = 1.6시간)

세부 강의 계획

Objective 4-1: FastAPI 프레임워크 및 엔드포인트 구현

Objective 4-2: Docker 이미지 작성 및 레이어 최적화

Objective 4-3: 컨테이너 배포 및 헬스체크

참고 자료

유의사항

강의 슬라이드 추정

Next Action

Module 5: 모델 개발 및 최적화 (16시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 6.4시간)

실습 (60% = 9.6시간)

과제 (10% = 1.6시간)

세부 강의 계획

Objective 5-1: sklearn Pipeline과 ColumnTransformer 이해

Objective 5-2: 하이퍼파라미터 최적화(GridSearchCV)

Objective 5-3: 데이터 누수(Data Leakage) 방지

참고 자료

유의사항

강의 슬라이드 추정

Next Action

Module 6: MLOps 구성 및 모델 서빙 (16시간)

학습 결과

강의 구성 (시간 배분)

이론 (40% = 6.4시간)