해색주의 조용한 공간

이직한지 만3년이 지났다. 헤보고 싶은 일이 있어서 나왔다는 거창한 이야기와는 달리 재취업이 쉽지 않았다. 다행히 전문계약직으로 재취업이 되어서 금융권 빅데이터부서에서 데이터분석가로 일하고 있다.

 작년 한 해동안 같이 일할 직원 채용하느라 많은 분들의 이력서를 읽어봤고 면접에 참여했다. 

 회사에서도 몇 번이나 채용을 하려고 했지만, 최종 협상중에 결렬이 되는 경우가 몇 번 있었고 이번에 마지막에 결렬되었다. 새로운 팀장님이 오면서 다행히 업무도 많이 늘어났고 복잡한 분석 업무를 많이 하면서 팀의 업무에 과부하가 오기 시작했다. 사실 나는 작년 하반기부터 업무에 부하가 와서 거의 매달 야근을 꽉꽉 채워서 일을 해야만 했다. 매번 새로운 타입의 일을 하기 때문에 기존 코드를 재활용하기 힘들었고 모델링 업무도 끝나서 새로운 일을 계속해야 하는 상황이다.

 일을 열심히 하는데 혼자서 다하기는 어렵다.

 일을 잘하는 사람들은 여기저기 면접도 많이 보고, 뛰어난 사람들은 잘 팔린다는 생각이 든다. 그나저나 올해에는 외부 채용을 할 수 있을지 모르겠다.

금요일 하루 출근이기는 한데 무척이나 부담스럽기는 하다. 아픈 거는 좀 나아졌고, 이제 당분간은 무리하지 말아야지.

아래는 주어진 조건에 따라 모델을 구현한 Python 코드와 총 파라미터 개수를 계산한 결과입니다:

모델 구현

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense

# 모델 파라미터
vocab_size = 5000          # 단어 집합 크기
embedding_dim = 100        # 임베딩 벡터 차원
sequence_length = 30       # 샘플 길이
hidden_units = 128         # SimpleRNN 은닉 상태 크기

# 모델 생성
model = Sequential([
    Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=sequence_length),
    SimpleRNN(units=hidden_units, activation='tanh'),
    Dense(1, activation='sigmoid')
])

# 모델 요약 출력
model.summary()

총 파라미터 계산

1. Embedding Layer:
   • vocab_size×embedding_dim=5000×100=500,000\text{vocab\_size} \times \text{embedding\_dim} = 5000 \times 100 = 500,000vocab_size×embedding_dim=5000×100=500,000
2. SimpleRNN Layer:
   • SimpleRNN의 파라미터 계산 공식: RNN 파라미터 수=(input_dim+units+1)×units\text{RNN 파라미터 수} = (\text{input\_dim} + \text{units} + 1) \times \text{units}RNN 파라미터 수=(input_dim+units+1)×units 여기서,
     • input_dim=embedding_dim=100\text{input\_dim} = \text{embedding\_dim} = 100input_dim=embedding_dim=100
     • units=128\text{units} = 128units=128
     • 111은 bias 항목
     (input_dim+units+1)×units=(100+128+1)×128=229×128=29,312(\text{input\_dim} + \text{units} + 1) \times \text{units} = (100 + 128 + 1) \times 128 = 229 \times 128 = 29,312(input_dim+units+1)×units=(100+128+1)×128=229×128=29,312
3. Dense Layer:
   • units_in×units_out+bias=128×1+1=129\text{units\_in} \times \text{units\_out} + \text{bias} = 128 \times 1 + 1 = 129units_in×units_out+bias=128×1+1=129

총 파라미터

• Embedding Layer: 500,000
• SimpleRNN Layer: 29,312
• Dense Layer: 129
• 총 파라미터: 500,000+29,312+129=529,441500,000 + 29,312 + 129 = 529,441500,000+29,312+129=529,441

출력

model.summary()를 실행하면 다음과 유사한 출력이 나타납니다:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 30, 100)          500000    
                                                                 
 simple_rnn (SimpleRNN)      (None, 128)              29312     
                                                                 
 dense (Dense)               (None, 1)                129       
                                                                 
=================================================================
Total params: 529,441
Trainable params: 529,441
Non-trainable params: 0
_________________________________________________________________

아래는 주어진 조건을 만족하는 PyTorch 기반 모델 구현 코드입니다.

import torch
import torch.nn as nn

class SimpleRNNBinaryClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_units):
        super(SimpleRNNBinaryClassifier, self).__init__()
        self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
        self.rnn = nn.RNN(input_size=embedding_dim, hidden_size=hidden_units, batch_first=True)
        self.fc = nn.Linear(in_features=hidden_units, out_features=1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # Embedding layer
        x = self.embedding(x)  # Shape: (batch_size, sequence_length, embedding_dim)
        # RNN layer
        output, hidden = self.rnn(x)  # hidden has shape (1, batch_size, hidden_units)
        # Fully connected layer
        x = self.fc(hidden.squeeze(0))  # Shape: (batch_size, 1)
        # Sigmoid activation
        x = self.sigmoid(x)
        return x

# 모델 파라미터
vocab_size = 5000
embedding_dim = 100
sequence_length = 30
hidden_units = 128

# 모델 생성
model = SimpleRNNBinaryClassifier(vocab_size, embedding_dim, hidden_units)

# 모델 요약 출력 (파라미터 개수 포함)
print(model)

# 총 파라미터 개수 계산
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params}")

주요 변경점

1. Embedding Layer:
   • nn.Embedding을 사용하여 단어 집합 크기와 임베딩 벡터 차원 설정.
2. SimpleRNN Layer:
   • nn.RNN을 사용하여 은닉 상태 크기와 입력 크기 정의.
   • batch_first=True를 설정해 입력 텐서를 (batch_size, sequence_length, embedding_dim) 형태로 맞춤.
3. Dense Layer:
   • nn.Linear을 사용해 은닉 상태의 마지막 출력에서 1차원 출력 생성.
4. Sigmoid Activation:
   • 이진 분류 문제를 위해 nn.Sigmoid를 적용.

출력 예시

위 코드를 실행하면 모델 구조와 총 파라미터 개수를 확인할 수 있습니다.

예:

SimpleRNNBinaryClassifier(
  (embedding): Embedding(5000, 100)
  (rnn): RNN(100, 128, batch_first=True)
  (fc): Linear(in_features=128, out_features=1, bias=True)
  (sigmoid): Sigmoid()
)
Total parameters: 529441

 구릅 코랩과 챗지피티가 아니었다면, 머신러닝을 지나 딥러닝/NLP까지 도착하지는 못했을 것이다. 늘 고맙게 감사하게 생각한다.

torch.nn.Embedding에서 _weight 옵션은 임베딩 행렬의 초기값을 설정하는 데 사용됩니다. 이 매개변수는 주로 Embedding.from_pretrained() 메서드 내부에서 사용되며, 사용자가 직접 임베딩 행렬을 지정할 수 있습니다.

기본 동작

nn.Embedding을 생성할 때 _weight를 명시적으로 설정하면, 해당 값을 임베딩 행렬로 사용합니다. 이를 통해 사전 학습된 임베딩(예: GloVe, FastText)을 모델 초기화에 활용할 수 있습니다.

_weight 매개변수

• 타입: torch.Tensor
• 크기: (num_embeddings, embedding_dim)
  • num_embeddings: 사전에 포함된 고유 토큰 수.
  • embedding_dim: 각 토큰의 임베딩 벡터 차원.
• 역할: 초기 임베딩 행렬로 사용되며, 학습 가능 여부는 모델 설정에 따라 달라집니다.
• 주의: _weight는 Embedding 객체를 초기화할 때만 사용할 수 있으며, 이후에는 접근하거나 수정할 수 없습니다.

사용 예제

1. _weight를 수동으로 설정

import torch
import torch.nn as nn

# 사용자 지정 임베딩 행렬 (사전 학습된 값 예시)
pretrained_weights = torch.tensor([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])

# nn.Embedding 초기화 시 _weight 설정
embedding = nn.Embedding(num_embeddings=3, embedding_dim=2, _weight=pretrained_weights)

# 입력 데이터
input_indices = torch.tensor([0, 2])
output = embedding(input_indices)

print(output)
# 출력: [[0.1, 0.2], [0.5, 0.6]]

2. from_pretrained()와 비교

Embedding.from_pretrained()는 _weight를 설정하는 더 편리한 방법입니다.

# 동일한 pretrained_weights 사용
embedding = nn.Embedding.from_pretrained(pretrained_weights)

# 입력 데이터
input_indices = torch.tensor([0, 2])
output = embedding(input_indices)

print(output)
# 출력: [[0.1, 0.2], [0.5, 0.6]]

사전 학습된 임베딩 사용

_weight를 활용하면 사전 학습된 임베딩을 쉽게 사용할 수 있습니다. 예를 들어, GloVe나 FastText 임베딩을 가져와 torch.Tensor로 변환한 뒤 _weight에 전달하면 됩니다.

import numpy as np

# 사전 학습된 GloVe 임베딩 (numpy 배열)
pretrained_glove = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])

# torch.Tensor로 변환
pretrained_weights = torch.tensor(pretrained_glove)

