Method forward

model/classification/textvdcnn.py:94–139

(self, batch)

                param_group["lr"] = 0

    def forward(self, batch):
        def convolutional_block(inputs, num_layers, convs, batch_norms):
            """Convolutional Block of VDCNN
            Convolutional block contains 2 conv layers, and can be repeated
            Temp Conv-->Batch Norm-->ReLU-->Temp Conv-->Batch Norm-->ReLU
            """
            hidden_layer = inputs
            for i in range(0, num_layers):
                batch_norm = batch_norms[i](convs[i](inputs))
                hidden_layer = torch.nn.functional.relu(batch_norm)
            return hidden_layer

        if self.config.feature.feature_names[0] == "token":
            embedding = self.token_embedding(
                batch[cDataset.DOC_TOKEN].to(self.config.device))
        else:
            embedding = self.char_embedding(
                batch[cDataset.DOC_CHAR].to(self.config.device))
        embedding = embedding.transpose(1, 2)

        # first conv layer (kernel_size=3, #feature_map=64)
        first_conv = self.first_conv(embedding)
        first_conv = torch.nn.functional.relu(first_conv)

        # all convolutional blocks
        conv_block = first_conv
        for i in range(0, len(self.num_kernels)):
            conv_block = convolutional_block(
                conv_block,
                num_layers=self.vdcnn_num_convs[self.vdcnn_depth][i],
                convs=self.convs[i],
                batch_norms=self.batch_norms[i])
            if i < len(self.num_kernels) - 1:
                # max-pooling with stride=2
                pool = torch.nn.functional.max_pool1d(conv_block,
                                                      kernel_size=3, stride=2)
            else:
                # k-max-pooling
                pool = torch.topk(conv_block, self.top_k)[0].view(
                    conv_block.size(0), -1)

        pool_shape = int(np.prod(pool.size()[1:]))
        doc_embedding = torch.reshape(pool, (-1, pool_shape))
        fc1 = self.linear1(doc_embedding)
        fc2 = self.linear2(fc1)
        return self.dropout(self.linear(fc2))