Deep learning RuntimeError:三维权重[64512,1]应为三维输入，但得到的却是大小为[4512]的二维输入_Deep Learning_Pytorch_Cnn

Deep learning RuntimeError:三维权重[64512,1]应为三维输入，但得到的却是大小为[4512]的二维输入

deep-learning pytorch

Deep learning RuntimeError:三维权重[64512,1]应为三维输入，但得到的却是大小为[4512]的二维输入,deep-learning,pytorch,cnn,Deep Learning,Pytorch,Cnn,下面是我正在尝试运行的pytorch模型。但这是一个错误。我也发布了错误跟踪。它运行得非常好，除非我添加了卷积层。我对深入学习和学习仍然是新手。所以，如果这是一个愚蠢的问题，我道歉。我使用的是conv1d，为什么conv1d需要三维输入，而它也需要二维输入，这也很奇怪 class Net(nn.Module): def __init__(self): super().__init__() self.fc1 = nn.Linear(C

下面是我正在尝试运行的pytorch模型。但这是一个错误。我也发布了错误跟踪。它运行得非常好，除非我添加了卷积层。我对深入学习和学习仍然是新手。所以，如果这是一个愚蠢的问题，我道歉。我使用的是conv1d，为什么conv1d需要三维输入，而它也需要二维输入，这也很奇怪

class Net(nn.Module):
        def __init__(self):
            super().__init__()
            self.fc1 = nn.Linear(CROP_SIZE*CROP_SIZE*3, 512)
            self.conv1d1 = nn.Conv1d(in_channels=512, out_channels=64, kernel_size=1, stride=2)
            self.fc2 = nn.Linear(64, 128)
            self.conv1d2 = nn.Conv1d(in_channels=128, out_channels=64, kernel_size=1, stride=2)
            self.fc3 = nn.Linear(64, 256)
            self.conv1d3 = nn.Conv1d(in_channels=256, out_channels=64, kernel_size=1, stride=2)
            self.fc4 = nn.Linear(64, 256)
            self.fc4 = nn.Linear(256, 128)
            self.fc5 = nn.Linear(128, 64)
            self.fc6 = nn.Linear(64, 32)
            self.fc7 = nn.Linear(32, 64)
   

     self.fc8 = nn.Linear(64, frame['landmark_id'].nunique())

    def forward(self, x):
        x = F.relu(self.conv1d1(self.fc1(x)))
        x = F.relu(self.conv1d2(self.fc2(x)))
        x = F.relu(self.conv1d3(self.fc3(x)))
        x = F.relu(self.fc4(x))
        x = F.relu(self.fc5(x))
        x = F.relu(self.fc6(x))
        x = F.relu(self.fc7(x))
        x = self.fc8(x)
        return F.log_softmax(x, dim=1)


net = Net()

import torch.optim as optim

loss_function = nn.CrossEntropyLoss()
net.to(torch.device('cuda:0'))
for epoch in range(3): # 3 full passes over the data
    optimizer = optim.Adam(net.parameters(), lr=0.001)
    for data in tqdm(train_loader):  # `data` is a batch of data
        X = data['image'].to(device)  # X is the batch of features
        y = data['landmarks'].to(device) # y is the batch of targets.
        optimizer.zero_grad()  # sets gradients to 0 before loss calc. You will do this likely every step.
        output = net(X.view(-1,CROP_SIZE*CROP_SIZE*3))  # pass in the reshaped batch
#         print(np.argmax(output))
#         print(y)
        loss = F.nll_loss(output, y)  # calc and grab the loss value
        loss.backward()  # apply this loss backwards thru the network's parameters
        optimizer.step()  # attempt to optimize weights to account for loss/gradients

    print(loss)  # print loss. We hope loss (a measure of wrong-ness) declines!

错误跟踪

    ---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-42-f5ed7999ce57> in <module>
      5         y = data['landmarks'].to(device) # y is the batch of targets.
      6         optimizer.zero_grad()  # sets gradients to 0 before loss calc. You will do this likely every step.
----> 7         output = net(X.view(-1,CROP_SIZE*CROP_SIZE*3))  # pass in the reshaped batch
      8 #         print(np.argmax(output))
      9 #         print(y)

/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)
    548             result = self._slow_forward(*input, **kwargs)
    549         else:
--> 550             result = self.forward(*input, **kwargs)
    551         for hook in self._forward_hooks.values():
    552             hook_result = hook(self, input, result)

<ipython-input-37-6d3e34d425a0> in forward(self, x)
     16 
     17     def forward(self, x):
