text: import torch
  import torchvision
  import torch.nn as nn
  import torch.nn.functional as F
  
  from ..registry import LOSSES
  
  
  class Vgg19(nn.Module):
      def __init__(self, requires_grad=False):
          super(Vgg19, self).__init__()
          vgg_pretrained_features = torchvision.models.vgg19(pretrained=True).features
          self.slice1 = nn.Sequential()
          self.slice2 = nn.Sequential()
          self.slice3 = nn.Sequential()
          self.slice4 = nn.Sequential()
          self.slice5 = nn.Sequential()
          for x in range(2):
              self.slice1.add_module(str(x), vgg_pretrained_features[x])
          for x in range(2, 7):
              self.slice2.add_module(str(x), vgg_pretrained_features[x])
          for x in range(7, 12):
              self.slice3.add_module(str(x), vgg_pretrained_features[x])
          for x in range(12, 21):
              self.slice4.add_module(str(x), vgg_pretrained_features[x])
          for x in range(21, 30):
              self.slice5.add_module(str(x), vgg_pretrained_features[x])
          if not requires_grad:
              for param in self.parameters():
                  param.requires_grad = False
  
      def forward(self, X):
          h_relu1 = self.slice1(X)
          h_relu2 = self.slice2(h_relu1)
          h_relu3 = self.slice3(h_relu2)
          h_relu4 = self.slice4(h_relu3)
          h_relu5 = self.slice5(h_relu4)
          out = [h_relu1, h_relu2, h_relu3, h_relu4, h_relu5]
          return out
  
  
  @LOSSES.register_module
  class VGGLoss(nn.Module):
  
      def __init__(self,
                   layerids=None):
          super(VGGLoss, self).__init__()
          self.vgg = Vgg19()
          self.vgg.cuda()
          self.criterion = nn.L1Loss()
          self.weights = [1.0 / 32, 1.0 / 16, 1.0 / 8, 1.0 / 4, 1.0]
          self.layerids = layerids
  
      def forward(self, input, target):
          input_vgg = self.vgg(input)
          target_vgg = self.vgg(target)
          if self.layerids is None:
              self.layerids = list(range(len(input_vgg)))
  
          loss = 0.
          for i in self.layerids:
              loss += self.weights[i] * self.criterion(input_vgg[i], target_vgg[i].detach())
          return loss
  