I want to use PyTorch and PyTorch-Geometric to train my graph neural network. However, it raises RuntimeError about ‘Function ScatterAddBackward’ when it executes loss.backward() . I checked the shape of my input and output in my code but still cannot find where the problem is.
I give a demo here which can reproduce the issue. My code is executed on RTX 2080ti and windows 10 platform. The version of PyG and PyTorch are 2.0.2 and 1.9.0, respectively. Here is the RuntimeError:

Traceback (most recent call last):
File “demo.py”, line 101, in
loss.backward()
File “C:\software\Miniconda3\envs\AI\lib\site-packages\torch_tensor.py”, line 255, in backward
torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)
File “C:\software\Miniconda3\envs\AI\lib\site-packages\torch\autograd_init _.py”, line 147, in backward
Variable._execution_engine.run_backward(
RuntimeError: Function ScatterAddBackward returned an invalid gradient at index 1 - got [18, 1] but expected shape compatible with [18, 5]

Here is my code:
import torch
import torch_geometric
from torch_geometric.nn import MessagePassing, Linear
import torch.nn.functional as F
from torch_geometric.nn.inits import glorot
from torch_geometric.loader import NeighborLoader


class DemoConv(MessagePassing):

	def __init__(self, n_num: int=3, p_num: int=2, initializer: str='glorot',
					negative_slope: float=0.01):
		super(DemoConv, self).__init__(aggr='add', flow='source_to_target')
		self.n = n_num
		self.p = p_num
		self.negative_slope = negative_slope 									
		self.n_edgL = Linear(2*n_num, n_num, weight_initializer=initializer)
		self.p_edgL = Linear(2*p_num, p_num, weight_initializer=initializer)
		
		# self.n_tot = Linear(n_num, n_num, weight_initializer=initializer)
		self.n_sca = Linear(n_num, n_num, weight_initializer=initializer)	

		# self.p_tot = Linear(p_num, p_num, weight_initializer=initializer)
		self.p_sca = Linear(n_num+p_num, p_num, weight_initializer=initializer)


	def forward(self, x, edge_index, area, vol, Xts, Xss, Qext):
		''' Args:
			x: 				Size: (num_nodes, n_num + p_num)
			area: 	 		Size: (num_edges, 1)
			vol: 			Size: (num_nodes, 1)
			edge_index: 	Size: (2, num_edges)
			Xts: 			Size: (num_nodes, n_num + p_num)
			Xss: 			Size: (num_nodes, n_num + n_num + p_num)
			Qext: 			Size: (num_nodes, n_num + p_num)
		'''
		id_src, id_dst = edge_index 	# source node ID, target node ID
		num_nodes = x.size(0) 			# the number of nodes
		n_Input = torch.cat([x[id_src][:, :self.n], x[id_dst][:, :self.n]], dim=1) 	# Size: (num_edges, 2*n_num)
		p_Input = torch.cat([x[id_src][:, self.n:], x[id_dst][:, self.n:]], dim=1) 	# Size: (num_edges, 2*p_num)
		
		# InSize: (num_edges, 2*n_num)   OutSize: (num_edges, n_num)
		n_alpha = F.leaky_relu(self.n_edgL(n_Input), self.negative_slope)

		# InSize: (num_edges, 2*p_num)    OutSize: (num_edges, p_num)
		p_alpha = F.leaky_relu(self.p_edgL(p_Input), self.negative_slope)

		alpha = torch.cat([n_alpha, p_alpha], dim=1) 						# Size: (num_edges, n_num + p_num)
		# print('alpha size: {}    area: {}'.format(alpha.size(), area.size()))

		coe_fac = alpha * area 												# Size: (num_edges, n_num + p_num)
		coe_sum = torch.zeros([num_nodes, self.n+self.p]).to('cuda') 		# Size: (num_nodes, n_num + p_num)
		id_dstForScatter = id_dst.view(-1, 1)
		coe_sum.scatter_add_(dim=0, index=id_dstForScatter, src=coe_fac) 	# Size: (num_nodes, n_num + p_num)

		coe_sum = coe_sum + 20.0  											# avoid dividing zero 
		coe_x = coe_fac/coe_sum[id_dst] 									# Size: (num_edges, n_num + p_num)
		return self.propagate(edge_index, x=x, coe_x=coe_x, 
				coe_sum=coe_sum, vol=vol, Xts=Xts, Xss=Xss, Qext=Qext)	


	def message(self, x_j, coe_x):
		return -1.0*coe_x*x_j


	def update(self, aggr_out, x, coe_sum, vol, Xts, Xss, Qext):
		n_sterm = F.leaky_relu(self.n_sca(x[:, :self.n]*Xss[:, :self.n]), self.negative_slope) 	# InSize: (num_nodes, n_num)
		p_sterm = F.leaky_relu(self.p_sca(x*Xss[:, self.n:]), self.negative_slope) 				# InSize: (num_nodes, n_num + p_num)
		Q_s = torch.cat([n_sterm, p_sterm], dim=1)/coe_sum*vol 									# OutSize: (num_nodes, n_num + p_num)
		return aggr_out + Q_s + Qext/coe_sum



class DemoNet(torch.nn.Module):

	def __init__(self):
		super(DemoNet, self).__init__()
		self.conv = DemoConv()

	def forward(self, data):
		x, edge_index, area, vol, Xts, Xss, Qext = data.x, data.edge_index, data.area, data.vol, data.Xts, data.Xss, data.Qext
		x = self.conv(x=x, edge_index=edge_index, area=area, vol=vol, Xts=Xts, Xss=Xss, Qext=Qext)
		return x 


data = torch.load('./data.pth')
trainData = NeighborLoader(data, num_neighbors=[7], batch_size=5, input_nodes=data.train_mask)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = DemoNet().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
lossFunc = torch.nn.MSELoss()

model.train()
for epoch in range(1):
	for batchIdx, data in enumerate(trainData):
		data = data.to(device)
		optimizer.zero_grad()
		out = model(data)
		loss = lossFunc(out, data.y)
		loss.backward()
		optimizer.step()
		if batchIdx == 0 :
			break

I’m sorry for that .zip file is not supported for uploading here so I cannot upload the data file for the code execution.