Expected 3-dimensional input for 3-dimensional weight [64, 3, 7], but got 2-dimensional input of size [317829, 3] instead

gyemory: <p>Hi I am trying to apply a Resnet work model to my data.<br>
But i have the run time error Expected 3-dimensional input for 3-dimensional weight [64, 3, 7], but got 2-dimensional input of size [317829, 3] instead.<br>
What should i do now?</p>

ptrblck: <p>Your code is quite hard to read as it’s not formatted, so please wrap it into three backticks ``` which would make debugging easier. <img src="https://discuss.pytorch.org/images/emoji/apple/wink.png?v=10" title=":wink:" class="emoji" alt=":wink:"></p>
<p>Based on the error message the shape mismatch is most likely raised in the first <code>nn.Conv1d</code> layer, which expects an input in the shape <code>[batch_size, channels, seq_len]</code> while you are passing a 2D input to it.</p>

gyemory: <p>class BasicBlock7x7(nn.Module):<br>
expansion = 1</p>
<pre><code>def __init__(self, inplanes7, planes, stride=1, downsample=None):
    super(BasicBlock7x7, self).__init__()
    self.conv1 = conv7x7(inplanes7, planes, stride)
    self.bn1 = nn.BatchNorm1d(planes)
    self.relu = nn.ReLU(inplace=True)
    self.conv2 = conv7x7(planes, planes)
    self.bn2 = nn.BatchNorm1d(planes)
    self.downsample = downsample
    self.stride = stride

def forward(self, x):
    residual = x

    out = self.conv1(x)
    out = self.bn1(out)
    out = self.relu(out)

    out = self.conv2(out)
    out = self.bn2(out)

    if self.downsample is not None:
        residual = self.downsample(x)

    d = residual.shape[2] - out.shape[2]
    out1 = residual[:, :, 0:-d] + out
    out1 = self.relu(out1)
    # out += residual

    return out1
</code></pre>
<p>class BasicBlock9x9(nn.Module):<br>
expansion = 1</p>
<pre><code>def __init__(self, inplanes9, planes, stride=1, downsample=None):
    super(BasicBlock9x9, self).__init__()
    self.conv1 = conv9x9(inplanes9, planes, stride)
    self.bn1 = nn.BatchNorm1d(planes)
    self.relu = nn.ReLU(inplace=True)
    self.conv2 = conv9x9(planes, planes)
    self.bn2 = nn.BatchNorm1d(planes)
    self.downsample = downsample
    self.stride = stride

def forward(self, x):
    residual = x

    out = self.conv1(x)
    out = self.bn1(out)
    out = self.relu(out)

    out = self.conv2(out)
    out = self.bn2(out)

    if self.downsample is not None:
        residual = self.downsample(x)

    d = residual.shape[2] - out.shape[2]
    out1 = residual[:, :, 0:-d] + out
    out1 = self.relu(out1)
    # out += residual

    return out1</code></pre>

gyemory: <p>class MSResNet(nn.Module):<br>
def <strong>init</strong>(self, input_channel, layers=[1, 1, 1, 1], num_classes=10):<br>
self.inplanes3 = 64<br>
self.inplanes5 = 64<br>
self.inplanes7 = 64<br>
self.inplanes9 = 64</p>
<pre><code>    super(MSResNet, self).__init__()

    self.conv1 = nn.Conv1d(input_channel, 64, kernel_size=7, stride=2, padding=3,
                           bias=False)
    self.bn1 = nn.BatchNorm1d(64)
    self.relu = nn.ReLU(inplace=True)
    self.maxpool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1)

    self.layer3x3_1 = self._make_layer3(BasicBlock3x3, 64, layers[0], stride=2)
    self.layer3x3_2 = self._make_layer3(BasicBlock3x3, 128, layers[1], stride=2)
    self.layer3x3_3 = self._make_layer3(BasicBlock3x3, 256, layers[2], stride=2)
    self.layer3x3_4 = self._make_layer3(BasicBlock3x3, 512, layers[3], stride=2)
    self.layer3x3_5 = self._make_layer3(BasicBlock3x3, 1024, layers[3], stride=2)

    # maxplooing kernel size: 16, 11, 6
    self.maxpool3 = nn.AvgPool1d(kernel_size=1, stride=1, padding=0)


    self.layer5x5_1 = self._make_layer5(BasicBlock5x5, 64, layers[0], stride=2)
    self.layer5x5_2 = self._make_layer5(BasicBlock5x5, 128, layers[1], stride=2)
    self.layer5x5_3 = self._make_layer5(BasicBlock5x5, 256, layers[2], stride=2)
    self.layer5x5_4 = self._make_layer5(BasicBlock5x5, 512, layers[3], stride=2)
    self.maxpool5 = nn.AvgPool1d(kernel_size=3, stride=1, padding=0)


    self.layer7x7_1 = self._make_layer7(BasicBlock7x7, 64, layers[0], stride=2)
    self.layer7x7_2 = self._make_layer7(BasicBlock7x7, 128, layers[1], stride=2)
    self.layer7x7_3 = self._make_layer7(BasicBlock7x7, 256, layers[2], stride=2)
    self.layer7x7_4 = self._make_layer7(BasicBlock7x7, 512, layers[3], stride=2)
    self.maxpool7 = nn.AvgPool1d(kernel_size=3, stride=1, padding=0)

    self.layer9x9_1 = self._make_layer9(BasicBlock9x9, 64, layers[0], stride=2)
    self.layer9x9_2 = self._make_layer9(BasicBlock9x9, 128, layers[1], stride=2)
    self.layer9x9_3 = self._make_layer9(BasicBlock9x9, 256, layers[2], stride=2)
    self.layer9x9_4 = self._make_layer9(BasicBlock9x9, 512, layers[3], stride=2)
    self.maxpool9 = nn.AvgPool1d(kernel_size=3, stride=1, padding=0)

    # self.drop = nn.Dropout(p=0.2)
    
    self.fc = nn.Linear(4*256+1024, num_classes)
    
    # todo: modify the initialization
    # for m in self.modules():
    #     if isinstance(m, nn.Conv1d):
    #         n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
    #         m.weight.data.normal_(0, math.sqrt(2. / n))
    #     elif isinstance(m, nn.BatchNorm1d):
    #         m.weight.data.fill_(1)
    #         m.bias.data.zero_()

def _make_layer3(self, block, planes, blocks, stride=2):
    downsample = None
    if stride != 1 or self.inplanes3 != planes * block.expansion:
        downsample = nn.Sequential(
            nn.Conv1d(self.inplanes3, planes * block.expansion,
                      kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm1d(planes * block.expansion),
        )

    layers = []
    layers.append(block(self.inplanes3, planes, stride, downsample))
    self.inplanes3 = planes * block.expansion
    for i in range(1, blocks):
        layers.append(block(self.inplanes3, planes))

    return nn.Sequential(*layers)

def _make_layer5(self, block, planes, blocks, stride=2):
    downsample = None
    if stride != 1 or self.inplanes5 != planes * block.expansion:
        downsample = nn.Sequential(
            nn.Conv1d(self.inplanes5, planes * block.expansion,
                      kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm1d(planes * block.expansion),
        )

    layers = []
    layers.append(block(self.inplanes5, planes, stride, downsample))
    self.inplanes5 = planes * block.expansion
    for i in range(1, blocks):
        layers.append(block(self.inplanes5, planes))

    return nn.Sequential(*layers)


def _make_layer7(self, block, planes, blocks, stride=2):
    downsample = None
    if stride != 1 or self.inplanes7 != planes * block.expansion:
        downsample = nn.Sequential(
            nn.Conv1d(self.inplanes7, planes * block.expansion,
                      kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm1d(planes * block.expansion),
        )

    layers = []
    layers.append(block(self.inplanes7, planes, stride, downsample))
    self.inplanes7 = planes * block.expansion
    for i in range(1, blocks):
        layers.append(block(self.inplanes7, planes))

    return nn.Sequential(*layers)

def _make_layer9(self, block, planes, blocks, stride=2):
    downsample = None
    if stride != 1 or self.inplanes9 != planes * block.expansion:
        downsample = nn.Sequential(
            nn.Conv1d(self.inplanes9, planes * block.expansion,
                      kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm1d(planes * block.expansion),
        )

    layers = []
    layers.append(block(self.inplanes9, planes, stride, downsample))
    self.inplanes9 = planes * block.expansion
    for i in range(1, blocks):
        layers.append(block(self.inplanes9, planes))

    return nn.Sequential(*layers)</code></pre>

gyemory: <pre><code>def forward(self, x0):
    x0 = self.conv1(x0)
    x0 = self.bn1(x0)
    x0 = self.relu(x0)
    x0 = self.maxpool(x0)

    x = self.layer3x3_1(x0)
    x = self.layer3x3_2(x)
    x = self.layer3x3_3(x)
    x = self.layer3x3_4(x)
    x = self.layer3x3_5(x)           
    x = self.maxpool3(x) 

    y = self.layer5x5_1(x0)
    y = self.layer5x5_2(y)
    y = self.layer5x5_3(y)
    y = self.layer5x5_4(y)
    y = self.maxpool5(y)

    z = self.layer7x7_1(x0)
    z = self.layer7x7_2(z)
    z = self.layer7x7_3(z)
    z = self.maxpool7(z)

    xx = self.layer9x9_1(x0)
    xx = self.layer9x9_2(xx)
    xx = self.layer9x9_3(xx)
    xx = self.maxpool9(xx)

    out = torch.cat([x, y, z, xx], dim=1)

    out = out.squeeze()
    # out = self.drop(out)
    out1 = self.fc(out)
    
    return out1, out</code></pre>

gyemory: <p>i have reformatted the code, if it possible, please help me debug the code.<br>
Thanks</p>

ptrblck: <p>Unfortunately, you haven’t properly formatted the code and even after copying and fixing the code locally, the code is still not executable since <code>BasicBlock3x3</code> is undefined.<br>
As previously described, check the input shape and make sure it’s a 3D tensor with the expected shapes.</p>

my3bikaht: <aside class="quote no-group" data-username="gyemory" data-post="8" data-topic="136343">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://discuss.pytorch.org/letter_avatar_proxy/v4/letter/g/a88e57/48.png" class="avatar"> gyemory:</div>
<blockquote>
<pre><code class="lang-auto">self.conv1 = nn.Conv1d(input_channel, 64, kernel_size=7, stride=2, padding=3,
                           bias=False)
</code></pre>
</blockquote>
</aside>
<p>it is just right here, first convolution<br>
seems like you’re passing single tensor shaped [317829, 3] but you need to pass 3 dimensional tensor where dim 0 contains batch size of elements. If you want to pass single element, unsqueeze(0) tensor you’re passing to model to add dim 0. Also, if your tensor is correct, you’ll need to transpose it before unsqueeze.</p>

gyemory: <p>Thanks for your time. I have solved the probelm.</p>