# Different Channel Errors

Hello everyone,

I am working on a deep learning project using PyTorch to build a SoccerMap architecture which calculate success surface of ass in Football. I saw this concept in this paper

The model involves multiple convolutional, pooling, and upsampling layers. However, I am encountering a `RuntimeError` during the forward pass related to the dimensions of the concatenated tensors.

Here is the model code:

``````
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummaryX import summary

class SoccerMap(nn.Module):
def __init__(self, input_channels=11):
super(SoccerMap, self).__init__()

# 1x scale layers
self.conv1x_1 = nn.Conv2d(input_channels, 64, kernel_size=5, stride=1, padding=2)
self.conv1x_2 = nn.Conv2d(64, 64, kernel_size=5, stride=1, padding=2)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)

# 1/2x scale layers
self.conv1_2x_1 = nn.Conv2d(64, 128, kernel_size=5, stride=1, padding=2)
self.conv1_2x_2 = nn.Conv2d(128, 128, kernel_size=5, stride=1, padding=2)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)

# 1/4x scale layers
self.conv1_4x_1 = nn.Conv2d(128, 256, kernel_size=5, stride=1, padding=2)
self.conv1_4x_2 = nn.Conv2d(256, 128, kernel_size=5, stride=1, padding=2)

# 1x1 convolution for reducing channels
self.conv4 = nn.Conv2d(in_channels=256, out_channels=64, kernel_size=1)

# Upsample layers with additional convolutions
self.upsample1 = nn.Upsample(scale_factor=2, mode='nearest')
self.upsample_conv1_1 = nn.Conv2d(in_channels=160, out_channels=32, kernel_size=3, padding=1)
self.upsample_conv1_2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=1)

self.upsample2 = nn.Upsample(scale_factor=2, mode='nearest')
self.upsample_conv2_1 = nn.Conv2d(in_channels=96, out_channels=32, kernel_size=3, padding=1)
self.upsample_conv2_2 = nn.Conv2d(in_channels=32, out_channels=1, kernel_size=3, padding=1)

self.pred_conv1 = nn.Conv2d(in_channels=128, out_channels=32, kernel_size=1)
self.pred_conv2 = nn.Conv2d(in_channels=32, out_channels=1, kernel_size=1)

def forward(self, x):
# 1x scale
x1 = F.relu(self.conv1x_1(x))
x1 = F.relu(self.conv1x_2(x1))
p1 = self.pool1(x1)

# 1/2x scale
x2 = F.relu(self.conv1_2x_1(p1))
x2 = F.relu(self.conv1_2x_2(x2))
p2 = self.pool2(x2)

# 1/4x scale
x3 = F.relu(self.conv1_4x_1(p2))
x3 = F.relu(self.conv1_4x_2(x3))

# Prediction at 1/4x scale
pred1 = F.relu(self.pred_conv1(x3))
pred1 = self.pred_conv2(pred1)  # Linear activation

pred2 = F.relu(self.pred_conv1(x2))
pred2 = self.pred_conv2(pred2)  # Linear activation

# Upsample and concatenate
u1 = self.upsample1(pred1)
cat1 = torch.cat([u1, pred2], dim=1)

x4 = F.relu(self.upsample_conv1_1(cat1))
x4 = self.upsample_conv1_2(x4)  # Linear activation

u2 = self.upsample2(x4)
pred3 = F.relu(self.pred_conv1(x1))
pred3 = self.pred_conv2(pred3)  # Linear activation

cat2 = torch.cat([u2, pred3], dim=1)
x5 = F.relu(self.upsample_conv2_1(cat2))
x5 = self.upsample_conv2_2(x5)  # Linear activation

pred4 = F.relu(self.pred_conv1(x5))
pred4 = self.pred_conv2(pred4)

return pred4

if __name__ == "__main__":
input_size = 11
model = SoccerMap(input_size)

summary(model, torch.zeros((1, input_size, 80, 120)))

``````

And an error occures.

RuntimeError: Given groups=1, weight of size [32, 160, 3, 3], expected input[1, 2, 40, 60] to have 160 channels, but got 2 channels instead

I suspect the issue might be related to the channel dimensions during concatenation, but I am not entirely sure how to resolve it. Any guidance or suggestions would be greatly appreciated.

Also this is the model archtecture what i want to implement.

``````F.relu(self.upsample_conv1_1(cat1))
Since the concatenated tensor was created via an (upsampled) output of `self.pred_conv2` which returns an output activation with a single output channel while 160 channels are expected.