Hi there I’m trying to implement the pre-trained VGG net to my script, in order to recognize faces from my dataset in RGB [256,256], but I’m getting a  “size mismatch, m1: [1 x 2622], m2: [4096 x 2]” even if im resizing my images, as you can see my code work with resnet and alexnet.
import argparse
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
import scipy.misc
import imageio
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torchvision.datasets
import matplotlib.pyplot as plt
import numpy as np
import VGG_FACE


num_epochs = 20
num_classes = 2
batch_size = 4

DATA_PATH1 = '/Users/danieleligato/Documents/FILE/Università/tesi/dataset/Train'
trans = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = torchvision.datasets.ImageFolder(root=DATA_PATH1, transform=trans)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
classes = ('coperte', 'scoperte')
dataiter = iter(train_loader)
# DATAITER SARà TI TIPO ITERATORE CON DENTRO I VALORI DI TRAINLOADER

def imshow(img):
    img = img / 2 + 0.5
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))

def training(model_conv, learning_rate, wd, net):

    criterion = nn.CrossEntropyLoss(weight= torch.FloatTensor([1,1]))
    optimizer = torch.optim.Adam(model_conv.fc.parameters(), lr=learning_rate, weight_decay = wd)
    total_step = len(train_loader)
    loss_list = []
    acc_list = []
    print("Inizio il training")

    for epoch in range(num_epochs):
        for i, (im, labels) in enumerate(train_loader):  #il TRAIN_LOADER ha dentro le immagini e le labels

            if net == "vgg":
                images = torch.nn.functional.interpolate(im, 224, mode='bilinear')

            if  net != "vgg":
                images = torch.nn.functional.interpolate(im, 224, mode = 'bilinear')

            outputs = model_conv(images)
            loss = criterion(outputs, labels)
            loss_list.append(loss.item())
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            if (i + 1) % 100 == 0:
                print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                      .format(epoch + 1, num_epochs, i + 1, total_step, loss.item()))
    torch.save(model_conv, 'TrainedModel.pt')
    return images, labels

def main():

    net = "vgg"
    learning_rate = 10e-6
    wd = 10e-4

    if net == "vgg":
        print("Hai selezionato VGG")
        model_conv = VGG_FACE.vgg_face
        data = torch.load("VGG_FACE.pth")
        model_conv.load_state_dict(data) #carico i parametri nella mia rete

        # Modifica per classificazione:
        model_conv.fc = nn.Linear(4096, 2)
        model_conv[-1] = model_conv.fc


    if net == "resnet18":
        print("Hai selezionato ResNet18")
        model_conv = torchvision.models.resnet18(pretrained=True)
        for param in model_conv.parameters():
            param.requires_grad = False  #in_feature is the number of inputs for your linear layer:
        num_ftrs = model_conv.fc.in_features  #fc è il nome del layer che andremo a sostituire #512
        model_conv.fc = nn.Linear(num_ftrs, 2) #viene sostuito con un nn.linear

    if net == "resnet50":
        print("Hai selezionato ResNet50")
        model_conv = torchvision.models.resnet50(pretrained=True)
        for param in model_conv.parameters():
            param.requires_grad = False
        num_ftrs = model_conv.fc.in_features  # fc è il nome del layer che andremo a sostituire #512
        model_conv.fc = nn.Linear(num_ftrs, 2)  # viene sostuito con un nn.linear

    if net == "alexnet":
        print("Hai selezionato AlexNet")
        model_conv = torchvision.models.alexnet(pretrained=True)
        for param in model_conv.parameters():
            param.requires_grad = False
        model_conv.fc = nn.Linear(4096, 2)
        model_conv.classifier[-1] = model_conv.fc

    training(model_conv, learning_rate, wd, net)

if __name__ == '__main__':
    main()

And this is another code where I used correctly my VGG with some random images
import VGG_FACE
import torch
import numpy as np
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
import scipy.misc
import sys

