PyTorch 卷积 - 为什么是四个维度？

Question

I am trying to create a PyTorch network like shown in the image below (see: this link for the arXiv paper). The network aims to learn features for source code. Basically, it consists of an embedding lookup layer, followed by convolution, max-pooling and a dense layer.

My attempt to build this network looks like this:

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
"""
Class Net.
This network is used to learn source code features in a
supervised manner.
"""

def __init__(self, n_vocab, n=512, k=13, m=10):
    """
    Constructor.

    :parm n_vocab:      size of the vocabulary
    :param n:           number of convolution filters
    :param k:           embedding size
    :param m:           kernel size
    """
    super(Net, self).__init__()

    # embedding layer
    self.emb = nn.Embedding(n_vocab, k)

    # convolution and pooling
    self.conv1 = nn.Conv2d(1, n, (m, k))
    self.pool = nn.AdaptiveMaxPool2d(1)

    # fully connected layers
    self.fc1 = nn.Linear(n, 100)
    self.fc2 = nn.Linear(100, 5)


def forward(self, input):
    """
    Performs a forward pass through the network.

    :param input:       input to network
    :return:            network output
    """
    x = self.emb(torch.LongTensor(input))
    x = x.view(1, 500, 13)
    x = self.pool(F.relu(self.conv1(x)))
    x = F.relu(self.fc1(x))
    x = self.fc2(x)

    return x

I cannot get the convolution to work. I keep getting the error: *** RuntimeError: Expected 4-dimensional input for 4-dimensional weight 512 1 10 13, but got 3-dimensional input of size [1, 500, 13] instead . The input to my network consists of vocabulary indices which are fed into the embedding layer. An example input looks like this:

[55, 28, 14, 56, 20, 55, 70, 14, 56, 20, 55, ..., 31, 31, 31, 31, 31, 31, 31]

After feeding this example input into the network, I get the corresponding embeddings:

ensor([[[-0.5966, -1.4197,  0.9875,  ..., -0.0211, -2.3168,  0.3744],
        [-0.1759, -1.1841, -0.0564,  ..., -0.0804, -1.1820, -0.1344],
        [ 1.4525,  0.1342, -0.3820,  ..., -0.2679,  0.5997,  1.1058],
        ...,
        [ 1.2074,  0.4087, -0.3353,  ..., -0.1959,  0.5806, -1.4581],
        [ 1.2074,  0.4087, -0.3353,  ..., -0.1959,  0.5806, -1.4581],
        [ 1.2074,  0.4087, -0.3353,  ..., -0.1959,  0.5806, -1.4581]]],
      grad_fn=<ViewBackward>)

The output looks right for me. Apparently, PyTorch needs 4 dimensions for the convolutions, but I only have three. What is the missing dimension?

My train function looks like this:

def train(X, y, n_vocab, epochs=5):
"""
Trains the network.

:param X:           network input (indices into vocabulary)
:param y:           gold labels
:param epochs:      number of epochs to train the network
                    (default = 5)
:return:            trained network
"""
# instantiate network model
net = Net(n_vocab)

# define training loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# train several epochs
for epoch in range(epochs):

    running_loss = 0.0
    for i in range(len(X)):
        X_b, y_b = X[i], y[i]

        # zero the parameter gradients
        optimizer.zero_grad()

        # perform forward pass
        y_pred = net(X_b)
        # compute loss
        loss = criterion(y_pred, y_b)
        # perform backpropagation
        loss.backward()
        # optimize model parameters
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 0:
            print("[%d, %5d] loss: %.3f" %
                (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print("Finished training")
return net

Any help would be greatly appreciated!

Thank you in advance.

Answer 1

The first dimension of the data should be the batch, mentioned in the documentation :

Applies a 2D convolution over an input signal composed of several input planes.

... the output value of the layer with input size (N, C, H, W) ...

...

N is a batch size, C denotes a number of channels, H is a height of input planes in pixels, and W is width in pixels.

So you should batch your data before passing it to the net, or at least reshape it to a shape of (1, 1, 500, 13) to use a batch size of 1.