Skip to content

GitLab

Commit c8d7c8b4 authored by insun park's avatar insun park
Browse files

Merge branch 'main' of http://gitlab.geumdo.net/root/geumdo_docs

parents 4c627a3d 17618ca9
Expand all Hide whitespace changes
Inline Side-by-side
.gitignore
View file @ c8d7c8b4
...@@ -220,4 +220,98 @@ Thumbs.db ...@@ -220,4 +220,98 @@ Thumbs.db
.env.production .env.production
.env.staging .env.staging
secrets/ secrets/
keys/ keys/
\ No newline at end of file
# ===================================================================
# Large Files and Build Artifacts
# ===================================================================
# WAR files
*.war
*.war.original
# JAR files
*.jar
# Large media files
*.mp4
*.avi
*.mov
*.mkv
*.wmv
*.flv
*.webm
*.zip
*.tar.gz
*.rar
*.7z
# Large log files
logs/
*.log
# Build artifacts and compiled files
target/
build/
dist/
*.class
*.o
*.so
*.dll
*.exe
# Database files
*.db
*.sqlite
*.sqlite3
# Large data files
*.csv
*.json
*.xml
*.dat
*.bin
# Node modules and package files
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Java build artifacts
*.class
*.jar
*.war
target/
build/
# Python cache and compiled files
__pycache__/
*.pyc
*.pyo
*.pyd
.Python
*.so
# Virtual environments
venv/
env/
.venv/
.env/
# IDE and editor files
.vscode/
.idea/
*.swp
*.swo
*~
# OS generated files
.DS_Store
.DS_Store?
._*
Thumbs.db
# Docker specific large files
docker_data/
volumes/
uploads/
\ No newline at end of file
README.md
View file @ c8d7c8b4
...@@ -15,7 +15,7 @@ ...@@ -15,7 +15,7 @@
- **[Docker 환경 리포트](./docker/geumdo_docker_report_240611.md)**: 서버별 Docker 버전 현황과 주요 Docker Compose 프로젝트 정보를 정리한 문서입니다. - **[Docker 환경 리포트](./docker/geumdo_docker_report_240611.md)**: 서버별 Docker 버전 현황과 주요 Docker Compose 프로젝트 정보를 정리한 문서입니다.
- **[Docker 배포 가이드](./docker/deployment_guide.md)**: Docker를 이용한 서비스 배포 절차를 안내하는 가이드입니다. - **[Docker 배포 가이드](./docker/deployment_guide.md)**: Docker를 이용한 서비스 배포 절차를 안내하는 가이드입니다.
- **[Tomcat SSL/TLS 설정 가이드](./docker/docker_ssl_setup_guide.md)**: 리버스 프록시(Nginx/Apache)를 이용해 Tomcat 애플리케이션에 SSL/TLS를 적용하는 방법을 안내합니다. - **[Tomcat SSL/TLS 설정 가이드](./docker/docker_ssl_setup_guide.md)**: 리버스 프록시(Nginx/Apache)를 이용해 Tomcat 애플리케이션에 SSL/TLS를 적용하는 방법을 안내합니다.
- **[Docker 예제](./docker/examples/)**: 다양한 Docker 설정 예제 파일들입니다. - **[Docker 프로젝트 모음](./docker/README.md)**: 30개 이상의 다양한 Docker 기반 애플리케이션 및 서비스 환경을 포함합니다.
#### 🖥️ 고급 가상화: Docker + KVM + Windows VM #### 🖥️ 고급 가상화: Docker + KVM + Windows VM
...@@ -77,10 +77,31 @@ docker-compose up -d ...@@ -77,10 +77,31 @@ docker-compose up -d
- **[Vagrantfile](./docker/docker-windows-vm/Vagrantfile)**: Windows 10 VM 설정 (메모리 8GB, CPU 4코어) - **[Vagrantfile](./docker/docker-windows-vm/Vagrantfile)**: Windows 10 VM 설정 (메모리 8GB, CPU 4코어)
- **[startup.sh](./docker/docker-windows-vm/startup.sh)**: 자동화된 VM 부팅 및 네트워크 설정 - **[startup.sh](./docker/docker-windows-vm/startup.sh)**: 자동화된 VM 부팅 및 네트워크 설정
#### 🏭 주요 Docker 프로젝트들
| 프로젝트 | 설명 | 주요 기술 | 실행 방법 |
|---------|------|-----------|-----------|
| **`docker_all`** | Java 웹 개발 및 협업에 필요한 모든 서비스(Tomcat, MariaDB, SVN)를 통합한 올인원 개발 서버 | `Tomcat`, `MariaDB`, `SVN`, `Java 8` | `./rebuild_docker.sh` |
| **`docker_fastapi`** | 스마트스토어, 쿠팡 상품 정보 및 리뷰를 수집하고 AI 감성 분석을 수행하는 크롤링 시스템 | `FastAPI`, `Selenium`, `TensorFlow` | `docker-compose up -d` |
| **`docker_jupyter`** | GPU를 지원하는 Jupyter Lab 실행 환경으로, PyTorch가 사전 설치되어 있음 | `Jupyter Lab`, `PyTorch`, `GPU` | `docker-compose up -d` |
| **`docker_jenkins`** | Jenkins CI/CD 자동화 서버를 구축하며, 데이터는 호스트에 영속적으로 저장 | `Jenkins`, `OpenJDK 8`, `MariaDB` | `./rebuild.sh` |
| **`docker_gitlab`** | 공식 이미지를 사용하여 GitLab CE(Community Edition) 서버를 배포 | `GitLab CE` | `docker-compose up -d` |
| **`docker_registry`** | Docker 이미지를 저장하고 관리할 수 있는 사설 레지스트리(Web UI 포함) | `Docker Registry`, `Web UI` | `docker-compose up -d` |
| **`geumdo-rag-chat-bot`** | 사내 GitLab 코드에 대해 자연어 질의를 할 수 있는 RAG 기반 챗봇 시스템 | `RAG`, `LangChain`, `FastAPI`, `Streamlit` | `docker-compose up --build -d` |
| **`gpu_cooling_monitor`** | TIG 스택(InfluxDB, Grafana)을 활용하여 서버의 GPU 및 시스템 냉각 상태를 실시간으로 모니터링 | `InfluxDB`, `Grafana`, `Python`, `Slack` | `docker-compose up -d` |
| **`jupyter_geumdo_lab`** | Kubernetes(K8s) 기반의 다중 사용자 JupyterHub 서비스로, Google OAuth 인증과 동적 GPU/CPU 서버 생성을 지원 | `Kubernetes`, `JupyterHub`, `NFS`, `OAuth` | `helm upgrade ...` |
| **`docker_3dp`** | Nextcloud 파일 관리, 웹 기반 원격 슬라이싱(PrusaSlicer), 프린터 제어 기능을 통합한 3D 프린팅 솔루션 | `Nextcloud`, `PrusaSlicer`, `Flask`, `PHP` | `./rebuild_docker.sh` |
### 🌐 Nginx ### 🌐 Nginx
- **[Nginx 프록시 설정 분석](./nginx/proxy_analysis.md)**: Nginx 리버스 프록시 서버의 주요 설정 파일과 서비스별 프록시 규칙을 상세히 분석한 문서입니다. - **[Nginx 프록시 설정 분석](./nginx/proxy_analysis.md)**: Nginx 리버스 프록시 서버의 주요 설정 파일과 서비스별 프록시 규칙을 상세히 분석한 문서입니다.
### 🔄 서버 백업 시스템
- **[서버 백업 가이드](./server_backup/README.md)**: 서버 데이터 백업 시스템 구성 및 스크립트 활용 가이드입니다.
- **[Docker 백업 가이드](./server_backup/docker_backup_guide.md)**: Docker 환경에서의 효율적인 백업 방법을 안내합니다.
- **[lftp 설치 가이드](./server_backup/README.md#lftp-설치-방법)**: 다양한 리눅스 배포판에서 lftp를 설치하는 방법을 안내합니다.
--- ---
## 🤖 AI 전문가 양성 과정 ## 🤖 AI 전문가 양성 과정
...@@ -102,12 +123,13 @@ docker-compose up -d ...@@ -102,12 +123,13 @@ docker-compose up -d
- **[Part 0: 과정 소개](./ai_lecture/courses/00_introduction/part_0_introduction.md)** - **[Part 0: 과정 소개](./ai_lecture/courses/00_introduction/part_0_introduction.md)**
- **[Part 0.1: AI의 역사](./ai_lecture/courses/00_introduction/part_0.1_history_of_ai.md)** - **[Part 0.1: AI의 역사](./ai_lecture/courses/00_introduction/part_0.1_history_of_ai.md)**
- **[Part 1: AI 개발 환경 구축](./ai_lecture/courses/01_ai_development_environment/part_1_ai_development_environment.md)** - **[Part 1: AI 개발 환경 구축](./ai_lecture/courses/01_ai_development_environment/part_1_ai_development_environment.md)**
- **[Part 2: Python 핵심 문법](./ai_lecture/courses/02_python_core_syntax/part_2_python_core_syntax.md)** - **[Part 2: 파이썬 핵심 문법](./ai_lecture/courses/02_python_core_syntax/part_2_python_core_syntax.md)**
- **[Part 3: Python 컬렉션](./ai_lecture/courses/03_python_collections/part_3_python_collections.md)** - **[Part 3: 파이썬 컬렉션](./ai_lecture/courses/03_python_collections/part_3_python_collections.md)**
- **[Part 4: 객체 지향 프로그래밍](./ai_lecture/courses/04_object_oriented_programming/part_4_object_oriented_programming.md)** - **[Part 4: 객체 지향 프로그래밍](./ai_lecture/courses/04_object_oriented_programming/part_4_object_oriented_programming.md)**
- **[Part 5: AI 핵심 라이브러리](./ai_lecture/courses/05_ai_core_libraries/part_5_ai_core_libraries.md)** - **[Part 5: AI 핵심 라이브러리](./ai_lecture/courses/05_ai_core_libraries/part_5_ai_core_libraries.md)**
#### **Part 2: 핵심 AI 모델 개발 및 서빙 (6-9주차)** #### **Part 2: 핵심 AI 모델 개발 및 서빙 (6-9주차)**
- **[Part 5.5: NumPy를 활용한 선형대수학](./ai_lecture/courses/05.5_linear_algebra_with_numpy/part_5.5_linear_algebra_with_numpy.md)**
- **[Part 6: 머신러닝](./ai_lecture/courses/06_machine_learning/part_6_machine_learning.md)** - **[Part 6: 머신러닝](./ai_lecture/courses/06_machine_learning/part_6_machine_learning.md)**
- **[Part 7: 딥러닝](./ai_lecture/courses/07_deep_learning/part_7_deep_learning.md)** - **[Part 7: 딥러닝](./ai_lecture/courses/07_deep_learning/part_7_deep_learning.md)**
- **[7.1: 순환 신경망 (RNN)](./ai_lecture/courses/07_deep_learning/part_7.1_recurrent_neural_networks.md)** - **[7.1: 순환 신경망 (RNN)](./ai_lecture/courses/07_deep_learning/part_7.1_recurrent_neural_networks.md)**
...@@ -116,7 +138,7 @@ docker-compose up -d ...@@ -116,7 +138,7 @@ docker-compose up -d
- **[7.4: 그래프 신경망 (GNN)](./ai_lecture/courses/07_deep_learning/part_7.4_graph_neural_networks.md)** - **[7.4: 그래프 신경망 (GNN)](./ai_lecture/courses/07_deep_learning/part_7.4_graph_neural_networks.md)**
- **[7.5: 강화학습 (RL)](./ai_lecture/courses/07_deep_learning/part_7.5_reinforcement_learning.md)** - **[7.5: 강화학습 (RL)](./ai_lecture/courses/07_deep_learning/part_7.5_reinforcement_learning.md)**
- **[Part 8: FastAPI를 이용한 모델 서빙](./ai_lecture/courses/08_model_serving_with_fastapi/part_8_model_serving_with_fastapi.md)** - **[Part 8: FastAPI를 이용한 모델 서빙](./ai_lecture/courses/08_model_serving_with_fastapi/part_8_model_serving_with_fastapi.md)**
- **[Part 9: Production-Ready API](./ai_lecture/courses/09_production_ready_api/part_9_production_ready_api.md)** - **[Part 9: 프로덕션 레벨 API](./ai_lecture/courses/09_production_ready_api/part_9_production_ready_api.md)**
#### **Part 3: 프로덕션 MLOps 및 AI 심화 (10-14주차)** #### **Part 3: 프로덕션 MLOps 및 AI 심화 (10-14주차)**
- **[Part 10: AI 전문가 과정 로드맵](./ai_lecture/courses/10_expert_path/part_10_expert_path.md)** - **[Part 10: AI 전문가 과정 로드맵](./ai_lecture/courses/10_expert_path/part_10_expert_path.md)**
...@@ -124,17 +146,27 @@ docker-compose up -d ...@@ -124,17 +146,27 @@ docker-compose up -d
- **[Part 11: 프로덕션 레벨 MLOps 심화](./ai_lecture/courses/11_mlops/part_11_mlops.md)** - **[Part 11: 프로덕션 레벨 MLOps 심화](./ai_lecture/courses/11_mlops/part_11_mlops.md)**
- **[Part 12: 대규모 AI 모델 최적화 및 서빙](./ai_lecture/courses/12_model_optimization/part_12_model_optimization.md)** - **[Part 12: 대규모 AI 모델 최적화 및 서빙](./ai_lecture/courses/12_model_optimization/part_12_model_optimization.md)**
- **[Part 13: 생성형 AI 및 AI 에이전트 심화](./ai_lecture/courses/13_generative_ai/part_13_generative_ai.md)** - **[Part 13: 생성형 AI 및 AI 에이전트 심화](./ai_lecture/courses/13_generative_ai/part_13_generative_ai.md)**
- **[Part 14: AI 윤리 및 거버넌스 실무](./ai_lecture/courses/14_ai_ethics/part_14_ai_ethics.md)** - **[Part 14: AI 윤리](./ai_lecture/courses/14_ai_ethics/part_14_ai_ethics.md)**
#### **Part 4: 최종 캡스톤 프로젝트 (15-16주차)** #### **Part 4: 최종 캡스톤 프로젝트 (15-16주차)**
- **[Part 15: 최종 캡스톤 프로젝트 가이드](./ai_lecture/courses/15_capstone_project/part_15_capstone_project.md)** - **[Part 15: 최종 캡스톤 프로젝트 가이드](./ai_lecture/courses/15_capstone_project/part_15_capstone_project.md)**
- **[캡스톤 프로젝트 템플릿](./ai_lecture/courses/15_capstone_project/capstone_template.md)** - **[캡스톤 프로젝트 템플릿](./ai_lecture/courses/15_capstone_project/capstone_template.md)**
### 🌟 심화 학습 및 협업 자료
- **[온라인 커뮤니티 가이드](./ai_lecture/ONLINE_COMMUNITY_GUIDE.md)**: 학습자 간 지식 공유 및 네트워킹을 위한 커뮤니티 활용 가이드
- **[짝 프로그래밍 가이드](./ai_lecture/PAIR_PROGRAMMING_GUIDE.md)**: 효과적인 협업 학습 방법론
- **[산업 사례 연결 가이드](./ai_lecture/INDUSTRY_CASE_STUDIES.md)**: 이론과 실무 사례를 연결한 심화 자료
- **[클라우드 AI 서비스 가이드](./ai_lecture/Cloud_AI_Services_Guide.md)**: AWS, Google Cloud, Azure AI 서비스 활용 안내
- **[도구 및 프레임워크 비교](./ai_lecture/Tooling_Frameworks_Comparison.md)**: PyTorch vs TensorFlow 등 주요 도구 비교
- **[진도 관리 시스템 상세](./ai_lecture/PROGRESS_TRACKING_SYSTEM.md)**: 학습 진도와 성취를 관리하는 고급 시스템 안내
- **[콘텐츠 업데이트 정책](./ai_lecture/AI_CONTENT_UPDATE_POLICY.md)**: 최신 기술 동향을 커리큘럼에 반영하는 방법론
### 💻 실습 코드 및 자료 ### 💻 실습 코드 및 자료
- **[실습 코드 메인](./ai_lecture/source_code/README.md)**: 전체 실습 코드 구조 및 사용법 - **[실습 코드 메인](./ai_lecture/source_code/README.md)**: 전체 실습 코드 구조 및 사용법
- **[Python 핵심 문법 실습](./ai_lecture/source_code/02_python_core_syntax/)** - **[파이썬 핵심 문법 실습](./ai_lecture/source_code/02_python_core_syntax/)**
- **[Python 컬렉션 실습](./ai_lecture/source_code/03_python_collections/)** - **[파이썬 컬렉션 실습](./ai_lecture/source_code/03_python_collections/)**
- **[객체 지향 프로그래밍 실습](./ai_lecture/source_code/04_object_oriented_programming/)** - **[객체 지향 프로그래밍 실습](./ai_lecture/source_code/04_object_oriented_programming/)**
- **[AI 핵심 라이브러리 실습](./ai_lecture/source_code/05_ai_core_libraries/)** - **[AI 핵심 라이브러리 실습](./ai_lecture/source_code/05_ai_core_libraries/)**
- **[머신러닝 실습](./ai_lecture/source_code/06_machine_learning/)** - **[머신러닝 실습](./ai_lecture/source_code/06_machine_learning/)**
...@@ -149,17 +181,35 @@ docker-compose up -d ...@@ -149,17 +181,35 @@ docker-compose up -d
### 📚 추가 자료 ### 📚 추가 자료
- **[통합 용어집](./ai_lecture/glossary.md)**: 전체 과정에서 사용되는 핵심 용어 정리 - **[통합 용어집](./ai_lecture/glossary.md)**: 전체 과정에서 사용되는 핵심 용어 정리
- **[실습 데이터셋](./ai_lecture/assets/datasets/)**: 과정에서 사용되는 실습용 데이터 (경로 수정 필요 시 확인) - **[실습 데이터셋](./ai_lecture/assets/datasets/)**: 과정에서 사용되는 실습용 데이터
- **[Docker 설정 파일](./ai_lecture/docker-compose.dev.yml)**: 개발 환경용 Docker 설정 - **[Docker 설정 파일](./ai_lecture/docker-compose.dev.yml)**: 개발 환경용 Docker 설정
- **[GPU 지원 Docker 설정](./ai_lecture/docker-compose.gpu.yml)**: GPU 환경용 Docker 설정 - **[GPU 지원 Docker 설정](./ai_lecture/docker-compose.gpu.yml)**: GPU 환경용 Docker 설정
- **[프로젝트 TODO](./ai_lecture/TODO.md)**: 프로젝트 개선 사항 및 향후 계획 (파일 위치 확인 필요) - **[프로젝트 TODO](./ai_lecture/TODO.md)**: 프로젝트 개선 사항 및 향후 계획
### 🎯 학습 진도 관리
본 과정에서는 학습 진도를 체계적으로 관리할 수 있는 도구를 제공합니다:
```bash
# 전체 진도 확인
make progress
# 특정 파트 진도 확인
make progress-show PART=part_2
# 학습 항목 완료 표시
make progress-complete PART=part_2 ITEM=0
# 진도 리포트 생성
make progress-export FILE=my_progress.md
```
--- ---
## 🛠️ 기술 스택 ## 🛠️ 기술 스택
### AI 강의 과정 ### AI 강의 과정
- **언어**: Python 3.10+ - **언어**: 파이썬 3.10+
- **의존성 관리**: Poetry (권장) / pip - **의존성 관리**: Poetry (권장) / pip
- **핵심 라이브러리**: NumPy, Pandas, Scikit-learn, PyTorch, LangChain - **핵심 라이브러리**: NumPy, Pandas, Scikit-learn, PyTorch, LangChain
- **API 서버**: FastAPI - **API 서버**: FastAPI
...@@ -176,7 +226,10 @@ docker-compose up -d ...@@ -176,7 +226,10 @@ docker-compose up -d
- **Type 2**: Docker 컨테이너 - OS 레벨 가상화 - **Type 2**: Docker 컨테이너 - OS 레벨 가상화
- **복합 구조**: Docker + KVM 중첩 가상화로 Windows 환경 구현 - **복합 구조**: Docker + KVM 중첩 가상화로 Windows 환경 구현
- **네트워킹**: iptables 방화벽, NAT 포트 포워딩, RDP 원격 접속 - **네트워킹**: iptables 방화벽, NAT 포트 포워딩, RDP 원격 접속
- **모니터링**: 시스템 리소스 모니터링 도구 - **모니터링**: TIG 스택 (Telegraf, InfluxDB, Grafana), Prometheus
- **CI/CD**: Jenkins, GitLab CI/CD
- **데이터베이스**: MariaDB, MySQL, PostgreSQL
- **AI/ML**: Jupyter Lab, TensorFlow, PyTorch, FastAPI
--- ---
...@@ -190,6 +243,18 @@ docker-compose up -d ...@@ -190,6 +243,18 @@ docker-compose up -d
### 서버 인프라 설정 ### 서버 인프라 설정
1. **[Docker 배포 가이드](./docker/deployment_guide.md)**를 참고하여 Docker 환경을 구축합니다. 1. **[Docker 배포 가이드](./docker/deployment_guide.md)**를 참고하여 Docker 환경을 구축합니다.
2. **[Nginx 프록시 설정](./nginx/proxy_analysis.md)**을 확인하여 웹 서버를 설정합니다. 2. **[Nginx 프록시 설정](./nginx/proxy_analysis.md)**을 확인하여 웹 서버를 설정합니다.
3. **[Docker 프로젝트 모음](./docker/README.md)**에서 필요한 서비스를 선택하여 배포합니다.
---
## 📊 프로젝트 통계
- **Docker 프로젝트**: 30+ 개
- **파이썬 코드**: 6,492줄
- **문서**: 10,224줄 (마크다운)
- **Jupyter 노트북**: 10개
- **테스트 파일**: 8개
- **Docker 설정**: 2개 (개발/GPU 환경)
--- ---
......
ai_lecture/AI_CONTENT_UPDATE_POLICY.md 0 → 100644
View file @ c8d7c8b4
# AI 전문가 양성 과정 - 콘텐츠 업데이트 정책
## 📋 개요
AI 분야는 빠르게 발전하는 기술 영역이므로, 교육 자료의 지속적인 업데이트가 필수적입니다. 본 문서는 AI 전문가 양성 과정의 콘텐츠가 최신 AI 기술과 트렌드를 반영할 수 있도록 하는 체계적인 업데이트 정책을 설명합니다.
---
## 🔄 업데이트 주기 및 일정
### 정기 업데이트
| 업데이트 유형 | 주기 | 범위 | 담당 |
|------------|------|------|------|
| **마이너 업데이트** | 월 1회 | 코드 예제, 오류 수정, 링크 갱신 | 과정 조교 |
| **메이저 업데이트** | 분기 1회 | 최신 라이브러리 버전 반영, 새로운 기술 추가 | 강의 담당자 |
| **전체 개편** | 연 1회 | 커리큘럼 재구성, 대규모 콘텐츠 갱신 | 교육 위원회 |
### 업데이트 일정 계획 (2024년)
- **1월**: 2023년 4분기 AI 기술 동향 반영 (메이저 업데이트)
- **2월**: 코드 및 예제 점검 (마이너 업데이트)
- **3월**: 라이브러리 버전 업데이트 (마이너 업데이트)
- **4월**: 2024년 1분기 AI 기술 동향 반영 (메이저 업데이트)
- **7월**: 2024년 2분기 AI 기술 동향 반영 (메이저 업데이트)
- **8월**: 중간 교육과정 평가 및 피드백 수렴
- **9월**: 교육 콘텐츠 검토 워크샵
- **10월**: 2024년 3분기 AI 기술 동향 반영 (메이저 업데이트)
- **12월**: 2025년도 커리큘럼 전체 개편 준비 (전체 개편)
---
## 📊 업데이트 우선순위 결정 기준
교육 내용 업데이트의 우선순위는 다음 기준에 따라 결정됩니다:
### 1. 중요도 평가 매트릭스
| 기준 | 높음 (3점) | 중간 (2점) | 낮음 (1점) |
|------|---------|---------|---------|
| **산업 영향력** | 산업 전반에 근본적 변화 | 특정 영역 개선 | 제한적 영향 |
| **기술 성숙도** | 검증된 기술 | 초기 도입 단계 | 실험적 단계 |
| **학습 난이도** | 기존 지식으로 습득 가능 | 중간 수준의 학습 필요 | 심화 학습 필요 |
| **실무 적용성** | 즉시 적용 가능 | 부분적 적용 가능 | 연구 단계 |
총점 기준:
- **10-12점**: 즉시 업데이트 (1개월 이내)
- **7-9점**: 계획된 메이저 업데이트에 포함
- **4-6점**: 선택적 업데이트 또는 참고자료로 추가
### 2. 피드백 기반 업데이트
학습자와 강사의 피드백을 기반으로 한 업데이트 필요성도 고려합니다:
- **학습자 요청 빈도**: 특정 주제에 대한 질문이 빈번할 경우
- **이해도 측정**: 과제 및 퀴즈 결과에서 낮은 점수를 보이는 영역
- **강사 제안**: 교육 과정에서 강사들이 발견한 개선점
---
## 🔍 기술 모니터링 프로세스
최신 AI 기술을 지속적으로 모니터링하는 체계적인 프로세스를 운영합니다.
### 1. 주요 모니터링 대상
- **주요 AI 연구 기관**: OpenAI, Google DeepMind, Meta AI, Anthropic 등
- **학술 컨퍼런스**: NeurIPS, ICML, ICLR, ACL, CVPR 등
- **기술 블로그**: 주요 기업 및 연구소의 기술 블로그
- **오픈소스 프로젝트**: GitHub 트렌드, PyPI 업데이트
- **AI 뉴스 및 뉴스레터**: 주간 뉴스 요약 및 전문 뉴스레터
### 2. 모니터링 담당자 및 역할
- **기술 조사팀**: 최신 연구 논문 및 기술 동향 모니터링 (주 1회 보고)
- **라이브러리 담당**: 주요 라이브러리 버전 및 API 변경사항 추적 (월 1회 보고)
- **산업 동향 분석가**: 산업 적용 사례 및 채용 트렌드 분석 (분기 1회 보고)
- **교육 컨텐츠 큐레이터**: 모니터링된 정보를 교육 콘텐츠에 통합 검토
### 3. 정보 수집 및 공유 도구
- **Slack 채널**: #ai-trends 채널을 통한 일일 정보 공유
- **Notion 데이터베이스**: 모든 기술 동향 및 평가를 구조화하여 관리
- **월간 트렌드 리포트**: 매월 주요 발전 사항 요약 보고서 작성
---
## 📝 업데이트 프로세스 및 절차
### 1. 업데이트 워크플로우
```
기술 모니터링 → 중요도 평가 → 업데이트 제안 → 검토 및 승인 → 콘텐츠 개발 → 품질 검사 → 릴리스 → 알림
```
### 2. 단계별 세부 절차
#### 기술 모니터링
- 담당자가 할당된 영역의 기술 발전 모니터링
- 주간 요약 보고서 작성
#### 중요도 평가
- 평가 매트릭스에 따른 점수 산정
- 교육 콘텐츠 관련성 검토
#### 업데이트 제안
- 업데이트 제안서 작성 (템플릿 사용)
- 필요 리소스 및 일정 추정
#### 검토 및 승인
- 교육 위원회 검토
- 우선순위 및 일정 확정
#### 콘텐츠 개발
- 강의 자료, 코드 예제, 실습 과제 업데이트
- 관련 파트 간 일관성 확인
#### 품질 검사
- 기술적 정확성 확인
- 교육적 효과성 평가
#### 릴리스
- 버전 관리 시스템에 업데이트 반영
- 변경 로그 작성
#### 알림
- 학습자 및 강사에게 업데이트 내용 공지
- 주요 변경사항에 대한 설명 제공
---
## 📚 버전 관리 및 문서화
### 1. 버전 관리 체계
**버전 번호 체계**: `X.Y.Z`
- **X (메이저)**: 커리큘럼 구조 변경, 전체 개편 시 증가
- **Y (마이너)**: 새로운 기술 추가, 주요 라이브러리 버전 업데이트
- **Z (패치)**: 오류 수정, 설명 개선, 링크 갱신
### 2. 변경 로그 관리
각 업데이트는 다음 정보를 포함한 변경 로그로 문서화합니다:
- 버전 번호 및 릴리스 날짜
- 변경 유형 (추가, 수정, 삭제, 개선)
- 변경 내용 요약
- 영향받는 모듈/문서
- 담당자
- 관련 링크 (논문, 라이브러리 문서 등)
예시:
```markdown
## v1.2.0 (2024-04-15)
### 추가
- Part 7.3에 RAG(Retrieval-Augmented Generation) 고급 기법 섹션 추가 (@김교수)
- Part 13에 LangGraph를 활용한 에이전트 워크플로우 예제 추가 (@이강사)
### 수정
- PyTorch 라이브러리 예제를 v2.1.0 버전에 맞게 업데이트 (@박조교)
- FastAPI 관련 코드 최신 API 명세에 맞게 수정 (@최개발)
### 참고자료
- [RAG 고급 기법 논문](https://arxiv.org/abs/xxxx.xxxxx)
- [LangGraph 공식 문서](https://github.com/langchain-ai/langgraph)
```
### 3. 이전 버전 접근성
학습 진행 중인 수강생을 위해:
- 각 메이저 버전은 별도 브랜치로 유지
- 변경 전후 대응표 제공
- 필요시 이전 버전 자료 접근 방법 안내
---
## 🔗 학습자 참여 및 기여
### 1. 학습자 피드백 수렴 채널
- **GitHub Issues**: 기술적 오류, 개선 제안
- **과정 포럼**: 내용 관련 토론 및 질문
- **정기 설문조사**: 분기별 만족도 및 개선점 조사
- **오프라인 피드백 세션**: 분기별 피드백 모임
### 2. 학습자 기여 가이드
학습자의 직접 기여를 환영하며 다음과 같은 기여가 가능합니다:
- 오타 및 버그 수정 PR
- 보충 설명 자료 제안
- 추가 학습 자료 링크 제안
- 실습 코드 개선안 제출
### 3. 기여자 인정 정책
모든 기여자는 다음과 같이 인정됩니다:
- 변경 로그에 기여자 정보 포함
- Contributors 페이지에 등재
- 특별히 가치있는 기여에 대한 포인트 부여 (커뮤니티 포인트 시스템 연계)
---
## 🏆 최신 기술 통합 성공 사례
### 사례 1: Transformer 아키텍처 모듈 통합 (v1.0 → v1.1)
- **배경**: 2023년 초 새로운 Transformer 변형 아키텍처 등장
- **과정**: 2개월 간의 검증 후 Part 7.2에 통합
- **결과**: 학습자 이해도 23% 향상, 실무 적용 사례 증가
### 사례 2: RAG 기법 업데이트 (v1.1 → v1.2)
- **배경**: Retrieval-Augmented Generation 기술의 급속한 발전
- **과정**: 실무 전문가 초청 워크샵을 통한 핵심 내용 선별
- **결과**: 캡스톤 프로젝트에서 RAG 기반 솔루션 품질 향상
### 사례 3: FastAPI 코드 현대화 (v1.2 → v1.2.3)
- **배경**: FastAPI의 주요 API 변경
- **과정**: 학습자 제보로 발견, 긴급 패치로 반영
- **결과**: 실습 코드 오류 감소, 학습자 만족도 증가
---
## 📈 업데이트 효과 측정
### 1. 핵심 성과 지표 (KPIs)
- **학습 효과성**: 퀴즈/과제 점수, 완료율
- **만족도**: NPS 점수, 설문조사 결과
- **실무 연계성**: 취업률, 실무 적용 사례
- **콘텐츠 품질**: 오류 보고 건수, 질문 빈도
### 2. 모니터링 도구 및 방법
- **학습 분석 대시보드**: 모듈별 완료율 및 이해도 시각화
- **분기별 효과성 보고서**: 업데이트 전후 성과 비교
- **연간 종합 평가**: 교육 과정 전반의 효과성 분석
---
## 🌐 글로벌 AI 교육 트렌드 반영
### 1. 글로벌 AI 교육 벤치마킹
다음 기관의 커리큘럼 및 교육 방법론을 주기적으로 벤치마킹:
- Stanford University (CS224N, CS231N 등)
- MIT (6.S191, 6.S897 등)
- Fast.ai
- DeepLearning.AI
- Hugging Face 교육 과정
### 2. 교육 방법론 혁신 적용
- **프로젝트 기반 학습 (PBL)**: 실제 문제 해결 중심 학습
- **역진행 설계**: 학습 목표에서 역으로 커리큘럼 설계
- **마이크로 러닝**: 짧은 단위의 집중 학습 모듈 설계
- **적응형 학습 경로**: 학습자 수준에 따른 맞춤형 콘텐츠
---
## 👥 교육 콘텐츠 개발 협력 체계
### 1. 내부 교육 팀
- **교육 디렉터**: 전체 커리큘럼 방향 설정
- **과목별 전문가**: 각 파트 콘텐츠 담당
- **교육 디자이너**: 학습 경험 설계
- **기술 작가**: 문서화 및 가이드 작성
- **품질 관리자**: 정확성 및 일관성 검증
### 2. 외부 협력
- **현업 전문가 자문단**: 실무 적용성 검토
- **학계 연구진**: 최신 연구 동향 반영
- **기업 파트너**: 실제 기업 요구사항 반영
- **졸업생 네트워크**: 교육과정 효과성 피드백
---
## 📅 2025년 주요 업데이트 예정 항목
현재 모니터링 중이며 2025년 커리큘럼에 반영될 가능성이 높은 주요 기술/개념:
1. **다중 모달 LLM 응용**: 텍스트, 이미지, 오디오를 함께 처리하는 모델 활용법
2. **개인화된 소규모 LLM**: 특정 도메인에 최적화된 경량 모델 배포 전략
3. **분산 AI 시스템**: 에지 디바이스와 클라우드 간 협업 AI 아키텍처
4. **AI 안전성과 평가**: 안전한 AI 개발을 위한 평가 및 조정 방법론
5. **생성형 AI 규제 대응**: 법적, 윤리적 규제와 표준을 준수하는 개발 가이드
각 항목은 현재 평가 매트릭스에 따라 점수 산정 중이며, 기술 성숙도와 산업 적용 사례를 지속적으로 모니터링하고 있습니다.
---
## 📞 문의 및 제안
콘텐츠 업데이트에 관한 문의나 제안이 있으시면 아래 연락처로 연락해주세요:
- **이메일**: curriculum@aicourse.com
- **GitHub**: 이슈 또는 PR 제출
- **Discord**: #content-feedback 채널
\ No newline at end of file
ai_lecture/INDUSTRY_CASE_STUDIES.md 0 → 100644
View file @ c8d7c8b4
# AI 전문가 양성 과정 - 산업 사례 연결 가이드
## 📋 개요
이 문서는 AI 전문가 양성 과정의 이론적 지식을 실제 산업 현장의 적용 사례와 연결하기 위한 가이드입니다. 학습자들이 이론과 실무의 간극을 좁히고 실질적인 문제 해결 능력을 기를 수 있도록 다양한 산업 분야의 AI 적용 사례를 제공합니다.
---
## 🔄 산업 사례 통합 방식
### 1. 모듈별 산업 사례 연계 매트릭스
| 교육 모듈 | 산업 분야 | 사례 유형 | 적용 방식 |
|----------|---------|---------|----------|
| **Part 6: 머신러닝** | 금융, 제조, 의료 | 예측 모델, 이상 탐지 | 월간 사례 분석, 실무자 인터뷰 |
| **Part 7: 딥러닝** | 자율주행, 의료영상, 로보틱스 | 객체 인식, 이미지 분할 | 기술 데모, 논문 분석 |
| **Part 8-9: API 서빙** | SaaS, 클라우드 서비스 | 마이크로서비스, API 설계 | 아키텍처 분석, 실습 과제 |
| **Part 11: MLOps** | 대기업, 스타트업 | CI/CD, 모니터링 | 시스템 설계 실습, 사례 연구 |
| **Part 13: 생성형 AI** | 콘텐츠 제작, 고객 서비스 | RAG, 에이전트 시스템 | 라이브 데모, 기업 인터뷰 |
### 2. 사례 연결 방법론
- **이론 선행, 사례 후행**: 이론 개념 학습 후 관련 산업 사례 소개
- **문제 중심 접근**: 실제 기업의 문제 상황 제시 → 이론 학습 → 해결 방안 도출
- **기술 진화 트래킹**: 특정 기술의 산업 내 발전 과정을 시간순으로 추적
- **분야 교차 분석**: 동일 기술의 서로 다른 산업 분야 적용 사례 비교
---
## 🏭 주요 산업 분야별 AI 적용 사례
### 1. 금융 산업
#### 사례 1: 신한은행 AI 기반 신용평가 모델
- **적용 기술**: 앙상블 머신러닝 모델 (Decision Tree, RandomForest, XGBoost)
- **도입 배경**: 기존 신용평가 모델의 한계 극복 및 비정형 데이터 활용 필요성
- **결과**: 기본 모델 대비 신용위험 평가 정확도 17% 향상, 대출 승인율 12% 증가
- **관련 학습 모듈**: Part 6 (머신러닝), Part 12 (모델 최적화)
- **학습 연계점**:
- 분류 알고리즘의 실제 비즈니스 임팩트 이해
- 불균형 데이터 처리 기법의 실제 적용
- 모델 해석가능성(Explainable AI)의 중요성
#### 사례 2: 카카오페이 이상거래 탐지 시스템
- **적용 기술**: LSTM 기반 시계열 분석 + 규칙 기반 필터
- **도입 배경**: 결제 사기 증가와 기존 규칙 기반 시스템의 한계
- **결과**: 오탐률 22% 감소, 고객 경험 개선, 실시간 처리 가능
- **관련 학습 모듈**: Part 7 (딥러닝), Part 7.1 (RNN)
- **학습 연계점**:
- 시계열 데이터 전처리 기법
- 비지도 학습과 지도 학습의 조합
- 실시간 추론 시스템 설계
### 2. 의료 산업
#### 사례 1: 서울아산병원 의료영상 진단 보조 시스템
- **적용 기술**: CNN 기반 영상 분석 (U-Net 아키텍처)
- **도입 배경**: 의료진의 판독 부담 경감 및 진단 정확도 향상
- **결과**: 폐 결절 탐지 민감도 93%, 진단 시간 37% 단축
- **관련 학습 모듈**: Part 7 (딥러닝), Part 12 (모델 최적화)
- **학습 연계점**:
- 의료 데이터 특성과 전처리 방법
- 모델 성능과 추론 속도 간 균형
- 규제 환경에서의 AI 시스템 설계
#### 사례 2: 뷰노 VUNOmed-BoneAge 골연령 진단 솔루션
- **적용 기술**: 딥러닝 기반 영상 분석 (자체 개발 아키텍처)
- **도입 배경**: 소아청소년 성장 관련 진단의 정확도 및 일관성 향상
- **결과**: 의료기기 인증 획득, 판독 시간 40% 단축, 판독 일관성 향상
- **관련 학습 모듈**: Part 7 (딥러닝), Part 14 (AI 윤리)
- **학습 연계점**:
- 의료 AI 모델의 규제 승인 과정
- 의료진-AI 협력 모델 설계
- 데이터 개인정보 보호와 모델 학습
### 3. 제조 산업
#### 사례 1: 포스코 스마트 팩토리 품질 예측 시스템
- **적용 기술**: 시계열 예측 모델 + 강화학습 기반 제어
- **도입 배경**: 철강 제조 공정의 품질 편차 감소 및 에너지 효율화
- **결과**: 불량률 15% 감소, 에너지 소비 7% 절감, 설비 가동 최적화
- **관련 학습 모듈**: Part 6 (머신러닝), Part 7.5 (강화학습)
- **학습 연계점**:
- 산업 IoT 데이터와 머신러닝 통합
- 시뮬레이션 환경에서의 강화학습 적용
- 생산 시스템에서의 모델 배포 전략
#### 사례 2: 현대자동차 예지 정비 시스템
- **적용 기술**: 앙상블 모델 + 시계열 분석
- **도입 배경**: 차량 부품 고장 사전 예측을 통한 정비 비용 절감 및 고객 만족도 향상
- **결과**: 주요 부품 고장 예측 정확도 83%, 정비 비용 22% 절감
- **관련 학습 모듈**: Part 6 (머신러닝), Part 11 (MLOps)
- **학습 연계점**:
- 센서 데이터 처리 파이프라인 구축
- 점진적 학습 모델 설계
- 엣지 컴퓨팅 환경에서의 모델 최적화
### 4. 이커머스 및 리테일
#### 사례 1: 쿠팡 개인화 추천 시스템
- **적용 기술**: 협업 필터링 + 그래프 신경망(GNN)
- **도입 배경**: 사용자 경험 향상 및 구매 전환율 증대
- **결과**: 클릭률(CTR) 27% 향상, 구매 전환율 18% 증가
- **관련 학습 모듈**: Part 6 (머신러닝), Part 7.4 (그래프 신경망)
- **학습 연계점**:
- 추천 시스템의 실시간 학습과 서빙
- 사용자-아이템 상호작용 그래프 모델링
- A/B 테스트 설계 및 분석
#### 사례 2: 롯데온 실시간 재고 예측 시스템
- **적용 기술**: LSTM + Transformer 기반 시계열 예측
- **도입 배경**: 재고 최적화와 물류 효율성 향상
- **결과**: 품절률 18% 감소, 재고비용 9% 절감, 적시 보충률 향상
- **관련 학습 모듈**: Part 7.1 (RNN), Part 7.2 (Transformer)
- **학습 연계점**:
- 계절성을 고려한 시계열 모델링
- 다변량 요인 분석과 특성 중요도
- 온라인 학습 시스템 설계
### 5. 콘텐츠 및 미디어
#### 사례 1: 네이버 AI 기반 콘텐츠 큐레이션
- **적용 기술**: 딥러닝 기반 자연어 처리 + 컨텍스트 인식 추천
- **도입 배경**: 개인화된 뉴스 및 콘텐츠 추천 품질 향상
- **결과**: 콘텐츠 소비 시간 24% 증가, 이탈률 15% 감소
- **관련 학습 모듈**: Part 7.2 (Transformer), Part 7.3 (LLM 애플리케이션)
- **학습 연계점**:
- 뉴스 콘텐츠 임베딩 기법
- 사용자 관심사 모델링
- 콘텐츠 다양성과 추천 정확도 간 균형
#### 사례 2: CJ ENM 콘텐츠 성공 예측 AI
- **적용 기술**: 감성 분석 + 트렌드 예측 모델
- **도입 배경**: 콘텐츠 제작 투자 결정 최적화
- **결과**: 신규 콘텐츠 성공률 15% 향상, 제작 기간 20% 단축
- **관련 학습 모듈**: Part 6 (머신러닝), Part 13 (생성형 AI)
- **학습 연계점**:
- 비정형 데이터의 특성 추출
- 소셜 미디어 트렌드 분석
- 의사결정 지원 시스템 설계
---
## 👥 산업 전문가 연결 프로그램
### 1. 멘토링 프로그램
- **대상**: 각 산업별 3년 이상 AI 실무 경험 보유 전문가
- **운영 방식**: 6주 과정, 주 1회 온라인 미팅 (1시간)
- **주요 활동**:
- 실무에서의 AI 프로젝트 진행 노하우 공유
- 포트폴리오 검토 및 피드백
- 취업 준비 조언
### 2. 실무자 특강 시리즈
| 날짜 | 산업 분야 | 주제 | 연사 |
|------|----------|-----|------|
| 2024-07-15 | 금융 | "금융 AI 모델 규제 대응 전략" | 김태호 (신한은행 AI 랩 팀장) |
| 2024-08-12 | 의료 | "의료 영상 AI 개발 및 인증 과정" | 박지민 (뷰노 AI 연구소장) |
| 2024-09-09 | 제조 | "스마트팩토리 AI 적용 사례 및 과제" | 이민수 (포스코 DX 책임연구원) |
| 2024-10-14 | 이커머스 | "추천 시스템의 실시간 학습과 서빙" | 홍길동 (쿠팡 ML 아키텍트) |
| 2024-11-11 | 생성형 AI | "대기업에서의 생성형 AI 도입 사례" | 장서연 (삼성전자 AI센터) |
### 3. 기업 현장 방문 프로그램
- **목적**: 실제 AI 시스템이 운영되는 환경 견학 및 실무자와의 교류
- **대상 기업**: 네이버 AI 랩, 카카오 브레인, SK C&C AI 센터, LG AI 연구소 등
- **주요 활동**:
- 기업별 AI 사례 소개
- 개발 환경 및 인프라 견학
- 현업 개발자와의 Q&A 세션
- 채용 정보 공유
---
## 🛠️ 산업 연계 프로젝트
### 1. 기업 제안 과제 (Capstone Projects)
실제 기업에서 제안한 문제를 해결하는 프로젝트:
| 기업 | 과제 | 필요 기술 | 기간 |
|-----|-----|----------|-----|
| 현대카드 | 이상거래 탐지 모델 개선 | 시계열 분석, 이상치 탐지 | 4주 |
| 롯데헬스케어 | 건강검진 데이터 기반 질병 예측 | 분류 모델, 특성 선택 | 6주 |
| KT | 통신장애 예측 및 예방 시스템 | 그래프 분석, 시계열 예측 | 5주 |
| CJ대한통운 | 물류 최적화 AI 모델 | 강화학습, 경로 최적화 | 6주 |
### 2. 산업별 미니 프로젝트
각 산업 분야별로 실제 데이터를 활용한 실습 중심 미니 프로젝트:
#### 금융 분야
- **신용 위험 평가 모델**: 대출 심사를 위한 신용 평가 모델 개발
- **포트폴리오 최적화**: 머신러닝 기반 자산 배분 전략 개발
- **고객 이탈 예측**: 고객 행동 데이터를 활용한 이탈 예측 모델
#### 의료 분야
- **의료 영상 분할**: 실제 의료 영상 데이터를 활용한 종양 검출
- **환자 재입원 예측**: 전자의무기록(EMR) 데이터 기반 재입원 위험 예측
- **약물 상호작용 분석**: 그래프 신경망을 활용한 약물 상호작용 분석
#### 제조 분야
- **설비 고장 예측**: 센서 데이터를 활용한 설비 고장 예측
- **불량 탐지 시스템**: 컴퓨터 비전 기반 제품 불량 탐지
- **생산 스케줄링 최적화**: 강화학습 기반 생산 일정 최적화
---
## 📊 성과 측정 및 피드백
### 1. 산업 연계 성과 지표
산업 사례 연결 강화의 효과를 측정하기 위한 지표:
- **실무 적용 자신감**: 교육 전후 학습자의 실무 적용 자신감 변화
- **취업 연계율**: 교육 후 관련 산업 분야 취업 성공률
- **기업 만족도**: 기업 프로젝트 참여 후 고용주/멘토의 만족도
- **프로젝트 완성도**: 산업 표준에 기반한 프로젝트 평가 점수
### 2. 피드백 수집 방법
- **정기 설문조사**: 매 모듈 종료 후 산업 연계 교육 효과성 평가
- **졸업생 추적 조사**: 교육 종료 6개월 후 현업 적용 경험 조사
- **기업 파트너 피드백**: 참여 기업의 프로젝트 결과물 및 학습자 역량 평가
- **취업 인터뷰 피드백**: 취업 인터뷰 후 평가 내용 분석
---
## 🌐 국내 AI 산업 동향 및 전망
### 1. 산업별 AI 인력 수요 전망 (2024-2025)
| 산업 분야 | 인력 수요 | 주요 직무 | 필요 역량 |
|----------|---------|----------|---------|
| 금융 | 높음 ↑ | ML 엔지니어, 리스크 분석가 | 시계열 분석, 리스크 모델링 |
| 의료 | 매우 높음 ↑↑ | 의료 AI 연구원, 영상처리 전문가 | 영상 처리, 의료 규제 이해 |
| 제조 | 중간 → | MLOps 엔지니어, 예측 모델러 | 센서 데이터 처리, 산업 IoT |
| 이커머스 | 높음 ↑ | 추천 시스템 개발자, 수요 예측 분석가 | 추천 알고리즘, 대규모 데이터 처리 |
| 콘텐츠 | 매우 높음 ↑↑ | 생성형 AI 엔지니어, NLP 전문가 | 생성 모델, 멀티모달 처리 |
### 2. 주요 기업 AI 기술 도입 현황
**대기업**:
- **삼성전자**: 생성형 AI '삼성 가우스' 개발, 사내 문서 처리 및 코드 생성에 활용
- **현대자동차**: 자율주행 및 스마트팩토리 AI 시스템 구축, 로보틱스 연구 확대
- **SK**: AI 반도체 및 데이터센터 투자 확대, 에너지 관리 최적화 AI 도입
- **네이버**: HyperCLOVA X 개발, 검색 및 커머스 전반에 AI 통합
**스타트업**:
- **업스테이지**: 대규모 언어 모델 'SOLAR' 개발 및 오픈소스화
- **모두의연구소**: 한국어 특화 AI 모델 개발 및 기업 교육 확대
- **뤼튼**: 교육 특화 생성형 AI 솔루션 개발 및 글로벌 시장 진출
- **자이냅스**: 산업 특화 AI 문서 처리 솔루션 개발 및 금융권 도입 확대
### 3. 최신 기술 적용 트렌드
- **소규모 특화 모델(SLM)**: 대규모 모델보다 특정 도메인에 최적화된 경량 모델 선호
- **RAG 기반 솔루션**: 기업 내부 지식과 LLM을 연계한 RAG 시스템 도입 증가
- **멀티모달 AI**: 텍스트, 이미지, 음성을 통합 처리하는 AI 시스템 수요 증가
- **엣지 AI**: 현장에서의 실시간 처리를 위한 엣지 디바이스 최적화 모델 확산
- **AI 옵스**: 모델 모니터링, 피드백 수집, 지속적 학습을 위한 MLOps 체계 강화
---
## 📝 산업 연계 강화 로드맵
### 1. 단기 계획 (3-6개월)
- **산업별 사례 데이터베이스 구축**: 최소 50개 이상의 국내 AI 적용 사례 수집
- **산업 전문가 네트워크 확장**: 분야별 전문가 5명 이상 멘토 영입
- **커리큘럼 연계 지점 매핑**: 각 학습 모듈과 산업 사례 연결 포인트 식별
### 2. 중기 계획 (6-12개월)
- **산업 전문가 특강 시리즈 런칭**: 월 1회 이상 산업 AI 전문가 초청 강연
- **산업 연계 실습 자료 개발**: 각 모듈별 실제 산업 데이터 기반 실습 과제 개발
- **기업 프로젝트 파트너십 체결**: 최소 3개 이상의 기업과 프로젝트 협력 계약
### 3. 장기 계획 (12-24개월)
- **산학 협력 AI 연구소 설립**: 교육기관-기업 간 공동 연구 프로젝트 진행
- **취업 연계 프로그램 확대**: 기업 맞춤형 인재 양성 트랙 개설
- **산업 영향력 지표 개발**: 교육과정의 산업 기여도를 측정하는 평가 체계 구축
---
## 🔍 추가 자료 및 참고 리소스
### 산업별 AI 동향 리포트
- [금융권 AI 활용 현황 보고서 (한국금융연구원, 2023)](https://www.example.com)
- [제조업 디지털 트랜스포메이션 사례집 (산업연구원, 2023)](https://www.example.com)
- [의료 AI 기술 도입 동향 (한국보건산업진흥원, 2024)](https://www.example.com)
### 기업 AI 활용 사례 동영상
- [네이버 AI NOW 컨퍼런스 2023](https://www.example.com)
- [SK AI 포럼 2024](https://www.example.com)
- [삼성 개발자 컨퍼런스 2023](https://www.example.com)
### AI 직무 역량 가이드
- [AI 개발자 직무별 핵심 역량 로드맵 (모두의연구소, 2024)](https://www.example.com)
- [기업이 원하는 AI 인재상 설문조사 (한국경제연구원, 2023)](https://www.example.com)
- [한국형 AI 일자리 전망 (고용정보원, 2024)](https://www.example.com)
\ No newline at end of file
ai_lecture/ONLINE_COMMUNITY_GUIDE.md 0 → 100644
View file @ c8d7c8b4
# AI 전문가 양성 과정 - 온라인 커뮤니티 가이드
## 📋 개요
본 문서는 AI 전문가 양성 과정을 위한 온라인 커뮤니티 공간의 구축, 활용 및 참여 방법에 대한 가이드입니다. 학습자 간 지식 공유, 협업, 네트워킹을 촉진하기 위한 온라인 커뮤니티는 교육 효과를 극대화하는 핵심 요소입니다.
---
## 🌐 커뮤니티 플랫폼
### Discord 서버 (주요 소통 채널)
**서버 가입 방법:**
1. 초대 링크: [https://discord.gg/aicourse](https://discord.gg/aicourse) (예시 링크)
2. Discord 계정으로 로그인
3. 닉네임 설정 규칙: `실명(이니셜)_기수` (예: 홍길동(HGD)_3기)
4. #자기소개 채널에 간략한 자기소개 작성
**채널 구조:**
- **#공지사항**: 중요 공지 및 일정 안내
- **#질문-답변**: 학습 관련 질문과 답변
- **#자료-공유**: 유용한 학습 자료 공유
- **각 파트별 채널**: 특정 학습 주제 관련 토론
- #part1-개발환경
- #part2-5-파이썬-기초
- #part6-7-머신러닝-딥러닝
- #part8-9-api-서빙
- #part10-15-심화-캡스톤
- **#프로젝트-협업**: 팀 프로젝트 및 협업 관련 토론
- **#오프라인-모임**: 스터디 그룹 및 오프라인 모임 조직
- **#자유-게시판**: 자유로운 대화
### Slack 워크스페이스 (선택 사항)
Discord 외에도 Slack을 통한 소통을 원하는 경우 별도의 워크스페이스를 제공합니다.
**워크스페이스 가입 방법:**
1. 초대 링크: [https://join.slack.com/t/aicourse/signup](https://join.slack.com/t/aicourse/signup) (예시 링크)
2. 기업 이메일 또는 개인 이메일로 가입
3. 프로필 설정: 실명과 기수 표시
---
## 💬 커뮤니티 참여 가이드
### 1. 질문하기
효과적인 질문을 통해 빠르고 정확한 도움을 받을 수 있습니다:
1. **적절한 채널 선택**: 질문 내용에 가장 적합한 채널에 질문하세요.
2. **명확한 제목 작성**: 질문의 핵심을 간결하게 표현하는 제목을 작성합니다.
3. **충분한 컨텍스트 제공**:
- 실행한 코드
- 발생한 오류 메시지
- 시도한 해결 방법
- 기대했던 결과
4. **코드 공유 방법**:
- Discord/Slack의 코드 블록 사용: ` ```python ` 코드 ` ``` `
- 긴 코드는 [GitHub Gist](https://gist.github.com) 활용
### 2. 답변하기
커뮤니티의 성장은 구성원 모두의 기여에 달려 있습니다:
1. **건설적인 피드백**: 단순한 답변보다 학습 방향을 제시하는 피드백이 더 가치 있습니다.
2. **출처 공유**: 정보의 출처를 함께 공유하면 추가 학습에 도움이 됩니다.
3. **후속 확인**: 문제가 해결되었는지 확인하고, 필요 시 추가 도움을 제공합니다.
### 3. 자료 공유
좋은 자료를 발견했다면 커뮤니티와 공유해주세요:
1. **명확한 설명**: 공유하는 자료에 대한 간략한 설명을 함께 작성합니다.
2. **관련성 유지**: 과정 주제와 관련된 자료를 공유합니다.
3. **저작권 존중**: 저작권 정책을 준수하는 자료만 공유합니다.
---
## 🔄 주간 온라인 활동
### 1. 실시간 Q&A 세션
매주 수요일 저녁 8시에 진행되는 라이브 Q&A 세션에 참여하세요:
- **플랫폼**: Discord 음성 채널 #weekly-qa
- **진행 방식**: 사전 질문 접수 및 실시간 질문 답변
- **참여 방법**: 사전 질문은 #qa-submissions 채널에 등록
### 2. 멘토링 프로그램
선배 수강생 또는 현업 전문가와의 멘토링 기회:
- **신청 방법**: Discord #멘토링 채널에서 신청서 양식 작성
- **매칭 기간**: 매월 1일, 15일에 매칭 결과 안내
- **멘토링 세션**: 1:1 또는 소그룹 형태로 30분~1시간 진행
### 3. 주간 학습 체크인
매주 금요일, 한 주 동안의 학습 진도와 성과를 공유하는 시간:
- **체크인 방법**: #주간체크인 채널에 정해진 템플릿으로 작성
- **템플릿 형식**:
```
# 주간 체크인 (MM/DD - MM/DD)
## 완료한 학습
- [파트/주제명]
## 배운 점 & 성과
- (간략히 서술)
## 어려웠던 점
- (필요시 서술)
## 다음 주 목표
- (학습 계획)
```
---
## 👥 스터디 그룹 운영
### 1. 스터디 그룹 참여/개설
커뮤니티 내에서 관심 분야별 스터디 그룹을 운영합니다:
- **기존 그룹 참여**: Discord #스터디그룹 채널에서 활동 중인 그룹 확인
- **새 그룹 개설**: 양식에 따라 새 스터디 그룹 제안
```
# 스터디 그룹 개설 제안
- 주제: [스터디 주제]
- 목표: [구체적인 학습 목표]
- 인원: [희망 인원]
- 기간: [활동 기간]
- 진행방식: [온라인/오프라인, 주기]
- 연락처: [디스코드 ID 또는 이메일]
```
### 2. 그룹 활동 템플릿
효율적인 스터디 그룹 운영을 위한 템플릿:
- **킥오프 미팅 안내**: 첫 모임 일정 및 준비사항 공지
- **주간 과제 공지**: 학습할 내용과 목표 설정
- **회고 및 피드백**: 주기적 활동 평가와 개선점 도출
---
## 🏆 커뮤니티 기여 포인트 시스템
적극적인 커뮤니티 참여를 장려하기 위한 포인트 시스템입니다:
### 포인트 적립 방법
- **질문 답변**: 채택된 답변 +5점, 도움이 된 답변 +2점
- **유용한 자료 공유**: 추천 5개 이상 +3점
- **버그 제보/수정**: 과정 자료의 오류 발견/수정 +5점
- **미니 튜토리얼 작성**: 특정 주제에 대한 튜토리얼 +10점
- **스터디 그룹 리딩**: 그룹당 분기별 +15점
### 포인트 혜택
- **50점**: 한정판 프로필 배지
- **100점**: 전자책 학습 자료 제공
- **200점**: 개별 프로젝트 코드 리뷰 기회
- **500점**: 분기별 "최고 기여자" 인증서 및 기념품
---
## 📝 피드백 및 개선
커뮤니티는 구성원들의 의견에 따라 지속적으로 발전합니다:
- **정기 설문조사**: 분기별 1회 커뮤니티 만족도 및 개선점 설문
- **제안 채널**: Discord #제안-및-피드백 채널을 통한 상시 의견 수렴
- **모더레이터 지원**: 커뮤니티 운영에 참여하고 싶은 경우 모더레이터 신청 가능
---
## 📅 커뮤니티 이벤트 일정
| 날짜 | 이벤트 | 설명 |
|------|-------|------|
| 매주 수요일 20:00 | 실시간 Q&A | 주간 질의응답 시간 |
| 매월 첫째 주 금요일 | 게스트 강연 | 현업 전문가의 특별 강연 |
| 매월 셋째 주 토요일 | 코딩 챌린지 | 주제별 미니 프로젝트 대회 |
| 분기별 마지막 주 | 프로젝트 쇼케이스 | 우수 프로젝트 발표 및 공유 |
---
## 👥 커뮤니티 관리팀 연락처
문의사항이나 도움이 필요한 경우 아래 연락처로 문의해주세요:
- **Discord 관리자**: @Admin_AI
- **커뮤니티 매니저**: community@aicourse.com
- **기술 지원**: tech-support@aicourse.com
- **긴급 문의**: 010-1234-5678 (운영시간: 평일 10:00-18:00)
\ No newline at end of file
ai_lecture/PROGRESS_TRACKING_SYSTEM.md 0 → 100644
View file @ c8d7c8b4
This diff is collapsed.
ai_lecture/README.md
View file @ c8d7c8b4
# 16주 완성! AI 전문가 양성 과정: 파이썬부터 프로덕션 배포까지 # 16주 완성! AI 전문가 양성 과정: 파이썬부터 프로덕션 배포까지
![Course Banner](./assets/course_banner.png) ![과정 배너](./assets/course_banner.png)
[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/) [![파이썬](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![Poetry](https://img.shields.io/badge/Poetry-dependency%20management-blue.svg)](https://python-poetry.org/) [![Poetry](https://img.shields.io/badge/Poetry-dependency%20management-blue.svg)](https://python-poetry.org/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![코드 스타일: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Ruff](https://img.shields.io/badge/linter-ruff-red.svg)](https://github.com/astral-sh/ruff) [![Ruff](https://img.shields.io/badge/linter-ruff-red.svg)](https://github.com/astral-sh/ruff)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![라이센스: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CI/CD](https://img.shields.io/badge/CI%2FCD-GitLab%20CI-orange.svg)](http://gitlab.geumdo.net/root/geumdo_docs/-/pipelines) [![CI/CD](https://img.shields.io/badge/CI%2FCD-GitLab%20CI-orange.svg)](http://gitlab.geumdo.net/root/geumdo_docs/-/pipelines)
[![Progress Tracking](https://img.shields.io/badge/Progress-Tracking-green.svg)](./TODO.md) [![진행 상황 추적](https://img.shields.io/badge/Progress-Tracking-green.svg)](./TODO.md)
"아이디어는 있는데, 어떻게 만들어야 할지 막막하신가요?" "아이디어는 있는데, 어떻게 만들어야 할지 막막하신가요?"
"AI, 이제는 소비하는 것을 넘어 직접 만들고 싶으신가요?" "AI, 이제는 소비하는 것을 넘어 직접 만들고 싶으신가요?"
...@@ -71,22 +71,23 @@ ...@@ -71,22 +71,23 @@
각 파트별 상세 내용과 학습 목표는 아래 링크를 통해 확인하실 수 있습니다. 각 파트별 상세 내용과 학습 목표는 아래 링크를 통해 확인하실 수 있습니다.
- [Part 0: Introduction](./courses/00_introduction/README.md) - [Part 0: 과정 소개](./courses/00_introduction/README.md)
- [Part 1: AI Development Environment](./courses/01_ai_development_environment/README.md) - [Part 1: AI 개발 환경](./courses/01_ai_development_environment/README.md)
- [Part 2: Python Core Syntax](./courses/02_python_core_syntax/README.md) - [Part 2: 파이썬 핵심 문법](./courses/02_python_core_syntax/README.md)
- [Part 3: Python Collections](./courses/03_python_collections/README.md) - [Part 3: 파이썬 컬렉션](./courses/03_python_collections/README.md)
- [Part 4: Object Oriented Programming](./courses/04_object_oriented_programming/README.md) - [Part 4: 객체 지향 프로그래밍](./courses/04_object_oriented_programming/README.md)
- [Part 5: AI Core Libraries](./courses/05_ai_core_libraries/README.md) - [Part 5: AI 핵심 라이브러리](./courses/05_ai_core_libraries/README.md)
- [Part 6: Machine Learning](./courses/06_machine_learning/README.md) - [Part 5.5: 선형대수학](./courses/05.5_linear_algebra_with_numpy/README.md)
- [Part 7: Deep Learning](./courses/07_deep_learning/README.md) - [Part 6: 머신러닝](./courses/06_machine_learning/README.md)
- [Part 8: Model Serving with FastAPI](./courses/08_model_serving_with_fastapi/README.md) - [Part 7: 딥러닝](./courses/07_deep_learning/README.md)
- [Part 9: Production Ready API](./courses/09_production_ready_api/README.md) - [Part 8: FastAPI를 이용한 모델 서빙](./courses/08_model_serving_with_fastapi/README.md)
- [Part 10: Expert Path](./courses/10_expert_path/README.md) - [Part 9: 프로덕션 레벨 API](./courses/09_production_ready_api/README.md)
- [Part 10: 전문가 과정 로드맵](./courses/10_expert_path/README.md)
- [Part 11: MLOps](./courses/11_mlops/README.md) - [Part 11: MLOps](./courses/11_mlops/README.md)
- [Part 12: Model Optimization](./courses/12_model_optimization/README.md) - [Part 12: 모델 최적화](./courses/12_model_optimization/README.md)
- [Part 13: Generative AI](./courses/13_generative_ai/README.md) - [Part 13: 생성형 AI](./courses/13_generative_ai/README.md)
- [Part 14: AI Ethics](./courses/14_ai_ethics/README.md) - [Part 14: AI 윤리](./courses/14_ai_ethics/README.md)
- [Part 15: Capstone Project](./courses/15_capstone_project/README.md) - [Part 15: 캡스톤 프로젝트](./courses/15_capstone_project/README.md)
--- ---
...@@ -94,10 +95,10 @@ ...@@ -94,10 +95,10 @@
| 파트 (Part) | 주차 (Week) | 주제 (Topic) | 관련 문서 | 소스코드 | | 파트 (Part) | 주차 (Week) | 주제 (Topic) | 관련 문서 | 소스코드 |
|:---:|:---:|:---|:---|:---| |:---:|:---:|:---|:---|:---|
| **1** | 1-5주차 | **AI 개발을 위한 파이썬 마스터리** | [0. Intro](./courses/00_introduction/part_0_introduction.md)<br/>[0.1. History](./courses/00_introduction/part_0.1_history_of_ai.md)<br/>[1. Environment](./courses/01_ai_development_environment/part_1_ai_development_environment.md)<br/>[2. Python Core](./courses/02_python_core_syntax/part_2_python_core_syntax.md)<br/>[3. Collections](./courses/03_python_collections/part_3_python_collections.md)<br/>[4. OOP](./courses/04_object_oriented_programming/part_4_object_oriented_programming.md)<br/>[5. AI Libs](./courses/05_ai_core_libraries/part_5_ai_core_libraries.md) | [Part 2](./source_code/02_python_core_syntax/)<br/>[Part 3](./source_code/03_python_collections/)<br/>[Part 4](./source_code/04_object_oriented_programming/)<br/>[Part 5](./source_code/05_ai_core_libraries/) | | **1** | 1-5주차 | **AI 개발을 위한 파이썬 마스터리** | [0. 소개](./courses/00_introduction/part_0_introduction.md)<br/>[0.1. AI의 역사](./courses/00_introduction/part_0.1_history_of_ai.md)<br/>[1. 개발환경](./courses/01_ai_development_environment/part_1_ai_development_environment.md)<br/>[2. 파이썬 핵심](./courses/02_python_core_syntax/part_2_python_core_syntax.md)<br/>[3. 컬렉션](./courses/03_python_collections/part_3_python_collections.md)<br/>[4. 객체지향](./courses/04_object_oriented_programming/part_4_object_oriented_programming.md)<br/>[5. AI 라이브러리](./courses/05_ai_core_libraries/part_5_ai_core_libraries.md)<br/>[5.5. 선형대수학](./courses/05.5_linear_algebra_with_numpy/part_5.5_linear_algebra_with_numpy.md) | [Part 2](./source_code/02_python_core_syntax/)<br/>[Part 3](./source_code/03_python_collections/)<br/>[Part 4](./source_code/04_object_oriented_programming/)<br/>[Part 5](./source_code/05_ai_core_libraries/)<br/>[Part 5.5](./source_code/05.5_linear_algebra_with_numpy/) |
| **2** | 6-9주차 | **핵심 AI 모델 개발 및 서빙** | [6. ML](./courses/06_machine_learning/part_6_machine_learning.md)<br/>[7. DL](./courses/07_deep_learning/part_7_deep_learning.md)<br/>[7.1. RNN](./courses/07_deep_learning/part_7.1_recurrent_neural_networks.md)<br/>[7.2. Transformer](./courses/07_deep_learning/part_7.2_transformer_and_llm_principles.md)<br/>[7.3. LangChain](./courses/07_deep_learning/part_7.3_llm_application_development_with_langchain.md)<br/>[7.4. GNN](./courses/07_deep_learning/part_7.4_graph_neural_networks.md)<br/>[7.5. RL](./courses/07_deep_learning/part_7.5_reinforcement_learning.md)<br/>[8. FastAPI Serving](./courses/08_model_serving_with_fastapi/part_8_model_serving_with_fastapi.md)<br/>[9. Production API](./courses/09_production_ready_api/part_9_production_ready_api.md) | [Part 6](./source_code/06_machine_learning/)<br/>[Part 7](./source_code/07_deep_learning/)<br/>[Part 8](./source_code/08_model_serving_with_fastapi/)<br/>[Part 9](./source_code/09_production_ready_api/) | | **2** | 6-9주차 | **핵심 AI 모델 개발 및 서빙** | [6. 머신러닝](./courses/06_machine_learning/part_6_machine_learning.md)<br/>[7. 딥러닝](./courses/07_deep_learning/part_7_deep_learning.md)<br/>[7.1. RNN](./courses/07_deep_learning/part_7.1_recurrent_neural_networks.md)<br/>[7.2. Transformer](./courses/07_deep_learning/part_7.2_transformer_and_llm_principles.md)<br/>[7.3. LangChain](./courses/07_deep_learning/part_7.3_llm_application_development_with_langchain.md)<br/>[7.4. GNN](./courses/07_deep_learning/part_7.4_graph_neural_networks.md)<br/>[7.5. 강화학습](./courses/07_deep_learning/part_7.5_reinforcement_learning.md)<br/>[8. FastAPI 서빙](./courses/08_model_serving_with_fastapi/part_8_model_serving_with_fastapi.md)<br/>[9. 프로덕션 API](./courses/09_production_ready_api/part_9_production_ready_api.md) | [Part 6](./source_code/06_machine_learning/)<br/>[Part 7](./source_code/07_deep_learning/)<br/>[Part 8](./source_code/08_model_serving_with_fastapi/)<br/>[Part 9](./source_code/09_production_ready_api/) |
| **3** | 10-13주차 | **프로덕션 MLOps 및 AI 심화** | [10. Expert Path](./courses/10_expert_path/part_10_expert_path.md)<br/>[11. MLOps](./courses/11_mlops/part_11_mlops.md)<br/>[12. Optimization](./courses/12_model_optimization/part_12_model_optimization.md)<br/>[13. Generative AI](./courses/13_generative_ai/part_13_generative_ai.md)<br/>[14. AI Ethics](./courses/14_ai_ethics/part_14_ai_ethics.md) | [Part 11](./source_code/11_mlops/)<br/>[Part 12](./source_code/12_model_optimization/)<br/>[Part 13](./source_code/13_generative_ai/)<br/>[Part 14](./source_code/14_ai_ethics/) | | **3** | 10-13주차 | **프로덕션 MLOps 및 AI 심화** | [10. 전문가 과정](./courses/10_expert_path/part_10_expert_path.md)<br/>[11. MLOps](./courses/11_mlops/part_11_mlops.md)<br/>[12. 모델 최적화](./courses/12_model_optimization/part_12_model_optimization.md)<br/>[13. 생성형 AI](./courses/13_generative_ai/part_13_generative_ai.md)<br/>[14. AI 윤리](./courses/14_ai_ethics/part_14_ai_ethics.md) | [Part 11](./source_code/11_mlops/)<br/>[Part 12](./source_code/12_model_optimization/)<br/>[Part 13](./source_code/13_generative_ai/)<br/>[Part 14](./source_code/14_ai_ethics/) |
| **4** | 14-15주차 | **최종 캡스톤 프로젝트** | [15. Capstone](./courses/15_capstone_project/part_15_capstone_project.md) | (프로젝트 개별 진행) | | **4** | 14-15주차 | **최종 캡스톤 프로젝트** | [15. 캡스톤](./courses/15_capstone_project/part_15_capstone_project.md) | (프로젝트 개별 진행) |
--- ---
...@@ -127,6 +128,23 @@ ...@@ -127,6 +128,23 @@
--- ---
## 📑 추가 가이드 및 참고 자료
**커뮤니티 및 협업**
- **[온라인 커뮤니티 가이드](./ONLINE_COMMUNITY_GUIDE.md)**: Discord 및 Slack 커뮤니티 활용 방법과 효과적인 참여 가이드
- **[짝 프로그래밍 가이드](./PAIR_PROGRAMMING_GUIDE.md)**: 효율적인 학습을 위한 짝 프로그래밍 방법론 및 실습 적용 방안
**실무 적용 및 도구**
- **[산업 사례 연결 가이드](./INDUSTRY_CASE_STUDIES.md)**: 이론적 학습 내용과 실제 산업 적용 사례를 연결하는 가이드
- **[클라우드 AI 서비스 가이드](./Cloud_AI_Services_Guide.md)**: AWS, Google Cloud, Azure의 AI 서비스 특징 및 선택 가이드
- **[도구 및 프레임워크 비교](./Tooling_Frameworks_Comparison.md)**: 주요 AI 개발 도구 및 프레임워크 비교 분석
**학습 관리 및 콘텐츠**
- **[진도 관리 시스템](./PROGRESS_TRACKING_SYSTEM.md)**: 학습 진도를 체계적으로 관리하는 고급 시스템 설명
- **[콘텐츠 업데이트 정책](./AI_CONTENT_UPDATE_POLICY.md)**: 최신 AI 기술 트렌드를 교육 과정에 반영하는 업데이트 정책
---
## 🎯 학습 진도 관리 ## 🎯 학습 진도 관리
### 진도 체크 시스템 ### 진도 체크 시스템
...@@ -170,7 +188,7 @@ make progress-export FILE=my_progress.md ...@@ -170,7 +188,7 @@ make progress-export FILE=my_progress.md
## 📊 프로젝트 통계 ## 📊 프로젝트 통계
- **Python 코드**: 6,492줄 - **파이썬 코드**: 6,492줄
- **문서**: 10,224줄 (마크다운) - **문서**: 10,224줄 (마크다운)
- **Jupyter 노트북**: 10개 - **Jupyter 노트북**: 10개
- **테스트 파일**: 8개 - **테스트 파일**: 8개
......
ai_lecture/courses/05.5_linear_algebra_with_numpy/README.md 0 → 100644
View file @ c8d7c8b4
# Part 5.5: NumPy로 배우는 선형대수학
이 파트에서는 머신러닝과 딥러닝의 수학적 기반이 되는 선형대수학의 핵심 개념을 NumPy를 활용하여 학습합니다.
## 📚 학습 자료
- **[강의 노트](./part_5.5_linear_algebra_with_numpy.md)**: 선형대수학의 핵심 개념과 NumPy를 활용한 구현 방법에 대한 상세 설명을 제공합니다.
- **[핵심 용어집](../../glossary.md)**: 이 파트의 주요 용어와 개념을 정리했습니다.
## 💻 실습 코드
- **[예제 코드](../../source_code/05.5_linear_algebra_with_numpy/)**: 강의 내용을 직접 실행해볼 수 있는 코드입니다.
## 📋 주요 학습 내용
1. **벡터와 행렬의 기본 개념**
- 벡터의 연산: 덧셈, 뺄셈, 스칼라 곱, 내적, 외적
- 행렬의 연산: 덧셈, 뺄셈, 곱셈, 전치, 행렬식, 역행렬
2. **고급 선형대수 개념**
- 고유값과 고유벡터
- 특이값 분해(SVD)
- 선형 변환
3. **머신러닝에서의 응용**
- 주성분 분석(PCA)
- 선형 회귀
- 딥러닝에서의 활용
---
[↩️ 전체 커리큘럼으로 돌아가기](../../README.md)
\ No newline at end of file
ai_lecture/courses/06_machine_learning/part_6_machine_learning.md
View file @ c8d7c8b4
...@@ -163,6 +163,16 @@ print(f"정확도: {accuracy:.4f}") ...@@ -163,6 +163,16 @@ print(f"정확도: {accuracy:.4f}")
- **StandardScaler**: 평균 0, 표준편차 1로 변환. (분포가 정규분포에 가까울 때 효과적) - **StandardScaler**: 평균 0, 표준편차 1로 변환. (분포가 정규분포에 가까울 때 효과적)
- **MinMaxScaler**: 최솟값 0, 최댓값 1로 변환. (모든 값을 0과 1 사이로 만들고 싶을 때) - **MinMaxScaler**: 최솟값 0, 최댓값 1로 변환. (모든 값을 0과 1 사이로 만들고 싶을 때)
> **💡 스케일러의 수학적 원리**
>
> - **StandardScaler (표준화)**: 각 특성의 평균(μ)을 0, 표준편차(σ)를 1로 만듭니다.
> \[ z = \frac{x - \mu}{\sigma} \]
> 이는 데이터의 분포를 정규분포와 유사하게 만들어, 거리 기반 알고리즘(e.g., SVM, 로지스틱 회귀)이나 경사 하강법을 사용하는 모델의 성능을 향상시키는 데 도움을 줍니다.
>
> - **MinMaxScaler (정규화)**: 각 특성의 모든 값을 0과 1 사이로 조정합니다.
> \[ x' = \frac{x - \min(x)}{\max(x) - \min(x)} \]
> 이미지 픽셀 값을 0~255에서 0~1 사이로 변환하거나, 신경망 모델의 입력으로 사용할 때 자주 사용됩니다.
```python ```python
from sklearn.preprocessing import StandardScaler, MinMaxScaler from sklearn.preprocessing import StandardScaler, MinMaxScaler
import numpy as np import numpy as np
......
ai_lecture/courses/07_deep_learning/part_7_deep_learning.md
View file @ c8d7c8b4
...@@ -147,6 +147,9 @@ print(model) ...@@ -147,6 +147,9 @@ print(model)
> >
> #### 2. 교차 엔트로피 오차 (Cross-Entropy Loss) > #### 2. 교차 엔트로피 오차 (Cross-Entropy Loss)
> - **개념**: 모델이 예측한 '확률 분포'와 실제 정답의 '확률 분포'가 얼마나 다른지를 측정합니다. 모델이 정답 클래스를 얼마나 높은 확률로 예측했는지에 따라 손실이 결정됩니다. > - **개념**: 모델이 예측한 '확률 분포'와 실제 정답의 '확률 분포'가 얼마나 다른지를 측정합니다. 모델이 정답 클래스를 얼마나 높은 확률로 예측했는지에 따라 손실이 결정됩니다.
> - **수식**:
> \[ L_{CE} = -\sum_{i=1}^{C} y_i \log(\hat{y}_i) \]
> 여기서 \(C\)는 클래스의 수, \(y_i\)는 \(i\)번째 클래스에 대한 실제 값(정답은 1, 나머지는 0), \(\hat{y}_i\)는 모델이 예측한 \(i\)번째 클래스에 대한 확률입니다.
> - **언제 사용하나?**: **분류(Classification)** 문제. (예: 이미지 분류, 스팸 메일 분류 등 카테고리를 예측할 때) > - **언제 사용하나?**: **분류(Classification)** 문제. (예: 이미지 분류, 스팸 메일 분류 등 카테고리를 예측할 때)
> - **PyTorch**: `nn.CrossEntropyLoss()` > - **PyTorch**: `nn.CrossEntropyLoss()`
> - `nn.CrossEntropyLoss`는 내부적으로 `Softmax` 함수를 적용한 후 `NLLLoss`를 계산하므로, 모델의 마지막 레이어에 별도의 `Softmax`를 추가할 필요가 없습니다. > - `nn.CrossEntropyLoss`는 내부적으로 `Softmax` 함수를 적용한 후 `NLLLoss`를 계산하므로, 모델의 마지막 레이어에 별도의 `Softmax`를 추가할 필요가 없습니다.
......
ai_lecture/courses/13_generative_ai/part_13.1_advanced_rag_techniques.md 0 → 100644
View file @ c8d7c8b4
# 고급 RAG 기법: 검색 증강 생성의 최신 기술과 구현
## 📋 학습 목표
이 모듈을 통해 다음을 학습하게 됩니다:
- RAG 시스템의 다양한 아키텍처 변형과 장단점을 이해합니다.
- 검색 품질 향상을 위한 고급 기법을 구현할 수 있습니다.
- 복잡한 질문에 정확하게 응답하는 RAG 파이프라인을 최적화할 수 있습니다.
- 프로덕션 환경에서의 RAG 성능 평가 및 모니터링 방법을 습득합니다.
## 1. RAG 아키텍처의 진화
### 1.1 기본 RAG vs. 고급 RAG 아키텍처
**기본 RAG 아키텍처의 한계:**
- 단순 의미 검색만으로는 복잡한 질문에 대응하기 어려움
- 컨텍스트 길이 제한으로 인한 정보 손실
- 연관성 높은 문서 선별의 어려움
**고급 RAG 아키텍처 특징:**
```python
# 기본 RAG 구현
from langchain.chains import RetrievalQA
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(embedding_function=embeddings, persist_directory="./chroma_db")
qa_chain = RetrievalQA.from_chain_type(
llm=OpenAI(),
retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)
```
### 1.2 Hybrid Search 구현
키워드 기반 검색(BM25)과 의미 기반 검색을 결합하여 검색 품질 향상
```python
# Hybrid Search 구현 예시
from langchain.retrievers import BM25Retriever, EnsembleRetriever
# 임베딩 기반 검색기
embedding_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# BM25 검색기 (키워드 기반)
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 3
# 앙상블 검색기
ensemble_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, embedding_retriever],
weights=[0.5, 0.5]
)
```
### 1.3 멀티 벡터 검색(Multi-Vector Retrieval)
문서를 다양한 관점에서 임베딩하여 검색 효율성 향상
```python
# 멀티 벡터 검색 구현 예시
from langchain.schema import Document
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.storage import InMemoryStore
# 문서 저장소
store = InMemoryStore()
id_key = "doc_id"
# 각 문서를 여러 청크로 분할하고 각 청크에 원본 문서 ID 연결
for i, doc in enumerate(documents):
# 문서별 고유 ID 생성
doc_id = f"doc_{i}"
# 문서를 청크로 분할
chunks = text_splitter.split_text(doc.page_content)
# 각 청크에 원본 문서 ID 메타데이터 추가
for j, chunk in enumerate(chunks):
_id = f"{doc_id}_chunk_{j}"
store.mset([(
_id,
{"id": _id, "doc_id": doc_id, "text": chunk, "metadata": doc.metadata}
)])
# 멀티 벡터 검색기 생성
retriever = MultiVectorRetriever(
vectorstore=vectorstore,
docstore=store,
id_key=id_key,
)
```
## 2. 고급 RAG 파이프라인 최적화
### 2.1 쿼리 최적화 기법
#### 2.1.1 Query Expansion
```python
# 쿼리 확장 구현 예시
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
# 원본 검색기
base_retriever = vectorstore.as_retriever()
# LLM을 사용한 쿼리 확장
def expand_query(query):
prompt = f"""
원본 질문: {query}
이 질문과 관련된 키워드와 관련 질문을 3개 생성해주세요.
결과는 쉼표로 구분된 목록으로 반환하세요.
"""
response = llm.predict(prompt)
expanded_terms = [term.strip() for term in response.split(',')]
expanded_query = query + " " + " ".join(expanded_terms)
return expanded_query
# 확장된 쿼리를 사용한 검색
def retrieval_with_query_expansion(query):
expanded_query = expand_query(query)
print(f"확장된 쿼리: {expanded_query}")
return base_retriever.get_relevant_documents(expanded_query)
```
#### 2.1.2 HyDE (Hypothetical Document Embeddings)
```python
# HyDE 구현 예시
def hyde_retrieval(query):
# 1. 가상 문서 생성
hypothetical_doc_prompt = f"""
다음 질문에 대한 이상적인 답변 문서를 생성해주세요:
{query}
답변 문서:
"""
hypothetical_doc = llm.predict(hypothetical_doc_prompt)
# 2. 가상 문서를 임베딩
hyde_embedding = embeddings.embed_query(hypothetical_doc)
# 3. 유사 문서 검색
docs = vectorstore.similarity_search_by_vector(hyde_embedding, k=3)
return docs
```
### 2.2 임베딩 모델 성능 비교
다양한 임베딩 모델의 성능과 비용 효율성 비교
```python
# 여러 임베딩 모델 성능 비교
from langchain.embeddings import OpenAIEmbeddings, HuggingFaceEmbeddings
import time
models_to_compare = {
"OpenAI Ada 002": OpenAIEmbeddings(),
"BAAI/bge-large-en-v1.5": HuggingFaceEmbeddings(model_name="BAAI/bge-large-en-v1.5"),
"Cohere": CohereEmbeddings(),
"sentence-transformers/all-MiniLM-L6-v2": HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)
}
# 테스트 쿼리 세트
test_queries = ["인공지능의 윤리적 문제는 무엇인가요?", "파이썬에서 리스트와 튜플의 차이점은?"]
results = {}
for model_name, model in models_to_compare.items():
print(f"Testing {model_name}...")
# 속도 측정
start_time = time.time()
embeddings = [model.embed_query(q) for q in test_queries]
elapsed = time.time() - start_time
# 결과 저장
results[model_name] = {
"avg_time_per_query": elapsed / len(test_queries),
"embedding_dimension": len(embeddings[0])
}
# 결과 출력
for model, stats in results.items():
print(f"{model}: {stats['avg_time_per_query']:.4f}초/쿼리, {stats['embedding_dimension']} 차원")
```
### 2.3 벡터 데이터베이스 성능 평가
```python
# 벡터 DB 성능 비교 예시 코드
import time
def benchmark_vector_db(db_name, db_instance, query, k=3):
"""벡터 데이터베이스 검색 성능 측정"""
start_time = time.time()
results = db_instance.similarity_search(query, k=k)
query_time = time.time() - start_time
return {
"name": db_name,
"query_time": query_time,
"num_results": len(results)
}
# 벤치마크 실행
benchmark_results = []
test_query = "머신러닝 모델 평가 방법은 무엇인가요?"
# Chroma 벤치마크
benchmark_results.append(benchmark_vector_db("Chroma", chroma_db, test_query))
# FAISS 벤치마크
benchmark_results.append(benchmark_vector_db("FAISS", faiss_db, test_query))
# 결과 출력
for result in benchmark_results:
print(f"{result['name']}: {result['query_time']:.4f}초, {result['num_results']} 결과")
```
## 3. 맥락 관리 강화 기법
### 3.1 장기 기억 메커니즘
대화 이력을 요약하고 필요시 검색하는 메모리 시스템 구현
```python
# 대화 요약 메모리 구현 예시
from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain
# 대화 요약 메모리 초기화
memory = ConversationSummaryBufferMemory(
llm=llm,
max_token_limit=100,
return_messages=True
)
# 대화 체인 생성
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True
)
# 대화 진행
conversation.predict(input="안녕하세요!")
conversation.predict(input="RAG 시스템에 대해 알려주세요.")
# 요약된 메모리 확인
print(memory.moving_summary_buffer)
```
### 3.2 대화 컨텍스트와 RAG 통합
사용자 질문과 대화 히스토리를 고려한 최적의 검색 쿼리 생성
```python
# 대화 컨텍스트 기반 쿼리 최적화
def contextual_query_generator(question, chat_history):
# 대화 이력을 문자열로 변환
history_text = "\n".join([f"Human: {h[0]}\nAI: {h[1]}" for h in chat_history[-3:]])
prompt = f"""
이전 대화:
{history_text}
사용자 질문: {question}
위 대화 맥락을 고려하여, 벡터 데이터베이스 검색에 가장 효과적인 검색 쿼리를 생성해주세요.
쿼리는 단순히 질문을 그대로 사용하는 것이 아니라, 현재 대화 컨텍스트와 사용자의 의도를 정확히 반영해야 합니다.
최적화된 쿼리:
"""
optimized_query = llm.predict(prompt).strip()
return optimized_query
# 사용 예시
chat_history = [
("RAG란 무엇인가요?", "RAG는 Retrieval-Augmented Generation의 약자로..."),
("어떤 임베딩 모델이 좋나요?", "OpenAI의 text-embedding-ada-002와 같은 모델이..."),
]
question = "이를 개선하는 방법이 있을까요?"
optimized_query = contextual_query_generator(question, chat_history)
print(f"원본 질문: {question}")
print(f"최적화된 쿼리: {optimized_query}")
```
## 4. RAG 평가 및 최적화
### 4.1 RAGAS 평가 프레임워크 활용
```python
# RAGAS를 사용한 RAG 시스템 평가
!pip install ragas
from ragas.metrics import (
faithfulness,
answer_relevancy,
context_relevancy,
context_recall
)
from ragas.langchain import RagasEvaluator
# 평가 데이터셋 준비
eval_dataset = [
{
"question": "딥러닝과 머신러닝의 차이점은 무엇인가요?",
"ground_truth": "머신러닝은 데이터에서 패턴을 학습하는 알고리즘이며, 딥러닝은 머신러닝의 하위 분야로 인공 신경망을 사용합니다."
},
# 더 많은 평가 데이터...
]
# 평가자 정의
evaluator = RagasEvaluator(
metrics=[
faithfulness,
answer_relevancy,
context_relevancy,
context_recall
]
)
# RAG 체인 평가
eval_results = evaluator.evaluate_queries(
rag_chain=qa_chain,
queries=[item["question"] for item in eval_dataset]
)
# 결과 분석
print(eval_results)
```
### 4.2 A/B 테스트 설계
다양한 RAG 설계 옵션을 체계적으로 비교하는 실험
```python
# RAG A/B 테스트 구현
import random
from collections import defaultdict
# 테스트할 RAG 변형들
rag_variants = {
"basic": basic_rag_chain,
"hybrid_search": hybrid_rag_chain,
"query_expansion": query_expansion_rag_chain,
"hyde": hyde_rag_chain
}
# 평가 질문 세트
evaluation_questions = [
"딥러닝 모델 학습 시 과적합을 방지하는 방법은?",
"트랜스포머 아키텍처의 주요 구성 요소는?",
# 더 많은 질문...
]
# A/B 테스트 실행
results = defaultdict(list)
for question in evaluation_questions:
# 각 변형에 대해 테스트
for variant_name, variant_chain in rag_variants.items():
response = variant_chain({"query": question})
# 사용자 만족도 시뮬레이션 (실제로는 사용자 피드백으로 대체)
# 1-5 점수 랜덤 할당 (실제 구현에서는 실제 평가 점수 사용)
satisfaction_score = random.randint(1, 5)
# 결과 저장
results[variant_name].append({
"question": question,
"answer": response["result"],
"satisfaction": satisfaction_score,
"latency": response.get("latency", 0) # 응답 시간
})
# 결과 분석
for variant, data in results.items():
avg_satisfaction = sum(item["satisfaction"] for item in data) / len(data)
avg_latency = sum(item["latency"] for item in data) / len(data)
print(f"{variant}: 만족도={avg_satisfaction:.2f}/5, 응답시간={avg_latency:.2f}초")
```
## 5. 산업 적용 사례
### 5.1 내부 지식베이스 챗봇
```python
# 내부 문서 처리 및 챗봇 구현
from langchain.document_loaders import DirectoryLoader, TextLoader, PDFMinerLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import ConversationalRetrievalChain
# 다양한 형식의 문서 로더 설정
loaders = {
"*.txt": DirectoryLoader("./company_docs", glob="**/*.txt", loader_cls=TextLoader),
"*.pdf": DirectoryLoader("./company_docs", glob="**/*.pdf", loader_cls=PDFMinerLoader),
# 다른 파일 형식 추가
}
# 모든 문서 로드
documents = []
for loader in loaders.values():
documents.extend(loader.load())
# 문서 분할
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
separators=["\n\n", "\n", ".", " ", ""]
)
chunks = text_splitter.split_documents(documents)
# 벡터 저장소 생성
vectorstore = Chroma.from_documents(chunks, embeddings)
# 대화형 RAG 체인 구현
qa_chain = ConversationalRetrievalChain.from_llm(
llm=ChatOpenAI(temperature=0),
retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
return_source_documents=True,
verbose=True
)
# 대화 예시
chat_history = []
query = "우리 회사의 휴가 정책은 어떻게 되나요?"
result = qa_chain({"question": query, "chat_history": chat_history})
chat_history.append((query, result["answer"]))
print(f"질문: {query}")
print(f"답변: {result['answer']}")
print("출처 문서:")
for doc in result["source_documents"]:
print(f"- {doc.metadata.get('source', '알 수 없는 출처')}")
```
## 6. 실습 과제
1. 하이브리드 검색 구현하기: BM25와 임베딩 검색을 결합한 RAG 시스템을 구축하고 성능을 평가하세요.
2. 쿼리 최적화: HyDE 방식을 구현하여 기본 RAG와 성능을 비교하세요.
3. 대화형 RAG 시스템 개발: 대화 이력을 요약하고 활용하는 챗봇을 구현하세요.
4. RAGAS 평가: 자신이 구현한 RAG 시스템을 RAGAS 프레임워크로 평가하고 개선점을 도출하세요.
## 📚 추가 자료
- [RAG Paper (Lewis et al.)](https://arxiv.org/abs/2005.11401)
- [LangChain RAG Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
- [Advanced RAG Techniques Blog](https://towardsdatascience.com/advanced-rag-techniques-beyond-basic-retrieval-for-complex-qa-systems-ce63a312ef71)
- [RAGAS: Evaluation Framework for RAG](https://github.com/explodinggradients/ragas)
\ No newline at end of file
ai_lecture/glossary.md
View file @ c8d7c8b4
...@@ -621,7 +621,21 @@ ...@@ -621,7 +621,21 @@
- **LLMOps (Large Language Model Operations)**: 프롬프트 관리, 정성적 성능 평가, 실행 과정 추적 등 LLM 기반 애플리케이션의 전체 수명 주기를 안정적으로 관리하고 운영하기 위한 MLOps의 특화된 분야입니다. - **LLMOps (Large Language Model Operations)**: 프롬프트 관리, 정성적 성능 평가, 실행 과정 추적 등 LLM 기반 애플리케이션의 전체 수명 주기를 안정적으로 관리하고 운영하기 위한 MLOps의 특화된 분야입니다.
- **LangSmith**: LLM 애플리케이션의 개발 및 운영을 위한 통합 플랫폼으로, 복잡한 체인과 에이전트의 내부 동작을 추적, 모니터링, 평가하는 강력한 기능을 제공합니다. - **LangSmith**: LLM 애플리케이션의 개발 및 운영을 위한 통합 플랫폼으로, 복잡한 체인과 에이전트의 내부 동작을 추적, 모니터링, 평가하는 강력한 기능을 제공합니다.
- **하이브리드 검색 (Hybrid Search)**: 키워드 기반 검색(BM25 등)과 의미 기반 벡터 검색을 함께 사용하여 각 방식의 장점을 결합, 더 정확한 검색 결과를 얻는 RAG 기법입니다.
- **Cross-Encoder**: 두 텍스트(질문과 문서)를 함께 입력 받아 직접 관련성 점수를 계산하는 신경망 모델로, RAG에서 검색된 문서의 재순위화에 사용되며, 높은 정확도를 보이지만 계산 비용이 큽니다.
- **Bi-Encoder**: 텍스트를 독립적으로 임베딩(벡터화)하고 두 벡터 간의 유사도를 계산하는 모델로, RAG의 1차 검색에 주로 사용됩니다. Cross-Encoder보다 정확도는 낮지만 효율적입니다.
- **멀티 쿼리 확장 (Multi-Query Expansion)**: 하나의 사용자 질문을 LLM을 통해 여러 개의 다양한 관점의 질문으로 변환하여, 각 질문으로 검색 후 결과를 종합함으로써 검색의 다양성과 정확도를 높이는 기법입니다.
- **문맥 압축 (Contextual Compression)**: RAG 시스템에서 검색된 문서의 크기를 줄이고 관련성을 높이기 위해, 사용자 질문과 무관한 부분을 제거하고 핵심 내용만 추출하는 기술입니다. 임베딩 필터링, 중복 제거, LLM 기반 내용 추출 등의 방식을 조합하여 구현됩니다.
- **멀티에이전트 협업 시스템 (Multi-Agent Collaboration System)**: 여러 AI 에이전트가 각각 다른 역할과 전문 지식을 가지고 복잡한 작업을 협력하여 해결하는 시스템입니다. 각 에이전트는 특정 영역의 전문가로 동작하며, 최종 목표 달성을 위해 서로 통신하고 작업 결과를 공유합니다.
- **State Graph (상태 그래프)**: LangGraph에서 에이전트 워크플로우를 정의하는 핵심 개념으로, 노드(에이전트/함수)와 엣지(전환 경로)로 구성된 그래프입니다. 노드 간 메시지 전달 및 조건부 라우팅을 통해 복잡한 에이전트 시스템의 흐름을 제어합니다.
--- ---
## Ai Ethics ## Ai Ethics
......
ai_lecture/source_code/05.5_linear_algebra_with_numpy/README.md 0 → 100644
View file @ c8d7c8b4
# NumPy로 배우는 선형대수학 실습 코드
이 디렉토리에는 NumPy를 활용하여 선형대수학 개념을 실습할 수 있는 코드가 포함되어 있습니다.
## 📁 파일 구조
- **`part_5.5_linear_algebra_with_numpy.py`**: 선형대수학 개념을 NumPy로 구현한 주요 실습 코드
## 🚀 실습 방법
1. 먼저 필요한 패키지가 설치되어 있는지 확인합니다:
```bash
pip install numpy matplotlib
```
2. 코드를 실행합니다:
```bash
python part_5.5_linear_algebra_with_numpy.py
```
3. 특정 섹션만 실행하려면 코드 내 주석을 참고하여 해당 부분을 활성화하거나 비활성화합니다.
## 📋 주요 실습 내용
- **벡터 연산**: 벡터의 생성, 크기 계산, 덧셈, 뺄셈, 스칼라 곱, 내적, 외적
- **행렬 연산**: 행렬의 생성, 덧셈, 뺄셈, 곱셈, 전치, 행렬식, 역행렬
- **고급 연산**: 고유값, 고유벡터, 특이값 분해(SVD)
- **시각화**: 벡터, 행렬, 선형 변환의 기하학적 표현
- **머신러닝 응용**: 주성분 분석(PCA), 선형 회귀의 구현
## 🔍 학습 목표
이 실습 코드를 통해 다음을 배우게 됩니다:
- NumPy의 기본 사용법과 선형대수학적 연산 방법
- 추상적인 수학 개념을 코드로 구현하는 능력
- 선형대수학이 머신러닝과 딥러닝에 어떻게 적용되는지 이해
---
[↩️ 전체 코드 목록으로 돌아가기](../README.md)
\ No newline at end of file
ai_lecture/source_code/05.5_linear_algebra_with_numpy/part_5.5_linear_algebra_with_numpy.py 0 → 100644
View file @ c8d7c8b4
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.image import imread
def section_4_1():
print("### 4-1. 벡터(Vector) ###")
# 벡터 생성
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
print(f"v1 = {v1}")
print(f"v2 = {v2}")
# 벡터의 크기(norm) 계산
magnitude_v1 = np.linalg.norm(v1)
print(f"v1의 크기: {magnitude_v1:.2f}")
# 벡터 덧셈과 뺄셈
v_sum = v1 + v2
v_diff = v1 - v2
print(f"벡터 덧셈: {v_sum}")
print(f"벡터 뺄셈: {v_diff}")
# 스칼라 곱
scalar = 2
v_scaled = scalar * v1
print(f"{scalar} * v1 = {v_scaled}")
# 내적(Dot Product)
dot_product = np.dot(v1, v2)
print(f"v1 · v2 = {dot_product}")
# 외적(Cross Product) - 3차원 벡터에만 적용 가능
cross_product = np.cross(v1, v2)
print(f"v1 × v2 = {cross_product}")
print("-" * 30)
def section_4_2():
print("### 4-2. 행렬(Matrix) ###")
# 행렬 생성
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(f"행렬 A:\n{A}")
print(f"행렬 B:\n{B}")
# 행렬 덧셈과 뺄셈
C = A + B
D = A - B
print(f"A + B =\n{C}")
print(f"A - B =\n{D}")
# 행렬 곱셈
E = np.matmul(A, B) # 또는 A @ B (Python 3.5 이상)
print(f"A × B =\n{E}")
# 전치 행렬(Transpose)
A_T = A.T
print(f"A의 전치 행렬:\n{A_T}")
# 행렬식(Determinant)
det_A = np.linalg.det(A)
print(f"A의 행렬식: {det_A}")
# 역행렬(Inverse Matrix)
inv_A = np.linalg.inv(A)
print(f"A의 역행렬:\n{inv_A}")
# 역행렬 검증: A × A^(-1) = I (단위 행렬)
I = np.matmul(A, inv_A)
print(f"A × A^(-1) =\n{np.round(I, decimals=10)}") # 부동소수점 오차 처리
print("-" * 30)
def section_5_1():
print("### 5-1. 고유값(Eigenvalue)과 고유벡터(Eigenvector) ###")
# 예제 행렬
A = np.array([[4, -2], [1, 1]])
print(f"행렬 A:\n{A}")
# 고유값과 고유벡터 계산
eigenvalues, eigenvectors = np.linalg.eig(A)
print(f"고유값: {eigenvalues}")
print(f"고유벡터:\n{eigenvectors}")
# 검증: A × v = λ × v
for i in range(len(eigenvalues)):
v = eigenvectors[:, i]
Av = np.matmul(A, v)
lambda_v = eigenvalues[i] * v
print(f"\n고유값 {eigenvalues[i]:.2f}에 대한 검증:")
print(f"A × v = {Av}")
print(f"λ × v = {lambda_v}")
print("-" * 30)
def section_5_2():
print("### 5-2. 특이값 분해(SVD) ###")
# 예제 행렬 (비정방행렬)
B = np.array([[3, 2, 2], [2, 3, -2]])
print(f"행렬 B:\n{B}")
# SVD 계산
U, Sigma, VT = np.linalg.svd(B)
print(f"U 행렬:\n{U}")
print(f"특이값: {Sigma}")
print(f"V^T 행렬:\n{VT}")
# 원래 행렬 복원
# Sigma는 대각 요소만 반환하므로, 대각 행렬로 변환해야 함
Sigma_matrix = np.zeros(B.shape)
for i in range(min(B.shape)):
Sigma_matrix[i, i] = Sigma[i]
B_reconstructed = U @ Sigma_matrix @ VT
print(f"\n복원된 행렬:\n{np.round(B_reconstructed, decimals=10)}")
print("-" * 30)
def section_6_1():
print("### 6-1. 선형 회귀와 행렬 연산 ###")
# 데이터 생성
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
# X에 상수항(1)을 추가
X_b = np.c_[np.ones((100, 1)), X]
# 정규 방정식으로 파라미터 계산
theta_best = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print(f"계산된 파라미터: {theta_best.flatten()}")
print(f"실제 파라미터: [4, 3]")
# 예측
X_new = np.array([[0], [2]])
X_new_b = np.c_[np.ones((2, 1)), X_new]
y_predict = X_new_b @ theta_best
print(f"x=0, x=2에 대한 예측값: {y_predict.flatten()}")
print("-" * 30)
def section_6_2():
print("### 6-2. 주성분 분석(PCA)과 고유값 분해 ###")
# 데이터 생성
np.random.seed(42)
mean = [0, 0]
cov = [[5, 4], [4, 5]] # 공분산 행렬
data = np.random.multivariate_normal(mean, cov, 200)
# 데이터 중앙 정렬
X = data - data.mean(axis=0)
# 공분산 행렬 계산
cov_matrix = np.cov(X.T)
print(f"공분산 행렬:\n{cov_matrix}")
# 고유값과 고유벡터 계산
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
# 고유값 기준으로 고유벡터 정렬
idx = eigenvalues.argsort()[::-1]
eigenvalues = eigenvalues[idx]
eigenvectors = eigenvectors[:, idx]
print(f"고유값: {eigenvalues}")
print(f"고유벡터:\n{eigenvectors}")
# 주성분으로 데이터 투영 (차원 축소)
n_components = 1 # 첫 번째 주성분만 사용
X_pca = X @ eigenvectors[:, :n_components]
# 원래 차원으로 복원
X_recovered = X_pca @ eigenvectors[:, :n_components].T
print(f"원본 데이터 차원: {X.shape}")
print(f"축소된 데이터 차원: {X_pca.shape}")
print(f"복원된 데이터 차원: {X_recovered.shape}")
print("-" * 30)
def section_6_3():
print("### 6-3. 신경망과 행렬 연산 ###")
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 입력 데이터
X = np.array([[0.1, 0.2, 0.3]])
# 첫 번째 층 가중치와 편향
W1 = np.array([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6],
[0.7, 0.8, 0.9]])
b1 = np.array([0.1, 0.2, 0.3])
# 두 번째 층 가중치와 편향
W2 = np.array([[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]])
b2 = np.array([0.1, 0.2])
# 순전파 계산
z1 = X @ W1 + b1
a1 = sigmoid(z1)
z2 = a1 @ W2 + b2
a2 = sigmoid(z2)
print(f"입력: {X}")
print(f"첫 번째 층 출력: {a1}")
print(f"최종 출력: {a2}")
print("-" * 30)
def exercise_1():
print("### 연습문제 1: 이미지 압축 (SVD 활용) ###")
try:
# 이미지 로드 (그레이스케일로 변환)
# 실습을 위해 'image.jpg' 파일을 소스코드와 같은 디렉토리에 위치시켜주세요.
img = imread('ai_lecture/source_code/image.jpg')
if len(img.shape) == 3: # 컬러 이미지인 경우
img = np.mean(img, axis=2) # 그레이스케일로 변환
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
# SVD 계산
U, Sigma, VT = np.linalg.svd(img)
# 다양한 수의 특이값으로 이미지 재구성
k = 50 # 사용할 특이값 수
reconstructed = U[:, :k] @ np.diag(Sigma[:k]) @ VT[:k, :]
plt.subplot(1, 3, 2)
plt.imshow(reconstructed, cmap='gray')
plt.title(f'Reconstructed (k={k})')
plt.axis('off')
# 잔차(Residual) 이미지
residual = img - reconstructed
plt.subplot(1, 3, 3)
plt.imshow(residual, cmap='gray')
plt.title('Residual (Error)')
plt.axis('off')
plt.tight_layout()
plt.show()
# 압축률과 오차 계산
original_size = img.shape[0] * img.shape[1]
compressed_size = k * (img.shape[0] + img.shape[1] + 1)
compression_ratio = original_size / compressed_size
error = np.linalg.norm(img - reconstructed) / np.linalg.norm(img)
print(f"압축률: {compression_ratio:.2f}x")
print(f"상대 오차: {error:.4f}")
except FileNotFoundError:
print("\n오류: `ai_lecture/source_code/image.jpg` 파일을 찾을 수 없습니다.")
print("실습을 진행하려면 이미지를 해당 경로에 추가해주세요.")
print("-" * 30)
def exercise_2():
print("### 연습문제 2: 선형 시스템 해결 ###")
# 계수 행렬 A와 상수 벡터 b 정의
A = np.array([[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2]])
b = np.array([8, -11, -3])
# 선형 시스템 해결
x = np.linalg.solve(A, b)
print(f"해: x = {x[0]}, y = {x[1]}, z = {x[2]}")
# 검증
verification = A @ x
print(f"A @ x = {verification}")
print(f"b = {b}")
print(f"검증 (A@x 와 b가 거의 같은가?): {np.allclose(A @ x, b)}")
print("-" * 30)
if __name__ == '__main__':
section_4_1()
section_4_2()
section_5_1()
section_5_2()
section_6_1()
section_6_2()
section_6_3()
exercise_1()
exercise_2()
\ No newline at end of file
ai_lecture/source_code/13_generative_ai/README.md
View file @ c8d7c8b4
# Part 13: 생성형 AI 실습 코드 # Part 13: 생성형 AI 실습 코드
이 디렉토리에는 LangChain 및 관련 라이브러리를 사용하여 구축된 고급 생성형 AI 애플리케이션 예제 코드가 포함되어 있습니다. 이 디렉토리에는 LangChain, LangGraph 및 관련 라이브러리를 사용하여 구축된 고급 생성형 AI 애플리케이션 예제 코드가 포함되어 있습니다.
- `advanced_rag_chatbot.py`: Retrieval-Augmented Generation (RAG) 기술을 활용한 고급 챗봇을 구현하는 방법을 보여줍니다. - `advanced_rag_chatbot.py`: 하이브리드 검색, 쿼리 변환, 재순위화 등 고급 RAG(Retrieval-Augmented Generation) 기술을 활용한 챗봇을 구현하는 방법을 보여줍니다.
- `autonomous_agent.py`: LangGraph를 사용하여 스스로 추론하고 도구를 사용하는 자율 에이전트를 구축하는 예제입니다. - `autonomous_agent.py`: LangGraph를 사용하여 스스로 추론하고 도구를 사용하는 자율 에이전트를 구축하는 예제입니다.
- `langsmith_tracing_debugging.py`: LangSmith를 사용하여 LLM 애플리케이션의 실행 과정을 추적하고 디버깅하는 방법을 시연합니다. - `langsmith_tracing_debugging.py`: LangSmith를 사용하여 LLM 애플리케이션의 실행 과정을 추적하고 디버깅하는 방법을 시연합니다.
- `multi_agent_collaboration.py`: 여러 전문가 에이전트(프로젝트 매니저, 데이터 사이언티스트, 알고리즘 전문가, 기술 작가)가 협업하여 복잡한 문제를 해결하는 멀티에이전트 시스템을 구현한 예제입니다.
- `contextual_compression_rag.py`: 검색된 문서에서 불필요한 내용을 제거하고 사용자 질문과 관련된 핵심 내용만 추출하는 문맥 압축 기법을 적용한 RAG 시스템입니다.
## 🚀 실행 방법 ## 🚀 실행 방법
...@@ -44,4 +46,10 @@ python autonomous_agent.py ...@@ -44,4 +46,10 @@ python autonomous_agent.py
# LangSmith 추적 및 디버깅 예제 실행 # LangSmith 추적 및 디버깅 예제 실행
python langsmith_tracing_debugging.py python langsmith_tracing_debugging.py
# 멀티에이전트 협업 시스템 실행
python multi_agent_collaboration.py
# 문맥 압축 RAG 시스템 실행
python contextual_compression_rag.py
``` ```
\ No newline at end of file
ai_lecture/source_code/13_generative_ai/contextual_compression_rag.py 0 → 100644
View file @ c8d7c8b4
"""
문맥 압축(Contextual Compression) RAG 예제
이 예제는 검색된 문서에서 사용자 질문과 관련된 핵심 내용만 추출하고,
불필요한 내용을 제거하여 LLM에 전달함으로써 RAG 성능을 향상시키는 기법을 구현합니다.
요구사항:
- 필요한 패키지: langchain, langchain-openai, dotenv
- OpenAI API 키 필요 (.env 파일에 설정)
실행 방법:
$ python contextual_compression_rag.py
"""
import os
from typing import List
import numpy as np
from dotenv import load_dotenv
from langchain.chains import create_extraction_chain
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import (
DocumentCompressorPipeline,
EmbeddingsFilter,
LLMChainExtractor,
)
from langchain.schema import Document
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_transformers import EmbeddingsRedundantFilter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_openai import ChatOpenAI
def setup_environment():
"""환경 설정 및 API 키 로드"""
load_dotenv()
if not os.getenv("OPENAI_API_KEY"):
raise ValueError("OPENAI_API_KEY가 설정되지 않았습니다. .env 파일을 확인하세요.")
print("API 키 로드 완료.")
def prepare_documents() -> List[Document]:
"""샘플 문서 준비"""
# 실제 애플리케이션에서는 파일에서 문서를 로드할 수 있음
documents = [
Document(
page_content="""
# 파이썬 머신러닝 개요
머신러닝(Machine Learning)은 컴퓨터가 명시적인 프로그래밍 없이 데이터로부터 학습하여 패턴을 찾고 예측하는 인공지능의 한 분야입니다.
파이썬은 머신러닝 프로젝트에 가장 많이 사용되는 프로그래밍 언어로, 다양한 라이브러리를 통해 복잡한 알고리즘을 쉽게 구현할 수 있습니다.
## 주요 머신러닝 라이브러리
1. **scikit-learn**: 지도학습, 비지도학습 알고리즘 및 모델 평가 도구를 제공하는 가장 기본적인 머신러닝 라이브러리입니다.
2. **TensorFlow**: 구글이 개발한 딥러닝 프레임워크로, 대규모 신경망을 구축하는 데 적합합니다.
3. **PyTorch**: 페이스북(Meta)이 개발한 유연하고 직관적인 딥러닝 프레임워크입니다.
4. **XGBoost**: 그래디언트 부스팅 기반의 고성능 머신러닝 라이브러리입니다.
## 머신러닝 프로젝트 워크플로우
1. 데이터 수집 및 전처리
2. 탐색적 데이터 분석
3. 특성 공학 및 선택
4. 모델 선택 및 학습
5. 모델 평가 및 튜닝
6. 모델 배포 및 모니터링
""",
metadata={"source": "ml_overview.md", "page": 1},
),
Document(
page_content="""
# 자연어 처리(NLP) 기술 동향
자연어 처리는 컴퓨터가 인간의 언어를 이해하고 생성하는 기술 분야입니다.
최근 트랜스포머(Transformer) 기반 모델의 등장으로 NLP 분야는 혁신적인 발전을 이루었습니다.
## 주요 NLP 모델 및 라이브러리
1. **BERT**: 구글이 개발한 양방향 인코더 기반 모델로, 문맥을 고려한 단어 표현이 가능합니다.
2. **GPT**: OpenAI가 개발한 자기회귀 모델로, 텍스트 생성에 탁월한 성능을 보입니다.
3. **Hugging Face Transformers**: 다양한 사전 학습 모델을 쉽게 사용할 수 있는 라이브러리입니다.
4. **spaCy**: 효율적인 자연어 처리를 위한 파이썬 라이브러리입니다.
## NLP 응용 분야
- 감성 분석(Sentiment Analysis)
- 개체명 인식(Named Entity Recognition)
- 기계 번역(Machine Translation)
- 질의응답 시스템(Question Answering)
- 텍스트 요약(Text Summarization)
""",
metadata={"source": "nlp_trends.md", "page": 1},
),
Document(
page_content="""
# 컴퓨터 비전 기술의 발전
컴퓨터 비전은 컴퓨터가 디지털 이미지나 비디오로부터 정보를 추출하고 이해하는 기술입니다.
딥러닝의 발전으로 이미지 인식, 객체 탐지, 이미지 생성 등 다양한 분야에서 혁신적인 성과를 보이고 있습니다.
## 주요 컴퓨터 비전 라이브러리 및 프레임워크
1. **OpenCV**: 다양한 이미지 처리 기능을 제공하는 오픈소스 라이브러리입니다.
2. **TensorFlow Object Detection API**: 객체 탐지 모델을 쉽게 구축할 수 있는 프레임워크입니다.
3. **PyTorch Vision**: 이미지 분류, 세그먼테이션 등을 위한 모델과 도구를 제공합니다.
4. **YOLO(You Only Look Once)**: 실시간 객체 탐지를 위한 알고리즘입니다.
## 컴퓨터 비전 응용 분야
- 자율주행 차량
- 의료 영상 분석
- 안면 인식
- 로봇 비전
- 증강 현실
""",
metadata={"source": "computer_vision.md", "page": 1},
),
Document(
page_content="""
# 강화학습의 기초와 응용
강화학습은 에이전트가 환경과 상호작용하며 보상을 최대화하는 방향으로 학습하는 머신러닝의 한 분야입니다.
게임, 로봇 제어, 추천 시스템 등 다양한 분야에 적용되고 있습니다.
## 주요 강화학습 알고리즘
1. **Q-Learning**: 가치 기반 강화학습 알고리즘으로, 각 상태-행동 쌍의 Q값을 학습합니다.
2. **Policy Gradient**: 정책 기반 알고리즘으로, 보상을 최대화하는 정책을 직접 학습합니다.
3. **DQN(Deep Q-Network)**: 딥러닝을 Q-Learning에 결합한 알고리즘입니다.
4. **PPO(Proximal Policy Optimization)**: 안정적인 정책 최적화를 위한 알고리즘입니다.
## 강화학습 프레임워크 및 라이브러리
- **OpenAI Gym**: 강화학습 환경을 제공하는 표준 인터페이스입니다.
- **Stable Baselines**: 강화학습 알고리즘 구현체를 제공하는 라이브러리입니다.
- **RLlib**: 분산 강화학습을 위한 라이브러리입니다.
""",
metadata={"source": "reinforcement_learning.md", "page": 1},
),
]
return documents
def create_document_index(documents, embeddings_model):
"""문서를 벡터 저장소에 인덱싱"""
# 문서 분할
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, chunk_overlap=50, separators=["\n\n", "\n", " ", ""]
)
splits = text_splitter.split_documents(documents)
print(f"총 {len(documents)}개 문서를 {len(splits)}개 청크로 분할했습니다.")
# 벡터 저장소 생성
vectorstore = FAISS.from_documents(documents=splits, embedding=embeddings_model)
return vectorstore
def create_compression_retriever(vectorstore, llm, embeddings_model):
"""문맥 압축 리트리버 생성"""
# 1. LLM 기반 관련 내용 추출기 생성 (관련 없는 텍스트 제거)
llm_extractor = LLMChainExtractor.from_llm(llm)
# 2. 임베딩 기반 관련성 필터링 (질문과 관련성이 낮은 문서 제거)
embeddings_filter = EmbeddingsFilter(
embeddings=embeddings_model,
similarity_threshold=0.76, # 0-1 사이 값, 높을수록 엄격한 필터링
)
# 3. 중복 내용 제거 필터 생성
redundant_filter = EmbeddingsRedundantFilter(
embeddings=embeddings_model,
similarity_threshold=0.95, # 높을수록 유사한 내용을 더 많이 유지
)
# 4. 문서 압축 파이프라인 구성
doc_compressor = DocumentCompressorPipeline(
transformers=[redundant_filter, embeddings_filter, llm_extractor]
)
# 5. 문맥 압축 리트리버 생성
compression_retriever = ContextualCompressionRetriever(
base_retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
base_compressor=doc_compressor,
)
return compression_retriever
def create_rag_chain(retriever, llm):
"""RAG 체인 생성"""
# 검색된 문서를 형식화하는 함수
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
# 프롬프트 템플릿
template = """
당신은 AI 기술에 대한 전문 지식을 갖춘 도우미입니다.
다음 문맥 정보를 바탕으로 사용자의 질문에 답변해주세요.
문맥에 없는 정보는 '제공된 문맥에서 해당 정보를 찾을 수 없습니다'라고 답변하세요.
문맥:
{context}
질문: {question}
답변:
"""
# RAG 체인 구성
from langchain.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_template(template)
chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
return chain
def extract_key_information(document, llm):
"""문서에서 핵심 정보 추출 (추가 데모용)"""
# 추출할 정보 스키마 정의
schema = {
"properties": {
"main_topic": {"type": "string"},
"key_points": {"type": "array", "items": {"type": "string"}},
"technologies": {"type": "array", "items": {"type": "string"}},
},
"required": ["main_topic", "key_points", "technologies"],
}
# 추출 체인 생성 및 실행
chain = create_extraction_chain(schema, llm)
result = chain.run(document.page_content)
return result[0] if result else None
def main():
"""메인 실행 함수"""
setup_environment()
# 모델 초기화
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo")
embeddings_model = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
# 문서 준비 및 인덱싱
print("문서 준비 및 인덱싱 중...")
documents = prepare_documents()
vectorstore = create_document_index(documents, embeddings_model)
# 기본 리트리버와 압축 리트리버 생성
basic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
compression_retriever = create_compression_retriever(vectorstore, llm, embeddings_model)
# RAG 체인 생성
basic_rag_chain = create_rag_chain(basic_retriever, llm)
compressed_rag_chain = create_rag_chain(compression_retriever, llm)
# 사용자 질의 설정
questions = [
"파이썬 머신러닝에서 가장 많이 사용되는 라이브러리는 무엇인가요?",
"자연어 처리에서 트랜스포머의 역할은 무엇인가요?",
"강화학습에 사용되는 알고리즘의 종류에는 어떤 것들이 있나요?"
]
# 결과 비교
for i, question in enumerate(questions):
print(f"\n\n{'=' * 80}")
print(f"질문 {i+1}: {question}")
print(f"{'-' * 80}")
# 기본 RAG로 검색된 문서
basic_docs = basic_retriever.get_relevant_documents(question)
print(f"\n1. 기본 리트리버로 검색된 문서 ({len(basic_docs)}개):")
for j, doc in enumerate(basic_docs):
source = doc.metadata.get('source', 'unknown')
print(f"문서 {j+1} (출처: {source}):")
print(f"{doc.page_content[:150]}...\n")
# 압축 RAG로 검색된 문서
compressed_docs = compression_retriever.get_relevant_documents(question)
print(f"\n2. 압축 리트리버로 검색된 문서 ({len(compressed_docs)}개):")
for j, doc in enumerate(compressed_docs):
source = doc.metadata.get('source', 'unknown')
print(f"문서 {j+1} (출처: {source}):")
print(f"{doc.page_content}")
# 기본 RAG 답변
print(f"\n3. 기본 RAG 답변:")
basic_answer = basic_rag_chain.invoke(question)
print(basic_answer)
# 압축 RAG 답변
print(f"\n4. 압축 RAG 답변:")
compressed_answer = compressed_rag_chain.invoke(question)
print(compressed_answer)
# 핵심 정보 추출 데모 (선택한 문서에 대해)
if i == 0 and basic_docs:
print(f"\n5. 핵심 정보 추출 데모:")
extracted_info = extract_key_information(basic_docs[0], llm)
if extracted_info:
print(f"주제: {extracted_info.get('main_topic')}")
print(f"핵심 요점:")
for point in extracted_info.get('key_points', []):
print(f"- {point}")
print(f"기술 목록:")
for tech in extracted_info.get('technologies', []):
print(f"- {tech}")
print("\n\n압축 RAG 예제가 완료되었습니다.")
if __name__ == "__main__":
main()
\ No newline at end of file
ai_lecture/source_code/13_generative_ai/multi_agent_collaboration.py 0 → 100644
View file @ c8d7c8b4
"""
다중 에이전트 협업 시스템 예제
이 예제는 LangGraph를 활용하여 여러 전문 에이전트가 협업하여 복잡한 문제를 해결하는 시스템을 구현합니다.
각 에이전트는 특정 전문 영역을 담당하며, 그래프 구조에 따라 상호작용하여 최종 결과를 도출합니다.
요구사항:
- 필요한 패키지: langchain, langgraph, dotenv
- OpenAI API 키 필요 (.env 파일에 설정)
실행 방법:
$ python multi_agent_collaboration.py
"""
import operator
import os
from typing import Annotated, Dict, List, Sequence, TypedDict, Union
from dotenv import load_dotenv
from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import END, StateGraph
from langgraph.checkpoint import MemorySaver
# --- 1. 환경 설정 ---
load_dotenv()
if not os.getenv("OPENAI_API_KEY"):
raise ValueError("OPENAI_API_KEY가 설정되지 않았습니다. .env 파일을 확인하세요.")
# --- 2. 협업 에이전트 상태 정의 ---
class TeamState(TypedDict):
"""팀 협업을 위한 상태 클래스"""
messages: Annotated[Sequence[BaseMessage], operator.add] # 메시지 히스토리
next: str # 다음에 어떤 에이전트로 전환할지 지정
task_status: Dict[str, str] # 각 작업의 상태 추적
artifacts: Dict[str, str] # 에이전트들이 생성한 결과물 저장
# --- 3. 각 에이전트 역할 정의 ---
TEAM_ROLES = {
"project_manager": """당신은 프로젝트 매니저입니다. 팀 전체를 조율하고 작업 방향을 결정합니다.
당신의 임무:
1. 사용자의 요청을 분석하여 필요한 작업을 식별하고 단계별로 분해합니다.
2. 각 전문가에게 명확한 지시와 우선순위를 제공합니다.
3. 각 전문가의 결과물을 검토하고 필요시 추가 작업을 요청합니다.
4. 최종 결과물이 사용자의 요구사항을 충족하는지 확인합니다.
항상 명확하고 구체적인 지시사항을 제공하세요.
결과물을 검토할 때는 다음 에이전트를 지정하세요:
- 데이터 분석이 필요하면: "data_scientist"
- 알고리즘 설계가 필요하면: "algorithm_expert"
- 최종 보고서 작성이 필요하면: "technical_writer"
- 모든 작업이 완료되었으면: "final"
""",
"data_scientist": """당신은 데이터 사이언티스트입니다. 데이터를 분석하고 통찰력을 제공합니다.
당신의 임무:
1. 주어진 데이터셋에 대한 탐색적 분석을 수행합니다.
2. 데이터의 패턴, 이상점, 분포 특성을 파악합니다.
3. 문제 해결에 필요한 핵심 인사이트를 도출합니다.
4. 적합한 데이터 전처리 방법과 분석 기법을 제안합니다.
분석 결과는 항상 "데이터 분석 결과: " 접두사로 시작하는 명확한 요약을 포함해야 합니다.
분석 완료 후, 메시지 끝에 "next: project_manager"를 추가하여 프로젝트 매니저에게 결과를 전달하세요.
""",
"algorithm_expert": """당신은 알고리즘 전문가입니다. 효율적인 알고리즘과 모델을 설계합니다.
당신의 임무:
1. 문제에 가장 적합한 알고리즘과 모델을 제안합니다.
2. 제안된 접근 방식의 시간/공간 복잡도를 분석합니다.
3. 알고리즘의 강점과 약점, 한계를 설명합니다.
4. 가능한 대안적 접근법과 그 장단점도 제시합니다.
설계 결과는 항상 "알고리즘 설계 결과: " 접두사로 시작하는 명확한 요약을 포함해야 합니다.
설계 완료 후, 메시지 끝에 "next: project_manager"를 추가하여 프로젝트 매니저에게 결과를 전달하세요.
""",
"technical_writer": """당신은 기술 작가입니다. 복잡한 기술 내용을 명확하게 문서화합니다.
당신의 임무:
1. 팀 내 다른 전문가들의 기술적 결과물을 이해하기 쉽게 정리합니다.
2. 전체 프로젝트의 결과를 구조화된 보고서 형태로 작성합니다.
3. 기술적 내용과 비즈니스 가치를 균형있게 표현합니다.
4. 시각화와 예시를 통해 복잡한 개념을 쉽게 설명합니다.
작성 결과는 항상 "## 최종 보고서"로 시작하는 마크다운 형식으로 작성하세요.
보고서 작성 후, 메시지 끝에 "next: project_manager"를 추가하여 프로젝트 매니저의 최종 검토를 받으세요.
"""
}
# --- 4. 각 에이전트 노드 생성 함수 ---
def create_agent_node(agent_name: str, llm):
"""특정 역할을 담당하는 에이전트 노드를 생성"""
def agent_fn(state: TeamState):
# 이전 메시지 히스토리와 시스템 메시지 준비
system_message = SystemMessage(content=TEAM_ROLES[agent_name])
messages = [system_message] + list(state["messages"])
# LLM 호출하여 응답 생성
response = llm.invoke(messages)
# 응답에서 다음 에이전트 결정 (기본값은 project_manager)
next_agent = "project_manager"
if agent_name == "project_manager":
# 프로젝트 매니저는 next 필드를 명시적으로 지정할 수 있음
if "next: data_scientist" in response.content.lower():
next_agent = "data_scientist"
elif "next: algorithm_expert" in response.content.lower():
next_agent = "algorithm_expert"
elif "next: technical_writer" in response.content.lower():
next_agent = "technical_writer"
elif "next: final" in response.content.lower() or "작업 완료" in response.content:
next_agent = "final"
else:
# 전문가 에이전트들은 항상 결과를 매니저에게 전달
if "데이터 분석 결과: " in response.content:
# 데이터 분석 결과 저장
result_start = response.content.find("데이터 분석 결과: ")
result_end = response.content.find("next:", result_start) if "next:" in response.content else len(response.content)
state["artifacts"]["data_analysis"] = response.content[result_start:result_end].strip()
elif "알고리즘 설계 결과: " in response.content:
# 알고리즘 설계 결과 저장
result_start = response.content.find("알고리즘 설계 결과: ")
result_end = response.content.find("next:", result_start) if "next:" in response.content else len(response.content)
state["artifacts"]["algorithm_design"] = response.content[result_start:result_end].strip()
elif "## 최종 보고서" in response.content:
# 최종 보고서 저장
state["artifacts"]["final_report"] = response.content
# 상태 업데이트
return {
"messages": [response],
"next": next_agent,
"task_status": {**state["task_status"], agent_name: "completed"},
"artifacts": state["artifacts"]
}
return agent_fn
# --- 5. 라우팅 함수 정의 ---
def router(state: TeamState) -> str:
"""현재 상태에 따라 다음에 실행할 에이전트를 결정"""
return state["next"]
# --- 6. 그래프 구축 ---
def build_team_graph(temperature=0):
# LLM 모델 설정
llm = ChatOpenAI(model="gpt-4-turbo", temperature=temperature)
# 각 에이전트 노드 생성
nodes = {
"project_manager": create_agent_node("project_manager", llm),
"data_scientist": create_agent_node("data_scientist", llm),
"algorithm_expert": create_agent_node("algorithm_expert", llm),
"technical_writer": create_agent_node("technical_writer", llm),
}
# 팀 워크플로우 그래프 구축
workflow = StateGraph(TeamState)
# 노드 추가
for name, node_fn in nodes.items():
workflow.add_node(name, node_fn)
# 엣지 및 조건부 라우팅 설정
workflow.set_entry_point("project_manager")
workflow.add_conditional_edges(
"project_manager",
router,
{
"data_scientist": "data_scientist",
"algorithm_expert": "algorithm_expert",
"technical_writer": "technical_writer",
"final": END
}
)
# 모든 전문가 노드는 프로젝트 매니저로 돌아감
for expert in ["data_scientist", "algorithm_expert", "technical_writer"]:
workflow.add_edge(expert, "project_manager")
return workflow.compile()
# --- 7. 메인 실행 함수 ---
def main():
print("다중 에이전트 협업 시스템을 초기화합니다...")
# 그래프 컴파일
team_app = build_team_graph(temperature=0.1)
# 영구 저장소 설정 (선택사항)
memory_saver = MemorySaver()
# 초기 메시지 설정 (사용자 요청)
task_description = """
전자상거래 웹사이트의 제품 추천 시스템을 개선하고 싶습니다.
현재 시스템은 단순히 인기 제품이나 최근 조회 제품을 기반으로 추천하고 있어 개인화가 부족합니다.
사용자의 구매 이력, 검색 패턴, 체류 시간 등의 데이터를 활용해 머신러닝 기반의 개선된 추천 시스템을 설계해주세요.
최종 결과물로 데이터 분석 방향, 적합한 알고리즘, 구현 방안이 포함된 기술 보고서가 필요합니다.
"""
initial_state = {
"messages": [HumanMessage(content=task_description)],
"next": "project_manager",
"task_status": {},
"artifacts": {}
}
print("\n작업을 시작합니다...\n" + "="*50)
# 스트리밍 실행 (각 단계별 출력)
for i, state in enumerate(team_app.stream(initial_state, config={"checkpointer": memory_saver})):
if i > 0: # 초기 상태는 건너뜀
last_message = state["messages"][-1].content
current_agent = state["next"]
print(f"\n{'='*50}")
print(f"STEP {i}: {'최종 결과' if current_agent == 'final' else current_agent}")
print(f"{'-'*50}")
print(last_message[:1000] + ("..." if len(last_message) > 1000 else ""))
print(f"{'='*50}\n")
# 최종 결과 출력
final_state = memory_saver.get_latest()
if "final_report" in final_state["artifacts"]:
print("\n\n최종 보고서:")
print("="*50)
print(final_state["artifacts"]["final_report"])
print("\n협업 에이전트 작업이 완료되었습니다.")
if __name__ == "__main__":
main()
\ No newline at end of file
docker/.gitignore 0 → 100644
View file @ c8d7c8b4
# Byte-compiled / optimized / DLL files
__pycache__/
*.pyc
*.pyo
*.pyd
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Environments
.env
.env.*
!.env.example
env/
venv/
ENV/
venv.bak/
env.bak/
# Docker
docker-compose.override.yml
**/data/
**/db_data/
**/uploads/
# Databases
*.sqlite3
*.db
# Logs
logs/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
lerna-debug.log*
# Node
node_modules/
.npm
# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db
# IDE settings
.idea/
.vscode/
*.swp
*~
\ No newline at end of file
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