source : https://www.k-a.in/transformers.html

• embedding class

import torch
import torch.nn as nn
import math
class InputEmbeddings(nn.Module):
    # 생성자는 모델 차원과 어휘 크기를 매개변수로 받습니다.
    def __init__(self, d_model:int, vocab_size:int):
        # 모델의 dim과 vocab 크기를 클래스 속성으로 저장합니다.
        self.d_model = d_model
        self.vocab_size = vocab_size
        # 토큰 인덱스를 d_model 차원 벡터에 매핑하는 임베딩 계층을 생성합니다.
        self.embedding = nn.Embedding(vocab_size,d_model)

    # 입력 x를 처리하는 정방향 패스 방식.
    def forward(self,x):
        # 임베딩을 적용하고곱합니다. 논문에 기술된 대로 분산을 안정적으로 유지합니다.
        return self.embedding(x) * math.sqrt(self.d_model)

• positional encoding class

# 임베딩에 위치 정보를 추가하기 위한 클래스입니다.
class PositionalEncoding(nn.Module):
    # 생성자는 모델 차원, 최대 시퀀스 길이, 드롭아웃 비율을 매개변수로 받습니다.
    def __init__(self, d_model:int, seq_len:int, dropout:float) -> None:
        # 차원을 클래스 속성으로 저장합니다.
        self.d_model = d_model
        self.seq_len = seq_len
        # 드롭아웃 레이어를 생성합니다
        self.droput = nn.Dropout(dropout)
        # 위치 인코딩을 위한 텐서를 0으로 초기화합니다.
        pe = torch.zeros(seq_len,d_model)
        position = torch.arange(0,seq_len,dtype=torch.float).unsqueeze(1)
        # 0부터 seq_len-1까지의 위치 인덱스를 갖는 열 벡터를 생성합니다.
        div_term = torch.exp(torch.arange(0,d_model,2).float()*(-math.log(10000.0)/d_model))
        # 논문 공식에 따라 사인 함수에 대한 나눗셈 항을 생성합니다.
        pe[:,0::2] = torch.sin(position*div_term)
        pe[:,1::2] = torch.cos(position*div_term)
        # 위치 인코딩의 홀수 인덱스에 코사인을 적용합니다.
        pe = pe.unsqueeze(0)
        # 위치 인코딩 텐서를 버퍼(매개변수가 아닌 영구 상태)로 등록합니다.
        self.register_buffer('pe',pe)
    # 입력 x에 대한 순방향 패스 방법.
    def forward(self,x):
        # 입력에 위치 인코딩을 추가하고, 입력 시퀀스 길이에 맞게 트리밍하며, 그래디언트는 비활성화됩니다.
        x = x + (self.pe[:,:x.shape[1],:]).requires_grad_(False)
        # 입력과 위치 인코딩의 합계에 드롭아웃을 적용합니다.
        return self.dropput(x)

• multi head attention block class

# 멀티헤드 어텐션 메커니즘을 구현합니다.
class MultiHeadAttentionBlock(nn.Module):
    # 모델 차원, 헤드 수, 중도 탈락률을 갖춘 생성자입니다.
    def __init__(self,d_model:int,h:int,dropout:float)->None:
        # 차원을 속성으로 저장합니다.
        self.d_model = d_model
        self.h = h
        # 모델의 차원이 헤드 개수로 나누어 떨어지는지 확인합니다.
        assert d_model % h == 0, "d_model is not divisible by h"
        self.d_k = d_model // h
        # 편향 없는 쿼리 벡터에 대한 선형 투영.
        self.w_q = nn.Linear(d_model,d_model,bias=False)
        self.w_k = nn.Linear(d_model,d_model,bias=False)
        self.w_v = nn.Linear(d_model,d_model,bias=False)
        self.w_o = nn.Linear(d_model,d_model,bias=False)

        self.dropout = nn.Dropout(dropout)

    # 확장된 점곱 어텐션을 구현하는 정적 메서드입니다.
    @staticmethod
    def attention(query,key,value,mask,dropout:nn.Dropout):
        # 키/쿼리의 차원을 가져옵니다.
        d_k = query.shape[-1]
        # 행렬 곱셈과 스케일링을 사용하여 주의 점수를 계산합니다.
        attention_scores = (query @ key.transpose(-2,-1))/math.sqrt(d_k)
        # 마스크된 위치를 음의 무한대(매우 그렇지만 실제로는 아님) 값으로 설정하여 마스크를 적용합니다.
        if mask is not None:    attention_scores.masked_fill_(mask==0,-1e9)
        attention_scores = attention_scores.softmax(dim=-1)
        # attention score에 드롭아웃을 적용합니다.
        if dropout is not None:    attention_scores = dropout(attention_scores) 
        return (attention_scores @ value), attention_scores

    def forward(self,q,k,v,mask):
        query = self.w_q(q)
        key = self.w_k(k)
        value = self.w_v(v)

        # 멀티헤드 처리를 위해 텐서를 재구성하고 전치합니다.
        query = query.view(query.shape[0],query.shape[1],self.h,self.d_k).transpose(1,2)
        key = key.view(key.shape[0],key.shape[1],self.h,self.d_k).transpose(1,2)
        value = value.view(value.shape[0],value.shape[1],self.h,self.d_k).transpose(1,2)
 
        # attention을 계산하고 점수를 저장합니다.
        x,self.attention_scores = MultiHeadAttentionBlock.attention(query,key,value,mask,self.dropout)


        # 출력물을 원래 크기로 다시 조정합니다.
        x = x.transpose(1,2).contiguous().view(x.shape[0],-1,self.h*self.d_k)

        return self.w_o(x)

