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

docs: AI 강의 README 및 커리큘럼 개편

parent fc694b32
......@@ -13,7 +13,7 @@
* **오류 해결:** 설치나 실습 중 발생하는 오류는 숨기지 말고, 오히려 좋은 학습 기회로 삼습니다. 오류 메시지를 함께 읽고 해결하는 과정을 보여주며 문제 해결 능력을 길러줍니다.
**1주차: 과정 소개 및 AI 개발 환경 구축**
* **6/23 (월):** 1일차 - 과정 소개 AI/ML 개요
* **6/23 (월):** 1일차 - 과정 소개, AI/ML 개요**인공지능의 역사**
* **6/24 (화):** 2일차 - Python, VSCode, Git 설치 및 기본 설정
* **6/25 (수):** 3일차 - 가상환경(venv)의 이해와 실습
* **6/26 (목):** 4일차 - Jupyter Notebook/Lab 기본 사용법 및 단축키
......
# 12주 완성! AI 전문가 양성 과정: 파이썬부터 프로덕션 배포까지
# 16주 완성! AI 전문가 양성 과정: 파이썬부터 프로덕션 배포까지
![Course Banner](https://example.com/course_banner.png) <!-- 이 부분은 나중에 적절한 이미지로 교체하세요 -->
"아이디어는 있는데, 어떻게 만들어야 할지 막막하신가요?"
"AI, 이제는 소비하는 것을 넘어 직접 만들고 싶으신가요?"
본 과정은 파이썬 기초 문법부터 시작하여, 실제 동작하는 AI 서비스를 직접 기획하고, 개발하며, 세상에 배포하는 전 과정을 경험하는 **12주 완성 실전형 AI 엔지니어링 코스**입니다. 막연한 아이디어를 현실로 만드는 '만들기 능력자'로 거듭나세요.
본 과정은 파이썬 기초 문법부터 시작하여, 실제 동작하는 AI 서비스를 직접 기획하고, 개발하며, 세상에 배포하는 전 과정을 경험하는 **16주 완성 실전형 AI 엔지니어링 코스**입니다. 막연한 아이디어를 현실로 만드는 '만들기 능력자'로 거듭나세요.
---
## 🚀 이 과정을 통해 얻을 수 있는 것
- **AI 서비스 개발의 A to Z**: 데이터 분석, 머신러닝/딥러닝 모델링, API 서버 개발, Docker를 이용한 배포까지, AI 제품 개발의 전체 사이클을 직접 경험하고 이해합니다.
- **실무 중심의 프로젝트 경험**: 9주간의 체계적인 학습 후, 3주간 나만의 개성이 담긴 **캡스톤 프로젝트**를 진행하며 현업 수준의 문제 해결 능력과 포트폴리오를 확보합니다.
- **실무 중심의 프로젝트 경험**: 체계적인 학습 후, '나만의 개성이 담긴 **캡스톤 프로젝트**'를 진행하며 현업 수준의 문제 해결 능력과 포트폴리오를 확보합니다.
- **생산성을 극대화하는 최신 기술 스택**: `FastAPI`, `Docker`, `PyTorch`, `LangChain` 등 현업에서 가장 수요가 높은 기술 스택을 사용합니다. `Cursor`, `GitHub Copilot` 같은 AI 네이티브 도구를 활용하여 개발 효율을 극대화하는 방법을 체득합니다.
- **지속 가능한 성장을 위한 발판**: MLOps의 기본 개념을 이해하고, 최신 AI 기술 트렌드를 읽는 눈을 기르며, AI 전문가로서 지속적으로 성장할 수 있는 학습 로드맵을 얻게 됩니다.
......@@ -20,18 +20,12 @@
## 📚 전체 커리큘럼 개요
| 주차 (Week) | 주제 (Topic) | 핵심 학습 내용 | 바로가기 |
| :---------- | :--------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------- |
| **Part 1** | **1주차: AI 개발 환경 구축과 파이썬 기초 다지기** | AI 개발에 필요한 최적의 환경(VSCode, Git)을 구축하고, 파이썬의 기본 자료형과 변수, 제어문을 익힙니다. | [Part 1](./part_1_ai_development_environment.md) & [Part 2](./part_2_python_core_syntax.md) |
| **Part 2** | **2주차: 파이썬 컬렉션과 객체 지향 프로그래밍(OOP) 입문** | 리스트, 딕셔너리 등 데이터를 다루는 핵심 자료구조를 배우고, '붕어빵 비즈니스' 비유로 OOP의 개념을 이해합니다. | [Part 3](./part_3_python_collections.md) & [Part 4](./part_4_object_oriented_programming.md) |
| **Part 3** | **3주차: AI 핵심 라이브러리: NumPy & Pandas** | '계란판' 비유로 NumPy의 배열 연산을, '엑셀'에 빗대어 Pandas의 데이터프레임 조작 및 분석 기술을 마스터합니다. | [Part 5](./part_5_ai_core_libraries.md) |
| **Part 4** | **4주차: 머신러닝 입문과 Scikit-Learn** | 머신러닝의 전체 프로세스(데이터 전처리, 모델링, 평가)를 이해하고, Scikit-Learn으로 '타이타닉 생존자 예측' 실습을 진행합니다. | [Part 6](./part_6_machine_learning.md) |
| **Part 5** | **5주차: 딥러닝과 PyTorch 기초** | '레고 블록' 비유로 PyTorch의 작동 원리를 배우고, 딥러닝의 "Hello, World!"인 MNIST 손글씨 분류 모델을 구현합니다. | [Part 7](./part_7_deep_learning.md) |
| **Part 6** | **6주차: LLM 애플리케이션 개발과 LangChain** | '똑똑한 사서' 비유로 RAG의 개념을 이해하고, LangChain을 사용하여 간단한 Q&A 챗봇을 직접 만듭니다. | [Part 7.5](./part_7.5_llm_application_development_with_langchain.md) |
| **Part 7** | **7주차: FastAPI를 이용한 AI 모델 서빙** | '맛집 레시피'인 AI 모델을 '레스토랑' API 서버로 만드는 과정을 배우고, Fashion-MNIST 모델을 API로 배포합니다. | [Part 8](./part_8_model_serving_with_fastapi.md) |
| **Part 8** | **8주차: 프로덕션 레벨 API와 Docker** | '1인 식당'을 '프랜차이즈'로 확장하는 비유로 프로젝트를 구조화하고, Docker를 사용해 어디서든 동일하게 작동하는 서비스를 만듭니다. | [Part 9](./part_9_production_ready_api.md) |
| **Part 9** | **9주차: AI 전문가로 가는 길** | MLOps, AI 네이티브 IDE 등 전문가의 생산성 도구를 배우고, 최신 AI 트렌드를 바탕으로 다음 학습 로드맵을 설계합니다. | [Part 10](./part_10_expert_path.md) |
| **Part 10-12** | **10-12주차: 캡스톤 프로젝트** | 그동안 배운 모든 기술을 총동원하여 '나만의 AI 서비스'를 기획, 개발, 배포하고, 동료들에게 발표합니다. | [Part 11](./part_11_capstone_project_guide.md) |
| 파트 (Part) | 주차 (Week) | 주제 (Topic) | 핵심 학습 내용 | 관련 문서 |
|:---:|:---:|:---|:---|:---|
| **1** | 1-5주차 | **AI 개발을 위한 파이썬 마스터리** | 개발 환경 구축부터 파이썬 핵심 문법, OOP, NumPy/Pandas까지 AI 개발의 기초를 탄탄히 다집니다. | [Intro](./part_0_introduction.md), [History](./part_0.1_history_of_ai.md), [Env](./part_1_ai_development_environment.md), [Python](./part_2_python_core_syntax.md), [Collections](./part_3_python_collections.md), [OOP](./part_4_object_oriented_programming.md), [Libs](./part_5_ai_core_libraries.md) |
| **2** | 6-9주차 | **핵심 AI 모델 개발 및 서빙** | 머신러닝, 딥러닝(CNN, Transformer)의 기초를 배우고, LangChain으로 LLM 챗봇을 만든 뒤 FastAPI와 Docker로 서빙합니다. | [ML](./part_6_machine_learning.md), [DL](./part_7_deep_learning.md), [Transformer](./part_7.2_transformer_and_llm_principles.md), [LangChain](./part_7.3_llm_application_development_with_langchain.md), [API](./part_8_model_serving_with_fastapi.md), [Prod API](./part_9_production_ready_api.md) |
| **3** | 10-13주차 | **프로덕션 MLOps 및 AI 심화** | MLOps, 모델 최적화/경량화, 자율 AI 에이전트, AI 윤리 등 현업 전문가를 위한 심화 주제를 다룹니다. | [MLOps](./part_11_mlops.md), [Optimization](./part_12_model_optimization.md), [Generative AI](./part_13_generative_ai.md), [Ethics](./part_14_ai_ethics.md), [Roadmap](./part_10_expert_path.md) |
| **4** | 14-15주차 | **최종 캡스톤 프로젝트** | 나만의 AI 서비스를 기획, 개발, 배포하며 실전 경험을 쌓고 포트폴리오를 완성합니다. | [Capstone](./part_15_capstone_project.md) |
---
......@@ -47,20 +41,25 @@
## 📖 학습 자료
- **[전체 강의 계획서 (Course Schedule)](./AI_Expert_Course_Schedule.md)**: 12주 과정의 상세한 주차별 학습 목표와 내용을 확인하세요.
- **[전체 강의 계획서 (Course Schedule)](./AI_Expert_Course_Schedule.md)**: 16주 과정의 상세한 주차별 학습 목표와 내용을 확인하세요.
- **[파트별 용어집 (Glossaries)](./glossaries/)**: 과정 중에 등장하는 핵심 용어를 파트별로 다시 확인할 수 있습니다.
- [Part 0: 과정 소개](./glossaries/part_0_glossary.md)
- [Part 1: AI 개발 환경](./glossaries/part_1_glossary.md)
- [Part 2: Python 핵심 문법](./glossaries/part_2_glossary.md)
- [Part 3: Python 컬렉션](./glossaries/part_3_glossary.md)
- [Part 4: 객체 지향 프로그래밍](./glossaries/part_4_glossary.md)
- [Part 5: AI 핵심 라이브러리](./glossaries/part_5_glossary.md)
- [Part 6: 머신러닝](./glossaries/part_6_glossary.md)
- [Part 7: 딥러닝](./glossaries/part_7_glossary.md)
- [Part 7.5: LangChain](./glossaries/part_7.5_glossary.md)
- [Part 7.3: LangChain & LLM 앱 개발](./glossaries/part_7.5_glossary.md)
- [Part 8: FastAPI](./glossaries/part_8_glossary.md)
- [Part 9: Production-Ready API](./glossaries/part_9_glossary.md)
- [Part 10: AI 전문가 과정](./glossaries/part_10_glossary.md)
- [Part 11: 최종 프로젝트](./glossaries/part_11_glossary.md)
- [Part 11: MLOps](./glossaries/part_11_glossary.md)
- [Part 12: 모델 최적화](./glossaries/part_12_glossary.md)
- [Part 13: 생성형 AI](./glossaries/part_13_glossary.md)
- [Part 14: AI 윤리](./glossaries/part_14_glossary.md)
- [Part 15: 캡스톤 프로젝트](./glossaries/part_15_glossary.md)
- **[실습 코드 모음 (Source Code)](./source_code/)**: 각 파트별 실습 코드를 직접 실행하고 수정해볼 수 있습니다.
> [!NOTE]
......
# Part 7: 딥러닝 기초와 PyTorch 용어집
## 핵심 용어
# Part 0 & 7: AI 역사와 딥러닝 심화 용어집
| 용어 (Term) | 설명 (Description) |
| --- | --- |
| **딥러닝 (Deep Learning)** | 여러 층(layers)으로 구성된 인공 신경망(Artificial Neural Network, ANN)을 사용하여 복잡한 패턴을 데이터로부터 학습하는 머신러닝의 한 분야입니다. 이미지, 음성, 텍스트와 같은 비정형 데이터 처리에서 뛰어난 성능을 보입니다. |
| **PyTorch** | Facebook의 AI 연구팀(FAIR)이 개발한 오픈소스 머신러닝 라이브러리입니다. Python 기반이며, `Tensor` 연산(NumPy와 유사하지만 GPU 지원)과 자동 미분(Autograd) 기능을 통해 유연하고 동적인 신경망 구축 및 학습을 지원합니다. 연구 및 프로토타이핑에 널리 사용됩니다. (비유: 레고 블록) |
| **텐서 (Tensor)** | PyTorch에서 데이터를 다루는 기본 단위이자 다차원 배열입니다. NumPy의 `ndarray`와 유사하지만, GPU를 사용한 고속 연산 및 자동 미분 기능을 핵심적으로 지원하여 딥러닝 모델 학습에 필수적입니다. |
| **인공 신경망 (Artificial Neural Network, ANN)** | 인간의 뇌 신경망 구조에서 영감을 받아 설계된 계산 모델입니다. 여러 개의 노드(뉴런)들이 서로 연결되어 계층(layer)을 이루며, 입력 데이터로부터 패턴을 학습하여 특정 작업을 수행합니다. |
| **`nn.Module`** | PyTorch에서 모든 신경망 모델의 기본이 되는 클래스입니다. 사용자는 이 클래스를 상속받아 자신만의 모델 구조(`__init__`)와 데이터 흐름(`forward`)을 정의합니다. 모델의 파라미터 관리, 저장 및 로드, GPU 이동 등의 기능을 제공합니다. |
| **활성화 함수 (Activation Function)** | 신경망의 선형 계층(Linear Layer) 통과 후 적용되는 비선형(non-linear) 함수입니다. 이 비선형성이 없다면 여러 계층을 쌓아도 결국 하나의 선형 함수와 같기 때문에, 활성화 함수는 모델이 복잡하고 구불구불한 데이터 패턴을 학습할 수 있는 표현력(Expressiveness)을 부여하는 핵심적인 역할을 합니다. |
| **손실 함수 (Loss Function / Cost Function)** | 모델의 예측값(prediction)과 실제 정답(target) 사이의 차이, 즉 '오차(Error)'를 수치적으로 계산하는 함수입니다. 딥러닝 학습은 이 손실 함수의 값을 최소화하는 방향으로 모델의 파라미터(가중치)를 업데이트하는 과정입니다. 해결하려는 문제의 종류(회귀, 분류)에 따라 적합한 손실 함수를 선택해야 합니다. |
| **ReLU (Rectified Linear Unit)** | 딥러닝에서 가장 널리 사용되는 활성화 함수. 입력이 0보다 크면 값을 그대로 출력하고, 0보다 작으면 0을 출력합니다 (`max(0, x)`). 계산이 매우 빠르고 Sigmoid나 Tanh의 Vanishing Gradient 문제를 해결하여 학습 속도를 높입니다. |
| **Softmax** | 다중 클래스 분류 문제의 마지막 출력층에서 사용되는 활성화 함수입니다. 모델의 최종 출력(Logits)을 각 클래스에 대한 '확률'로 변환해줍니다. 모든 출력의 합은 1이 되므로, 가장 확률이 높은 클래스를 선택하는 근거가 됩니다. |
| **교차 엔트로피 (Cross-Entropy)** | 분류 문제에서 사용되는 대표적인 손실 함수입니다. 모델이 예측한 확률 분포와 실제 정답의 확률 분포가 얼마나 다른지를 측정합니다. 모델이 정답 클래스를 낮은 확률로 예측할수록 손실 값이 커집니다. (PyTorch의 `nn.CrossEntropyLoss`는 Softmax를 내장하고 있습니다.) |
| **옵티마이저 (Optimizer)** | 손실 함수가 계산한 오차(손실 값)를 기반으로, 모델의 파라미터(가중치와 편향)를 효과적으로 업데이트하여 손실을 최소화하는 알고리즘입니다. (예: `Adam`, `SGD`, `RMSprop`) |
| **순전파 (Forward Propagation)** | 인공 신경망에서 입력 데이터가 입력층에서 시작하여 은닉층들을 거쳐 출력층까지 전달되면서 각 층에서 가중치와 곱해지고 활성화 함수를 통과하여 최종 예측값을 계산하는 과정입니다. |
| **역전파 (Backward Propagation)** | 순전파를 통해 계산된 예측값과 실제 정답 사이의 오차(손실)를 기반으로, 이 오차에 각 파라미터가 얼마나 기여했는지를 출력층부터 입력층 방향으로 거슬러 올라가며 계산하는 과정입니다(미분을 사용). 이 결과를 바탕으로 옵티마이저가 파라미터를 업데이트합니다. 딥러닝 학습의 핵심 알고리즘입니다. |
| **에포크 (Epoch)** | 전체 훈련 데이터셋이 신경망 모델을 통해 한 번 완전히 통과(순전파 및 역전파)된 횟수를 의미합니다. 즉, 모든 훈련 샘플이 학습에 한 번 사용되면 1 에포크가 완료된 것입니다. |
| **CNN (Convolutional Neural Network / 합성곱 신경망)** | 이미지 인식 및 처리에 특화된 딥러닝 모델 아키텍처입니다. 입력 데이터에서 특징(feature)을 추출하는 합성곱 계층(Convolutional Layer)과 풀링 계층(Pooling Layer)을 사용하여 공간적 계층 구조를 효과적으로 학습합니다. |
| **Attention** | RNN의 장기 의존성 문제를 해결하기 위해 등장한 메커니즘으로, 번역할 문장을 생성할 때 인코더의 모든 출력 중 현재 예측해야 할 단어와 연관이 높은 입력 단어에 더 집중(가중치 부여)하는 방식입니다. |
| **Transformer** | RNN을 사용하지 않고 Attention 메커니즘만으로 데이터의 순차적 정보와 문맥을 학습하는 혁신적인 신경망 아키텍처입니다. 병렬 처리가 가능하여 학습 속도가 매우 빠르며, 현대 자연어 처리 모델의 기반이 됩니다. |
| **Self-Attention** | Transformer의 핵심 구성 요소로, 문장 내의 단어들이 서로를 얼마나 참조해야 하는지(관련이 있는지)를 계산하는 메커니즘입니다. 이를 통해 문맥에 맞는 단어의 의미를 파악할 수 있습니다. |
| **Positional Encoding** | 순서 정보가 없는 Transformer에게 단어의 위치 정보를 제공하기 위해 각 단어의 임베딩 벡터에 더해주는 고정된 값입니다. 사인, 코사인 함수를 사용하여 위치 정보를 벡터로 표현합니다. |
| **Encoder (인코더)** | Transformer 구조의 일부로, 입력 문장을 받아 각 단어의 의미와 문맥 정보를 함축한 벡터 표현(representation)으로 변환하는 역할을 합니다. Self-Attention과 피드포워드 신경망으로 구성됩니다. |
| **Decoder (디코더)** | Transformer 구조의 일부로, 인코더의 출력과 이전에 생성된 출력값을 입력으로 받아 다음 단어를 예측하는 역할을 합니다. |
| **BERT (Bidirectional Encoder Representations from Transformers)** | Google에서 개발한 언어 모델로, Transformer의 인코더 구조만을 사용합니다. 문장의 양방향 문맥을 모두 학습하여 문맥을 이해하는 데 매우 뛰어난 성능을 보입니다. (주로 문장 이해, 분류, 개체명 인식 등에 활용) |
| **GPT (Generative Pre-trained Transformer)** | OpenAI에서 개발한 언어 모델로, Transformer의 디코더 구조만을 사용합니다. 이전 단어들을 기반으로 다음 단어를 예측하는 방식으로 학습되어 문장 생성에 매우 뛰어난 성능을 보입니다. (주로 챗봇, 텍스트 생성 등에 활용) |
| **강화학습 (Reinforcement Learning, RL)** | '정답' 데이터 없이 '보상(Reward)'이라는 신호를 통해, 에이전트가 환경과 상호작용하며 누적 보상을 최대화하는 행동 전략(정책)을 스스로 학습하는 머신러닝 패러다임입니다. (예: 게임 AI, 로봇 제어) |
| **게이트 (Gate)** | LSTM의 핵심 구성요소로, 정보의 흐름을 제어하는 장치. 시그모이드 함수를 통해 정보의 양을 조절하며, 망각/입력/출력 게이트를 통해 장기 기억을 가능하게 합니다. |
| **검색 증강 생성 (RAG, Retrieval-Augmented Generation)** | LLM이 답변을 생성하기 전에, 먼저 외부 지식 소스(예: 문서, DB)에서 관련 정보를 검색(Retrieval)하고, 이 정보를 참고하여 답변을 생성(Generation)하는 기술입니다. LLM의 환각 현상을 줄이고 최신 정보에 기반한 답변을 가능하게 합니다. |
| **거대 언어 모델 (LLM, Large Language Model)** | 방대한 양의 텍스트 데이터로 사전 학습된 매우 큰 규모의 Transformer 기반 언어 모델입니다. 문맥 이해, 생성, 요약 등 다양한 자연어 처리 작업을 수행할 수 있습니다. (예: GPT-4, LLaMA) |
| **그래프 신경망 (Graph Neural Network, GNN)** | 소셜 네트워크, 분자 구조와 같이 노드(객체)와 엣지(관계)로 구성된 그래프 데이터를 직접 처리하고 학습하는 데 특화된 신경망 아키텍처입니다. |
| **기울기 소실/폭발 (Vanishing/Exploding Gradient)** | 깊은 신경망이나 RNN에서 역전파 시, 그래디언트(기울기)가 층을 거치면서 너무 작아져(소실) 학습이 멈추거나, 너무 커져(폭발) 학습이 불안정해지는 문제입니다. |
| **기호주의 (Symbolic AI)** | AI 초기의 주요 접근법으로, 인간의 지식과 논리적 추론 과정을 기호와 규칙(Rule)으로 표현하고 컴퓨터로 처리하여 지능을 구현하려는 시도입니다. (예: 전문가 시스템) |
| **딥러닝 (Deep Learning)** | 여러 층(layers)으로 구성된 인공 신경망(ANN)을 사용하여 복잡한 패턴을 데이터로부터 학습하는 머신러닝의 한 분야입니다. 이미지, 음성, 텍스트와 같은 비정형 데이터 처리에서 뛰어난 성능을 보입니다. |
| **딥블루 (Deep Blue)** | 1997년, 당시 체스 세계 챔피언 가리 카스파로프를 꺾은 IBM의 체스 컴퓨터. AI가 특정 영역에서 인간 최고수를 이길 수 있음을 보여준 상징적인 사건입니다. |
| **랭체인 (LangChain)** | LLM을 외부 데이터 소스, API 등 다른 도구와 쉽게 연결하고, 복잡한 AI 애플리케이션(예: RAG, AI 에이전트)을 만들 수 있도록 도와주는 개발 프레임워크입니다. |
| **레스넷 (ResNet)** | '잔차 학습(Residual Learning)'과 '스킵 연결(Skip Connection)' 개념을 도입하여, 네트워크가 깊어져도 학습이 잘 되지 않는 퇴화(Degradation) 문제를 해결한 혁신적인 CNN 아키텍처입니다. 100층 이상의 매우 깊은 신경망 훈련을 가능하게 했습니다. |
| **머신러닝 (Machine Learning)** | 컴퓨터가 명시적인 프로그래밍 없이, 데이터를 기반으로 스스로 학습하여 특정 작업을 수행하는 능력을 갖추게 하는 AI의 한 분야입니다. |
| **메시지 패싱 (Message Passing)** | GNN의 핵심 작동 원리. 각 노드가 자신의 이웃 노드들과 정보를 주고받으며(메시지), 자신의 상태(표현 벡터)를 반복적으로 업데이트하는 과정입니다. |
| **보상 (Reward)** | 강화학습에서 에이전트가 특정 행동을 취했을 때 환경으로부터 받는 신호. 에이전트는 이 보상을 누적하여 최대화하는 방향으로 학습합니다. |
| **버트 (BERT)** | Transformer의 인코더 구조만을 사용하여 문장의 양방향 문맥을 학습하는 언어 모델. 문맥 이해에 강점을 보여 분류, 개체명 인식 등 분석 작업에 주로 사용됩니다. |
| **벡터 저장소 (Vector Store)** | 텍스트나 데이터를 벡터(임베딩) 형태로 저장하고, 의미적으로 유사한 벡터를 빠르고 효율적으로 검색할 수 있도록 설계된 데이터베이스입니다. RAG 시스템의 핵심 구성 요소입니다. |
| **순차 데이터 (Sequential Data)** | 텍스트, 시계열 데이터와 같이 데이터의 순서가 중요한 의미를 갖는 데이터입니다. |
| **순환 신경망 (Recurrent Neural Network, RNN)** | 내부에 순환 구조를 가져 이전 시간 단계의 정보(은닉 상태)를 기억하고, 이를 현재 계산에 활용하는 순차 데이터 처리에 특화된 신경망입니다. |
| **스킵 연결 (Skip Connection)** | ResNet의 핵심 아이디어. 입력값을 몇 개의 층을 건너뛰어 출력값에 바로 더해주는 '지름길' 구조입니다. 그래디언트의 흐름을 원활하게 하여 깊은 망의 학습을 돕습니다. |
| **셀프 어텐션 (Self-Attention)** | Transformer의 핵심 메커니즘으로, 문장 내의 단어들이 서로에게 얼마나 중요한지(관련 있는지)를 계산하여 문맥을 파악하는 방식입니다. |
| **에이전트 (Agent)** | 강화학습에서 학습의 주체. 환경과 상호작용하며 행동을 결정하고 보상을 통해 학습합니다. (예: 게임 플레이어, 로봇) |
| **역전파 (Backpropagation)** | 순전파 결과 나온 예측값과 실제 정답의 오차를 이용해, 신경망의 각 파라미터가 오차에 얼마나 기여했는지를 출력층부터 입력층까지 역으로 계산하고 업데이트하는 알고리즘입니다. 딥러닝 학습의 핵심입니다. |
| **연결주의 (Connectionism)** | 뇌의 뉴런 구조에서 영감을 받아, 수많은 단순한 처리 장치(노드)들의 연결과 상호작용을 통해 지능을 구현하려는 AI 접근법입니다. 현대 딥러닝의 철학적 기반이 됩니다. |
| **어텐션 (Attention)** | 디코더가 출력 단어를 예측할 때마다, 인코더의 입력 시퀀스 전체를 다시 참고하여 현재 예측과 가장 관련이 높은 단어에 더 높은 가중치를 부여하는 메커니즘입니다. |
| **위치 인코딩 (Positional Encoding)** | 단어를 순차적으로 처리하지 않는 Transformer에게 단어의 순서 정보를 알려주기 위해, 각 단어의 위치마다 고유한 값을 임베딩에 더해주는 기법입니다. |
| **은닉 상태 (Hidden State)** | RNN에서 특정 시간 단계까지의 입력 순서와 내용을 요약한 '기억' 또는 '문맥' 벡터. 이전 시간 단계의 은닉 상태와 현재의 입력을 받아 계산되며, 다음 시간 단계로 전달됩니다. |
| **임베딩 (Embedding)** | 단어나 문장을 컴퓨터가 처리할 수 있도록, 의미를 담은 고차원의 숫자 벡터로 변환하는 과정 또는 그 결과물입니다. |
| **인셉션 모듈 (Inception Module)** | GoogLeNet에서 제안된 구조로, 1x1, 3x3, 5x5 등 다양한 크기의 커널을 병렬로 적용하고 결과를 합쳐, 연산 효율을 높이면서 다양한 스케일의 특징을 한번에 잡아내는 블록입니다. |
| **잔차 학습 (Residual Learning)** | ResNet의 핵심 아이디어. 층이 출력값 `H(x)`를 직접 학습하는 대신, 변화량(Residual)인 `H(x) - x`를 학습하도록 하여 깊은 신경망의 학습을 용이하게 합니다. |
| **장기 의존성 문제 (Long-Term Dependency Problem)** | RNN이 순차 데이터의 길이가 길어질 경우, 먼 과거의 정보가 현재까지 제대로 전달되지 못하고 소실되는 문제. 기울기 소실 문제가 주요 원인입니다. |
| **전문가 시스템 (Expert System)** | 특정 전문 분야의 지식을 규칙 기반으로 컴퓨터에 저장하고, 이를 바탕으로 일반인도 전문가처럼 문제 해결을 할 수 있도록 돕는 기호주의 기반의 AI 시스템입니다. |
| **정책 (Policy)** | 강화학습에서 에이전트의 '뇌' 또는 전략. 특정 상태(State)에서 어떤 행동(Action)을 할지 결정하는 함수입니다. |
| **지피티 (GPT)** | Transformer의 디코더 구조만을 사용하여 이전 단어들을 바탕으로 다음 단어를 예측하며 학습하는 언어 모델. 텍스트 생성에 강점을 보여 챗봇, 콘텐츠 작성 등에 주로 사용됩니다. |
| **청킹/분할 (Chunking)** | RAG 파이프라인에서, 긴 문서를 LLM이 처리하기 좋은 크기의 작은 조각(Chunk)으로 나누는 과정입니다. |
| **튜링 테스트 (Turing Test)** | 앨런 튜링이 제안한 기계의 지능을 판별하는 테스트. 심사관이 인간과 기계의 대화를 구별할 수 없다면, 그 기계는 '생각'할 수 있다고 간주합니다. |
| **트랜스포머 (Transformer)** | 2017년 구글에서 발표한 딥러닝 모델로, RNN 구조 없이 '어텐션' 메커니즘만으로 언어를 처리합니다. 병렬 처리에 용이하여 현대 LLM의 기반 아키텍처가 되었습니다. |
| **퍼셉트론 (Perceptron)** | 1957년 프랭크 로젠블랫이 고안한 초창기 인공 신경망 모델. 여러 입력을 받아 하나의 출력을 내보내는 구조로, 딥러닝의 가장 기본적인 단위인 인공 뉴런의 시초가 되었습니다. |
| **행동 (Action)** | 강화학습에서 에이전트가 특정 상태에서 취할 수 있는 행위입니다. |
| **환경 (Environment)** | 강화학습에서 에이전트가 상호작용하는 대상. 에이전트의 행동에 따라 상태를 바꾸고 보상을 줍니다. (예: 게임 맵, 물리적 공간) |
| **환각 (Hallucination)** | LLM이 사실이 아니거나 학습 데이터에 근거하지 않은 정보를 그럴듯하게 꾸며서 생성하는 현상을 말합니다. |
| **활성화 함수 (Activation Function)** | 신경망의 선형 계층 통과 후 적용되는 비선형 함수. 모델이 복잡한 패턴을 학습할 수 있는 표현력을 부여하는 핵심적인 역할을 합니다. (예: ReLU, Sigmoid, Tanh) |
| **AI 겨울 (AI Winter)** | AI에 대한 기대가 과장되었다가 기술적 한계와 실망으로 인해 연구 자금 투자가 급격히 위축되는 시기를 의미합니다. 역사적으로 두 차례의 큰 겨울이 있었습니다. |
| **AlexNet** | 2012년 이미지 인식 대회(ILSVRC)에서 압도적인 성능으로 우승한 CNN 모델. ReLU 함수, Dropout, GPU 활용 등을 통해 딥러닝의 부흥을 이끈 기념비적인 모델입니다. |
| **BPTT (Backpropagation Through Time)** | RNN에서 시간의 흐름에 따라 펼쳐진 네트워크를 통해 오차를 역전파하는 학습 방식입니다. |
| **CNN (Convolutional Neural Network / 합성곱 신경망)** | 이미지 인식 및 처리에 특화된 딥러닝 모델. 데이터의 특징을 추출하는 합성곱 계층(Convolutional Layer)과 풀링 계층(Pooling Layer)을 사용합니다. |
| **GoogLeNet** | 2014년 이미지 인식 대회에서 우승한 CNN 모델. '인셉션 모듈'을 사용하여 파라미터 수를 줄이면서도 깊고 효율적인 네트워크를 구축했습니다. |
| **LSTM (Long Short-Term Memory)** | RNN의 장기 의존성 문제를 해결하기 위해 고안된 개선된 모델. '셀 상태(Cell State)'와 '게이트(Gate)' 구조를 통해 중요한 정보는 오래 기억하고 불필요한 정보는 잊는 메커니즘을 가집니다. |
| **PyTorch** | `Tensor` 연산과 자동 미분(Autograd) 기능을 통해 유연하고 동적인 신경망 구축을 지원하는 오픈소스 머신러닝 라이브러리입니다. (비유: 레고 블록) |
| **VGGNet** | 3x3의 작은 합성곱 필터를 깊게 쌓는 단순하면서도 강력한 구조를 제시한 CNN 모델. 네트워크의 '깊이(depth)'가 성능에 중요하다는 것을 보여주었습니다. |
---
*이 용어집은 `geumdo_docs/ai lecture/part_7_deep_learning.md` 와 `geumdo_docs/ai lecture/part_7.1_transformer_and_llm_principles.md` 파일 내용을 기반으로 작성되었습니다.*
\ No newline at end of file
*이 용어집은 `geumdo_docs/ai lecture/part_0.1_history_of_ai.md` 및 `part_7` 딥러닝 시리즈(`part_7_deep_learning.md`, `part_7.1_recurrent_neural_networks.md`, `part_7.2_transformer_and_llm_principles.md`, `part_7.3_llm_application_development_with_langchain.md`, `part_7.4_graph_neural_networks.md`, `part_7.5_reinforcement_learning.md`) 파일 내용을 기반으로 작성되었습니다.*
\ No newline at end of file
# 인공지능의 역사: 개념의 진화
## 서론: 생각하는 기계라는 오랜 꿈
인류는 고대부터 스스로 생각하는 기계를 꿈꿔왔습니다. 이러한 오랜 야망은 신화나 소설 속에서 지능을 가진 존재를 상상하고, 때로는 체스 두는 기계와 같은 실제 장치를 만들려는 역사적 시도로 나타났습니다. 20세기 중반, 이 꿈은 '인공지능'이라는 학문 분야로 구체화되었고, 수많은 부침(浮沈)을 거치며 오늘날 우리 삶을 바꾸는 핵심 기술로 자리 잡았습니다. 이 문서는 단순한 연대기 나열을 넘어, 주요 개념들이 어떻게 탄생하고 서로 영향을 주며 현재의 딥러닝과 생성 AI 시대로 이어졌는지 그 진화의 과정을 추적합니다.
## 1. 인공지능의 태동과 황금기 (1940년대 ~ 1960년대)
### 신경망의 첫 아이디어와 지능에 대한 질문
- **1943년, 신경망의 기원:** 신경과학자 워렌 맥컬록과 수학자 월터 피츠는 뇌의 뉴런이 작동하는 방식을 본뜬 간단한 수학 모델을 제안합니다. 이 모델은 '참' 또는 '거짓' 신호를 처리하는 논리 회로로, 비록 단순했지만 뇌를 계산 기계로 볼 수 있다는 가능성을 제시했습니다. 이는 훗날 **연결주의(Connectionism)** 라는 AI의 큰 흐름, 즉 수많은 단순한 처리 장치들의 연결로 지능을 구현하려는 시도의 씨앗이 됩니다.
- **1950년, 튜링 테스트:** "기계가 생각할 수 있는가?" 앨런 튜링은 이 철학적인 질문에 답하기 위해 '이미테이션 게임', 즉 **튜링 테스트**를 제안합니다. 이는 AI의 지능을 인간과 얼마나 구별하기 어려운지로 평가하는 실용적인 기준을 제시했으며, AI가 나아가야 할 목표와 철학적 기반을 제공했습니다.
### '인공지능'의 탄생과 폭발적인 낙관론
- **1956년, 다트머스 워크숍:** 존 매카시가 '인공지능(Artificial Intelligence)'이라는 용어를 처음 사용하며 역사적인 워크숍을 개최합니다. 이 사건은 AI를 공식적인 학문 분야로 만들었으며, 초기 AI 연구는 인간의 논리적 사고 과정을 컴퓨터로 재현하려는 **기호주의(Symbolic AI)** 에 집중되었습니다.
- **초기 성공과 낙관론:** 이 시기에는 Lisp(AI 연구의 표준 언어), 최초의 인공 신경망 SNARC, 그리고 패턴을 학습할 수 있었던 프랭크 로젠블랫의 **퍼셉트론(Perceptron, 1957)** 과 같은 성과들이 쏟아졌습니다. 특히 퍼셉트론은 신경망의 가능성을 보여주며 큰 기대를 모았고, 당시 연구자들은 10년 안에 인간 수준의 AI가 등장할 것이라 낙관했습니다.
## 2. 첫 번째 AI 겨울과 새로운 패러다임의 모색 (1970년대 ~ 1980년대)
### 퍼셉트론의 한계와 AI의 겨울
- **1969년, 퍼셉트론의 한계 증명:** AI의 선구자였던 마빈 민스키와 시모어 페퍼트는 저서 『퍼셉트론』에서 단층 퍼셉트론이 XOR와 같은 간단한 논리 문제조차 풀 수 없음을 수학적으로 증명했습니다. 이 연구는 당시 신경망 연구에 치명타를 날렸고, AI에 대한 과장된 약속에 실망한 정부와 기업들이 연구 자금을 대거 철회하면서 **첫 번째 AI 겨울(AI Winter)** 이 시작되었습니다.
- **기호주의의 한계:** 한편, 주류였던 기호주의 AI 역시 현실 세계의 복잡하고 애매모호한 문제들을 처리하는 데 어려움을 겪으며 한계에 부딪혔습니다.
### 전문가 시스템과 머신러닝의 등장
- **1980년대, 전문가 시스템(Expert System):** AI 연구는 '인간처럼 생각하는 기계' 대신, 특정 분야의 전문가 지식을 규칙 기반으로 저장해 문제를 해결하는 실용적인 '전문가 시스템'으로 방향을 전환합니다. 이는 AI가 처음으로 상업적 성공을 거두는 계기가 되었습니다.
- **1959년, '머신러닝'의 탄생:** 아서 사무엘은 스스로 체커 게임을 하면서 학습하여 실력을 향상시키는 프로그램을 개발하고, 여기에 **'머신러닝(Machine Learning)'** 이라는 이름을 붙였습니다. 데이터를 기반으로 컴퓨터가 명시적인 프로그래밍 없이 스스로 학습하는 이 개념은, 모든 규칙을 인간이 직접 입력해야 하는 기호주의 AI와 근본적으로 다른 패러다임이었습니다. 이 아이디어는 수십 년 후 AI의 주류가 됩니다.
## 3. 연결주의의 부활과 데이터 기반 접근법의 확립 (1980년대 후반 ~ 2000년대)
### 역전파 알고리즘과 연결주의의 부활
- **1986년, 역전파 알고리즘:** 제프리 힌튼을 비롯한 연구자들이 다층 신경망을 효과적으로 훈련시킬 수 있는 **역전파(Backpropagation) 알고리즘**을 대중화시켰습니다. 이는 '퍼셉트론'이 제기했던 한계를 정면으로 돌파하는 혁신이었고, 신경망 연구의 부활을 이끌었습니다. 비록 당시의 컴퓨팅 파워로는 깊은 신경망을 훈련시키기 어려웠지만, 이 알고리즘은 훗날 **딥러닝 혁명의 핵심 엔진**이 됩니다.
### 두 번째 AI 겨울과 통계적 머신러닝의 시대
- **1990년대, 두 번째 AI 겨울:** 80년대의 반짝 부흥을 이끌었던 전문가 시스템은 지식 추가 및 유지보수의 어려움 등으로 인해 다시 한계를 드러냈고, AI 시장은 또다시 침체기를 맞습니다.
- **데이터 기반 접근법의 승리:** 이 침체기 동안 AI 연구의 패러다임은 규칙 기반의 기호주의에서 **데이터 기반의 통계적 머신러닝**으로 완전히 전환되었습니다. 서포트 벡터 머신(SVM), 결정 트리 등 강력하고 수학적 기반이 탄탄한 알고리즘들이 주목받았고, AI는 더 과학적이고 실용적인 학문으로 발전했습니다.
- **1997년, 딥블루의 승리:** IBM의 체스 컴퓨터 '딥블루'가 세계 챔피언 가리 카스파로프를 꺾은 사건은 AI의 역사에서 중요한 이정표입니다. 딥블루는 머신러닝보다는 엄청난 계산 능력과 탐색 알고리즘에 의존했지만, 이 사건은 AI가 인간의 지능을 특정 영역에서 넘어설 수 있음을 대중에게 각인시켰습니다.
## 4. 딥러닝 혁명과 생성 AI의 시대 (2010년대 ~ 현재)
2010년대에 들어, 수십 년간 축적된 AI 연구는 세 가지 거대한 변화와 만나 폭발적인 '혁명'을 일으킵니다.
1. **빅데이터(Big Data):** 인터넷의 발달로 ImageNet과 같은 대규모의 정제된 데이터셋이 등장했습니다.
2. **하드웨어의 발전(Hardware):** 게임 산업을 위해 개발된 **GPU**가 신경망의 병렬 연산에 최적이라는 사실이 발견되면서, 이전에는 불가능했던 규모의 모델 훈련이 가능해졌습니다.
3. **알고리즘의 성숙(Algorithms):** 1980년대에 등장했던 **역전파 알고리즘**이 마침내 빛을 발하기 시작했습니다.
### 딥러닝의 충격과 전성기
- **2012년, AlexNet의 등장:** 제프리 힌튼과 그의 제자들이 개발한 심층 합성곱 신경망(Deep CNN)인 **AlexNet**이 이미지 인식 대회(ILSVRC)에서 압도적인 성능으로 우승합니다. 이 사건은 딥러닝(Deep Learning)의 잠재력을 전 세계에 증명했으며, 이후 AI 연구의 모든 패러다임을 딥러닝 중심으로 바꾸어 놓았습니다.
- **2016년, 알파고 쇼크:** 구글 딥마인드의 **알파고**는 딥러닝과 강화학습을 결합하여, 인간의 직관과 창의성의 영역으로 여겨졌던 바둑에서 세계 최고 기사 이세돌을 꺾었습니다. 이는 AI가 복잡한 전략적 사고까지 가능하다는 것을 보여준 충격적인 사건이었습니다.
### 거대 언어 모델과 생성 AI
- **2017년, 트랜스포머의 등장:** 구글 연구진이 발표한 "Attention Is All You Need" 논문에서 제시된 **트랜스포머(Transformer)** 아키텍처는 자연어 처리 분야에 혁명을 일으켰습니다. 순차적인 처리에 의존했던 기존 모델(RNN, LSTM)의 한계를 극복한 트랜스포머는 **GPT, BERT**와 같은 **거대 언어 모델(LLM)**의 기반이 되었습니다.
- **2020년대, 생성 AI의 부상:** OpenAI의 **GPT-3, DALL-E**를 시작으로, AI는 이제 주어진 데이터를 분석하고 예측하는 것을 넘어, 인간처럼 글을 쓰고, 그림을 그리고, 코드를 작성하고, 음악을 만드는 **생성(Generative) AI**의 시대로 접어들었습니다. 이는 AI가 단순한 도구를 넘어 창의적인 파트너가 될 수 있는 가능성을 열었습니다.
## 결론: 계속되는 진화
인공지능의 역사는 낙관과 절망, 경쟁과 협력이 교차하는 거대한 서사시입니다. 뇌를 모방하려던 작은 아이디어에서 시작해, 두 번의 겨울을 거치며 패러다임을 전환했고, 마침내 데이터와 컴퓨팅 파워를 만나 딥러닝 혁명을 이루었습니다. 현재 우리는 AI가 인간의 지능과 창의성을 어떻게 확장시킬 수 있는지 목격하는 새로운 시대의 출발점에 서 있습니다.
---
*이 문서는 [IBM의 AI 역사](https://www.ibm.com/think/topics/history-of-artificial-intelligence) 등 여러 AI 역사 관련 자료를 참고하여 개념의 흐름을 중심으로 재구성되었습니다.*
\ No newline at end of file
# Part 7.1: 순환 신경망 (RNN)과 LSTM
**⬅️ 이전 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**
**➡️ 다음 시간: [Part 7.2: Transformer와 LLM의 핵심 원리](./part_7.2_transformer_and_llm_principles.md)**
---
## 1. 학습 목표 (Learning Objectives)
이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
- 순차 데이터(Sequential Data)의 특징을 이해하고 RNN이 왜 필요한지 설명할 수 있습니다.
- RNN의 기본 구조와 순환하는 아이디어, 그리고 은닉 상태(Hidden State)의 역할을 이해합니다.
- 장기 의존성 문제(Vanishing/Exploding Gradient)가 무엇인지 설명할 수 있습니다.
- LSTM의 게이트(Gate) 구조가 어떻게 장기 의존성 문제를 해결하는지 기본 원리를 이해합니다.
- PyTorch를 사용하여 간단한 RNN/LSTM 모델을 구축하고 텍스트 생성 문제를 해결할 수 있습니다.
## 2. 핵심 키워드 (Keywords)
`순차 데이터(Sequential Data)`, `순환 신경망(RNN)`, `은닉 상태(Hidden State)`, `BPTT(Backpropagation Through Time)`, `장기 의존성 문제(Long-Term Dependency Problem)`, `기울기 소실/폭발(Vanishing/Exploding Gradient)`, `LSTM(Long Short-Term Memory)`, `게이트(Gate)`
## 3. 도입: 과거를 기억하는 모델, RNN
지금까지 우리가 다룬 MLP나 CNN은 입력 데이터 간의 순서나 시간적인 관계를 고려하지 않았습니다. 사진 속 고양이의 픽셀 위치는 중요하지만, '고양이'라는 단어를 이루는 '고', '양', '이' 글자들은 **순서**가 없다면 의미가 없습니다.
이렇게 **순서가 중요한 데이터****순차 데이터(Sequential Data)**라고 합니다.
- **텍스트**: 단어의 순서가 문장의 의미를 결정합니다. ("나는 너를 좋아해" vs "너는 나를 좋아해")
- **시계열 데이터**: 주가, 날씨 등 시간의 흐름에 따라 기록된 데이터입니다. 어제의 주가가 오늘의 주가에 영향을 미칩니다.
- **음성**: 소리의 파형은 시간 순서대로 이어져 의미를 가집니다.
**순환 신경망(Recurrent Neural Network, RNN)**은 바로 이 순차 데이터를 처리하기 위해 탄생한 특별한 아키텍처입니다. RNN은 모델 내부에 '기억'을 할 수 있는 **순환(Recurrent)** 구조를 가지고 있어, 이전 시간 단계(time step)의 정보를 현재 계산에 활용할 수 있습니다.
---
## 4. RNN의 작동 원리
### 4-1. 순환과 은닉 상태 (Recurrence and Hidden State)
RNN의 핵심 아이디어는 간단합니다. 네트워크의 출력이 다시 자기 자신에게 입력으로 들어가는 것입니다.
![RNN Unrolled](https://i.imgur.com/4f2p7gH.png)
*(이미지 출처: Christopher Olah's Blog)*
왼쪽의 압축된 형태를 보면, RNN 계층은 입력(`x_t`)을 받아 출력(`h_t`)을 내보내고, 이 출력(`h_t`)이 다시 다음 계산을 위해 자기 자신에게 입력됩니다. 이 과정을 오른쪽처럼 시간의 흐름에 따라 펼쳐보면(Unrolled), 각 시간 단계(time step)별로 동일한 가중치를 공유하는 네트워크가 연결된 모습과 같습니다.
여기서 가장 중요한 개념은 **은닉 상태(Hidden State)**, 즉 `h_t` 입니다.
- **은닉 상태 (h_t)**: 해당 시간 단계 `t`까지의 '기억' 또는 '문맥'을 요약한 벡터입니다. 이 벡터는 이전 시간 단계의 은닉 상태(`h_t-1`)와 현재 시간 단계의 입력(`x_t`)을 함께 사용하여 계산됩니다.
- **수식**: `h_t = tanh(W_xh * x_t + W_hh * h_t-1 + b)`
- `W_xh`: 입력 `x_t`에 대한 가중치
- `W_hh`: 이전 은닉 상태 `h_t-1`에 대한 가중치
- `b`: 편향(bias)
- `tanh`: 활성화 함수 (주로 Tanh가 사용됨)
이 과정을 통해 RNN은 "나는", "너를" 이라는 단어를 순서대로 읽으며, "좋아해"라는 단어가 나올 차례라는 것을 예측할 수 있게 됩니다.
### 4-2. 시간 역전파 (BPTT)
RNN의 학습은 시간의 흐름에 따라 펼쳐진 네트워크를 따라 오차를 거꾸로 전파하는 **BPTT(Backpropagation Through Time)** 방식을 사용합니다. 이는 일반적인 역전파와 원리는 같지만, 모든 시간 단계에 걸쳐 역전파가 일어난다는 점이 다릅니다.
---
## 5. 장기 의존성 문제 (The Long-Term Dependency Problem)
RNN의 아이디어는 훌륭하지만, 치명적인 약점이 있습니다. 문장이 길어지면 **아주 먼 과거의 정보가 현재까지 전달되지 못하는 현상**, 즉 **장기 의존성 문제**가 발생합니다.
> "오늘 아침 [프랑스]에서 유창하게 [프랑스어]를 구사하는 사람들을 만났다."
위 문장에서 마지막 단어 '프랑스어'를 예측하려면, 문장 맨 앞의 '프랑스'라는 단어를 기억해야 합니다. 하지만 이 두 단어 사이의 거리가 너무 멀면, BPTT 과정에서 그래디언트(기울기)가 전달되다가 점점 희미해지거나( **기울기 소실, Vanishing Gradient** ), 반대로 너무 커져서 발산하는( **기울기 폭발, Exploding Gradient** ) 문제가 발생합니다.
- **기울기 소실**: 활성화 함수(주로 `tanh`)의 미분값은 최대 1입니다. 역전파 과정에서 1보다 작은 값이 계속 곱해지면, 그래디언트는 0에 수렴하게 됩니다. 결국, 먼 과거의 정보는 가중치 업데이트에 거의 영향을 주지 못합니다. 이것이 RNN이 긴 문장을 잘 기억하지 못하는 주된 이유입니다.
## 6. LSTM: 장기 기억을 위한 해법
**LSTM(Long Short-Term Memory)** 은 이 장기 의존성 문제를 해결하기 위해 고안된 RNN의 개선된 버전입니다. LSTM은 '단기 기억'과 '장기 기억'을 모두 효과적으로 다룰 수 있습니다.
LSTM의 핵심은 **셀 상태(Cell State)****게이트(Gate)** 라는 정교한 메커니즘입니다.
![LSTM Structure](https://i.imgur.com/0uTjG3E.png)
*(이미지 출처: Christopher Olah's Blog)*
- **셀 상태 (Cell State)**: 컨베이어 벨트처럼 네트워크 전체를 가로지르는 정보의 흐름입니다. LSTM은 이 셀 상태에 정보를 추가하거나 제거하는 능력을 가지고 있습니다.
- **게이트 (Gates)**: 정보가 셀 상태를 통과하도록 제어하는 장치입니다. 게이트는 시그모이드(Sigmoid) 함수를 통해 0(정보를 차단)과 1(정보를 통과) 사이의 값을 출력하여 정보의 양을 조절합니다.
LSTM에는 3가지 주요 게이트가 있습니다.
1. **Forget Gate (망각 게이트)**: 과거의 정보 중 **무엇을 잊어버릴지** 결정합니다. "새로운 문장이 시작되었으니, 이전 문장의 주어는 잊어버리자."
2. **Input Gate (입력 게이트)**: 새로운 정보 중 **무엇을 저장할지** 결정합니다. "새로운 주어 '그녀'가 등장했으니, 이 정보를 셀 상태에 추가하자."
3. **Output Gate (출력 게이트)**: 셀 상태의 정보 중 **무엇을 출력으로 내보낼지** 결정합니다. "현재 시점에서는 주어 정보가 필요하니, '그녀'에 대한 정보를 출력하자."
이러한 게이트 구조 덕분에 LSTM은 중요한 정보는 오래 기억하고, 불필요한 정보는 잊어버릴 수 있어 RNN의 장기 의존성 문제를 효과적으로 해결합니다.
---
## 7. 직접 해보기 (Hands-on Lab): "hello" 예측하기
간단한 RNN 모델을 만들어, "hell" 이라는 입력을 받았을 때 마지막 글자 "o"를 예측하도록 학습시켜 보겠습니다.
```python
import torch
import torch.nn as nn
import numpy as np
# 1. 데이터 준비
# 입력 데이터: "hell" -> "o" 를 예측하는 것이 목표
# 어휘집(vocabulary) 생성
input_str = 'hello'
vocab = sorted(list(set(input_str)))
char_to_idx = {c: i for i, c in enumerate(vocab)}
idx_to_char = {i: c for i, c in enumerate(vocab)}
# 데이터셋 생성 (hell -> o)
input_data = [char_to_idx[c] for c in 'hell']
target_data = [char_to_idx['o']]
# 원-핫 인코딩
vocab_size = len(vocab)
x_one_hot = [np.eye(vocab_size)[x] for x in input_data]
y_one_hot = [np.eye(vocab_size)[y] for y in target_data]
# PyTorch 텐서로 변환 (sequence_length, batch_size, input_size)
inputs = torch.Tensor(x_one_hot).unsqueeze(1)
targets = torch.Tensor(y_one_hot).squeeze(0).argmax(dim=1)
# 2. RNN 모델 정의
class SimpleRNN(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SimpleRNN, self).__init__()
self.hidden_size = hidden_size
self.rnn = nn.RNN(input_size, hidden_size, batch_first=False) # batch_first=False 가 기본값
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x, hidden):
# x: (sequence_length, batch_size, input_size)
# hidden: (num_layers, batch_size, hidden_size)
out, hidden = self.rnn(x, hidden)
# 마지막 시퀀스의 출력만 사용
# out: (sequence_length, batch_size, hidden_size)
out = self.fc(out[-1, :, :]) # (batch_size, hidden_size) -> (batch_size, output_size)
return out, hidden
def init_hidden(self, batch_size=1):
return torch.zeros(1, batch_size, self.hidden_size)
# 3. 모델, 손실함수, 옵티마이저 설정
input_size = vocab_size
hidden_size = 5
output_size = vocab_size
learning_rate = 0.1
model = SimpleRNN(input_size, hidden_size, output_size)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# 4. 학습 루프
for epoch in range(100):
hidden = model.init_hidden(batch_size=1)
optimizer.zero_grad()
outputs, hidden = model(inputs, hidden)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
_, predicted_idx = outputs.max(1)
predicted_char = idx_to_char[predicted_idx.item()]
print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}, Predicted: "{predicted_char}" -> Target: "o"')
# 5. 최종 예측
hidden = model.init_hidden(batch_size=1)
outputs, hidden = model(inputs, hidden)
_, predicted_idx = outputs.max(1)
predicted_char = idx_to_char[predicted_idx.item()]
print(f'\nFinal prediction after training: "hell" -> "{predicted_char}"')
```
> [!TIP]
> 위 코드를 직접 실행해보면서 `hidden_size`, `learning_rate`, `epoch` 등의 하이퍼파라미터를 바꿔보세요. `nn.RNN`을 `nn.LSTM`으로 바꾸고 실행해보는 것도 좋습니다. (LSTM은 `forward`에서 `hidden`이 `(h_0, c_0)` 튜플 형태여야 합니다)
## 8. 되짚어보기 (Summary)
- **RNN**: 순서가 있는 데이터를 다루기 위해, 네트워크의 출력이 다시 입력으로 들어가는 **순환** 구조를 가집니다. **은닉 상태**를 통해 과거의 정보를 기억합니다.
- **장기 의존성 문제**: RNN은 구조적 한계로 인해 먼 과거의 정보를 기억하기 어렵습니다 (**기울기 소실**).
- **LSTM**: **셀 상태****게이트(망각, 입력, 출력)** 라는 정교한 메커니즘을 도입하여, 정보의 흐름을 효과적으로 제어하고 장기 기억을 가능하게 합니다.
- **활용**: RNN과 LSTM은 자연어 처리, 기계 번역, 시계열 예측 등 다양한 분야에서 딥러닝의 발전을 이끌고 있습니다.
## 9. 더 깊이 알아보기 (Further Reading)
- [The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/): Andrej Karpathy의 전설적인 블로그 포스트. RNN의 매력적인 가능성을 보여줍니다.
- [Understanding LSTM Networks](http://colah.github.io/posts/2015-08-Understanding-LSTMs/): Christopher Olah의 블로그 포스트. LSTM의 구조를 그림으로 매우 알기 쉽게 설명한 최고의 자료입니다.
---
**➡️ 다음 시간: [Part 7.2: Transformer와 LLM의 핵심 원리](./part_7.2_transformer_and_llm_principles.md)**
\ No newline at end of file
# Part 7.1: Transformer와 LLM의 핵심 원리
# Part 7.2: Transformer와 LLM의 핵심 원리
**⬅️ 이전 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
**⬅️ 이전 시간: [Part 7.1: 순환 신경망 (RNN)과 LSTM](./part_7.1_recurrent_neural_networks.md)**
**➡️ 다음 시간: [Part 7.3: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.3_llm_application_development_with_langchain.md)**
---
......@@ -109,4 +109,4 @@ Transformer 아키텍처는 현대 LLM의 근간이 되었습니다. 대표적
---
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
\ No newline at end of file
**➡️ 다음 시간: [Part 7.3: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.3_llm_application_development_with_langchain.md)**
\ No newline at end of file
# Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기
# Part 7.3: LangChain으로 LLM 애플리케이션 개발 맛보기
**⬅️ 이전 시간: [Part 7: 딥러닝 기초와 PyTorch](./part_7_deep_learning.md)**
**➡️ 다음 시간: [Part 8: FastAPI를 이용한 모델 서빙](./part_8_model_serving_with_fastapi.md)**
**⬅️ 이전 시간: [Part 7.2: Transformer와 LLM의 핵심 원리](./part_7.2_transformer_and_llm_principles.md)**
**➡️ 다음 시간: [Part 7.4: 그래프 신경망 (GNN)](./part_7.4_graph_neural_networks.md)**
---
......@@ -150,4 +150,4 @@ print(response["result"])
---
**➡️ 다음 시간: [Part 8: FastAPI를 이용한 모델 서빙](./part_8_model_serving_with_fastapi.md)**
\ No newline at end of file
**➡️ 다음 시간: [Part 7.4: 그래프 신경망 (GNN)](./part_7.4_graph_neural_networks.md)**
\ No newline at end of file
# Part 7.4: 그래프 신경망 (GNN)
**⬅️ 이전 시간: [Part 7.3: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.3_llm_application_development_with_langchain.md)**
**➡️ 다음 시간: [Part 7.5: 강화학습 (Reinforcement Learning)](./part_7.5_reinforcement_learning.md)**
---
> [!WARNING]
> 이 파트는 현재 준비 중입니다. GNN의 핵심 개념과 PyTorch Geometric을 사용한 실습 코드가 추가될 예정입니다.
## 1. 학습 목표 (Learning Objectives)
이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
- 그래프(Graph) 데이터의 구조와 특징을 이해합니다.
- GNN이 왜 필요한지, 기존의 신경망과 무엇이 다른지 설명할 수 있습니다.
- GNN의 핵심 아이디어인 메시지 패싱(Message Passing)의 기본 개념을 이해합니다.
- PyTorch Geometric 라이브러리를 사용하여 간단한 GNN 모델을 구성할 수 있습니다.
## 2. 핵심 키워드 (Keywords)
`그래프 신경망(GNN)`, `그래프 데이터(Graph Data)`, `노드(Node)`, `엣지(Edge)`, `인접 행렬(Adjacency Matrix)`, `메시지 패싱(Message Passing)`, `PyTorch Geometric`
## 3. 도입: 관계를 학습하는 모델, GNN
세상은 연결의 집합입니다.
- **소셜 네트워크**: 사람(노드)들은 친구 관계(엣지)로 연결됩니다.
- **분자 구조**: 원자(노드)들은 화학 결합(엣지)으로 연결됩니다.
- **도로망**: 교차로(노드)들은 도로(엣지)로 연결됩니다.
이처럼 **객체(노드)와 그들의 관계(엣지)로 표현되는 데이터****그래프 데이터**라고 합니다. 기존의 MLP나 CNN, RNN은 이러한 복잡한 관계성을 직접 다루기 어렵습니다.
**그래프 신경망(Graph Neural Network, GNN)**은 그래프 구조 자체를 입력으로 받아, 노드의 특징과 노드 간의 연결 관계를 종합적으로 학습하는 강력한 아키텍처입니다.
---
## 4. GNN의 핵심 아이디어: 메시지 패싱 (Message Passing)
GNN의 핵심 원리는 "이웃 노드로부터 정보를 받아서 나의 정보를 업데이트한다"는 **메시지 패싱** 아이디어로 요약할 수 있습니다.
![Message Passing](https://distill.pub/2021/gnn-intro/images/gnn-computation-2.gif)
*(이미지 출처: distill.pub)*
1. **메시지 생성**: 각 노드는 자신의 이웃 노드들에게 보낼 '메시지'를 생성합니다.
2. **정보 취합 (Aggregation)**: 각 노드는 이웃들로부터 받은 메시지들을 하나로 모읍니다. (예: 평균을 내거나, 합산)
3. **정보 업데이트 (Update)**: 각 노드는 취합된 정보와 자기 자신의 기존 정보를 바탕으로 새로운 상태(표현 벡터)를 계산합니다.
이 과정을 여러 번 반복(여러 GNN 레이어를 쌓음)함으로써, 노드들은 더 멀리 있는 이웃들의 정보까지 전달받아 자신의 표현을 더욱 풍부하게 만들 수 있습니다.
---
## 5. 직접 해보기 (Hands-on Lab): (내용 추가 예정)
PyTorch Geometric 라이브러리를 사용하여 소셜 네트워크의 사용자 직업을 예측하는 GNN 모델을 만들어볼 예정입니다.
---
## 6. 되짚어보기 (Summary)
- **GNN**: 노드와 엣지로 구성된 그래프 구조의 데이터를 직접 처리하기 위한 신경망입니다.
- **핵심 원리**: 이웃 노드와 '메시지'를 주고받으며 자신의 정보를 업데이트하는 **메시지 패싱**을 기반으로 합니다.
- **활용**: 추천 시스템, 신약 개발, 금융 사기 탐지 등 관계 속에서 패턴을 찾아내는 다양한 분야에 활용됩니다.
---
**➡️ 다음 시간: [Part 7.5: 강화학습 (Reinforcement Learning)](./part_7.5_reinforcement_learning.md)**
\ No newline at end of file
# Part 7.5: 강화학습 (Reinforcement Learning)
**⬅️ 이전 시간: [Part 7.4: 그래프 신경망 (GNN)](./part_7.4_graph_neural_networks.md)**
**➡️ 다음 시간: [Part 8: FastAPI를 이용한 모델 서빙](./part_8_model_serving_with_fastapi.md)**
---
> [!WARNING]
> 이 파트는 현재 준비 중입니다. 강화학습의 핵심 개념과 Gymnasium 라이브러리를 사용한 실습 코드가 추가될 예정입니다.
## 1. 학습 목표 (Learning Objectives)
이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
- 강화학습이 지도/비지도학습과 어떻게 다른지 설명할 수 있습니다.
- 에이전트, 환경, 상태, 행동, 보상 등 강화학습의 핵심 구성요소를 이해합니다.
- 정책(Policy)과 가치 함수(Value Function)의 개념을 설명할 수 있습니다.
- 강화학습이 어떤 문제들을 해결하는 데 사용될 수 있는지 이해합니다.
## 2. 핵심 키워드 (Keywords)
`강화학습(Reinforcement Learning)`, `에이전트(Agent)`, `환경(Environment)`, `상태(State)`, `행동(Action)`, `보상(Reward)`, `정책(Policy)`, `Q-러닝(Q-Learning)`, `Gymnasium`
## 3. 도입: 보상을 통해 학습하는 모델
지금까지 우리가 배운 딥러닝(지도학습)은 '정답'이 있는 데이터를 기반으로 했습니다. '이 이미지는 고양이'라는 정답을 알려주며 학습시켰습니다.
하지만 '자전거 타는 법'이나 '게임에서 이기는 법'을 배울 때를 생각해보세요. 모든 순간마다 '정답' 행동이 주어지지 않습니다. 우리는 수많은 '시행착오'를 통해 '이렇게 하니 넘어지더라(나쁜 보상)', '저렇게 하니 더 멀리 가더라(좋은 보상)'를 스스로 터득합니다.
**강화학습(Reinforcement Learning, RL)**은 이처럼 '정답' 대신 **'보상(Reward)'** 이라는 신호를 통해, 주어진 환경(Environment) 속에서 보상을 최대로 얻을 수 있는 행동 전략, 즉 **정책(Policy)** 을 학습하는 패러다임입니다.
![Reinforcement Learning](https://i.imgur.com/g8nN8e6.gif)
*(이미지 출처: MathWorks)*
- **에이전트 (Agent)**: 학습의 주체. 우리의 모델 (예: 게임 플레이어, 로봇)
- **환경 (Environment)**: 에이전트가 상호작용하는 세상 (예: 게임 맵, 실제 공간)
- **상태 (State)**: 환경의 현재 상황.
- **행동 (Action)**: 에이전트가 상태를 보고 취할 수 있는 행동.
- **보상 (Reward)**: 행동의 결과로 환경이 에이전트에게 주는 신호. (긍정적 또는 부정적)
에이전트의 목표는 단 하나, **누적 보상을 최대화**하는 것입니다.
---
## 4. 강화학습의 핵심 개념
- **정책 (Policy, π)**: 특정 상태에서 어떤 행동을 할지 결정하는 에이전트의 전략 또는 뇌. `π(action | state)`는 상태 `s`에서 행동 `a`를 할 확률을 의미합니다.
- **가치 함수 (Value Function, V, Q)**: 특정 상태 또는 (상태, 행동) 쌍이 미래에 얻을 것으로 예상되는 누적 보상의 기댓값. 즉, 현재 상태가 얼마나 '좋은지'를 나타냅니다.
- `V(s)`: 상태 `s`의 가치.
- `Q(s, a)`: 상태 `s`에서 행동 `a`를 했을 때의 가치.
강화학습은 이 정책과 가치 함수를 반복적으로 업데이트하며 최적의 해를 찾아갑니다.
---
## 5. 직접 해보기 (Hands-on Lab): (내용 추가 예정)
`Gymnasium` 라이브러리를 사용하여, 간단한 게임 환경('CartPole')에서 막대가 쓰러지지 않도록 균형을 잡는 에이전트를 학습시키는 딥러닝 모델(DQN)을 만들어볼 예정입니다.
---
## 6. 되짚어보기 (Summary)
- **강화학습**: 정답이 아닌 '보상'을 통해 시행착오를 거쳐 학습하는 머신러닝의 한 분야입니다.
- **핵심 구성요소**: **에이전트****환경** 속에서 특정 **상태**를 인식하고 **행동**을 취하면, 환경은 **보상**을 줍니다.
- **목표**: 에이전트는 누적 보상을 최대화하는 **정책**을 학습합니다.
- **활용**: 게임 AI(알파고), 로봇 제어, 자율주행, 자원 최적화 등 복잡한 의사결정 문제에 널리 사용됩니다.
---
**➡️ 다음 시간: [Part 8: FastAPI를 이용한 모델 서빙](./part_8_model_serving_with_fastapi.md)**
\ No newline at end of file
# Part 7: 딥러닝 기초와 PyTorch
**⬅️ 이전 시간: [Part 6: 머신러닝 모델링과 평가](./part_6_machine_learning.md)**
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
**➡️ 다음 시간: [Part 7.1: 순환 신경망 (RNN)과 LSTM](./part_7.1_recurrent_neural_networks.md)**
---
......@@ -17,7 +17,7 @@
## 2. 핵심 키워드 (Keywords)
`딥러닝(Deep Learning)`, `PyTorch`, `텐서(Tensor)`, `인공 신경망(ANN)`, `nn.Module`, `활성화 함수(Activation Function)`, `손실 함수(Loss Function)`, `옵티마이저(Optimizer)`, `순전파(Forward Propagation)`, `역전파(Backward Propagation)`, `에포크(Epoch)`, `CNN(Convolutional Neural Network)`
`딥러닝(Deep Learning)`, `PyTorch`, `텐서(Tensor)`, `인공 신경망(ANN)`, `다층 퍼셉트론(MLP)`, `nn.Module`, `활성화 함수(Activation Function)`, `손실 함수(Loss Function)`, `옵티마이저(Optimizer)`, `순전파(Forward Propagation)`, `역전파(Backward Propagation)`, `에포크(Epoch)`, `CNN(Convolutional Neural Network)`
## 3. 도입: 모델을 직접 조립하는 즐거움, PyTorch (Introduction)
......@@ -41,8 +41,8 @@
1. **GPU 가속**: `.to('cuda')` 코드 한 줄로 GPU를 사용한 초고속 연산이 가능합니다.
2. **자동 미분(Autograd)**: 딥러닝 학습의 핵심인 '역전파'를 위해 자동으로 미분값을 계산해줍니다.
### 4-2. 인공 신경망(ANN) 모델 만들기
PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래스(레고 조립 설명서)를 정의합니다.
### 4-2. 인공 신경망(ANN)과 다층 퍼셉트론(MLP) 모델 만들기
PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래스(레고 조립 설명서)를 정의합니다. 가장 기본적이면서도 강력한 신경망 구조 중 하나는 바로 **다층 퍼셉트론(Multi-Layer Perceptron, MLP)** 입니다. 아래 `SimpleNet` 예제가 바로 MLP의 간단한 구현체입니다.
- **`__init__(self)`**: 모델에 필요한 레고 블록들(레이어)을 정의하는 곳.
- **`forward(self, x)`**: 레고 블록들을 어떤 순서로 조립할지(데이터 흐름) 정의하는 곳.
......@@ -51,18 +51,17 @@ PyTorch에서는 `torch.nn.Module`을 상속받아 우리만의 신경망 클래
import torch
import torch.nn as nn
# 모델 정의 (레고 조립 설명서)
# 모델 정의 (MLP 예시)
class SimpleNet(nn.Module):
# 1. 필요한 레고 블록 선언
def __init__(self, input_size, hidden_size, num_classes):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size) # 완전 연결 계층
self.fc1 = nn.Linear(input_size, hidden_size) # 완전 연결 계층 (Input -> Hidden)
self.relu = nn.ReLU() # 활성화 함수
self.fc2 = nn.Linear(hidden_size, num_classes)
self.fc2 = nn.Linear(hidden_size, num_classes) # 완전 연결 계층 (Hidden -> Output)
# 2. 레고 블록 조립 순서 정의
def forward(self, x):
# 순전파: 데이터가 입력층부터 출력층까지 나아가는 과정
out = self.fc1(x)
out = self.relu(out) # 💡 비선형성을 추가하여 모델의 표현력을 높임
out = self.fc2(out)
......@@ -138,6 +137,14 @@ print(model)
> - **순전파 (Forward)**: 내가 만든 레시피로 요리를 해서(모델 예측) 손님에게 내놓는 과정.
> - **역전파 (Backward)**: 손님의 피드백("너무 짜요!")을 듣고, 소금을 얼마나 많이 넣었는지, 간장을 얼마나 넣었는지 원인을 거슬러 올라가 분석하는 과정. `optimizer.step()`은 이 분석을 바탕으로 다음 요리에서는 소금을 덜 넣는 행동입니다.
### 5-3. 학습, 검증, 그리고 추론 (Training, Validation, and Inference)
딥러닝 모델의 생명주기는 크게 '학습', '검증', '추론' 세 단계로 나뉩니다.
- **학습 (Training)**: `train_loader` 와 같이 훈련용 데이터를 사용하여 모델의 파라미터(가중치)를 최적화하는 과정입니다. 위에서 설명한 **학습 루프**가 바로 이 단계에 해당합니다. 모델은 정답을 보면서 오차를 줄여나갑니다.
- **검증 (Validation)**: 학습 과정 중에 모델이 얼마나 잘 학습되고 있는지, 과적합(Overfitting)은 발생하지 않는지 확인하기 위한 단계입니다. 학습에 사용되지 않은 `validation_loader` 데이터로 모델의 성능을 주기적으로 평가합니다. 이 평가 결과를 바탕으로 학습률(Learning Rate)을 조절하거나 학습을 조기 종료하는 등의 결정을 내립니다.
- **추론 (Inference)**: 학습이 완료된 모델을 사용하여 새로운 데이터에 대한 예측을 수행하는 단계입니다. 이 단계에서는 더 이상 모델의 가중치를 업데이트하지 않으므로, 역전파나 옵티마이저가 필요 없습니다. `torch.no_grad()` 컨텍스트 안에서 실행하여 메모리 사용량을 줄이고 계산 속도를 높이는 것이 일반적입니다. 서비스 배포 환경에서 모델이 사용되는 단계가 바로 추론입니다.
---
## 6. 직접 해보기 (Hands-on Lab): MNIST 손글씨 분류
......@@ -197,9 +204,79 @@ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# with torch.no_grad():
# - test_loader에서 데이터를 가져와 예측
# - 전체 테스트 정확도 계산 및 출력 코드 작성
```
---
### 6-1. 심화: 주요 CNN 아키텍처의 발전사
간단한 CNN 모델을 직접 만들어본 지금, 딥러닝 역사에 획을 그은 주요 CNN 아키텍처들이 어떻게 발전해왔는지 살펴보는 것은 매우 의미 있는 일입니다. 모델이 어떤 문제를 해결하려 했고, 어떤 아이디어를 제시했는지 이해하면 깊이 있는 모델을 설계하는 도움이 것입니다.
| 모델명 | 발표 연도 | 주요 특징 기여 |
|---|---|---|
| **LeNet-5** | 1998 | LeCun 교수가 제안. 최초의 성공적인 CNN. `Conv`-`Pool`-`Conv`-`Pool`-`FC` 구조의 기반을 마련. |
| **AlexNet** | 2012 | 이미지넷(ILSVRC) 챌린지에서 압도적 성능으로 우승하며 **딥러닝의 부흥** 이끌었다. **ReLU**, **Dropout**, **GPU 활용** 현재까지도 널리 쓰이는 기법들을 대거 도입했다. |
| **VGGNet** | 2014 | **3x3의 작은 커널** 여러 깊게 쌓는 단순하지만 효과적인 구조를 제시. 깊이(Depth) 성능에 미치는 영향을 증명했다. |
| **GoogLeNet** | 2014 | **인셉션 모듈(Inception Module)** 도입하여, 여러 크기의 커널을 병렬로 사용함으로써 연산 효율성과 성능을 동시에 잡았다. **파라미터 수를 줄이는 ** 집중했다. |
| **ResNet** | 2015 | **잔차 학습(Residual Learning)** **스킵 연결(Skip Connection)**이라는 혁신적인 아이디어로 100층이 넘는 **매우 깊은 신경망** 학습을 가능하게 했다. **Vanishing Gradient 문제를 해결**하며 딥러닝의 한계를 돌파했다. |
#### 1. LeNet-5: CNN의 서막
- Yann LeCun 교수가 제안한 모델로, 현대적인 CNN 구조(합성곱 층과 풀링 층의 반복, 마지막에 완전 연결 계층) 청사진을 제시했습니다. 당시에는 손글씨 숫자 인식과 같은 제한된 문제에서 성공을 거두었습니다.
#### 2. AlexNet: 딥러닝의 폭발
- 2012 이미지넷 분류 챌린지에서 전통적인 컴퓨터 비전 기법들을 압도적인 성능 차이로 이기고 우승하며, AI 커뮤니티에 엄청난 충격을 주었습니다. 딥러닝이 학계를 넘어 산업계의 주류 기술로 발돋움하는 결정적인 계기가 되었습니다.
- **주요 기여**:
- **ReLU 활성화 함수**: Sigmoid/Tanh의 Vanishing Gradient 문제를 해결하고 학습 속도를 크게 향상시켰습니다.
- **Dropout**: 학습 일부 뉴런을 무작위로 비활성화하여 과적합을 방지하는 효과적인 규제(Regularization) 기법을 제시했습니다.
- **GPU 활용**: 2개의 GPU를 병렬로 사용하여 대규모 연산을 효율적으로 처리하며 딥러닝의 대중화를 이끌었습니다.
#### 3. VGGNet: 깊고 단순함의 미학
- "더 깊게 쌓으면 성능이 좋아질까?"라는 단순한 질문에서 출발했습니다.
- **주요 기여**:
- **3x3 합성곱 필터**: 크기(: 5x5, 7x7) 필터를 사용하는 대신, 3x3의 작은 필터를 여러 연속으로 사용하여 동일한 Receptive Field를 가지면서도 파라미터 수를 줄이고 비선형성을 증가시켰습니다.
- **균일한 구조**: VGG-16, VGG-19 깊이만 다른 균일한 구조를 제시하여 모델 설계의 단순함을 보여주었습니다.
#### 4. GoogLeNet (Inception): 효율적인 깊이의 추구
- VGGNet처럼 무작정 깊게 쌓는 것이 아니라, "어떻게 하면 연산 자원을 효율적으로 사용하면서 성능을 높일 수 있을까?" 고민했습니다.
- **주요 기여**:
- **인셉션 모듈(Inception Module)**: 1x1, 3x3, 5x5 합성곱과 3x3 풀링을 하나의 블록 안에서 병렬로 처리하고 결과를 합칩니다. 이를 통해 모델이 다양한 스케일의 특징을 동시에 학습할 있게 됩니다.
- **1x1 Convolution 활용**: 채널(Channel) 수를 줄여(BottleNeck) 전체 연산량을 획기적으로 감소시키면서도 성능은 유지하거나 향상시켰습니다.
#### 5. ResNet: 깊이의 한계를 넘어서
- 네트워크가 깊어질수록 오히려 학습이 어려워지고 성능이 저하되는 **퇴화(Degradation) 문제** 발생했습니다. 이는 Vanishing/Exploding Gradient와는 다른 현상으로, 깊은 망이 얕은 망보다 학습하기 어렵다는 문제였습니다.
- **주요 기여**:
- **잔차 학습(Residual Learning)**: 층이 입력값 `x` `H(x)` 직접 변환하도록 학습하는 대신, **변화량(Residual), `F(x) = H(x) - x`** 학습하도록 구조를 바꿨습니다.
- **스킵 연결(Skip Connection)**: 입력 `x` 개의 층을 건너뛰어 출력에 그대로 더해주는 `H(x) = F(x) + x` 구조입니다. 간단한 '지름길' 통해 그래디언트가 깊은 층까지 소실되지 않고 흘러갈 있게 되어, 152층이라는 전례 없는 깊이의 네트워크 학습을 성공시켰습니다. ResNet의 등장은 이후 수많은 딥러닝 아키텍처에 지대한 영향을 미쳤습니다.
```python
# ResNet의 기본 빌딩 블록 (PyTorch 예시)
class ResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
# 입력과 출력의 차원(채널 수, 크기)이 다를 경우를 위한 다운샘플링 레이어
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels)
)
def forward(self, x):
identity = self.shortcut(x) # 스킵 연결을 위한 입력값 저장
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out += identity # ★ 핵심: Conv Layer를 통과한 결과에 입력값을 더해준다.
out = self.relu(out)
return out
```
## 7. 되짚어보기 (Summary)
......@@ -216,4 +293,30 @@ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
---
**➡️ 다음 시간: [Part 7.5: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.5_llm_application_development_with_langchain.md)**
\ No newline at end of file
## 9. 다양한 딥러닝 아키텍처 맛보기
지금까지 우리는 딥러닝의 기본적인 구성 요소와 MLP, CNN 모델을 살펴보았습니다. 딥러닝의 세계는 훨씬 더 넓고 다양하며, 해결하려는 문제의 종류에 따라 특화된 여러 아키텍처가 존재합니다. 앞으로 이어질 파트에서는 다음과 같은 모델들을 탐험하게 됩니다.
- **[Part 7.1: 순환 신경망 (RNN)과 LSTM](./part_7.1_recurrent_neural_networks.md)**
- **무엇을 위한 모델인가?**: 텍스트, 시계열 데이터와 같이 **순서가 있는 데이터(Sequential Data)**를 처리하는 데 특화되어 있습니다.
- **활용 분야**: 자연어 처리(번역, 챗봇), 주가 예측, 음성 인식 등
- **[Part 7.2: Transformer와 LLM의 핵심 원리](./part_7.2_transformer_and_llm_principles.md)**
- **무엇을 위한 모델인가?**: RNN의 한계를 극복하고 병렬 처리를 통해 문장 전체의 문맥을 파악합니다. 현대 거대 언어 모델(LLM)의 기반이 됩니다.
- **활용 분야**: 기계 번역(ChatGPT), 텍스트 생성 및 요약 등
- **[Part 7.3: LangChain으로 LLM 애플리케이션 개발 맛보기](./part_7.3_llm_application_development_with_langchain.md)**
- **무엇을 위한 모델인가?**: Transformer 기반의 LLM을 외부 데이터 소스나 다른 도구와 연결하여 더 강력한 애플리케이션을 만듭니다.
- **활용 분야**: RAG(검색 증강 생성) 챗봇, AI 에이전트 개발 등
- **[Part 7.4: 그래프 신경망 (GNN)](./part_7.4_graph_neural_networks.md)** (예정)
- **무엇을 위한 모델인가?**: 소셜 네트워크, 분자 구조와 같이 **관계와 연결의 구조를 가진 데이터(Graph Data)**를 처리합니다.
- **활용 분야**: 친구 추천 시스템, 신약 개발, 이상 거래 탐지 등
- **[Part 7.5: 강화학습 (Reinforcement Learning)](./part_7.5_reinforcement_learning.md)** (예정)
- **무엇을 위한 모델인가?**: 에이전트가 환경과 상호작용하며 **보상을 최대화하는 행동**을 학습합니다.
- **활용 분야**: 게임 AI(알파고), 로봇 제어, 자율 주행 등
---
**➡️ 다음 시간: [Part 7.1: 순환 신경망 (RNN)과 LSTM](./part_7.1_recurrent_neural_networks.md)**
\ 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