def test():
    N=5
    net = VGG_FACE.vgg_face
    data = torch.load("VGG_FACE.pth")
    net.load_state_dict(data)
    net.eval()
    names = open("names.txt").read().split()

    with torch.no_grad():

        mean = np.array([93.5940, 104.7624, 129.1863])
        images = scipy.misc.imread("cooper2.jpg", mode="RGB")
        images = scipy.misc.imresize(images, [224, 224])
        images = images.astype(np.float32)
        images -= mean[np.newaxis, np.newaxis, :]
        images = np.transpose(images, (2, 0, 1))
        images = images[np.newaxis, ...]
        images = torch.tensor(images, dtype=torch.float32)


        y = net(images)
        y = torch.nn.functional.softmax(y, 1)
        rank = torch.topk(y[0, :], N)
        for i in range(N):
            index = rank[1][i].item()
            score = rank[0][i].item()
            print("{}) {} ({:.2f})".format(i + 1, names[index], score))
        print()

    # Modifica per classificazione:
    numero_classi = 2
    net[-1] = torch.nn.Linear(4096, numero_classi)


if __name__ == "__main__":
    test()


This is the VGG
from functools import reduce

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

class LambdaBase(nn.Sequential):
    def __init__(self, fn, *args):
        super(LambdaBase, self).__init__(*args)
        self.lambda_func = fn

    def forward_prepare(self, input):
        output = []
        for module in self._modules.values():
            output.append(module(input))
        return output if output else input

class Lambda(LambdaBase):
    def forward(self, input):
        return self.lambda_func(self.forward_prepare(input))

class LambdaMap(LambdaBase):
    def forward(self, input):
        return map(self.lambda_func,self.forward_prepare(input))

class LambdaReduce(LambdaBase):
    def forward(self, input):
        return reduce(self.lambda_func,self.forward_prepare(input))


vgg_face = nn.Sequential( # Sequential,
	nn.Conv2d(3,64,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(64,64,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.MaxPool2d((2, 2),(2, 2),(0, 0),ceil_mode=True),
	nn.Conv2d(64,128,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(128,128,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.MaxPool2d((2, 2),(2, 2),(0, 0),ceil_mode=True),
	nn.Conv2d(128,256,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(256,256,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(256,256,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.MaxPool2d((2, 2),(2, 2),(0, 0),ceil_mode=True),
	nn.Conv2d(256,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(512,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(512,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.MaxPool2d((2, 2),(2, 2),(0, 0),ceil_mode=True),
	nn.Conv2d(512,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(512,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.Conv2d(512,512,(3, 3),(1, 1),(1, 1)),
	nn.ReLU(),
	nn.MaxPool2d((2, 2),(2, 2),(0, 0),ceil_mode=True),
	Lambda(lambda x: x.view(x.size(0),-1)), # View,
	nn.Sequential(Lambda(lambda x: x.view(1,-1) if 1==len(x.size()) else x ),nn.Linear(25088,4096)), # Linear,
	nn.ReLU(),
	nn.Dropout(0.5),
	nn.Sequential(Lambda(lambda x: x.view(1,-1) if 1==len(x.size()) else x ),nn.Linear(4096,4096)), # Linear,
	nn.ReLU(),
	nn.Dropout(0.5),
	nn.Sequential(Lambda(lambda x: x.view(1,-1) if 1==len(x.size()) else x ),nn.Linear(4096,2622)), # Linear,
)

You may think that using the transformation
mean = np.array([93.5940, 104.7624, 129.1863])
        images = scipy.misc.imread("cooper2.jpg", mode="RGB")
        images = scipy.misc.imresize(images, [224, 224])
        images = images.astype(np.float32)
        images -= mean[np.newaxis, np.newaxis, :]
        images = np.transpose(images, (2, 0, 1))
        images = images[np.newaxis, ...]
        images = torch.tensor(images, dtype=torch.float32)


As my second code the script should work but it doesn’t, that gives me another error
AttributeError: ‘Tensor’ object has no attribute ‘read’