# Advanced Mini-Batching

The creation of mini-batching is crucial for letting the training of a deep learning model scale to huge amounts of data.
Instead of processing examples one-by-one, a mini-batch groups a set of examples into a unified representation where it can efficiently be processed in parallel.
In the image or language domain, this procedure is typically achieved by rescaling or padding each example into a set to equally-sized shapes, and examples are then grouped in an additional dimension.
The length of this dimension is then equal to the number of examples grouped in a mini-batch and is typically referred to as the `batch_size`

.

Since graphs are one of the most general data structures that can hold *any* number of nodes or edges, the two approaches described above are either not feasible or may result in a lot of unnecessary memory consumption.
In PyG, we opt for another approach to achieve parallelization across a number of examples.
Here, adjacency matrices are stacked in a diagonal fashion (creating a giant graph that holds multiple isolated subgraphs), and node and target features are simply concatenated in the node dimension, *i.e.*

This procedure has some crucial advantages over other batching procedures:

GNN operators that rely on a message passing scheme do not need to be modified since messages still cannot be exchanged between two nodes that belong to different graphs.

There is no computational or memory overhead. For example, this batching procedure works completely without any padding of node or edge features. Note that there is no additional memory overhead for adjacency matrices since they are saved in a sparse fashion holding only non-zero entries,

*i.e.*, the edges.

PyG automatically takes care of batching multiple graphs into a single giant graph with the help of the `torch_geometric.loader.DataLoader`

class.
Internally, `DataLoader`

is just a regular PyTorch `torch.utils.data.DataLoader`

that overwrites its `collate()`

functionality, *i.e.*, the definition of how a list of examples should be grouped together.
Therefore, all arguments that can be passed to a PyTorch `DataLoader`

can also be passed to a PyG `DataLoader`

, *e.g.*, the number of workers `num_workers`

.

In its most general form, the PyG `DataLoader`

will automatically increment the `edge_index`

tensor by the cumulated number of nodes of all graphs that got collated before the currently processed graph, and will concatenate `edge_index`

tensors (that are of shape `[2, num_edges]`

) in the second dimension.
The same is true for `face`

tensors, *i.e.*, face indices in meshes.
All other tensors will just get concatenated in the first dimension without any further increasement of their values.

However, there are a few special use-cases (as outlined below) where the user actively wants to modify this behaviour to its own needs.
PyG allows modification to the underlying batching procedure by overwriting the `torch_geometric.data.Data.__inc__()`

and `torch_geometric.data.Data.__cat_dim__()`

functionalities.
Without any modifications, these are defined as follows in the `Data`

class:

```
def __inc__(self, key, value, *args, **kwargs):
if 'index' in key or 'face' in key:
return self.num_nodes
else:
return 0
def __cat_dim__(self, key, value, *args, **kwargs):
if 'index' in key or 'face' in key:
return 1
else:
return 0
```

We can see that `__inc__()`

defines the incremental count between two consecutive graph attributes, where as `__cat_dim__()`

defines in which dimension graph tensors of the same attribute should be concatenated together.
Both functions are called for each attribute stored in the `Data`

class, and get passed their specific `key`

and value `item`

as arguments.

In what follows, we present a few use-cases where the modification of `__inc__()`

and `__cat_dim__()`

might be absolutely necessary.

## Pairs of Graphs

In case you want to store multiple graphs in a single `Data`

object, *e.g.*, for applications such as graph matching, you need to ensure correct batching behaviour across all those graphs.
For example, consider storing two graphs, a source graph \(\mathcal{G}_s\) and a target graph \(\mathcal{G}_t\) in a `Data`

, *e.g.*:

```
from torch_geometric.data import Data
class PairData(Data):
def __init__(self, edge_index_s=None, x_s=None, edge_index_t=None, x_t=None):
super().__init__()
self.edge_index_s = edge_index_s
self.x_s = x_s
self.edge_index_t = edge_index_t
self.x_t = x_t
```

In this case, `edge_index_s`

should be increased by the number of nodes in the source graph \(\mathcal{G}_s\), *e.g.*, `x_s.size(0)`

, and `edge_index_t`

should be increased by the number of nodes in the target graph \(\mathcal{G}_t\), *e.g.*, `x_t.size(0)`

:

```
def __inc__(self, key, value, *args, **kwargs):
if key == 'edge_index_s':
return self.x_s.size(0)
if key == 'edge_index_t':
return self.x_t.size(0)
else:
return super().__inc__(key, value, *args, **kwargs)
```

We can test our `PairData`

batching behaviour by setting up a simple test script:

```
from torch_geometric.loader import DataLoader
edge_index_s = torch.tensor([
[0, 0, 0, 0],
[1, 2, 3, 4],
])
x_s = torch.randn(5, 16) # 5 nodes.
edge_index_t = torch.tensor([
[0, 0, 0],
[1, 2, 3],
])
x_t = torch.randn(4, 16) # 4 nodes.
data = PairData(edge_index_s, x_s, edge_index_t, x_t)
data_list = [data, data]
loader = DataLoader(data_list, batch_size=2)
batch = next(iter(loader))
print(batch)
>>> PairDataBatch(edge_index_s=[2, 8], x_s=[10, 16],
edge_index_t=[2, 6], x_t=[8, 16])
print(batch.edge_index_s)
>>> tensor([[0, 0, 0, 0, 5, 5, 5, 5],
[1, 2, 3, 4, 6, 7, 8, 9]])
print(batch.edge_index_t)
>>> tensor([[0, 0, 0, 4, 4, 4],
[1, 2, 3, 5, 6, 7]])
```

