Hello everyone, when i try to run my code i got this error message :
Given groups=1, weight of size [64, 1, 3, 3], expected input[1, 19, 304, 304] to have 1 channels, but got 19 channels instead
I asked to my teacher and she said that you should write a code about permute but i couldn’t write.Can anyone help me. Here is my codes.
class CustomDataset(Dataset):
def __init__(self, image_paths, target_paths, transform, train=True): # initial logic happens like transform
#self.image_paths = image_paths
self.target_paths = target_paths
self.transforms = transforms.ToTensor()
def __getitem__(self, index):
#image = Image.open(self.image_paths[index])
mask = np.load(self.target_paths[index])
t_image = self.transforms(mask)
return t_image
def __len__(self): # return count of sample we have
return len(self.target_paths)
image_paths = glob.glob("/content/drive/My Drive/Colab Notebooks/CustomDataset/SplitTrainingDataset5_0/test/images/*npy")
target_paths = glob.glob("/content/drive/My Drive/Colab Notebooks/CustomDataset/SplitTrainingDataset5_0/test/1st_manual/*npy")
len_data = len(target_paths)
#print(target_paths)
train_size = 0.6
train_image_paths = image_paths[:int(len_data*train_size)]
train_mask_paths = target_paths[:int(len_data*train_size)]
test_mask_paths = target_paths[int(len_data*train_size):]
test_image_paths = image_paths[int(len_data*train_size):]
transform = transforms.Compose(
[transforms.Resize([100, 100,]),
transforms.ToTensor()])
transform_images = ['Numpy_AS_1.npy', 'Numpy_AS_2.npy','Numpy_AS_3.npy','Numpy_AS_4.npy',
] # apply special transformation only on these images
transform_masks = ['Numpy_AS_GT_1.npy','Numpy_AS_GT_2.npy','Numpy_AS_GT_3.npy','Numpy_AS_GT_4.npy',
]
train_dataset = CustomDataset(train_image_paths, train_mask_paths, transform=transform, train=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=0)
test_dataset = CustomDataset(test_image_paths, test_mask_paths, transform=transform, train=False)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=4, shuffle=False, num_workers=0)
The model :
class Flatten(nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
class Unflatten(nn.Module):
def __init__(self, channel, height, width):
super(Unflatten, self).__init__()
self.channel = channel
self.height = height
self.width = width
def forward(self, input):
return input.view(input.size(0), self.channel, self.height, self.width)
class ConvVAE(nn.Module):
def __init__(self, latent_size):
super(ConvVAE, self).__init__()
self.latent_size = latent_size
self.encoder = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
Flatten(),
nn.Linear(80000, 1024),
nn.ReLU()
)
# hidden => mu
self.fc1 = nn.Linear(1024, self.latent_size)
# hidden => logvar
self.fc2 = nn.Linear(1024, self.latent_size)
self.decoder = nn.Sequential(
nn.Linear(self.latent_size, 1024),
nn.ReLU(),
nn.Linear(1024,80000),
nn.ReLU(),
Unflatten(128, 25, 25),
nn.ReLU(),
nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(64, 1, kernel_size=3, stride=2, padding=1),
nn.Sigmoid()
)
def encode(self, x):
h = self.encoder(x)
mu, logvar = self.fc1(h), self.fc2(h)
return mu, logvar
def decode(self, z):
z = self.decoder(z)
return z
def reparameterize(self, mu, logvar):
if self.training:
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
return eps.mul(std).add_(mu)
else:
return mu
def forward(self, x):
mu, logvar = self.encode(x)
z = self.reparameterize(mu, logvar)
return self.decode(z), mu, logvar
and the other parts:
def loss_function(recon_x, x, mu, logvar):
# reconstruction loss
BCE = F.binary_cross_entropy(recon_x.view(-1, 784), x.view(-1, 784), reduction='sum')
# KL divergence loss
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
return BCE + KLD
def train(epoch, model, train_loader, optimizer, args):
model.train()
train_loss = 0
for batch_idx, (test) in tqdm(enumerate(train_loader), total=len(train_loader), desc='train'):
test = test.to(device)
optimizer.zero_grad()
recon_batch, mu, logvar = model(test)
loss = loss_function(recon_batch, test, mu, logvar)
train_loss += loss.item()
loss.backward()
optimizer.step()
train_loss /= len(train_loader.dataset)
return train_loss
def test(epoch, model, test_loader, writer, args):
model.eval()
test_loss = 0
with torch.no_grad():
for batch_idx, (test) in tqdm(enumerate(test_loader), total=len(test_loader), desc='test'):
test = test.to(device)
recon_batch, mu, logvar = model(test)
test_loss += loss_function(recon_batch, test, mu, logvar).item()
if batch_idx == 0:
n = min(test.size(0), 8)
comparison = torch.cat([test[:n], recon_batch.view(args.batch_size, 1, 352, 352)[:n]]).cpu()
img = make_grid(comparison)
writer.add_image('reconstruction', img, epoch)
save_image(comparison.cpu(), 'results/reconstruction_' + str(epoch) + '.png', nrow=n)
test_loss /= len(test_loader.dataset)
return test_loss
def save_checkpoint(state, is_best, outdir='results'):
checkpoint_file = os.path.join(outdir, 'checkpoint.pth')
best_file = os.path.join(outdir, 'model_best.pth')
torch.save(state,checkpoint_file )
if is_best:
shutil.copyfile(checkpoint_file, best_file)
def main():
parser = argparse.ArgumentParser(description='Convolutional VAE MNIST Example')
parser.add_argument('--result_dir', type=str, default='results', metavar='DIR',
help='output directory')
parser.add_argument('--batch_size', type=int, default=100, metavar='N',
help='input batch size for training (default: 128)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: None')
# model options
parser.add_argument('--latent_size', type=int, default=32, metavar='N',
help='latent vector size of encoder')
parser.add_argument("-f", "--fff", help="a dummy argument to fool ipython", default="1")
args = parser.parse_args()
torch.manual_seed(args.seed)
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_dataset = CustomDataset(train_image_paths, train_mask_paths, transform=transform, train=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=1, shuffle=True, num_workers=0)
test_dataset = CustomDataset(test_image_paths, test_mask_paths, transform=transform, train=False)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=0)
model = ConvVAE(args.latent_size).to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
start_epoch = 0
best_test_loss = np.finfo('f').max
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print('=> loading checkpoint %s' % args.resume)
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch'] + 1
best_test_loss = checkpoint['best_test_loss']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print('=> loaded checkpoint %s' % args.resume)
else:
print('=> no checkpoint found at %s' % args.resume)
writer = SummaryWriter()
for epoch in range(start_epoch, args.epochs):
train_loss = train(epoch, model, train_loader, optimizer, args)
test_loss = test(epoch, model, test_loader, writer, args)
# logging
writer.add_scalar('train/loss', train_loss, epoch)
writer.add_scalar('test/loss', test_loss, epoch)
print('Epoch [%d/%d] loss: %.3f val_loss: %.3f' % (epoch + 1, args.epochs, train_loss, test_loss))
is_best = test_loss < best_test_loss
best_test_loss = min(test_loss, best_test_loss)
save_checkpoint({
'epoch': epoch,
'best_test_loss': best_test_loss,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}, is_best)
with torch.no_grad():
sample = torch.randn(64, 32).to(device)
sample = model.decode(sample).cpu()
img = make_grid(sample)
writer.add_image('sampling', img, epoch)
save_image(sample.view(64, 1, 28, 28), 'results/sample_' + str(epoch) + '.png')
if __name__ == '__main__':
main()