class LSTMModel(nn.Layer):
    def __init__(self,
                 vocab_size,
                 num_classes,
                 emb_dim=128,
                 padding_idx=0,
                 lstm_hidden_size=198,
                 direction='forward',
                 lstm_layers=1,
                 dropout_rate=0.0,
                 pooling_type=None,
                 fc_hidden_size=96):
        super(LSTMModel, self).__init__()

        # Сначала преобразуем входной word id в word embedding с помощью таблицы
        self.embedder = nn.Embedding(
            num_embeddings=vocab_size,
            embedding_dim=emb_dim,
            padding_idx=padding_idx)

        # Преобразуем word embedding через LSTMEncoder в пространство семантического представления текста
        self.lstm_encoder = ppnlp.seq2vec.LSTMEncoder(
            emb_dim,
            lstm_hidden_size,
            num_layers=lstm_layers,
            direction=direction,
            dropout=dropout_rate,
            pooling_type=pooling_type)

        # Метод LSTMEncoder.get_output_dim() позволяет получить размер выходного представления после encoder
        self.fc = nn.Linear(self.lstm_encoder.get_output_dim(), fc_hidden_size)

        # Конечный классификатор
        self.output_layer = nn.Linear(fc_hidden_size, num_classes)
    
    @paddle.jit.to_static
    def forward(self, text, seq_len):
        # Размерность: (batch_size, num_tokens, embedding_dim)
        embedded_text = self.embedder(text)

        # Размерность: (batch_size, num_tokens, num_directions * lstm_hidden_size)
        # num_directions = 2 если direction равно 'bidirectional', иначе 1
        text_repr = self.lstm_encoder(embedded_text, sequence_length=seq_len)


        # Размерность: (batch_size, fc_hidden_size)
        fc_out = paddle.tanh(self.fc(text_repr))

        # Размерность: (batch_size, num_classes)
        logits = self.output_layer(fc_out)
        
        # probs - вероятностные значения классификации
        probs = F.softmax(logits, axis=-1)
        return probs
```# Определение модели
model = LSTMModel(
        len(vocab),
        len(train_ds.label_list),
        direction='двунаправленный',
        padding_idx=vocab['[PAD]'])

# Ошибка при создании объекта Model от PaddlePaddle
error_occurred_in_model_wrapping = model = paddle.Model(model)