Everything looks good so far!
`edge_index_s`

and `edge_index_t`

get correctly batched together, even when using different numbers of nodes for \(\mathcal{G}_s\) and \(\mathcal{G}_t\).
However, the `batch`

attribute (that maps each node to its respective graph) is missing since PyG fails to identify the actual graph in the `PairData`

object.
That’s where the `follow_batch`

argument of the `DataLoader`

comes into play.
Here, we can specify for which attributes we want to maintain the batch information:

```
loader = DataLoader(data_list, batch_size=2, follow_batch=['x_s', 'x_t'])
batch = next(iter(loader))
print(batch)
>>> PairDataBatch(edge_index_s=[2, 8], x_s=[10, 16], x_s_batch=[10],
edge_index_t=[2, 6], x_t=[8, 16], x_t_batch=[8])
print(batch.x_s_batch)
>>> tensor([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
print(batch.x_t_batch)
>>> tensor([0, 0, 0, 0, 1, 1, 1, 1])
```

As one can see, `follow_batch=['x_s', 'x_t']`

now successfully creates assignment vectors called `x_s_batch`

and `x_t_batch`

for the node features `x_s`

and `x_t`

, respectively.
That information can now be used to perform reduce operations, *e.g.*, global pooling, on multiple graphs in a single `Batch`

object.

## Bipartite Graphs

The adjacency matrix of a bipartite graph defines the relationship between nodes of two different node types.
In general, the number of nodes for each node type do not need to match, resulting in a non-quadratic adjacency matrix of shape \(\mathbf{A} \in \{ 0, 1 \}^{N \times M}\) with \(N \neq M\) potentially.
In a mini-batching procedure of bipartite graphs, the source nodes of edges in `edge_index`

should get increased differently than the target nodes of edges in `edge_index`

.
To achieve this, consider a bipartite graph between two node types with corresponding node features `x_s`

and `x_t`

, respectively:

```
from torch_geometric.data import Data
class BipartiteData(Data):
def __init__(self, edge_index=None, x_s=None, x_t=None):
super().__init__()
self.edge_index = edge_index
self.x_s = x_s
self.x_t = x_t
```

For a correct mini-batching procedure in bipartite graphs, we need to tell PyG that it should increment source and target nodes of edges in `edge_index`

independently on each other:

```
def __inc__(self, key, value, *args, **kwargs):
if key == 'edge_index':
return torch.tensor([[self.x_s.size(0)], [self.x_t.size(0)]])
else:
return super().__inc__(key, value, *args, **kwargs)
```

Here, `edge_index[0]`

(the source nodes of edges) get incremented by `x_s.size(0)`

while `edge_index[1]`

(the target nodes of edges) get incremented by `x_t.size(0)`

.
We can again test our implementation by running a simple test script:

```
from torch_geometric.loader import DataLoader
edge_index = torch.tensor([
[0, 0, 1, 1],
[0, 1, 1, 2],
])
x_s = torch.randn(2, 16) # 2 nodes.
x_t = torch.randn(3, 16) # 3 nodes.
data = BipartiteData(edge_index, x_s, x_t)
data_list = [data, data]
loader = DataLoader(data_list, batch_size=2)
batch = next(iter(loader))
print(batch)
>>> BipartiteDataBatch(edge_index=[2, 8], x_s=[4, 16], x_t=[6, 16])
print(batch.edge_index)
>>> tensor([[0, 0, 1, 1, 2, 2, 3, 3],
[0, 1, 1, 2, 3, 4, 4, 5]])
```

Again, this is exactly the behaviour we aimed for!

## Batching Along New Dimensions

Sometimes, attributes of `data`

objects should be batched by gaining a new batch dimension (as in classical mini-batching), *e.g.*, for graph-level properties or targets.
Specifically, a list of attributes of shape `[num_features]`

should be returned as `[num_examples, num_features]`

rather than `[num_examples * num_features]`

.
PyG achieves this by returning a concatenation dimension of `None`

in `__cat_dim__()`

:

```
from torch_geometric.data import Data
from torch_geometric.loader import DataLoader
class MyData(Data):
def __cat_dim__(self, key, value, *args, **kwargs):
if key == 'foo':
return None
else:
return super().__cat_dim__(key, value, *args, **kwargs)
edge_index = torch.tensor([
[0, 1, 1, 2],
[1, 0, 2, 1],
])
foo = torch.randn(16)
data = MyData(edge_index=edge_index, foo=foo)
data_list = [data, data]
loader = DataLoader(data_list, batch_size=2)
batch = next(iter(loader))
print(batch)
>>> MyDataBatch(edge_index=[2, 8], foo=[2, 16])
```

As desired, `batch.foo`

is now described by two dimensions: The batch dimension and the feature dimension.