When trying to train seq2seq or other models based on RNNs, we usually have layers like an embedding before the RNN cell and a Dense layer at the output to obtain a final output of a desired size at each time step. These layers are time distributed, as in their weights are the same for each time step.
To implement this for batches of variable length sequences, we usually pad the sequences and keep a track of each sequence length, so that we can mask the outputs of these layers accordingly.
However, I have seen that pytorch has a util to create PackedSequences objects which can be fed directly into recurrent modules like LSTMs and it returns the output as a PackedSequence as well.
To my knowledge, we can’t provide a PackedSequence as input to a non-recurrent layer like an Embedding. But, since these layers are time distributed, wouldn’t the application of them simply be applying the layer to each element in the PackedSequence.data tensor, while retaining the same set of batch_sizes?
Currently we can implement this by doing something like:
embedding = nn.Embedding(num_embeddings, embedding_size)
rnn = nn.RNN(input_size=embedding_size,hidden_size=hidden_size)
out_linear = nn.Linear(hidden_size, output_size)

def forward(input,hidden):
    # input is a PackedSequence
    batch_sizes = input.batch_sizes
    
    embedded = embedding(input.data) # apply the layer to the data tensor
    
    # make a new packed sequence with the outputs
    rnn_in = nn.utils.rnn.PackedSequence(embedded,batch_sizes)
    
    # feed to rnn
    rnn_out,hidden = rnn(rnn_in,hidden)
    
    # apply output linear layer
    outputs = out_linear(rnn_out.data)

    # again, make a new packed sequence to return
    final_output = nn.utils.rnn.PackedSequence(outputs,batch_sizes)
    return final_output

However, to do this we have to manually create an instance of a PackedSequence, which is not recommended. Is there any other way to go about this?