All performant pretrained models that I’m aware of require data to be normalized in some way, Inception is a different normalization than Resnet/VGG but they both require it.
If you need the normalization to be part of the model so you can feed it 0…1 float RGB images and backprop through it, etc, you can implement the normalize as a Module and wrap your model with it…
class NormalizeLe(nn.Module):
    """Normalize to -1..1 in Google Inception style
    """
    def __init__(self):
        super(NormalizeLe, self).__init__()

    def forward(self, x):
        return (x - 0.5) * 2.0


class Normalize(nn.Module):
    """Standardize in VGG/ResNet/DenseNet style
    """
    def __init__(self):
        super(Normalize, self).__init__()

        self.register_buffer('mean', torch.FloatTensor([0.485, 0.456, 0.406]).view(-1, 1, 1))
        self.register_buffer('std', torch.FloatTensor([0.229, 0.224, 0.225]).view(-1, 1, 1))

    def forward(self, x):
        return (x - autograd.Variable(self.mean)) / autograd.Variable(self.std)

class NormalizedModel(nn.Module):

    def __init__(self, model, normalizer=Normalize()):
        super(NormalizedModel, self).__init__()
        self.model = model
        self.normalizer = normalizer

    def forward(self, x):
        x_norm = self.normalizer(x)
        return self.model(x_norm)