Hi everyone!!
I am using this model architecture below to output a tensor with shape (1x313x64x64) where these 313 layers are probability distributions for each pixel of the image/tensor. As last layer, I am using a RELU to avoid negative values in the output.
##################################################
############## MODEL ARCHITECTURE ##############
##################################################

class Color_model(nn.Module):
    def __init__(self):
        super(Color_model, self).__init__()
        self.features = nn.Sequential(
            # conv1
            nn.Conv2d(in_channels = 1, out_channels = 64, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 64, out_channels = 64, kernel_size = 3, stride = 2, padding = 1),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 64),
            # conv2
            nn.Conv2d(in_channels = 64, out_channels = 128, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 128, out_channels = 128, kernel_size = 3, stride = 2, padding = 1),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 128),
            # conv3
            nn.Conv2d(in_channels = 128, out_channels = 256, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 2, padding = 1),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 256),
            # conv4
            nn.Conv2d(in_channels = 256, out_channels = 512, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 512),
            # conv5
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 512),
            # conv6
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 2, dilation = 2),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 512),
            # conv7
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1, dilation = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1, dilation = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1, dilation = 1),
            nn.ReLU(),
            nn.BatchNorm2d(num_features = 512),
            # conv8
            nn.ConvTranspose2d(in_channels = 512, out_channels = 256, kernel_size = 4, stride = 2, padding = 1, dilation = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1, dilation = 1),
            nn.ReLU(),
            nn.Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1, dilation = 1),
            nn.ReLU(),
            # conv8_313
            nn.Conv2d(in_channels = 256, out_channels = 313, kernel_size = 1, stride = 1,dilation = 1),
            nn.ReLU(),            
	        # decoding
            #nn.Conv2d(in_channels = 313, out_channels = 2, kernel_size = 1, stride = 1)
        )
        self.apply(weights_init)

#######################################
############## TEST CODE ##############
#######################################
import torch
from torch.autograd import Variable
from skimage.color import lab2rgb
from skimage.io import imread
from model import Color_model
#from data_loader import ValImageFolder
import numpy as np
from skimage.color import rgb2lab, rgb2gray
import torch.nn as nn 
from PIL import Image
import scipy.misc
from scipy.misc import imsave
from torchvision import datasets, transforms
from training_layers import decode
import torch.nn.functional as F
import os
import imageio


scale_transform = transforms.Compose([
    transforms.Resize((64,64),2),
    #transforms.RandomCrop(224),
])

def load_image(image_path,transform=None):
    rgb_image = Image.open(image_path)
    
    if transform is not None:
        rgb_image_resized = transform(rgb_image)

    rgb_image_resized = np.asarray(rgb_image_resized)
    lab_image_resized = rgb2lab(rgb_image_resized)
    lab_image_resized = lab_image_resized.transpose(2,0,1)    
    img_l_resized = lab_image_resized[0,:,:]
    img_l_resized = (np.round(img_l_resized)).astype(np.int) # L channel
    img_l_resized = torch.from_numpy(img_l_resized).unsqueeze(0)
    
    return img_l_resized

def main():
    data_dir = "\\Dataset\\test\\images\\"
    dirs=os.listdir(data_dir)
    print(dirs)
    color_model = Color_model().cuda().eval()
    color_model.load_state_dict(torch.load('\\models\\model-1-1.ckpt'))

    T = 0.38
    soft = nn.Softmax2d()
    Q_bins = np.load('\\code\\resources\\pts_in_hull.npy')
    #print(Q_bins.shape)
    #print(Q_bins) 
    
    for file in dirs:
    
        img_l_resized = load_image(data_dir+'\\'+file, scale_transform)       
        img_l_resized = img_l_resized.unsqueeze(0).float().cuda()
        
        img_ab_313 = color_model(img_l_resized)
                
        img_ab_313 = img_ab_313.cpu()
        
        img_ab_313_log_t = (torch.log10(img_ab_313))/T
        print(img_ab_313_log_t.max())
        
        soft_image_log_t = soft(img_ab_313_log_t)

When I get the output from the model (img_ab_313) and check min() and max() values, for the min() values there are some -inf values that I don’t understand.
I am using this formula (img_ab_313_log_t = (torch.log10(img_ab_313))/T) because this will be the input of softmax() function as described in an paper that I am trying to implement. See the formula below:

The torch.log10() don’t accept negative values because the result is nan…so I inserted the RELU in the end to avoid this…but I am getting -inf in the output…
Someone could help me with this? 
Best regards,
Matheus Santos.