Fixed

README.md

@@ -1,332 +1,332 @@
----
-license: apache-2.0
----
-
-안녕하세요 Oneclick AI 입니다!!  
-오늘은, RNN(순환 신경망, Recurrent Neural Network) 모델에 대해서 알아보는 시간을 가져볼까 합니다.  
-
-딥러닝이 문장, 음성, 주가 예측과 같은 순서가 있는 데이터(Sequential Data)를 다룰 수 있게 된 것은 전적으로 RNN 덕분입니다.  
-단순한 신경망이 '순서'라는 개념을 이해하지 못하는 반면,  
-RNN은 마치 사람처럼 시간의 흐름에 따라 정보를 기억하고, 다음을 예측할 수 있는 능력을 갖추고 있습니다.  
-
-오늘은 이 RNN이라는 신경망이 어떻게 과거의 정보를 기억하며 작동하는지,  
-그리고 어떻게 문장의 숨겨진 문맥과 의미를 파악할 수 있는지 알아봅시다.  
-
----
-
-## 목차  
-1. RNN 핵심 원리 파악하기  
-    - 왜 순차 데이터에 RNN을 사용해야만 할까?  
-    - RNN의 심장 : 순환 구조와 은닉 상태의 역학  
-    - RNN을 시간에 따라 펼쳐보기  
-    - RNN의 주요 구성 요소 상세 분석  
-2. 아키텍처를 통한 내부 코드 들여다 보기  
-    - Keras로 구현한 RNN 모델 아키텍처  
-    - model.summary()로 구조 확인하기  
-3. 직접 RNN 구현해 보기  
-    - 1단계 : 데이터 로드 및 전처리  
-    - 2단계 : 모델 컴파일  
-    - 3단계 : 모델 학습 및 평가  
-    - 4단계 : 학습된 모델 저장 및 재사용  
-    - 5단계 : 나만의 문장으로 모델 테스트하기  
-4. 나만의 RNN 모델 업그레이드하기  
-    - 기초 체력 훈련 : 하이퍼파라미터 튜닝  
-    - RNN의 치명적 약점 : 장기 의존성 문제  
-    - 기억력 강화 : LSTM과 GRU의 등장  
-    - 과거와 미래를 동시에 : 양방향 RNN  
-5. 결론
----
-
-## 1. RNN 핵심원리 파악하기
-가장 먼저, RNN이 왜 순차적인 데이터를 이해하는 데 필수적인 도구인지 그 근본적인 이유부터 살펴보겠습니다.  
-
-**왜 순차 데이터에 RNN을 사용할까?? with MLP, CNN의 한계**  
-가장 기본적인 신경망인 MLP(다층 퍼셉트론)에 "나는 학교에 간다"라는 문장을 입력한다고 상상해 봅시다.  
-MLP는 각 단어를 독립적인 특징으로 보기 때문에, "학교에 나는 간다"라는 문장과 거의 동일하게 받아들입니다.  
-단어의 '순서'가 가진 중요한 의미, 즉 문맥을 완전히 잃어버리는 것입니다.  
-이미지 처리에 특화된 CNN 역시 마찬가지입니다.  
-CNN은 공간적인 특징(픽셀 주변 관계)을 추출하는 데는 뛰어나지만, 시간적인 순서나 흐름을 파악하도록 설계되지 않았습니다.  
-반면, RNN은 설계 자체가 '순서'를 기억하기 위해 만들어졌습니다.  
-이전 단계의 처리 결과를 다음 단계의 입력으로 재사용하는 '순환' 구조를 통해, 마치 우리가 문장을 앞에서부터 차례로 읽으며 내용을 머릿속에 축적하는 것과 같은 방식으로 작동합니다.  
-
-**RNN의 심장 : 순환 구조와 은닉 상태의 역학**  
-RNN의 핵심 아이디어는 바로 순환 구조(Recurrent Structure)와 은닉 상태(Hidden State) 입니다.  
-- 순환 구조(Recurrent Structure)  
-신경망 내부에 '루프'가 존재하여, 정보가 계속해서 순환할 수 있는 구조를 말합니다.  
-각 타임스텝 $t$에서 모델은 입력 $x_t$와 이전 타임스텝의 정보 요약본인 $h_{t-1}$을 함께 받아 처리합니다.  
-
-- 은닉 상태(Hidden State, $h_t$)  
-은닉 상태는 '메모리' 또는 '문맥 벡터'라고 불리며, RNN의 모든 것을 담고 있습니다.  
-특정 타임스텝 t에서의 은닉 상태 $h_t$는 다음과 같은 수식으로 계산됩니다.  
-$h_t=tanh(W_hhh_t−1+W_xhx_t+b_h)$여기서 $W_hh$, $W_{xh}$는 학습을 통해 최적화되는 가중치 행렬이며, $b_h$는 편향입니다.  
-중요한 점은 모든 타임스텝에서 동일한 가중치($W$)와 편향($b$)이 공유된다는 것입니다.  
-이는 모델이 시간과 관계없이 일관된 패턴을 학습하게 하며, 파라미터 수를 크게 줄여줍니다.  
-tanh와 같은 활성화 함수는 계산된 값을 특정 범위(-1에서 1 사이)로 압축하는 역할을 합니다.
-
-**RNN을 시간에 따라 펼쳐보기**  
-아래 그림처럼 시간에 따라 네트워크를 길게 펼쳐서 표현하면, 쉽게 이해할 수 있습니다.   
-```markdown
-시간 흐름 ───▶
-입력 시퀀스:  x₁     x₂      x₃     ...     xₜ
-              ↓      ↓      ↓              ↓
-           ┌────┐ ┌────┐  ┌────┐   ...   ┌────┐
-h₀  ───▶  │RNN │▶│RNN │▶│RNN │ ▶ ... ▶│RNN │
-           └────┘ └────┘  └────┘         └────┘
-             │      │       │               │
-             ▼      ▼       ▼               ▼
-             h₁     h₂      h₃              hₜ
-```
-RNN은 내부적으로 **같은 셀** 을 매 시점마다 반복해서 사용하는 구조 입니다.  
-펼쳐서 보면, 위 그림처럼 하나의 RNN셀이 시간이 흐름에 따라 여러 번 복제된 것 처럼 보입니다.  
-순서대로 보자면,  
-1. 각 시점의 $X_t$가 RNN 셀에 들어가고,
-2. 이전 시점의 은식 상태의 $h_(t^-1)$도 함께 들어가서,  
-3. 새로운 은닉상태 $h_t$를 출력합니다.  
-4. 이 $h_t$는 다음 시점으로 전달되어 메모리 역할을 합니다.  
-
-위 그림 속 여러 셀은 같은 RNN 셀을 시간에 따라 복제한 것이고, 모든 셀은 가중치를 공유하기 때문에 시점이 달라도 같은 규칙으로 계산이 이루어 집니다.  
-
-보충설명 하자면,  
-`나는 학교에 간다`  
-를 입력하면,  
-$X_1$이 나는, $X_2$가 학교에, $X_3$ 가 간다가 되면서 시간에 따른 연산이 이루어 진다고 생각하시면 됩니다.  
-
-## 2. 아키텍처를 통한 내부 코드 들여다 보기
-이제 이론을 바탕으로, TensorFlow Keras 를 통해 직접 RNN을 구현해 봅시다.  
-Keras로 구현한 RNN 모델 아키텍처 심층 분석다음은 IMDB 영화 리뷰 감성 분석을 위한 간단한 RNN 모델입니다.  
-
-```python
-import tensorflow as tf
-from tensorflow import keras
-
-# 모델 아키텍처 정의
-model = keras.Sequential([
-    # 1. 단어 임베딩 층
-    # input_dim: 전체 단어 집합의 크기 (가장 빈번한 1만개 단어)
-    # output_dim: 각 단어를 표현할 벡터의 차원 (32차원)
-    keras.layers.Embedding(input_dim=10000, output_dim=32),
-    
-    # 2. RNN 층
-    # units: 은닉 상태 벡터의 차원 (32차원)
-    keras.layers.SimpleRNN(32),
-    
-    # 3. 최종 분류기(Classifier)
-    # units: 출력 뉴런의 수 (긍정/부정 1개)
-    # activation: 출력 값을 0~1 사이 확률로 변환 (이진 분류)
-    keras.layers.Dense(1, activation="sigmoid"),
-])
-
-# 모델 구조 요약 출력
-model.summary()
-```
-레이어를 자세히 들어다 봅시다.  
-
-- **임베딩 층(Embedding)**  
-```python
-keras.layers.Embedding(input_dim=10000, output_dim=32)
-```
-컴퓨터는 '영화', '재미' 같은 단어를 직접 이해하지 못합니다.  
-Embedding 층은 각 단어에 부여된 고유한 정수 인덱스를 output_dim 차원의 의미론적 벡터로 변환합니다.  
-이 과정에서 '슬픔'과 '비극' 같은 단어들은 벡터 공간상에서 가까운 위치에, '행복'과는 먼 위치에 표현되도록 학습됩니다.  
-
-- **순환 계층(SimpleRNN)**  
-```python
-keras.layers.SimpleRNN(32),
-```
-이 층이 순환 신경망의 본체입니다.  
-입력된 단어 임베딩 벡터 시퀀스를 순서대로 하나씩 처리하며 은닉 상태를 계속해서 업데이트합니다.  
-기본적으로 마지막 단어까지 처리한 후의 최종 은닉 상태만을 다음 층으로 전달합니다.  
-이 최종 은닉 상태 벡터는 전체 문장의 문맥을 압축한 결과물입니다.  
-
-- **완전 연결 계층(Dense)**  
-```python
-keras.layers.Dense(1, activation="sigmoid")
-```
-최종 은닉 상태 벡터를 받아, 리뷰가 긍정(1에 가까운 값)인지 부정(0에 가까운 값)인지 최종 판단을 내립니다. 
-model.summary()로 파라미터 수 계산 원리 이해하기위 코드에서 model.summary()를 실행하면 다음과 같은 결과가 나옵니다.  
-
-```bash
-Model: "sequential"
-_________________________________________________________________
- Layer (type)                Output Shape              Param #   
-=================================================================
- embedding (Embedding)       (None, None, 32)          320000    
-                                                                 
- simple_rnn (SimpleRNN)      (None, 32)                2080      
-                                                                 
- dense (Dense)               (None, 1)                 33        
-                                                                 
-=================================================================
-Total params: 322,113
-Trainable params: 322,113
-Non-trainable params: 0
-_________________________________________________________________
-```
-
-각 층의 파라미터 수는 어떻게 계산되는지 알아보자면,    
-1. Embedding: input_dim * output_dim = 10,000 * 32 = 320,000 개. (1만 개 단어 각각에 대한 32차원 벡터)  
-2. SimpleRNN:  
-    - 입력 가중치(W_xh): input_shape * units = 32 * 32 = 1024  
-    - 은닉 상태 가중치(W_hh): units * units = 32 * 32 = 1024  
-    - 편향(b_h): units = 32  
-    - 총합: 1024 + 1024 + 32 = 2,080 개.  
-3. Dense: input_shape * units + bias = 32 * 1 + 1 = 33 개.  
-
-이처럼 summary를 통해 모델의 구조뿐만 아니라, 각 층이 얼마나 많은 파라미터를 ���습해야 하는지 정확히 파악할 수 있습니다.  
-
-
-## 3. 직접 RNN 구현해 보기 (실전 예제)
-이제 전체 코드를 단계별로 실행하며 직접 모델을 학습시켜 보겠습니다.  
-
-**1단계 : 데이터 로드 및 전처리 (패딩의 중요성)**  
-RNN은 고정된 길이의 시퀀스를 입력으로 받습니다.  
-하지만 영화 리뷰는 길이가 제각각이므로, **패딩(Padding)**을 통해 모든 리뷰의 길이를 동일하게 맞춰줘야 합니다.  
-```python
-import numpy as np
-import tensorflow as tf
-from tensorflow import keras
-from keras import layers
-
-# 가장 빈도가 높은 1만개 단어만 사용하여 데이터셋 로드
-(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000)
-
-print(f"패딩 전 첫 번째 리뷰 길이: {len(x_train[0])}")
-
-# 모든 시퀀스의 길이를 256으로 통일
-# maxlen보다 길면 잘라내고, 짧으면 앞부분을 0으로 채움 (pre-padding)
-x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=256)
-x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=256)
-
-print(f"패딩 후 첫 번째 리뷰 길이: {len(x_train[0])}")
-```
-
-**2단계 : 모델 컴파일** 
-모델을 어떻게 학습시킬지 학습 방법을 설정합니다.
-```python
-model.compile(
-    # 손실 함수: 예측이 정답과 얼마나 다른지 측정.
-    # 이진 분류(0 또는 1) 문제이므로 binary_crossentropy가 가장 적합.
-    loss="binary_crossentropy",
-    
-    # 옵티마이저: 손실을 최소화하기 위해 모델의 가중치를 업데이트하는 알고리즘.
-    # Adam은 현재 가장 널리 쓰이고 성능이 좋은 옵티마이저 중 하나.
-    optimizer="adam",
-    
-    # 평가지표: 훈련 과정을 모니터링할 지표. 정확도를 사용.
-    metrics=["accuracy"]
-)
-```
-
-**3단계 : 모델 학습 및 평가 (배치, 에포크, 그리고 과적합)**
-model.fit() 함수로 실제 학습을 시작합니다.  
-batch_size: 한 번에 처리할 데이터 샘플의 수. 메모리 효율성과 학습 속도에 영향을 줍니다.  
-epochs: 전체 데이터셋을 몇 번 반복하여 학습할지 결정합니다.  
-
-```python
-batch_size = 128
-epochs = 10
-
-# 모델 학습 실행
-# validation_data를 지정하여 매 에포크마다 테스트 데이터로 성능을 검증
-history = model.fit(
-    x_train, y_train,
-    batch_size=batch_size,
-    epochs=epochs,
-    validation_data=(x_test, y_test)
-)
-
-# 학습 완료 후 최종 성능 평가
-score = model.evaluate(x_test, y_test, verbose=0)
-print(f"\nTest loss: {score[0]:.4f}")
-print(f"Test accuracy: {score[1]:.4f}")
-```
-
-학습 과정을 지켜볼 때, 훈련 데이터의 정확도(accuracy)는 계속 오르는데 검증 데이터의 정확도(val_accuracy)가 어느 순간부터 정체되거나 떨어진다면, 모델이 훈련 데이터에만 과하게 적응하는 **과적합(Overfitting)**이 발생하고 있다는 신호입니다.  
-이럴 때는, 드롭아웃의 비율을 높이거나 학습율을 조정하는 방법으로 해결할 수 있습니다.  
-
-**4단계 : 학습된 모델 저장 및 재사용**
-학습에 오랜 시간이 걸리는 모델은 그 결과를 저장해두고 필요할 때마다 불러서 사용하는 것이 효율적입니다.  
-
-```python
-# 모델의 구조, 가중치, 학습 설정을 모두 '.keras' 파일 하나에 저장
-model.save("my_rnn_model_imdb.keras")
-
-# 저장된 모델 불러오기
-loaded_model = keras.models.load_model("my_rnn_model_imdb.keras")
-```
-
-**5단계 : 나만의 문장으로 모델 테스트하기 (실전 예측)**
-실제 문장을 예측하려면, 훈련 데이터와 동일한 전처리 과정을 거쳐야 합니다.  
-
-```python
-# IMDB 데이터셋의 단어-인덱스 사전 로드
-word_index = keras.datasets.imdb.get_word_index()
-
-# 새로운 리뷰 문장
-review = "This movie was fantastic and wonderful"
-
-# 1. 소문자 변환 및 단어 분리 -> 2. 단어 인덱스로 변환
-tokens = [word_index.get(word, 2) for word in review.lower().split()]
-
-# 3. 패딩 처리
-padded_tokens = keras.preprocessing.sequence.pad_sequences([tokens], maxlen=256)
-
-# 4. 예측
-prediction = loaded_model.predict(padded_tokens)
-print(f"리뷰: '{review}'")
-print(f"긍정 확률: {prediction[0][0] * 100:.2f}%")
-```
-
-4. 나만의 RNN 모델 업그레이드하기
-기본 RNN도 좋지만, 더 복잡한 문제를 해결하기 위해서는 몇 가지 한계를 극복해야 합니다.  
-
-**RNN의 치명적 약점 : 장기 의존성 문제 (Vanishing Gradients)**  
-"나는 프랑스에서 태어나 자랐다. ... (중략) ... 그래서 나는 ___를 유창하게 구사한다."  
-빈칸에 들어갈 말은 '프랑스어'입니다.  
-사람은 문장 맨 앞의 '프랑스'라는 단어를 기억하여 쉽게 답을 찾습니다.  
-하지만 기본 RNN은 시퀀스가 길어질수록, 역전파 과정에서 그래디언트(기울기)가 계속 곱해지면서 0에 가까워져 사라지는 그래디언트 소실(Vanishing Gradient) 문제가 발생합니다.  
-이로 인해 문장 앞부분의 중요한 정보를 학습하지 못하게 됩니다.  
-이를 장기 의존성 문제라고 합니다.  
-
-**기억력 강화 : LSTM과 GRU의 등장**  
-이 문제를 해결하기 위해 **LSTM(Long Short-Term Memory)**과 **GRU(Gated Recurrent Unit)**가 등장했습니다.  
-이들은 RNN 내부에 **게이트(Gate)**라는 정교한 장치를 추가하여 정보의 흐름을 제어합니다.  
-- LSTM: '셀 상태(Cell State)'라는 별도의 기억 컨베이어 벨트를 두고, 망각 게이트(Forget Gate), 입력 게이트(Input Gate), 출력 게이트(Output Gate) 3개의 게이트를 통해 어떤 정보를 버리고, 어떤 정보를 새로 기억하고, 어떤 정보를 출력할지 학습합니다.   
-장기 기억에 매우 효과적입니다.  
-- GRU: LSTM을 더 단순화한 모델로, **리셋 게이트(Reset Gate)**와 업데이트 게이트(Update Gate) 2개의 게이트만 사용합니다.  
-파라미터 수가 적어 계산 효율성이 높고, 많은 경우 LSTM과 비슷한 성능을 보입니다.  
-
-```python
-# LSTM을 2개 층으로 쌓은 모델
-model_lstm = keras.Sequential([
-    layers.Embedding(input_dim=10000, output_dim=64),
-    # return_sequences=True: 다음 LSTM 층으로 전체 시퀀스를 전달
-    layers.LSTM(64, return_sequences=True), 
-    layers.LSTM(32),
-    layers.Dense(1, activation='sigmoid')
-])
-```
-
-**과거와 미래를 동시에 : 양방향 RNN (Bidirectional RNN)**  
-"오늘 새로 온 ___ 선생님은 정말 멋지다."  
-빈칸에 들어갈 '영어'라는 단어는 뒷부분의 '선생님'이라는 단어를 봐야 더 정확히 유추할 수 있습니다.  
-이처럼 문맥은 순방향뿐만 아니라 역방향의 정보도 중요합니다.  
-**양방향 RNN(Bidirectional RNN)**은 시퀀스를 정방향으로 한번, 역방향으로 한번 독립적으로 처리한 후, 두 결과를 합쳐서 최종 출력을 만듭니다.  
-이를 통해 문맥을 훨씬 더 풍부하게 이해할 수 있습니다.  
-
-```python
-model_bidirectional = keras.Sequential([
-    layers.Embedding(input_dim=10000, output_dim=64),
-    # LSTM 레이어를 Bidirectional 래퍼로 감싸기만 하면 됨
-    layers.Bidirectional(layers.LSTM(64)),
-    layers.Dropout(0.5), # 과적합 방지를 위한 드롭아웃 추가
-    layers.Dense(1, activation='sigmoid')
-])
-```
-
-## 5. 결론  
-오늘은 순차 데이터 처리의 근간이 되는 RNN의 핵심 원리부터 시작하여, 실제 코드로 모델을 구현하고, LSTM, GRU, 양방향 RNN과 같은 고급 기법을 통해 성능을 개선하는 방법까지 상세하게 알아보았습니다.  
-RNN은 그 자체로도 강력하지만, 자연어 처리 분야의 발전에 엄청난 기여를 한 기념비적인 모델입니다.  
-특히 RNN의 한계를 극복하려는 시도 속에서 탄생한 어텐션(Attention) 메커니즘은 이후 **트랜스포머(Transformer)**라는 혁신적인 모델의 기반이 되었습니다.  
-다음에는 어텐션 기법과 트랜스포머 모델, 인코더, 디코더로 돌아오겠습니다!!  
+---
+license: apache-2.0
+---
+
+안녕하세요 Oneclick AI 입니다!!  
+오늘은, RNN(순환 신경망, Recurrent Neural Network) 모델에 대해서 알아보는 시간을 가져볼까 합니다.  
+
+딥러닝이 문장, 음성, 주가 예측과 같은 순서가 있는 데이터(Sequential Data)를 다룰 수 있게 된 것은 전적으로 RNN 덕분입니다.  
+단순한 신경망이 '순서'라는 개념을 이해하지 못하는 반면,  
+RNN은 마치 사람처럼 시간의 흐름에 따라 정보를 기억하고, 다음을 예측할 수 있는 능력을 갖추고 있습니다.  
+
+오늘은 이 RNN이라는 신경망이 어떻게 과거의 정보를 기억하며 작동하는지,  
+그리고 어떻게 문장의 숨겨진 문맥과 의미를 파악할 수 있는지 알아봅시다.  
+
+---
+
+## 목차  
+1. RNN 핵심 원리 파악하기  
+    - 왜 순차 데이터에 RNN을 사용해야만 할까?  
+    - RNN의 심장 : 순환 구조와 은닉 상태의 역학  
+    - RNN을 시간에 따라 펼쳐보기  
+    - RNN의 주요 구성 요소 상세 분석  
+2. 아키텍처를 통한 내부 코드 들여다 보기  
+    - Keras로 구현한 RNN 모델 아키텍처  
+    - model.summary()로 구조 확인하기  
+3. 직접 RNN 구현해 보기  
+    - 1단계 : 데이터 로드 및 전처리  
+    - 2단계 : 모델 컴파일  
+    - 3단계 : 모델 학습 및 평가  
+    - 4단계 : 학습된 모델 저장 및 재사용  
+    - 5단계 : 나만의 문장으로 모델 테스트하기  
+4. 나만의 RNN 모델 업그레이드하기  
+    - 기초 체력 훈련 : 하이퍼파라미터 튜닝  
+    - RNN의 치명적 약점 : 장기 의존성 문제  
+    - 기억력 강화 : LSTM과 GRU의 등���  
+    - 과거와 미래를 동시에 : 양방향 RNN  
+5. 결론
+---
+
+## 1. RNN 핵심원리 파악하기
+가장 먼저, RNN이 왜 순차적인 데이터를 이해하는 데 필수적인 도구인지 그 근본적인 이유부터 살펴보겠습니다.  
+
+**왜 순차 데이터에 RNN을 사용할까?? with MLP, CNN의 한계**  
+가장 기본적인 신경망인 MLP(다층 퍼셉트론)에 "나는 학교에 간다"라는 문장을 입력한다고 상상해 봅시다.  
+MLP는 각 단어를 독립적인 특징으로 보기 때문에, "학교에 나는 간다"라는 문장과 거의 동일하게 받아들입니다.  
+단어의 '순서'가 가진 중요한 의미, 즉 문맥을 완전히 잃어버리는 것입니다.  
+이미지 처리에 특화된 CNN 역시 마찬가지입니다.  
+CNN은 공간적인 특징(픽셀 주변 관계)을 추출하는 데는 뛰어나지만, 시간적인 순서나 흐름을 파악하도록 설계되지 않았습니다.  
+반면, RNN은 설계 자체가 '순서'를 기억하기 위해 만들어졌습니다.  
+이전 단계의 처리 결과를 다음 단계의 입력으로 재사용하는 '순환' 구조를 통해, 마치 우리가 문장을 앞에서부터 차례로 읽으며 내용을 머릿속에 축적하는 것과 같은 방식으로 작동합니다.  
+
+**RNN의 심장 : 순환 구조와 은닉 상태의 역학**  
+RNN의 핵심 아이디어는 바로 순환 구조(Recurrent Structure)와 은닉 상태(Hidden State) 입니다.  
+- 순환 구조(Recurrent Structure)  
+신경망 내부에 '루프'가 존재하여, 정보가 계속해서 순환할 수 있는 구조를 말합니다.  
+각 타임스텝 $t$에서 모델은 입력 $x_t$와 이전 타임스텝의 정보 요약본인 $h_{t-1}$을 함께 받아 처리합니다.  
+
+- 은닉 상태(Hidden State, $h_t$)  
+은닉 상태는 '메모리' 또는 '문맥 벡터'라고 불리며, RNN의 모든 것을 담고 있습니다.  
+특정 타임스텝 t에서의 은닉 상태 $h_t$는 다음과 같은 수식으로 계산됩니다.  
+$h_t=tanh(W_hhh_t−1+W_xhx_t+b_h)$여기서 $W_hh$, $W_{xh}$는 학습을 통해 최적화되는 가중치 행렬이며, $b_h$는 편향입니다.  
+중요한 점은 모든 타임스텝에서 동일한 가중치($W$)와 편향($b$)이 공유된다는 것입니다.  
+이는 모델이 시간과 관계없이 일관된 패턴을 학습하게 하며, 파라미터 수를 크게 줄여줍니다.  
+tanh와 같은 활성화 함수는 계산된 값을 특정 범위(-1에서 1 사이)로 압축하는 역할을 합니다.
+
+**RNN을 시간에 따라 펼쳐보기**  
+아래 그림처럼 시간에 따라 네트워크를 길게 펼쳐서 표현하면, 쉽게 이해할 수 있습니다.   
+```markdown
+시간 흐름 ───▶
+입력 시퀀스:  x₁     x₂      x₃     ...     xₜ
+              ↓      ↓      ↓              ↓
+           ┌────┐ ┌────┐  ┌────┐   ...   ┌────┐
+h₀  ───▶  │RNN │▶│RNN │▶│RNN │ ▶ ... ▶│RNN │
+           └────┘ └────┘  └────┘         └────┘
+             │      │       │               │
+             ▼      ▼       ▼               ▼
+             h₁     h₂      h₃              hₜ
+```
+RNN은 내부적으로 **같은 셀** 을 매 시점마다 반복해서 사용하는 구조 입니다.  
+펼쳐서 보면, 위 그림처럼 하나의 RNN셀이 시간이 흐름에 따라 여러 번 복제된 것 처럼 보입니다.  
+순서대로 보자면,  
+1. 각 시점의 $X_t$가 RNN 셀에 들어가고,
+2. 이전 시점의 은식 상태의 $h_(t^-1)$도 함께 들어가서,  
+3. 새로운 은닉상태 $h_t$를 출력합니다.  
+4. 이 $h_t$는 다음 시점으로 전달되어 메모리 역할을 합니다.  
+
+위 그림 속 여러 셀은 같은 RNN 셀을 시간에 따라 복제한 것이고, 모든 셀은 가중치를 공유하기 때문에 시점이 달라도 같은 규칙으로 계산이 이루어 집니다.  
+
+보충설명 하자면,  
+`나는 학교에 간다`  
+를 입력하면,  
+$X_1$이 나는, $X_2$가 학교에, $X_3$ 가 간다가 되면서 시간에 따른 연산이 이루어 진다고 생각하시면 됩니다.  
+
+## 2. 아키텍처를 통한 내부 코드 들여다 보기
+이제 이론을 바탕으로, TensorFlow Keras 를 통해 직접 RNN을 구현해 봅시다.  
+Keras로 구현한 RNN 모델 아키텍처 심층 분석다음은 IMDB 영화 리뷰 감성 분석을 위한 간단한 RNN 모델입니다.  
+
+```python
+import tensorflow as tf
+from tensorflow import keras
+
+# 모델 아키텍처 정의
+model = keras.Sequential([
+    # 1. 단어 임베딩 층
+    # input_dim: 전체 단어 집합의 크기 (가장 빈번한 1만개 단어)
+    # output_dim: 각 단어를 표현할 벡터의 차원 (32차원)
+    keras.layers.Embedding(input_dim=10000, output_dim=32),
+    
+    # 2. RNN 층
+    # units: 은닉 상태 벡터의 차원 (32차원)
+    keras.layers.SimpleRNN(32),
+    
+    # 3. 최종 분류기(Classifier)
+    # units: 출력 뉴런의 수 (긍정/부정 1개)
+    # activation: 출력 값을 0~1 사이 확률로 변환 (이진 분류)
+    keras.layers.Dense(1, activation="sigmoid"),
+])
+
+# 모델 구조 요약 출력
+model.summary()
+```
+레이어를 자세히 들어다 봅시다.  
+
+- **임베딩 층(Embedding)**  
+```python
+keras.layers.Embedding(input_dim=10000, output_dim=32)
+```
+컴퓨터는 '영화', '재미' 같은 단어를 직접 이해하지 못합니다.  
+Embedding 층은 각 단어에 부여된 고유한 정수 인덱스를 output_dim 차원의 의미론적 벡터로 변환합니다.  
+이 과정에서 '슬픔'과 '비극' 같은 단어들은 벡터 공간상에서 가까운 위치에, '행복'과는 먼 위치에 표현되도록 학습됩니다.  
+
+- **순환 계층(SimpleRNN)**  
+```python
+keras.layers.SimpleRNN(32),
+```
+이 층이 순환 신경망의 본체입니다.  
+입력된 단어 임베딩 벡터 시퀀스를 순서대로 하나씩 처리하며 은닉 상태를 계속해서 업데이트합니다.  
+기본적으로 마지막 단어까지 처리한 후의 최종 은닉 상태만을 다음 층으로 전달합니다.  
+이 최종 은닉 상태 벡터는 전체 문장의 문맥을 압축한 결과물입니다.  
+
+- **완전 연결 계층(Dense)**  
+```python
+keras.layers.Dense(1, activation="sigmoid")
+```
+최종 은닉 상태 벡터를 받아, 리뷰가 긍정(1에 가까운 값)인지 부정(0에 가까운 값)인지 최종 판단을 내립니다. 
+model.summary()로 파라미터 수 계산 원리 이해하기위 코드에서 model.summary()를 실행하면 다음과 같은 결과가 나옵니다.  
+
+```bash
+Model: "sequential"
+_________________________________________________________________
+ Layer (type)                Output Shape              Param #   
+=================================================================
+ embedding (Embedding)       (None, None, 32)          320000    
+                                                                 
+ simple_rnn (SimpleRNN)      (None, 32)                2080      
+                                                                 
+ dense (Dense)               (None, 1)                 33        
+                                                                 
+=================================================================
+Total params: 322,113
+Trainable params: 322,113
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+각 층의 파라미터 수는 어떻게 계산되는지 알아보자면,    
+1. Embedding: input_dim * output_dim = 10,000 * 32 = 320,000 개. (1만 개 단어 각각에 대한 32차원 벡터)  
+2. SimpleRNN:  
+    - 입력 가중치(W_xh): input_shape * units = 32 * 32 = 1024  
+    - 은닉 상태 가중치(W_hh): units * units = 32 * 32 = 1024  
+    - 편향(b_h): units = 32  
+    - 총합: 1024 + 1024 + 32 = 2,080 개.  
+3. Dense: input_shape * units + bias = 32 * 1 + 1 = 33 개.  
+
+이처럼 summary를 통해 모델의 구조뿐만 아니라, 각 층이 얼마나 많은 파라미터를 학습해야 하는지 정확히 파악할 수 있습니다.  
+
+
+## 3. 직접 RNN 구현해 보기 (실전 예제)
+이제 전체 코드를 단계별로 실행하며 직접 모델을 학습시켜 보겠습니다.  
+
+**1단계 : 데이터 로드 및 전처리 (패딩의 중요성)**  
+RNN은 고정된 길이의 시퀀스를 입력으로 받습니다.  
+하지만 영화 리뷰는 길이가 제각각이므로, **패딩(Padding)**을 통해 모든 리뷰의 길이를 동일하게 맞춰줘야 합니다.  
+```python
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from keras import layers
+
+# 가장 빈도가 높은 1만개 단어만 사용하여 데이터셋 로드
+(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000)
+
+print(f"패딩 전 첫 번째 리뷰 길이: {len(x_train[0])}")
+
+# 모든 시퀀스의 길이를 256으로 통일
+# maxlen보다 길면 잘라내고, 짧으면 앞부분을 0으로 채움 (pre-padding)
+x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=256)
+x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=256)
+
+print(f"패딩 후 첫 번째 리뷰 길이: {len(x_train[0])}")
+```
+
+**2단계 : 모델 컴파일** 
+모델을 어떻게 학습시킬지 학습 방법을 설정합니다.
+```python
+model.compile(
+    # 손실 함수: 예측이 정답과 얼마나 다른지 측정.
+    # 이진 분류(0 또는 1) 문제이므로 binary_crossentropy가 가장 적합.
+    loss="binary_crossentropy",
+    
+    # 옵티마이저: 손실을 최소화하기 위해 모델의 가중치를 업데이트하는 알고리즘.
+    # Adam은 현재 가장 널리 쓰이고 성능이 좋은 옵티마이저 중 하나.
+    optimizer="adam",
+    
+    # 평가지표: 훈련 과정을 모니터링할 지표. 정확도를 사용.
+    metrics=["accuracy"]
+)
+```
+
+**3단계 : 모델 학습 및 평가 (배치, 에포크, 그리고 과적합)**
+model.fit() 함수로 실제 학습을 시작합니다.  
+batch_size: 한 번에 처리할 데이터 샘플의 수. 메모리 효율성과 학습 속도에 영향을 줍니다.  
+epochs: 전체 데이터셋을 몇 번 반복하여 학습할지 결정합니다.  
+
+```python
+batch_size = 128
+epochs = 10
+
+# 모델 학습 실행
+# validation_data를 지정하여 매 에포크마다 테스트 데이터로 성능을 검증
+history = model.fit(
+    x_train, y_train,
+    batch_size=batch_size,
+    epochs=epochs,
+    validation_data=(x_test, y_test)
+)
+
+# 학습 완료 후 최종 성능 평가
+score = model.evaluate(x_test, y_test, verbose=0)
+print(f"\nTest loss: {score[0]:.4f}")
+print(f"Test accuracy: {score[1]:.4f}")
+```
+
+학습 과정을 지켜볼 때, 훈련 데이터의 정확도(accuracy)는 계속 오르는데 검증 데이터의 정확도(val_accuracy)가 어느 순간부터 정체되거나 떨어진다면, 모델이 훈련 데이터에만 과하게 적응하는 **과적합(Overfitting)**이 발생하고 있다는 신호입니다.  
+이럴 때는, 드롭아웃의 비율을 높이거나 학습율을 조정하는 방법으로 해결할 수 있습니다.  
+
+**4단계 : 학습된 모델 저장 및 재사용**
+학습에 오랜 시간이 걸리는 모델은 그 결과를 저장해두고 필요할 때마다 불러서 사용하는 것이 효율적입니다.  
+
+```python
+# 모델의 구조, 가중치, 학습 설정을 모두 '.keras' 파일 하나에 저장
+model.save("my_rnn_model_imdb.keras")
+
+# 저장된 모델 불러오기
+loaded_model = keras.models.load_model("my_rnn_model_imdb.keras")
+```
+
+**5단계 : 나만의 문장으로 모델 테스트하기 (실전 예측)**
+실제 문장을 예측하려면, 훈련 데이터와 동일한 전처리 과정을 거쳐야 합니다.  
+
+```python
+# IMDB 데이터셋의 단어-인덱스 사전 로드
+word_index = keras.datasets.imdb.get_word_index()
+
+# 새로운 리뷰 문장
+review = "This movie was fantastic and wonderful"
+
+# 1. 소문자 변환 및 단어 분리 -> 2. 단어 인덱스로 변환
+tokens = [word_index.get(word, 2) for word in review.lower().split()]
+
+# 3. 패딩 처리
+padded_tokens = keras.preprocessing.sequence.pad_sequences([tokens], maxlen=256)
+
+# 4. 예측
+prediction = loaded_model.predict(padded_tokens)
+print(f"리뷰: '{review}'")
+print(f"긍정 확률: {prediction[0][0] * 100:.2f}%")
+```
+
+4. 나만의 RNN 모델 업그레이드하기
+기본 RNN도 좋지만, 더 복잡한 문제를 해결하기 위해서는 몇 가지 한계를 극복해야 합니다.  
+
+**RNN의 치명적 약점 : 장기 의존성 문제 (Vanishing Gradients)**  
+"나는 프랑스에서 태어나 자랐다. ... (중략) ... 그래서 나는 ___를 유창하게 구사한다."  
+빈칸에 들어갈 말은 '프랑스어'입니다.  
+사람은 문장 맨 앞의 '프랑스'라는 단어를 기억하여 쉽게 답을 찾습니다.  
+하지만 기본 RNN은 시퀀스가 길어질수록, 역전파 과정에서 그래디언트(기울기)가 계속 곱해지면서 0에 가까워져 사라지는 그래디언트 소실(Vanishing Gradient) 문제가 발생합니다.  
+이로 인해 문장 앞부분의 중요한 정보를 학습하지 못하게 됩니다.  
+이를 장기 의존성 문제라고 합니다.  
+
+**기억력 강화 : LSTM과 GRU의 등장**  
+이 문제를 해결하기 위해 **LSTM(Long Short-Term Memory)**과 **GRU(Gated Recurrent Unit)**가 등장했습니다.  
+이들은 RNN 내부에 **게이트(Gate)**라는 정교한 장치를 추가하여 정보의 흐름을 제어합니다.  
+- LSTM: '셀 상태(Cell State)'라는 별도의 기억 컨베이어 벨트를 두고, 망각 게이트(Forget Gate), 입력 게이트(Input Gate), 출력 게이트(Output Gate) 3개의 게이트를 통해 어떤 정보를 버리고, 어떤 정보를 새로 기억하고, 어떤 정보를 출력할지 학습합니다.   
+장기 기억에 매우 효과적입니다.  
+- GRU: LSTM을 더 단순화한 모델로, **리셋 게이트(Reset Gate)**와 업데이트 게이트(Update Gate) 2개의 게이트만 사용합니다.  
+파라미터 수가 적어 계산 효율성이 높고, 많은 경우 LSTM과 비슷한 성능을 보입니다.  
+
+```python
+# LSTM을 2개 층으로 쌓은 모델
+model_lstm = keras.Sequential([
+    layers.Embedding(input_dim=10000, output_dim=64),
+    # return_sequences=True: 다음 LSTM 층으로 전체 시퀀스를 전달
+    layers.LSTM(64, return_sequences=True), 
+    layers.LSTM(32),
+    layers.Dense(1, activation='sigmoid')
+])
+```
+
+**과거와 미래를 동시에 : 양방향 RNN (Bidirectional RNN)**  
+"오늘 새로 온 ___ 선생님은 정말 멋지다."  
+빈칸에 들어갈 '영어'라는 단어는 뒷부분의 '선생님'이라는 단어를 봐야 더 정확히 유추할 수 있습니다.  
+이처럼 문맥은 순방향뿐만 아니라 역방향의 정보도 중요합니다.  
+**양방향 RNN(Bidirectional RNN)**은 시퀀스를 정방향으로 한번, 역방향으로 한번 ���립적으로 처리한 후, 두 결과를 합쳐서 최종 출력을 만듭니다.  
+이를 통해 문맥을 훨씬 더 풍부하게 이해할 수 있습니다.  
+
+```python
+model_bidirectional = keras.Sequential([
+    layers.Embedding(input_dim=10000, output_dim=64),
+    # LSTM 레이어를 Bidirectional 래퍼로 감싸기만 하면 됨
+    layers.Bidirectional(layers.LSTM(64)),
+    layers.Dropout(0.5), # 과적합 방지를 위한 드롭아웃 추가
+    layers.Dense(1, activation='sigmoid')
+])
+```
+
+## 5. 결론  
+오늘은 순차 데이터 처리의 근간이 되는 RNN의 핵심 원리부터 시작하여, 실제 코드로 모델을 구현하고, LSTM, GRU, 양방향 RNN과 같은 고급 기법을 통해 성능을 개선하는 방법까지 상세하게 알아보았습니다.  
+RNN은 그 자체로도 강력하지만, 자연어 처리 분야의 발전에 엄청난 기여를 한 기념비적인 모델입니다.  
+특히 RNN의 한계를 극복하려는 시도 속에서 탄생한 어텐션(Attention) 메커니즘은 이후 트랜스포머(Transformer)라는 혁신적인 모델의 기반이 되었습니다.  
+다음에는 어텐션 기법과 트랜스포머 모델, 인코더, 디코더로 돌아오겠습니다!!  
 오늘도 좋은하루 보내세요!!