Hello,

I am trying to perform graph classification. I have a list of DGL graphs which look like this

```
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)
```

and its corresponding label is `tensor([0, 1])`

. I was following an example as I am not familiar with PyTorch.

The model definition is as below

```
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)
```

Upon calling the `loss_fn`

, i get an error `ValueError: Expected input batch_size (64267) to match target batch_size (64).`

. 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

```
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)
```

and i use this collate in another model in which I am using `dgllife.model.model_zoo.GCNPredictor`

and it does not create any issue.