• layer norm class

네트워크 활성화를 안정화하기 위해 레이어 정규화를 구현합니다.

class LayerNormalization(nn.Module): # 0으로 나누는 것을 방지하기 위해 기능 개수와 작은 엡실론을 사용한 생성자입니다. def init(self,features: int,eps:float=10**-6) -> None:

    self.eps = eps
    # 학습 가능한 스케일링 매개변수는 1로 초기화됩니다.
    self.alpha = nn.Parameter(torch.ones(features))
    # 학습 가능한 편향 매개변수는 0으로 초기화됩니다.
    self.bias = nn.Parameter(torch.zeros(features))
# 입력 x에 대한 순방향 패스 방법.
def forward(self,x):
    # 특성 차원 전체에 걸쳐 평균을 계산합니다.
    mean = x.mean(dim = -1, keepdim = True)
     # 특성 차원 전체에 걸쳐 표준 편차를 계산합니다.
    std = x.std(dim = -1, keepdim = True)
    # 입력을 정규화하고, 크기 조정 및 편향을 적용합니다.
    return self.alpha * (x-mean)/(std+self.eps) + self.bias

* feedforward block
class FeedForwardBlock(nn.Module):
    def __init__(self,d_model:int,d_ff:int,dropout:float) -> None:

        # d_model에서 d_ff 차원으로의 첫 번째 선형 변환입니다.
        self.linear_1 = nn.Linear(d_model,d_ff)
        # 정규화를 위한 드롭아웃 레이어.
        self.dropout = nn.Dropout(dropout)
        # d_ff에서 d_model 차원으로 다시 돌아가는 두 번째 선형 변환입니다.
        self.linear_2 = nn.Linear(d_ff,d_model)

    def forward(self,x):
        # 첫 번째 선형 변환, ReLU 활성화, 드롭아웃, 두 번째 선형 변환을 적용합니다.
        return self.linear_2(self.dropout(torch.relu(self.linear_1(x))))

• Residual connection class class ResidualConnection(nn.Module): def init(self,features: int,dropout:float) -> None:

    self.dropout = nn.Dropout(dropout)
    self.norm = LayerNormalization(features)
  

  def forward(self,x,sublayer): # 레이어 표준, 하위 레이어, 드롭아웃, 잔여 연결을 적용합니다. return x + self.dropout(sublayer(self.norm(x)))

* encoder block
class EncoderBlock(nn.Module):
    def __init__(self, features: int, self_attention_block: MultiHeadAttentionBlock, feed_forward_block: FeedForwardBlock, dropout: float) -> None:

        self.self_attention_block = self_attention_block
        self.feed_forward_block = feed_forward_block
        self.residual_connections = nn.ModuleList([ResidualConnection(features,dropout) for _ in range(2)])

    def forward(self,x,src_mask):
        x = self.residual_connections[0](x,lambda x: self.self_attention_block(x,x,x,src_mask))
        x = self.residual_connections[1](x, self.feed_forward_block)
        return x