# _weight로 초기화
embedding = nn.Embedding(num_embeddings=3, embedding_dim=2, _weight=pretrained_weights)

# 입력 데이터
input_indices = torch.tensor([1])
output = embedding(input_indices)

print(output)
# 출력: [[0.3, 0.4]]

_weight의 학습 가능 여부

• _weight로 설정된 임베딩 행렬은 기본적으로 학습 가능합니다.
• 학습을 방지하려면 from_pretrained()의 freeze=True를 사용하거나, 수동으로 파라미터를 고정해야 합니다:

  embedding = nn.Embedding.from_pretrained(pretrained_weights, freeze=True)
  

요약

• _weight는 초기 임베딩 행렬을 지정하는 데 사용됩니다.
• 주로 사전 학습된 임베딩을 사용할 때 활용됩니다.
• 학습 가능 여부를 설정하려면 추가적인 설정이 필요합니다.

더 자세한 사항이나 추가적인 질문이 있다면 알려주세요! 😊

주어진 `NewsClassifier` 모델은 PyTorch를 기반으로 한 뉴스 분류를 위한 신경망입니다. 주요 구조와 작동 방식을 아래에 정리했습니다.

---

### **주요 특징**

1. **임베딩 레이어**:
   - `pretrained_embeddings`(사전 학습된 임베딩)이 제공되면 이를 사용하여 임베딩 레이어를 초기화합니다. 
   - 제공되지 않으면 새로 임베딩 레이어를 생성합니다.
   - `padding_idx`는 패딩 토큰이 학습에 영향을 주지 않도록 설정합니다.

2. **합성곱 신경망(CNN)**:
   - 여러 개의 `Conv1d` 레이어로 구성된 합성곱 구조를 통해 입력 데이터를 처리합니다.
   - 각 합성곱 레이어 뒤에 `ELU` 활성화 함수가 적용됩니다.
   - `stride`와 `kernel_size` 설정으로 시퀀스 길이를 점진적으로 줄입니다.

3. **글로벌 평균 풀링**:
   - `avg_pool1d`를 사용하여 시퀀스 차원을 고정된 크기로 줄입니다.
   - 이를 통해 합성곱 레이어에서 추출된 특징을 요약합니다.

4. **완전 연결 레이어 (MLP)**:
   - 두 개의 선형 레이어(`fc1`, `fc2`)가 최종 분류기를 형성합니다.
   - 드롭아웃 레이어를 사용하여 과적합을 방지합니다.

5. **소프트맥스 활성화 함수 (선택적)**:
   - `apply_softmax` 플래그를 통해 소프트맥스를 출력에 적용할지 선택할 수 있습니다.
   - 이는 확률 분포를 해석하거나 추론 시 유용합니다.

---

### **정방향 계산 과정**

1. **임베딩**:
   - 입력 토큰을 임베딩 레이어를 통해 밀집 벡터(dense vector)로 변환합니다.
   - Conv1d 레이어에 적합하도록 시퀀스 축과 채널 축을 교환합니다.

2. **합성곱 및 풀링**:
   - 합성곱 레이어를 통해 특징을 추출하고 시퀀스 길이를 줄입니다.
   - `avg_pool1d`로 시퀀스 차원을 완전히 제거해 고정 크기 벡터를 만듭니다.

3. **분류**:
   - 완전 연결 네트워크를 통해 분류 작업을 수행합니다.
   - 드롭아웃을 적용하여 과적합을 방지합니다.
   - 최종 출력은 `(배치 크기, 클래스 개수)`의 텐서입니다.

4. **소프트맥스**:
   - `apply_softmax=True`일 경우, 출력 텐서를 확률 분포로 변환합니다.

---

### **개선 가능성**

1. **합성곱에서 패딩 사용**:
   - `padding="same"`을 적용하여 시퀀스 양 끝의 정보 손실을 방지할 수 있습니다.

2. **배치 정규화 (Batch Normalization)**:
   - 합성곱 레이어 뒤에 배치 정규화를 추가하면 학습 안정성과 수렴 속도가 개선됩니다.

3. **파라미터 초기화**:
   - Xavier 또는 Kaiming 초기화를 사용하면 모델 성능이 더 좋아질 수 있습니다.

4. **문서화**:
   - 중간 텐서들의 예상 크기를 주석으로 추가하면 가독성이 높아집니다.

5. **에러 핸들링**:
   - 입력 텐서의 차원을 검증하여 데이터 형태가 맞지 않을 경우 바로 에러를 출력하도록 설정합니다.

---

### **도움이 필요한 점이 있나요?**
위 모델을 개선하거나 학습에 사용할 코드를 추가적으로 작성해드릴까요? 😊