Mat1 and mat2 shapes cannot be multiplied (288000x64 and 180x540)

VickyRS: <p>Hi,<br>
Please I am new to ML and trying to add the WindowAttention to the self.conv_first layer and it’s showing the error “mat1 and mat2 shapes cannot be multiplied (288000x64 and 180x540)”. Please helpppp</p>
<p>Below is the WindowAttention class and OneChan class</p>
<p><strong>class WindowAttention(nn.Module):</strong><br>
def <strong>init</strong>(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):</p>
<pre><code>    super().__init__()
    self.dim = dim
    self.window_size = window_size  # Wh, Ww
    self.num_heads = num_heads
    head_dim = dim // num_heads
    self.scale = qk_scale or head_dim ** -0.5

    # define a parameter table of relative position bias
    self.relative_position_bias_table = nn.Parameter(
        torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH

    # get pair-wise relative position index for each token inside the window
    coords_h = torch.arange(self.window_size[0])
    coords_w = torch.arange(self.window_size[1])
    coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
    coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
    relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
    relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
    relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
    relative_coords[:, :, 1] += self.window_size[1] - 1
    relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
    relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
    self.register_buffer("relative_position_index", relative_position_index)

    self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
    self.attn_drop = nn.Dropout(attn_drop)
    self.proj = nn.Linear(dim, dim)

    self.proj_drop = nn.Dropout(proj_drop)

    trunc_normal_(self.relative_position_bias_table, std=.02)
    self.softmax = nn.Softmax(dim=-1)

def forward(self, x, mask=None):
    
    B_, N, C = x.shape
    qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
    q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)

    q = q * self.scale
    attn = (q @ k.transpose(-2, -1))

    relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
        self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
    relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
    attn = attn + relative_position_bias.unsqueeze(0)

    if mask is not None:
        nW = mask.shape[0]
        attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
        attn = attn.view(-1, self.num_heads, N, N)
        attn = self.softmax(attn)
    else:
        attn = self.softmax(attn)

    attn = self.attn_drop(attn)

    x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
    x = self.proj(x)
    x = self.proj_drop(x)
    return x
</code></pre>
<p><strong>class OneChan(nn.Module):</strong><br>
def <strong>init</strong>(self, img_size=64, patch_size=1, in_chans=3,<br>
embed_dim=96, depths=[6, 6, 6, 6], num_heads=[6, 6, 6, 6],<br>
window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,<br>
drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,<br>
norm_layer=nn.LayerNorm, ape=False, patch_norm=True,<br>
use_checkpoint=False, upscale=2, img_range=1., upsampler=‘’, resi_connection=‘1conv’,<br>
**kwargs):<br>
super(OneChan, self).<strong>init</strong>()<br>
num_in_ch = in_chans<br>
num_out_ch = in_chans<br>
num_feat = 64<br>
self.img_range = img_range<br>
if in_chans == 3:<br>
rgb_mean = (0.4488, 0.4371, 0.4040)<br>
self.mean = torch.Tensor(rgb_mean).view(1, 3, 1, 1)<br>
else:<br>
self.mean = torch.zeros(1, 1, 1, 1)<br>
self.upscale = upscale<br>
self.upsampler = upsampler<br>
self.window_size = window_size</p>
<pre><code>    #####################################################################################################
    ################################### 1, shallow feature extraction ###################################
    **self.conv_first = nn.Conv2d(num_in_ch, embed_dim, 3, 1, 1)**
</code></pre>
<p>**        self.multi_attn = WindowAttention(embed_dim, (window_size, window_size), num_heads[0], qkv_bias, qk_scale, attn_drop_rate, drop_rate)**</p>
<p>def forward(self, x):<br>
H, W = x.shape[2:]<br>
x = self.check_image_size(x)</p>
<pre><code>    self.mean = self.mean.type_as(x)
    x = (x - self.mean) * self.img_range

    if self.upsampler == 'nearest+conv':
        # for real-world SR
        **x_f = self.conv_first(x)**
       **x = self.multi_attn(x_f)**
        x = self.conv_after_body(self.forward_features(x)) + x
        x = self.conv_before_upsample(x)
        x = self.lrelu(self.conv_up1(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
        x = self.lrelu(self.conv_up2(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
        x = self.conv_last(self.lrelu(self.conv_hr(x)))
</code></pre>

ptrblck: <p>Double post from <a href="https://discuss.pytorch.org/t/runtimeerror-given-groups-1-weight-64-3-3-3-so-expected-input-16-64-256-256-to-have-3-channels-but-got-64-channels-instead/12765/84">here</a>.</p>