class CustomDataset(torch.utils.data.Dataset): 
  def __init__(self):
  데이터셋의 전처리를 해주는 부분

  def __len__(self):
  데이터셋의 길이. 즉, 총 샘플의 수를 적어주는 부분

  def __getitem__(self, idx): 
  데이터셋에서 특정 1개의 샘플을 가져오는 함수

import torchvision.transforms as T

# 이미지 전처리 작업을 정의
preprocess = T.Compose([
    T.Resize((256, 256)), # resize to (256, 256)
    T.RandomHorizontalFlip(), # 
    T.ToTensor(), # normalization with range [0, 1]
    T.Normalize((0.5), (0.5)) # 각 채널별 평균을 뺀뒤 표준편차로 나누어 표준화를 진행, standarazation에 가까움 
])

# 이미지에 전처리 작업 적용
image = Image.open('image.jpg')
imge = preprocess(image)

class Net(nn.Module):
    def __init__(self, input_dim, hidden_dim, seq_len, output_dim, layers):
        super(Net, self).__init__()
        self.hidden_dim = hidden_dim
        self.seq_len = seq_len
        self.output_dim = output_dim
        self.layers = layers

        self.lstm = nn.LSTM(input_size=input_dim, 
                            hidden_size=hidden_dim, 
                            num_layers=layers,
                            batch_first=True)
        
        self.fc = nn.Linear(in_features=hidden_dim, 
                            out_features=output_dim, 
                            bias=True)

    def reset_hidden_state(self, x):
        h_0 = torch.zeros(self.layers, x.size(0), self.hidden_dim)
        c_0 = torch.zeros(self.layers, x.size(0), self.hidden_dim)

        return h_0, c_0

    def forward(self, x):
        h_0, c_0 = self.reset_hidden_state(x)
        output, (h_t, c_t) = self.lstm(x, (h_0, c_0))
        x = self.fc(output[:, -1])
        return x

output, (h_t, c_t) = self.lstm(x, (h_0, c_0))

def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
    if input.is_cuda:
        ...
    hx, cx = hidden
    gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)
    ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)
    ingate     = F.sigmoid(ingate)
    forgetgate = F.sigmoid(forgetgate)
    cellgate   = F.tanh(cellgate)
    outgate    = F.sigmoid(outgate)
    cy = (forgetgate * cx) + (ingate * cellgate)
    hy = outgate * F.tanh(cy)
    return hy, cy