Graph Classification help

username: choke
cooked: <p>Hello,</p>
<p>I am trying to perform graph classification. I have a list of DGL graphs which look like this</p>
<pre><code class="lang-auto">DGLGraph(num_nodes=64267, num_edges=155523,
         ndata_schemes={}
         edata_schemes={'norm': Scheme(shape=(), dtype=torch.float32), 'rel_type': Scheme(shape=(17,), dtype=torch.float64)
</code></pre>
<p>and its corresponding label is <code>tensor([0, 1])</code>. I was following an example as I am not familiar with PyTorch.<br>
The model definition is as below</p>
<pre><code class="lang-auto">def gcn_message(edges):
    # The argument is a batch of edges.
    # This computes a (batch of) message called 'msg' using the source node's feature 'h'.
    return {'msg' : edges.src['h']}

def gcn_reduce(nodes):
    # The argument is a batch of nodes.
    # This computes the new 'h' features by summing received 'msg' in each node's mailbox.
    return {'h' : torch.sum(nodes.mailbox['msg'], dim=1)}

# Define the GCNLayer module
class GCNLayer(nn.Module):
    def __init__(self, in_feats, out_feats):
        super(GCNLayer, self).__init__()
        self.linear = nn.Linear(in_feats, out_feats)

    def forward(self, g, inputs):
        # g is the graph and the inputs is the input node features
        # first set the node features
        g.ndata['h'] = inputs
        # trigger message passing on all edges
        g.send(g.edges(), gcn_message)
        # trigger aggregation at all nodes
        g.recv(g.nodes(), gcn_reduce)
        # get the result node features
        h = g.ndata.pop('h')
        # perform linear transformation
        return self.linear(h)

class GCN(nn.Module):
    def __init__(self, in_feats, hidden_size, num_classes):
        super(GCN, self).__init__()
        self.gcn1 = GCNLayer(in_feats, hidden_size)
        self.gcn2 = GCNLayer(hidden_size, num_classes)

    def forward(self, g, inputs):
        h = self.gcn1(g, inputs)
        h = torch.relu(h)
        h = self.gcn2(g, h)
        return h
# The first layer transforms input features of size of 41 to a hidden size of 5.
# The second layer transforms the hidden layer and produces output features of
# size 2, corresponding to the two classification groups
net = GCN(7, 16, 2)

for epoch in range(epochs):
    epoch_loss = 0
    epoch_logits = []
    labs = []
    # Iterate over batches
    for i, (bg, labels) in enumerate(train_loader):
        logits = net(bg, bg.ndata['h'])
        # we save the logits for visualization later
        train_logits.append(logits.detach().numpy())
        epoch_logits.append(logits.detach().numpy()) 
        labs.append(labels.unsqueeze(1).detach().numpy())
        logp = F.softmax(logits, 1)
        loss = loss_fn(logp,labels)
</code></pre>
<p>Upon calling the <code>loss_fn</code>, i get an error <code>ValueError: Expected input batch_size (64267) to match target batch_size (64).</code>. For some reason, each node in my graph is treated as a different input value and the model returns a prediciton for it. The collate is defined as</p>
<pre><code class="lang-auto">def collate(samples):
    # The input `samples` is a list of pairs
    #  (graph, label).
    graphs, labels = map(list, zip(*samples))
    batched_graph = dgl.batch(graphs, node_attrs='h')
    batched_graph.set_n_initializer(dgl.init.zero_initializer)
    batched_graph.set_e_initializer(dgl.init.zero_initializer)
    return batched_graph, torch.stack(labels)
</code></pre>
<p>and i use this collate in another model in which I am using <code>dgllife.model.model_zoo.GCNPredictor</code>  and it does not create any issue.</p>