Error while running CNN for grayscale image

My net:

class convNet(nn.Module):
    #constructor
    def __init__(self):
        super(convNet, self).__init__()
        #defining layers in convnet
        #input size=32x32x3
        self.conv1 = nn.Conv2d(1, 96, kernel_size=3,stride=1,padding=1)
        #conv1: 28x28x1 -> 28x28x96
        self.conv2 = nn.Conv2d(96, 256, kernel_size=3,stride=1,padding=1)
        #conv2: 28x28x96 -> 28x28x256
        self.conv3 = nn.Conv2d(256,384,kernel_size=3,stride=1,padding=1)
        #conv3: 28x28x256 -> 28x28x384
        #pooling: 28x28x384 -> 14x14x384
        self.conv4 = nn.Conv2d(384,512,kernel_size=3,stride=1,padding=1)
        #conv4: 14x14x384 -> 14x14x512
        #pooling: 14x14x512 -> 7x7x512        
        self.fc1   = nn.Linear(7*7*512, 300)
        self.fc2   = nn.Linear(300, 100)
        self.fc3   = nn.Linear(100, 10)
    
def forward(self, x):
    conv1_relu = nnFunctions.relu(self.conv1(x))
    conv2_relu = nnFunctions.relu(self.conv2(conv1_relu))
    conv3_relu =nnFunctions.max_pool2d(nnFunctions.relu(self.conv3(conv2_relu)),2)
    conv4_relu =nnFunctions.max_pool2d(nnFunctions.relu(self.conv4(conv3_relu)),2)

    x = conv4_relu.view(-1, 7*7*512)
    x = nnFunctions.relu(self.fc1(x))
    x = nnFunctions.relu(self.fc2(x))
    x = self.fc3(x)
    return x

I have an image of 1x28x28 and I am feeding it to the above net.

But it gives me the following error:

RuntimeError: CHECK_ARG((long)pad.size() == input->nDimension - 2) failed at torch/csrc/cudnn/Conv.cpp:258

Are you sure you are passing the image as (1, 28, 28). It accepts input as (N, C, H, W). It runs on my computer perfectly.

import torch
import torch.nn as nn
from torch.autograd import Variable
import numpy as np

class channel1(nn.Module):
	def __init__(self):
		super(channel1, self).__init__()
		self.conv1 = nn.Conv2d(1, 96, kernel_size=3, stride=1, padding=1)
		self.relu1 = nn.ReLU(inplace=True)
		self.conv2 = nn.Conv2d(96, 10, kernel_size=3, stride=1, padding=1)

	def forward(self, x):
		x = self.conv1(x)
		x = self.relu1(x)
		x = self.conv2(x)
		return x

if __name__ == '__main__':
	someNet = channel1()
	x = Variable(torch.randn(1, 1, 28, 28))
	print someNet(x)

your code runs too on my system

if __name__ == '__main__':
    net = convNet()
    x = Variable(torch.randn(10, 1, 28, 28))
    print(net(x))

@sarthak1996 we only support batch mode. If you want to process a single image you have to unsqueeze an additional dimension at the front, to simulate a batch of 1 image.

This is my complete code:

np_data.shape                ->(42000, 784)
np_data=np_data.astype(np.float32).reshape(42000,28,28,1)
np_labels.shape              ->(42000, 1)
np_data.shape                ->(42000, 28, 28, 1)
np_data=np.transpose(np_data,[0,3,1,2])
np_data.shape                 ->(42000, 1, 28, 28)

batch_size=50
features=torch.from_numpy(np_data)
features=features.contiguous().view(42000,-1)
targets=torch.from_numpy(np_labels)

import torch.utils.data as data_utils

train = data_utils.TensorDataset(features, targets)
train_loader = data_utils.DataLoader(train, batch_size=batch_size, shuffle=True)

criterion = nn.CrossEntropyLoss() # use a Classification Cross-Entropy loss
import torch.optim as optim

def trainConvNet(train_loader,net,criterion,epochs,total_samples,learning_rate):
    prev_loss=0
    
    optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9)
    for epoch in range(int(epochs)): # loop over the dataset multiple times

        running_loss = 0.0
        for i,data in enumerate(train_loader):

            inputs,labels=data
            # wrap them in Variable
            inputs, labels = Variable(inputs).cuda(), Variable(labels).cuda()
            
            # zero the parameter gradients
            optimizer.zero_grad()

            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels[:,0])
            loss.backward()        
            optimizer.step()
            # print statistics
            running_loss += loss.data[0]
    print('Finished Training')
    return net


class convNet(nn.Module):
    #constructor
    def __init__(self):
        super(convNet, self).__init__()
        #defining layers in convnet
        #input size=32x32x3
        self.conv1 = nn.Conv2d(1, 96, kernel_size=3,stride=1,padding=1)
        #conv1: 28x28x1 -> 28x28x96
        self.conv2 = nn.Conv2d(96, 256, kernel_size=3,stride=1,padding=1)
        #conv2: 28x28x96 -> 28x28x256
        self.conv3 = nn.Conv2d(256,384,kernel_size=3,stride=1,padding=1)
        #conv3: 28x28x256 -> 28x28x384
        #pooling: 28x28x384 -> 14x14x384
        self.conv4 = nn.Conv2d(384,512,kernel_size=3,stride=1,padding=1)
        #conv4: 14x14x384 -> 14x14x512
        #pooling: 14x14x512 -> 7x7x512        
        self.fc1   = nn.Linear(7*7*512, 300)
        self.fc2   = nn.Linear(300, 100)
        self.fc3   = nn.Linear(100, 10)
        
    def forward(self, x):
        x = nnFunctions.relu(self.conv1(x))
        x = nnFunctions.relu(self.conv2(x))
        x = nnFunctions.max_pool2d(nnFunctions.relu(self.conv3(x)),2)
        x = nnFunctions.max_pool2d(nnFunctions.relu(self.conv4(x)),2)
    
        x = x.view(-1, 7*7*512)
        x = nnFunctions.relu(self.fc1(x))
        x = nnFunctions.relu(self.fc2(x))
        x = self.fc3(x)
        return x
net=convNet()
net.cuda()
net=trainConvNet(train_loader,net,criterion,1,42000,0.01)

I dont understand why am I getting the above error.

Add print(inputs.size()) before net(inputs). You’ve flattened the dataset to be 42000x784 so your batches will be of size 50x784. Remove .view(42000, -1) call on the features.

1 Like

Removing .view helped thanks a lot