药学数据模型构建5--Seq2Seq

class Encoder(nn.Module):

    def __init__(self, input_size, hidden_size):

        super().__init__()

        self.input_size = input_size

        self.hidden_size = hidden_size

        self.lstm = nn.LSTM(self.input_size, self.hidden_size, batch_first=True)

    def forward(self, input_seq, hidden=None):

        # x(batch_size, input_size)

        # input_seq = input_seq.unsqueeze(1)

        # x(batch_size, 1, input_size)

        if hidden is None:

            h_0 = torch.zeros(1, input_seq.size(0), self.hidden_size).to(input_seq.device)

            c_0 = torch.zeros(1, input_seq.size(0), self.hidden_size).to(input_seq.device)

            output, hidden  = self.lstm(input_seq, (h_0, c_0))

        else:

            output, hidden= self.lstm(input_seq, hidden)

        return output, hidden

class Decoder(nn.Module):

    def __init__(self, input_size, hidden_size, output_size):

        super().__init__()

        self.input_size = input_size

        self.hidden_size = hidden_size

        self.output_size = output_size

        self.num_directions = 1

        self.lstm = nn.LSTM(input_size, self.hidden_size, batch_first=True)

        self.linear = nn.Linear(self.hidden_size, self.output_size)

    def forward(self, input_seq, hidden):

        # x(batch_size, input_size)

        input_seq = input_seq.unsqueeze(1)

        # x(batch_size, 1, input_size)

        output, hidden = self.lstm(input_seq, hidden)

        # output(seq_len, num * hidden_size)

        pred = self.linear(output[:, -1, :])  # pred(1, output_size)

        return pred, hidden

class Seq2Seq(nn.Module):

    def __init__(self, input_size, output_size):

        super().__init__()

        self.output_size = output_size

        self.hidden_size = 64

        self.Encoder = Encoder(input_size, self.hidden_size)

        self.Decoder = Decoder(input_size, self.hidden_size, output_size)

    def forward(self, encoder_inputs, decoder_inputs=None, option=1, teacher_forcing_ratio=0.5):

        # x(batch_size, seq_len, input_size)

        if option != 1:

            raise ValueError("option 输入不合法")

        target_len = self.output_size  # 预测步长

        # encoder_inputs = encoder_inputs.permute(1, 0, 2)

        # x(seq_len, batch_size, input_size)

        batch_size, seq_len, input_size = encoder_inputs.shape[0], encoder_inputs.shape[1], encoder_inputs.shape[2]

        encoder_output, encoder_hidden = self.Encoder(encoder_inputs)

        # 是否使用 Teacher Forcing

        if random.random() < teacher_forcing_ratio and decoder_inputs is not None:

            use_teacher_forcing = True 

        else:

            use_teacher_forcing = False

        # Decoder's first input will be the '<sos>' token

        decoder_input_t = torch.tensor([[0.0]]*batch_size, device=encoder_inputs.device)  # SOS

        decoder_hidden = encoder_hidden

        outputs = torch.zeros(batch_size, target_len).to(encoder_inputs.device) # 存放预测结果

        for t in range(target_len):

            decoder_output, decoder_hidden = self.Decoder(decoder_input_t, decoder_hidden)

            outputs[:, t] = decoder_output.squeeze()

            if use_teacher_forcing:

                # Teacher Forcing: 利用实际目标作为下一步的输入

                decoder_input_t = decoder_inputs.index_select(1, torch.tensor([t]))

            else:

                # 没有 Teacher Forcing：使用模型预测的输出作为下一步输入

                decoder_input_t = decoder_output

        return outputs