hello, i get the same error Given groups=1, weight of size [8, 1, 7, 7], expected input[128, 3, 48, 48] to have 1 channels, but got 3 channels instead
here my code
from __future__ import print_function
import argparse
import pandas as pd
import numpy as np
from PIL import Image
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torch.utils.data.sampler import SubsetRandomSampler
from torchvision import transforms
import cv2
import matplotlib.pyplot as plt
from data_loaders import Plain_Dataset, eval_data_dataloader
from deep_emotion import Deep_Emotion
from generate_data import Generate_data
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
def Train(epochs,train_loader,val_loader,criterion,optmizer,device):
'''
Training Loop
'''
print("===================================Start Training===================================")
for e in range(epochs):
train_loss = 0
validation_loss = 0
train_correct = 0
val_correct = 0
# Train the model #
net.train()
for data, labels in train_loader:
data, labels = data.to(device), labels.to(device)
optmizer.zero_grad()
outputs = net(data)
loss = criterion(outputs,labels)
loss.backward()
optmizer.step()
train_loss += loss.item()
_, preds = torch.max(outputs,1)
train_correct += torch.sum(preds == labels.data)
#validate the model#
net.eval()
for data,labels in val_loader:
data, labels = data.to(device), labels.to(device)
val_outputs = net(data)
val_loss = criterion(val_outputs, labels)
validation_loss += val_loss.item()
_, val_preds = torch.max(val_outputs,1)
val_correct += torch.sum(val_preds == labels.data)
train_loss = train_loss/len(train_dataset)
train_acc = train_correct.double() / len(train_dataset)
validation_loss = validation_loss / len(validation_dataset)
val_acc = val_correct.double() / len(validation_dataset)
print('Iterasi: {} \tTraining Loss: {:.8f} \tValidation Loss {:.8f} \tAkurasi Training {:.3f}% \tAkurasi Validasi {:.3f}%'
.format(e+1, train_loss,validation_loss,train_acc * 100, val_acc*100))
torch.save(net.state_dict(),'deep_emotion-{}-{}-{}.pt'.format(epochs,batchsize,lr))
print("===================================Training Finished===================================")
epochs = 500
lr = 0.005
batchsize = 128
net = Deep_Emotion()
net.to(device)
print("Model archticture: ", net)
traincsv_file = 'dataset_final'+'/'+'train_aug.csv'
validationcsv_file = 'dataset_final'+'/'+'val_aug.csv'
train_img_dir = 'dataset_final'+'/'+'train_aug/'
validation_img_dir = 'dataset_final'+'/'+'val_aug/'
transformation= transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])
train_dataset= Plain_Dataset(csv_file=traincsv_file, img_dir = train_img_dir, datatype = 'train', transform = transformation)
validation_dataset= Plain_Dataset(csv_file=validationcsv_file, img_dir = validation_img_dir, datatype = 'val', transform = transformation)
train_loader= DataLoader(train_dataset,batch_size=batchsize,shuffle = True,num_workers=0)
val_loader= DataLoader(validation_dataset,batch_size=batchsize,shuffle = True,num_workers=0)
criterion= nn.CrossEntropyLoss()
optmizer= optim.Adam(net.parameters())
Train(epochs, train_loader, val_loader, criterion, optmizer, device)
and this for the model i code
import torch
import torch.nn as nn
import torch.nn.functional as F
class Deep_Emotion(nn.Module):
def __init__(self):
'''
Deep_Emotion class contains the network architecture.
'''
super(Deep_Emotion,self).__init__()
self.conv1 = nn.Conv2d(1,10,3)
self.conv2 = nn.Conv2d(10,10,3)
self.pool2 = nn.MaxPool2d(2,2)
self.conv3 = nn.Conv2d(10,10,3)
self.conv4 = nn.Conv2d(10,10,3)
self.pool4 = nn.MaxPool2d(2,2)
self.norm = nn.BatchNorm2d(10)
self.fc1 = nn.Linear(810,50)
self.fc2 = nn.Linear(50,7)
self.localization = nn.Sequential(
nn.Conv2d(1, 8, kernel_size=7),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True),
nn.Conv2d(8, 10, kernel_size=5),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True)
)
self.fc_loc = nn.Sequential(
nn.Linear(640, 32),
nn.ReLU(True),
nn.Linear(32, 3 * 2)
)
self.fc_loc[2].weight.data.zero_()
self.fc_loc[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))
def stn(self, x):
xs = self.localization(x)
xs = xs.view(-1, 640)
theta = self.fc_loc(xs)
theta = theta.view(-1, 2, 3)
grid = F.affine_grid(theta, x.size())
x = F.grid_sample(x, grid)
return x
def forward(self,input):
out = self.stn(input)
out = F.relu(self.conv1(out))
out = self.conv2(out)
out = F.relu(self.pool2(out))
out = F.relu(self.conv3(out))
out = self.norm(self.conv4(out))
out = F.relu(self.pool4(out))
out = F.dropout(out)
out = out.view(-1, 810)
out = F.relu(self.fc1(out))
out = self.fc2(out)
return out
any help will apreciated, sorry for my bad english