I am trying to make a custom CNN architecture using Pytorch. The current architecture is for text multilabel classification but I want to add some information, say the category of the text to the classification, the category can be a one-hot vector or something like that.
class CNN(nn.Module):
    """
    Convolutional Neural Model used for training the models. The total number of kernels that will be used in this
    CNN is Co * len(Ks). 
    Args:
        weights_matrix: numpy.ndarray, the shape of this n-dimensional array must be (words, dims) were words is
        the number of words in the vocabulary and dims is the dimensionality of the word embeddings.
        Co (number of filters): integer, stands for channels out and it is the number of kernels of the same size that will be used.
        Hu: integer, stands for number of hidden units in the hidden layer.
        C: integer, number of units in the last layer (number of classes)
        Ks: list, list of integers specifying the size of the kernels to be used. 
     
    """
    def __init__(self, vocab_size, emb_dim, Co, Hu, C, Ks, name = 'generic'):
        
        super(CNN, self).__init__()
        
        self.num_embeddings = vocab_size
        
        self.embeddings_dim = emb_dim

        self.padding_index = 0
        
        self.cnn_name = 'cnn_' + str(emb_dim) + '_' + str(Co) + '_' + str(Hu) + '_' + str(C) + '_' + str(Ks) + '_' + name

        self.Co = Co
        
        self.Hu = Hu
        
        self.C = C
        
        self.Ks = Ks
        
        self.embedding = nn.Embedding(self.num_embeddings, self.embeddings_dim, self.padding_index)
        self.convolutions = nn.ModuleList([nn.Conv2d(1,self.Co,(k, self.embeddings_dim)) for k in self.Ks])
        self.relu = nn.ReLU()
        self.drop_out = nn.Dropout(p=0.5)
        units = [self.Co * len(self.Ks)] + Hu
        
        self.linear_layers = nn.ModuleList([nn.Linear(units[k],units[k+1]) for k in range(len(units)-1)])
        
        self.linear_last = nn.Linear(self.Hu[-1], self.C)
        self.sigmoid = nn.Sigmoid()
        
     def forward(self,x):
        
        
        x = self.embedding(x)
        
        x = [self.relu(conv(x)).squeeze(3) for conv in self.convolutions]
        
        x = [F.max_pool1d(i, i.size(2)).squeeze(2) for i in x]

        x = torch.cat(x,1)
        
            x = linear(x)

            x = self.relu(x)
                  
        x = self.drop_out(x)
        x = self.linear_last(x)

        x = self.sigmoid(x)
        
        return x

I want to add a Linear layer that has ass input a one-hot vector and connect this layer to my neural network (concatenate the output of CNN with new layers) and AFAIK PyTorch does the backpropagation by itself.
I am new to Pytorch so if you can help me with what modifications I should add to the code or point me to any direction that can be useful. Thanks