@albanD @ptrblck and @fadetoblack
I have the following updated code:
How should I fix it now?
network = Network()
network.cuda()    

criterion = nn.MSELoss()
optimizer = optim.Adam(network.parameters(), lr=0.0001)

loss_min = np.inf
num_epochs = 1

start_time = time.time()
for epoch in range(1,num_epochs+1):
    
    loss_train = 0
    loss_test = 0
    running_loss = 0
    
    
    network.train()
    print('size of train loader is: ', len(train_loader))

    for step in range(1,len(train_loader)+1):

        
        batch = next(iter(train_loader))
        images, landmarks = batch['image'], batch['landmarks']
        #RuntimeError: Given groups=1, weight of size [64, 3, 7, 7], expected input[64, 600, 800, 3] to have 3 channels, but got 600 channels instead
        #using permute below to fix the above error
        images = images.permute(0,3,1,2)
        
        images = images.cuda()
    
        landmarks = landmarks.view(landmarks.size(0),-1).cuda() 
    
        norm_image = transforms.Normalize([0.3809, 0.3810, 0.3810], [0.1127, 0.1129, 0.1130]) 
        for image in images:
            image = image.float()
            ##image = to_tensor(image) #TypeError: pic should be PIL Image or ndarray. Got <class 'torch.Tensor'>
            image = norm_image(image)
        
        ###removing landmarks normalize because of the following error
        ###ValueError: Expected tensor to be a tensor image of size (C, H, W). Got tensor.size() = torch.Size([8, 8])
        ###norm_landmarks = transforms.Normalize(0.4949, 0.2165)
        ###landmarks = norm_landmarks(landmarks)
         
        #743 is max value in raw landmarks values
        landmarks = torch.div(landmarks, 743.)
        
        predictions = network(images)
        
        # clear all the gradients before calculating them
        optimizer.zero_grad()
        
        print('predictions are: ', predictions.float())
        print('landmarks are: ', landmarks.float())
        # find the loss for the current step
        loss_train_step = criterion(predictions.float(), landmarks.float())
        
        
        loss_train_step = loss_train_step.to(torch.float32)
        print("loss_train_step before backward: ", loss_train_step)
        
        # calculate the gradients
        loss_train_step.backward()
        
        # update the parameters
        optimizer.step()
        
        print("loss_train_step after backward: ", loss_train_step)

        
        loss_train += loss_train_step.item()
        
        print("loss_train: ", loss_train)
        running_loss = loss_train/step
        print('step: ', step)
        print('running loss: ', running_loss)
        
        print_overwrite(step, len(train_loader), running_loss, 'train')
        
    network.eval() 
    with torch.no_grad():
        
        for step in range(1,len(test_loader)+1):
            
            batch = next(iter(train_loader))
            images, landmarks = batch['image'], batch['landmarks']
            images = images.permute(0,3,1,2)
            images = images.cuda()
            landmarks = landmarks.view(landmarks.size(0),-1).cuda()
        
            predictions = network(images)

            # find the loss for the current step
            loss_test_step = criterion(predictions, landmarks)

            loss_test += loss_test_step.item()
            running_loss = loss_test/step

            print_overwrite(step, len(test_loader), running_loss, 'Validation')
    
    loss_train /= len(train_loader)
    loss_test /= len(test_loader)
    
    print('\n--------------------------------------------------')
    print('Epoch: {}  Train Loss: {:.4f} Valid Loss: {:.4f}'.format(epoch, loss_train, loss_test))
    print('--------------------------------------------------')
    
    if loss_test < loss_min:
        loss_min = loss_test
        torch.save(network.state_dict(), '../moth_landmarks.pth') 
        print("\nMinimum Valid Loss of {:.4f} at epoch {}/{}".format(loss_min, epoch, num_epochs))
        print('Model Saved\n')
     
print('Training Complete')
print("Total Elapsed Time : {} s".format(time.time()-start_time))

and I get the following result for one epoch:
size of train loader is:  90
predictions are:  tensor([[-0.1240, -0.1808, -0.2515, -0.1952, -0.2210, -0.0983, -0.2281,  0.0049],
        [-0.1408, -0.2126, -0.2820, -0.2684, -0.1838, -0.1007, -0.2736, -0.0101],
        [-0.1157, -0.2006, -0.2649, -0.2322, -0.2235, -0.1550, -0.2466,  0.0029],
        [-0.1365, -0.2064, -0.2617, -0.2820, -0.2069, -0.0940, -0.2331, -0.0061],
        [-0.0789, -0.2084, -0.2746, -0.2532, -0.2057, -0.0729, -0.2304,  0.0059],
        [-0.1729, -0.2225, -0.2642, -0.2592, -0.1818, -0.1400, -0.2861, -0.0068],
        [-0.1711, -0.2341, -0.2459, -0.2593, -0.2033, -0.0645, -0.2249, -0.0179],
        [-0.1397, -0.2168, -0.2554, -0.2688, -0.1928, -0.0323, -0.2625,  0.0265]],
       device='cuda:0', grad_fn=<AddmmBackward>)
landmarks are:  tensor([[0.6597, 0.3325, 0.9314, 0.4105, 0.4401, 0.4334, 0.5707, 0.4406],
        [0.6662, 0.3314, 0.7672, 0.1670, 0.4253, 0.2032, 0.6366, 0.4590],
        [0.6693, 0.3365, 0.9246, 0.4509, 0.4280, 0.4172, 0.6218, 0.4576],
        [0.6617, 0.3236, 0.9421, 0.4347, 0.4280, 0.3755, 0.5989, 0.4468],
        [0.6549, 0.3249, 0.9408, 0.3244, 0.3970, 0.3190, 0.5713, 0.4147],
        [0.6649, 0.3304, 0.8466, 0.2261, 0.3917, 0.2894, 0.6662, 0.4388],
        [0.6677, 0.3244, 0.9551, 0.3732, 0.3786, 0.3775, 0.6460, 0.4124],
        [0.6725, 0.3332, 0.9529, 0.3903, 0.4522, 0.4320, 0.6581, 0.4240]],
       device='cuda:0')
