CODEWITHSUNDEEP
pythonmachine-learningpytorch
gumenimeda
gumenimeda

Reputation: 835

conv2d getting bad input

I have trained a classifier and now trying to load it and run some predictions I am getting an error that is provided below

....
    return self._conv_forward(input, self.weight, self.bias)
  File "/usr/local/lib/python3.9/site-packages/torch/nn/modules/conv.py", line 439, in _conv_forward
    return F.conv2d(input, weight, bias, self.stride,
TypeError: conv2d() received an invalid combination of arguments - got (list, Parameter, Parameter, tuple, tuple, tuple, int), but expected one of:
 * (Tensor input, Tensor weight, Tensor bias, tuple of ints stride, tuple of ints padding, tuple of ints dilation, int groups)
      didn't match because some of the arguments have invalid types: (list, Parameter, Parameter, tuple, tuple, tuple, int)
 * (Tensor input, Tensor weight, Tensor bias, tuple of ints stride, str padding, tuple of ints dilation, int groups)
      didn't match because some of the arguments have invalid types: (list, Parameter, Parameter, tuple, tuple, tuple, int)

Here is the code

import torch
import torch.nn as nn
import numpy as np
from PIL import Image
from torchvision.transforms import transforms
from torch.utils.data import DataLoader

Transformer - used to encode images

transformer = transforms.Compose([
        transforms.RandomHorizontalFlip(0.5),
        transforms.ToTensor(),
    ])

Getting a file and converting to Tensor

def get_file_as_tensor(file_path):
    with np.load(file_path) as f:
        melspec_image_array = f['arr_0']
        image = Image.fromarray(melspec_image_array, mode='RGB')
        image_tensor = transformer(image).div_(255).float()
        return image_tensor.clone().detach()

Prediction function that is on top of the stack because the error occures when I run model([tensor])

def predict(tensor, model):
    yhat = model([tensor])
    yhat = yhat.clone().detach()
    return yhat

class ConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()

        self.conv1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, 1, 1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(out_channels, out_channels, 3, 1, 1),
            nn.ReLU(),
            nn.Dropout(0.5)
        )

        self._init_weights()

    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.zeros_(m.bias)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = F.avg_pool2d(x, 2)
        return x

class Classifier(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()

        self.conv = nn.Sequential(
            ConvBlock(in_channels=3, out_channels=64),
            ConvBlock(in_channels=64, out_channels=128),
            ConvBlock(in_channels=128, out_channels=256),
            ConvBlock(in_channels=256, out_channels=512),
        )

        self.fc = nn.Sequential(
            nn.Dropout(0.4),
            nn.Linear(512, 128),
            nn.PReLU(),
            #nn.BatchNorm1d(128),
            nn.Dropout(0.2),
            nn.Linear(128, num_classes),
        )

    def forward(self, x):
        x = self.conv(x)
        x = torch.mean(x, dim=3)
        x, _ = torch.max(x, dim=2)
        x = self.fc(x)
        return x

PATH = "models/model.pt"
model = Classifier()
model.load_state_dict(torch.load(PATH))

model.eval()

cry_file_path = "processed_np/car_file.npz"
car_tensor = get_file_as_tensor(car_file_path)

no_car_file_path = "raw_negative_processed/nocar-1041.npz"
no_car_tensor = get_file_as_tensor(no_car_file_path)

car_prediction = predict(car_tensor, model)
no_cry_prediction = predict(no_car_tensor, model)

print("car", car_prediction)
print("no car", no_car_prediction)

The code is self explanatory but SO keeps asking for more text Would really appreciate some help as I am new to ML

Upvotes: 3

Views: 16878

Answers (3)

Prajot Kuvalekar
Prajot Kuvalekar

Reputation: 6618

def predict(tensor, model):
    yhat = model(tensor.unsqueeze(0))
    yhat = yhat.clone().detach()
    return yhat

You should use this method definition instead of yours.

Upvotes: 3

Faisal Shahbaz
Faisal Shahbaz

Reputation: 528

The error is about conv2d() function not module.

The only thing I can think of here is that your input data is incorrect. Make sure it is a tensor in a form of (B, C, H, W).

Upvotes: 0

Shai
Shai

Reputation: 114786

Why are you applying your model to [tensor], that is to a python list containing a single element tensor?
You should apply your model to tensor directly: model(tensor).

You might need to add a singleton "batch dimension" to tensor. See this answer for more details.

Upvotes: 1

Related Questions