Upload README.md

README.md

@@ -1,3 +1,287 @@
 ---
 license: apache-2.0
 ---
+
+안녕하세요 Oneclick AI 입니다!!  
+오늘은, RNN의 한계를 극복한 LSTM(Long Short-Term Memory)과 GRU(Gated Recurrent Unit) 모델에 대해서 알아보는 시간을 가져볼까 합니다.  
+
+RNN이 순차 데이터를 다루는 데 혁신을 가져왔지만, 긴 시퀀스에서 과거 정보를 제대로 기억하지 못하는 '장기 의존성 문제'로 인해 한계를 드러냈습니다.  
+LSTM과 GRU는 이 문제를 해결하기 위해 고안된 고급 순환 신경망으로, 마치 사람의 장기 기억처럼 중요한 정보를 선택적으로 유지하고 잊어버릴 수 있는 '게이트' 메커니즘을 도입했습니다.  
+오늘은 이 두 모델이 어떻게 RNN의 약점을 보완하며 작동하는지, 그리고 어떻게 더 복잡한 문장이나 시계열 데이터를 정교하게 처리할 수 있는지 알아봅시다.  
+
+---
+
+## 목차  
+1. LSTM/GRU 핵심 원리 파악하기  
+    - 왜 LSTM/GRU를 사용해야만 할까?  
+    - LSTM의 심장 : 셀 상태와 3개의 게이트 메커니즘  
+    - GRU : LSTM의 간소화된 버전과 2개의 게이트  
+    - LSTM과 GRU를 시간에 따라 펼쳐보기  
+    - LSTM/GRU의 주요 구성 요소 상세 분석  
+2. 아키텍처를 통한 내부 코드 들여다 보기  
+    - Keras로 구현한 LSTM/GRU 모델 아키텍처  
+    - model.summary()로 구조 확인하기  
+3. 직접 LSTM/GRU 구현해 보기  
+    - 1단계 : 데이터 로드 및 전처리  
+    - 2단계 : 모델 컴파일  
+    - 3단계 : 모델 학습 및 평가  
+    - 4단계 : 학습된 모델 저장 및 재사용  
+    - 5단계 : 나만의 문장으로 모델 테스트하기  
+4. 나만의 LSTM/GRU 모델 업그레이드하기  
+    - 기초 체력 훈련 : 하이퍼파라미터 튜닝  
+    - 층 쌓기 : 다중 LSTM/GRU 레이어  
+    - 과거와 미래를 동시에 : 양방향 LSTM/GRU  
+    - 전이학습으로 성능 극대화 하기  
+5. 결론
+---
+
+## 1. LSTM/GRU 핵심원리 파악하기
+가장 먼저, LSTM과 GRU가 왜 RNN의 대안으로 등장했는지 그 근본적인 이유부터 살펴보겠습니다.  
+
+**왜 LSTM/GRU를 사용할까?? with RNN의 한계**  
+기본 RNN은 은닉 상태를 통해 과거 정보를 전달하지만, 시퀀스가 길어지면 그래디언트 소실(Vanishing Gradient)이나 폭발(Exploding Gradient) 문제가 발생합니다.  
+이는 학습 과정에서 기울기가 0에 가까워지거나 무한대가 되어, 문장 앞부분의 중요한 정보를 잊어버리는 '장기 의존성 문제(Long-Term Dependency)'를 초래합니다.  
+예를 들어, "어린 시절 프랑스에서 자랐기 때문에... (긴 내용)... 그래서 나는 프랑스어를 유창하게 구사한다."라는 문장에서 RNN은 '프랑스'라는 초기 정보를 잊기 쉽습니다.  
+LSTM과 GRU는 이 문제를 해결하기 위해 '게이트'라는 구조를 도입하여, 정보의 흐름을 제어합니다.  
+이들은 RNN의 기본 구조를 유지하면서도 중요한 정보를 선택적으로 기억하고 불필요한 것은 잊어버릴 수 있도록 설계되었습니다.  
+
+**LSTM의 심장 : 셀 상태와 3개의 게이트 메커니즘**  
+LSTM의 핵심은 '셀 상태(Cell State, $C_t$)'와 이를 제어하는 3개의 게이트입니다.  
+- 셀 상태(Cell State, $C_t$): 장기 기억을 위한 '컨베이어 벨트'로, 정보가 거의 변형 없이 전달됩니다.  
+- 게이트(Gates): 시그모이드(Sigmoid) 함수를 사용해 0~1 사이의 값을 출력하며, 정보의 통과 여부를 결정합니다.  
+
+1. 망각 게이트(Forget Gate, $f_t$): 이전 셀 상태 $C_{t-1}$에서 어떤 정보를 잊을지 결정합니다.  
+   $f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$  
+   (여기서 $\sigma$는 시그모이드 함수, $h_{t-1}$은 이전 은닉 상태, $x_t$는 현재 입력)  
+
+2. 입력 게이트(Input Gate, $i_t$)와 후보 셀 상태($\tilde{C_t}$): 새로운 정보를 얼마나 추가할지 결정합니다.  
+   $i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$  
+   $\tilde{C_t} = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$  
+
+3. 출력 게이트(Output Gate, $o_t$): 셀 상태에서 어떤 정보를 출력할지 결정합니다.  
+   $o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$  
+   최종 셀 상태 $C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C_t}$ ( $\odot$은 요소별 곱)  
+   은닉 상태 $h_t = o_t \odot \tanh(C_t)$  
+
+이 구조 덕분에 LSTM은 장기적인 의존성을 효과적으로 학습합니다.  
+
+**GRU : LSTM의 간소화된 버전과 2개의 게이트**  
+GRU는 LSTM의 변형으로, 파라미터를 줄여 계산 효율성을 높였습니다.  
+은닉 상태 $h_t$가 셀 상태 역할을 겸하며, 2개의 게이트만 사용합니다.  
+- 리셋 게이트(Reset Gate, $r_t$): 이전 은닉 상태를 얼마나 무시할지 결정합니다.  
+  $r_t = \sigma(W_r \cdot [h_{t-1}, x_t] + b_r)$  
+
+- 업데���트 게이트(Update Gate, $z_t$): 이전 상태와 새 후보 상태를 얼마나 섞을지 결정합니다. (LSTM의 망각+입력 게이트 역할)  
+  $z_t = \sigma(W_z \cdot [h_{t-1}, x_t] + b_z)$  
+  후보 은닉 상태 $\tilde{h_t} = \tanh(W_h \cdot [r_t \odot h_{t-1}, x_t] + b_h)$  
+  최종 $h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h_t}$  
+
+GRU는 LSTM만큼 강력하면서도 학습이 더 빠릅니다.  
+
+**LSTM/GRU를 시간에 따라 펼쳐보기**  
+아래 그림처럼 시간에 따라 네트워크를 길게 펼쳐서 표현하면, 쉽게 이해할 수 있습니다.   
+```markdown
+시간 흐름 ───▶
+입력 시퀀스:  x₁     x₂      x₃     ...     xₜ
+              ↓      ↓      ↓              ↓
+           ┌────┐ ┌────┐  ┌────┐   ...   ┌────┐
+h₀, C₀ ──▶│LSTM│▶│LSTM│▶│LSTM│ ▶ ... ▶│LSTM│ (또는 GRU)
+           └────┘ └────┘  └────┘         └────┘
+             │      │       │               │
+             ▼      ▼       ▼               ▼
+             h₁     h₂      h₃              hₜ
+```
+각 타임스텝에서 게이트가 정보를 제어하며, 셀 상태(또는 은닉 상태)가 장기적으로 전달됩니다.  
+
+**LSTM/GRU의 주요 구성 요소**  
+- 게이트 메커니즘: 정보 선택과 삭제.  
+- 은닉/셀 상태: 메모리 역할.  
+- 파라미터 공유: 모든 타임스텝에서 동일한 가중치 사용.  
+
+---
+
+## 2. 아키텍처를 통한 내부 코드 들여다 보기
+이제 이론을 바탕으로, TensorFlow Keras 를 통해 직접 LSTM과 GRU를 구현해 봅시다.  
+Keras로 구현한 LSTM/GRU 모델 아키텍처 심층 분석다음은 IMDB 영화 리뷰 감성 분석을 위한 간단한 LSTM 모델입니다. (GRU도 유사)  
+
+```python
+import tensorflow as tf
+from tensorflow import keras
+
+# 모델 아키텍처 정의
+model = keras.Sequential([
+    # 1. 단어 임베딩 층
+    keras.layers.Embedding(input_dim=10000, output_dim=32),
+    
+    # 2. LSTM 층 (GRU로 바꾸려면 SimpleRNN 대신 LSTM 또는 GRU 사용)
+    keras.layers.LSTM(32),
+    
+    # 3. 최종 분류기
+    keras.layers.Dense(1, activation="sigmoid"),
+])
+
+# 모델 구조 요약 출력
+model.summary()
+```
+레이어를 자세히 들어다 봅시다.  
+
+- **임베딩 층(Embedding)**  
+```python
+keras.layers.Embedding(input_dim=10000, output_dim=32)
+```
+단어를 벡터로 변환, RNN 문서와 동일.  
+
+- **순환 계층(LSTM 또는 GRU)**  
+```python
+keras.layers.LSTM(32),
+```
+또는  
+```python
+keras.layers.GRU(32),
+```
+내부적으로 게이트를 처리하며, 장기 의존성을 학습. 기본적으로 최종 은닉 상태만 출력.  
+
+- **완전 연결 계층(Dense)**  
+```python
+keras.layers.Dense(1, activation="sigmoid")
+```
+최종 판단.  
+
+model.summary()로 파라미터 수 계산 원리 이해하기위 코드에서 model.summary()를 실행하면 다음과 같은 결과가 나옵니다.  
+
+```bash
+Model: "sequential"
+_________________________________________________________________
+ Layer (type)                Output Shape              Param #   
+=================================================================
+ embedding (Embedding)       (None, None, 32)          320000    
+                                                                 
+ lstm (LSTM)                 (None, 32)                8320      
+                                                                 
+ dense (Dense)               (None, 1)                 33        
+                                                                 
+=================================================================
+Total params: 328,353
+Trainable params: 328,353
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+각 층의 파라미터 수는 어떻게 계산되는지 알아보자면,    
+1. Embedding: 10,000 * 32 = 320,000 개.  
+2. LSTM: 입력(32)과 은닉(32)을 고려한 4개의 게이트(입력, 망각, 출력, 후보)로, (32+32+1)*32*4 = 8,320 개. (GRU는 3배: 약 6,240)  
+3. Dense: 32 * 1 + 1 = 33 개.  
+
+---
+
+## 3. 직접 LSTM/GRU 구현해 보기
+이제, 전체 코드를 단계별로 실행하며 직접 모델을 학습시켜 보겠습니다. (RNN 문서와 유사, IMDB 데이터 사용)  
+
+**1단계. 데이터 로드 및 전처리**  
+```python
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from keras import layers
+
+(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000)
+
+x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=256)
+x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=256)
+```
+
+**2단계. 모델 컴파일**  
+```python
+model = keras.Sequential([
+    layers.Embedding(input_dim=10000, output_dim=32),
+    layers.LSTM(32),  # 또는 layers.GRU(32)
+    layers.Dense(1, activation="sigmoid")
+])
+
+model.compile(
+    loss="binary_crossentropy",
+    optimizer="adam",
+    metrics=["accuracy"]
+)
+```
+
+**3단계. 모델 학습 및 평가**  
+```python
+batch_size = 128
+epochs = 10
+
+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}")
+```
+
+**4단계. 학습된 모델 저장 및 재사용**  
+```python
+model.save("my_lstm_model_imdb.keras")
+loaded_model = keras.models.load_model("my_lstm_model_imdb.keras")
+```
+
+**5단계. 나만의 문장으로 모델 테스트하기**  
+```python
+word_index = keras.datasets.imdb.get_word_index()
+
+review = "This movie was fantastic and wonderful"
+tokens = [word_index.get(word, 2) for word in review.lower().split()]
+padded_tokens = keras.preprocessing.sequence.pad_sequences([tokens], maxlen=256)
+
+prediction = loaded_model.predict(padded_tokens)
+print(f"리뷰: '{review}'")
+print(f"긍정 확률: {prediction[0][0] * 100:.2f}%")
+```
+
+## 4. 나만의 LSTM/GRU 모델 업그레이드하기
+기본 모델을 더 강력하게 만들기 위해 다양한 기법을 적용해 보겠습니다.  
+
+- **기초 체력 훈련 : 하이퍼파라미터 튜닝**  
+학습률, 배치 크기, 유닛 수 등을 조정.  
+```python
+optimizer = keras.optimizers.Adam(learning_rate=0.001)
+model.compile(loss="binary_crossentropy", optimizer=optimizer, metrics=["accuracy"])
+```
+
+- **층 쌓기 : 다중 LSTM/GRU 레이어**  
+```python
+model = keras.Sequential([
+    layers.Embedding(input_dim=10000, output_dim=64),
+    layers.LSTM(64, return_sequences=True),
+    layers.LSTM(32),
+    layers.Dense(1, activation='sigmoid')
+])
+```
+
+- **과거와 미래를 동시에 : 양방향 LSTM/GRU**  
+```python
+model = keras.Sequential([
+    layers.Embedding(input_dim=10000, output_dim=64),
+    layers.Bidirectional(layers.LSTM(64)),
+    layers.Dropout(0.5),
+    layers.Dense(1, activation='sigmoid')
+])
+```
+
+- **전이학습으로 성능 극대화 하기**  
+사전 학습된 모델(예: GloVe 임베딩) 사용하거나, 대형 모델의 LSTM 레이어 freeze.  
+```python
+# 예: 사전 학습된 임베딩 로드 (별도 파일 필요)
+embedding_layer = layers.Embedding(input_dim=10000, output_dim=100, trainable=False)
+# GloVe 등으로 초기화
+```
+
+## 5. 결론
+오늘은, RNN의 한계를 넘어선 LSTM과 GRU의 핵심 원리부터 실제 구현, 업그레이드 방법까지 알아보았습니다.  
+이 두 모델은 자연어 처리뿐만 아니라 시계열 예측, 음성 인식 등에서 여전히 핵심적인 역할을 합니다.  
+특히, LSTM/GRU의 게이트 아이디어는 이후 어텐션 메커니즘과 트랜스포머 모델의 기반이 되었습니다.  
+다음에는 트랜스포머 모델로 돌아오겠습니다!!  
+오늘도 좋은하루 보내세요!!