I am currently working on pascal voc 2012 dataset. I am a bit confused regarding the Normalization of images. Do I need to normalize the ground-truth labels, if I am normalizing my input images?
For experimentation, I tried to normalize the ground-truth labels for the corresponding input images using transforms.Normalize() function. When I try to train my network I get an error:
RuntimeError                              Traceback (most recent call last)
<ipython-input-12-416ca5ee56ac> in <module>()
     10 model2 = model2.to(device)
     11 
---> 12 m1,loss_acc_dict = train_model(model=model2,criterion=criterion,optimizer=optimizer,num_epochs=175)

<ipython-input-10-1744505e89c5> in train_model(model, criterion, optimizer, scheduler, num_epochs)
     38             print(train_y)
     39             loss = criterion(outputs,train_y)
---> 40             epoch_loss += float(loss)
     41 
     42             #calculating the accuracy:

RuntimeError: cuda runtime error (59) : device-side assert triggered at /opt/conda/conda-bld/pytorch_1535491974311/work/aten/src/THC/generic/THCStorage.cpp:36

Here is my code for train helper function:
#Create a function for training a model.
def train_model(model, criterion, optimizer, scheduler=None, num_epochs=10):
#     since = time.time() #Start the timer
    
    model.train() #Put in train mode.
    
    total_acc = []
    total_loss = []
    total_iou = []
    
    for epochs in range(num_epochs):
        epoch_loss = 0.0
        epoch_acc = 0
        epoch_iou = 0
        
        print('\n')
        print("Epoch {}/{}".format(epochs,num_epochs-1))
        print('-'*10)
        iteration = 0
        total_iteration = train_images_dataloader.__len__()
        
        for batch, data in enumerate(train_images_dataloader):
            
            #Keeping count of currect iteration
            iteration += 1
            
            #loading the data on the GPU:
            train_x, train_y = data['image_x'].to(device), data['image_y'].to(device)
            
            #zero the parameter gradients:
            optimizer.zero_grad()
            
            #forward pass:
            outputs = model(train_x)
            
            #compute loss:
            train_y = train_y.squeeze().long()
            print(train_y)
            loss = criterion(outputs,train_y)
            epoch_loss += loss
            
            #calculating the accuracy:
            _, predicted_indices = torch.max(outputs,1)
            total = train_y.size(0)*train_y.size(1)*train_y.size(2)
            correct = (predicted_indices == train_y).sum().item()
            acc = (correct/total)
            epoch_acc += float(acc)
            
            m_iou = compute_iou(predicted_indices,train_y)
            epoch_iou +=m_iou
            print('Iteration = {}/{} Loss = {} Accuracy = {}, IOU = {}'.format(iteration,total_iteration,loss.item(),acc,m_iou),end="\r")
            
            #back-propogate:
            loss.backward()
            
            #update the weights:
            optimizer.step()
            
            #Memory management:
            del outputs,train_x,train_y
            
        writer.add_scalar('Train/Loss',epoch_loss/total_iteration,global_step=epochs)
        writer.add_scalar('Train/Accuracy',(epoch_acc/total_iteration)*100,global_step=epochs)
        writer.add_scalar('Train/Mean IOU',(epoch_iou/total_iteration),global_step=epochs)
        total_acc.append(epoch_acc/total_iteration)
        total_loss.append(epoch_loss/total_iteration)
        total_iou.append(epoch_iou/total_iteration)
        
    print('\n')
    print('Total accuracy = ',sum(total_acc)/num_epochs)
    print('Total Loss = ',sum(total_loss)/num_epochs)
    print('Total mean IOU = ',sum(total_iou)/num_epochs)
    
    return model,{'Accuracy':total_acc,'Loss':total_loss,'mIOU':total_iou} #divide by num_opochs and then sotre in dict.

Custom dataset loader:
#Creating custom dataloader fro PASCAL VOC 2012

'''
__init__ : class variables such as, images_path, transform etc.
__len__ : would return len of the entire dataset
__getitem__ : returns ith image from the dataset
'''

class PascalVocDataset(Dataset):
    
    def __init__(self,anno_path,ip_images_path,seg_images_path,transform=None):
        '''
        anno_path = path to train.txt file for image identifers
        ip_images_path = path to input image folders
        seg_images_path = path to segmentation maps class folder
        '''
        self.anno_path = anno_path
        self.ip_images_path = ip_images_path
        self.seg_images_path = seg_images_path
        self.transform = transform
        
    def getImagesNames(self,path):
        #Returns image identifiers from file_name
        #path = .txt location
        
        images_names = []
        with open(path) as fp:
            images_names = list(map((lambda x: x[:-1]),fp.readlines()))
            fp.close()
        return images_names
    
    def __len__(self):
        return len(self.getImagesNames(self.anno_path))
    
    def __getitem__(self, idx):
        file_names = self.getImagesNames(self.anno_path)
        file_path_x = self.ip_images_path+file_names[idx]+'.jpg'
        file_path_y = self.seg_images_path+file_names[idx]+'.png'
        
        #X images:
        im = Image.open(file_path_x)
        image_x = im.convert('RGB')
        
        #Y images:
        img = Image.open(file_path_y)
#         img = img.resize((224,224),Image.ANTIALIAS)
#         image_y = torch.tensor(np.array(img),dtype=torch.long)
        
        sample = {'image_x':image_x,'image_y':img}
        
        if self.transform:
            sample['image_x'] = self.transform(sample['image_x'])
            sample['image_y'] = self.transform(sample['image_y'])

    
        return sample