loss_train_step before backward:  tensor(0.5270, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train_step after backward:  tensor(0.5270, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train:  0.5269910097122192
step:  1
running loss:  0.5269910097122192
Train Steps: 1/90  Loss: 0.5270 predictions are:  tensor([[ 0.0726, -0.0202,  0.0980, -0.0746,  0.0344,  0.0454, -0.0194,  0.1157],
        [ 0.0655, -0.0531,  0.0659, -0.1021,  0.0001,  0.0213, -0.0158,  0.1084],
        [ 0.0638, -0.0443,  0.0428, -0.1006, -0.0364,  0.0365, -0.0607,  0.1060],
        [ 0.0188, -0.0712,  0.0311, -0.1251, -0.0448,  0.0120, -0.0597,  0.0611],
        [ 0.1286, -0.0592,  0.0563, -0.0872,  0.0017,  0.0563, -0.0240,  0.1095],
        [ 0.0882, -0.1077,  0.0509, -0.1139,  0.0134,  0.0415, -0.0563,  0.1066],
        [ 0.0850, -0.0224,  0.0958, -0.0640,  0.0305,  0.0387, -0.0557,  0.1140],
        [ 0.1260, -0.0629,  0.0767, -0.0713,  0.0251,  0.0520, -0.0157,  0.0794]],
       device='cuda:0', grad_fn=<AddmmBackward>)
landmarks are:  tensor([[0.6599, 0.3325, 0.9300, 0.4307, 0.4980, 0.4253, 0.5592, 0.4422],
        [0.6730, 0.3241, 0.9179, 0.4374, 0.4347, 0.4132, 0.6810, 0.4051],
        [   nan,    nan, 0.7744, 0.1895, 0.4347, 0.1655, 0.5532, 0.4563],
        [0.6756, 0.3249, 0.8314, 0.1680, 0.4729, 0.1804, 0.6929, 0.4272],
        [0.6549, 0.3249, 0.9408, 0.3244, 0.3970, 0.3190, 0.5713, 0.4147],
        [0.6748, 0.3306, 0.9381, 0.2490, 0.4738, 0.1830, 0.6729, 0.4199],
        [0.6570, 0.3229, 0.9421, 0.4145, 0.4118, 0.3836, 0.6070, 0.4105],
        [0.6572, 0.3253, 0.9408, 0.3957, 0.4401, 0.3661, 0.5459, 0.4449]],
       device='cuda:0')
loss_train_step before backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train_step after backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train:  nan
step:  2
running loss:  nan
Train Steps: 2/90  Loss: nan predictions are:  tensor([[nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan]], device='cuda:0',
       grad_fn=<AddmmBackward>)
landmarks are:  tensor([[0.6678, 0.3282, 0.8484, 0.1760, 0.4917, 0.1393, 0.6411, 0.4424],
        [0.6597, 0.3325, 0.9314, 0.4105, 0.4401, 0.4334, 0.5707, 0.4406],
        [0.6652, 0.3240, 0.9583, 0.3630, 0.4190, 0.4536, 0.6431, 0.3940],
        [0.6718, 0.3371, 0.9071, 0.4630, 0.5195, 0.3634, 0.6057, 0.4791],
        [0.6675, 0.3225, 0.9173, 0.3975, 0.4266, 0.3809, 0.6474, 0.4388],
        [0.6822, 0.3355, 0.9583, 0.2234, 0.5370, 0.2315, 0.7991, 0.4474],
        [0.6614, 0.3215, 0.9314, 0.3943, 0.4213, 0.3486, 0.5723, 0.4321],
        [0.6597, 0.3283, 0.9206, 0.4495, 0.5020, 0.4152, 0.5459, 0.4370]],
       device='cuda:0')
loss_train_step before backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train_step after backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train:  nan
step:  3
running loss:  nan
Train Steps: 3/90  Loss: nan predictions are:  tensor([[nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan],
        [nan, nan, nan, nan, nan, nan, nan, nan]], device='cuda:0',
       grad_fn=<AddmmBackward>)
landmarks are:  tensor([[0.6702, 0.3308, 0.8008, 0.1830, 0.4145, 0.2301, 0.6447, 0.4240],
        [0.6672, 0.3303, 0.8425, 0.2019, 0.4522, 0.2005, 0.6447, 0.4576],
        [0.6579, 0.3217, 0.9421, 0.3984, 0.4980, 0.3997, 0.6006, 0.4583],
        [0.6600, 0.3281, 0.9408, 0.4240, 0.4643, 0.3822, 0.5632, 0.4743],
        [0.6595, 0.3238, 0.9314, 0.3688, 0.3943, 0.3149, 0.6030, 0.4495],
        [0.6730, 0.3224, 0.9838, 0.3499, 0.4051, 0.4213, 0.7531, 0.4296],
        [0.6756, 0.3233, 0.9798, 0.3055, 0.4724, 0.2530, 0.7599, 0.4315],
        [0.6507, 0.3248, 0.7416, 0.1602, 0.4065, 0.2005, 0.5900, 0.4147]],
       device='cuda:0')
loss_train_step before backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train_step after backward:  tensor(nan, device='cuda:0', grad_fn=<MseLossBackward>)
loss_train:  nan


I am only showing 4 steps here.