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 &quot;/usr/local/lib/python3.9/site-packages/torch/nn/modules/conv.py&quot;, 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 = &quot;models/model.pt&quot;
model = Classifier()
model.load_state_dict(torch.load(PATH))

model.eval()

cry_file_path = &quot;processed_np/car_file.npz&quot;
car_tensor = get_file_as_tensor(car_file_path)

no_car_file_path = &quot;raw_negative_processed/nocar-1041.npz&quot;
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(&quot;car&quot;, car_prediction)
print(&quot;no car&quot;, 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

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

You should use this method definition instead of yours.
