I cannot reproduce the slowdown using your (partial) code snippets and get approx. 0.0152s/iter for CPU and 0.00044s/iter for a GPU run using:
import torch
import torch.nn as nn
import torch.nn.functional as F
import time

class GraphConvolution(nn.Module):
    def __init__(self, in_features, out_features, dropout=0., act=F.relu):
        super(GraphConvolution, self).__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.dropout = dropout
        self.act = act
        self.weight = nn.Parameter(torch.randn(in_features, out_features))
        self.reset_parameters()

    def reset_parameters(self):
        torch.nn.init.xavier_uniform_(self.weight)

    def forward(self, input, adj):
        input = F.dropout(input, self.dropout, self.training)
        support = torch.mm(input, self.weight)
        output = torch.spmm(adj, support)
        output = self.act(output)
        return output

device = 'cpu'
model = GraphConvolution(in_features=156, out_features=44).to(device)
x = torch.randn(44, 156).to(device)
adj = torch.randn(44, 44).to(device)

for _ in range(10):
    out = model(x, adj)
    out.backward(torch.ones_like(out))

nb_iters = 100
torch.cuda.synchronize()
t0 = time.time()
for _ in range(nb_iters):
    out = model(x, adj)
    out.backward(torch.ones_like(out))
torch.cuda.synchronize()
t1 = time.time()
print((t1 - t0)/nb_iters)

Note that I had to change:


self.weight to nn.Parameter, as glorot_init is undefined
used out_features=44 based on your provided shapes
used only GraphConvolution, since GVAE is undefined