---> 18         x = F.relu(self.conv1d1(self.fc1(x)))
     19         x = F.relu(self.conv1d2(self.fc2(x)))
     20         x = F.relu(self.conv1d3(self.fc3(x)))

/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)
    548             result = self._slow_forward(*input, **kwargs)
    549         else:
--> 550             result = self.forward(*input, **kwargs)
    551         for hook in self._forward_hooks.values():
    552             hook_result = hook(self, input, result)

/opt/conda/lib/python3.7/site-packages/torch/nn/modules/conv.py in forward(self, input)
    210                             _single(0), self.dilation, self.groups)
    211         return F.conv1d(input, self.weight, self.bias, self.stride,
--> 212                         self.padding, self.dilation, self.groups)
    213 
    214 

RuntimeError: Expected 3-dimensional input for 3-dimensional weight [64, 512, 1], but got 2-dimensional input of size [4, 512] instead

---------------------------------------------------------------------------
运行时错误回溯（上次最近调用）
在里面
5 y=数据['landmarks']。to（设备）#y是一批目标。
6 optimizer.zero_grad（）#在损失计算之前将梯度设置为0。您可能会在每一步都这样做。
---->7输出=净（X.view（-1，裁剪尺寸*裁剪尺寸*3））#通过重塑批次
8#打印（np.argmax（输出））
9#打印（y）
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/modules.py in____________（self，*input，**kwargs）
548结果=self.\u slow\u forward（*输入，**kwargs）
549其他：
-->550结果=自转发（*输入，**kwargs）
551用于钩住自身。\u向前\u钩住.values（）：
552钩子结果=钩子（自身、输入、结果）
前进中（自我，x）
16
17 def前进档（自身，x）：
--->18 x=F.relu（self.conv1d1（self.fc1（x）））
19 x=F.relu（self.conv1d2（self.fc2（x）））
20 x=F.relu（self.conv1d3（self.fc3（x）））
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/modules.py in____________（self，*input，**kwargs）
548结果=self.\u slow\u forward（*输入，**kwargs）
549其他：
-->550结果=自转发（*输入，**kwargs）
551用于钩住自身。\u向前\u钩住.values（）：
552钩子结果=钩子（自身、输入、结果）
/前进中的opt/conda/lib/python3.7/site-packages/torch/nn/modules/conv.py（自我，输入）
210_单个（0），自膨胀，自组）
211返回F.conv1d（输入、自身重量、自身偏差、自身步幅、，
-->212自填充、自膨胀、自组）
213
214
RuntimeError:三维权重[64512,1]应为三维输入，但得到的却是大小为[4512]的二维输入

您应该学习卷积是如何工作的（例如，请参见）和一些神经网络基础知识（）

基本上，

Conv1d

需要输入shape

[批次、频道、功能]

（其中

功能可以是一些时间步，并且可以变化，请参见示例）
nn.Linear
需要形状[批次，特征]
，因为它是完全连接的，并且每个输入特征都连接到每个输出特征
对于torch.nn.Linear
，您可以自己验证这些形状：
import torch

layer = torch.nn.Linear(20, 10)
data = torch.randn(64, 20)  # [batch, in_features]
layer(data).shape  # [64, 10], [batch, out_features]

对于Conv1d
：
layer = torch.nn.Conv1d(in_channels=20, out_channels=10, kernel_size=3, padding=1)
data = torch.randn(64, 20, 15)  # [batch, channels, timesteps]
layer(data).shape  # [64, 10, 15], [batch, out_features]

layer(torch.randn(32, 20, 25)).shape  # [32, 10, 25]

顺便说一句。在处理图像时，您应该使用torch.nn.Conv
2d
。
大多数Pytorch函数处理批数据，即它们接受大小（批大小、形状）
@Szymon Maszke已经发布了与此相关的答案
因此，在您的情况下，可以使用unqueze和sqeeze函数来添加和删除额外维度
以下是示例代码：
import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(100, 512)
        self.conv1d1 = nn.Conv1d(in_channels=512, out_channels=64, kernel_size=1, stride=2)
        self.fc2 = nn.Linear(64, 128)

    def forward(self, x):
        x = self.fc1(x)
        x = x.unsqueeze(dim=2)
        x = F.relu(self.conv1d1(x))
        x = x.squeeze()

        x = self.fc2(x)

        return x


net = Net()

bsize = 4
inp   = torch.randn((bsize, 100))

out = net(inp)
print(out.shape)