code: def get_style_model_and_losses(
      cnn,
      normalization_mean,
      normalization_std,
      style_img,
      content_img,
      content_layers=content_layers_default,
      style_layers=style_layers_default,
  ):
      cnn = copy.deepcopy(cnn)
  
      # normalization module
      normalization = Normalization(
          normalization_mean, normalization_std
      ).to(device)
  
      # just in order to have an iterable access to or list of content/syle
      # losses
      content_losses = []
      style_losses = []
  
      # assuming that cnn is a nn.Sequential, so we make a new nn.Sequential
      # to put in modules that are supposed to be activated sequentially
      model = nn.Sequential(normalization)
  
      i = 0  # increment every time we see a conv
      for layer in cnn.children():
          if isinstance(layer, nn.Conv2d):
              i += 1
              name = "conv_{}".format(i)
          elif isinstance(layer, nn.ReLU):
              name = "relu_{}".format(i)
              # The in-place version doesn't play very nicely with the ContentLoss
              # and StyleLoss we insert below. So we replace with out-of-place
              # ones here.
              layer = nn.ReLU(inplace=False)
          elif isinstance(layer, nn.MaxPool2d):
              name = "pool_{}".format(i)
          elif isinstance(layer, nn.BatchNorm2d):
              name = "bn_{}".format(i)
          else:
              raise RuntimeError(
                  "Unrecognized layer: {}".format(
                      layer.__class__.__name__
                  )
              )
  
          model.add_module(name, layer)
  
          if name in content_layers:
              # add content loss:
              target = model(content_img).detach()
              content_loss = ContentLoss(target)
              model.add_module(
                  "content_loss_{}".format(i), content_loss
              )
              content_losses.append(content_loss)
  
          if name in style_layers:
              # add style loss:
              target_feature = model(style_img).detach()
              style_loss = StyleLoss(target_feature)
              model.add_module("style_loss_{}".format(i), style_loss)
              style_losses.append(style_loss)
  
      # now we trim off the layers after the last content and style losses
      for i in range(len(model) - 1, -1, -1):
          if isinstance(model[i], ContentLoss) or isinstance(
              model[i], StyleLoss
          ):
              break
  
      model = model[: (i + 1)]
  
      return model, style_losses, content_losses
  
imports: from __future__ import print_function
  import os
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from PIL import Image
  import matplotlib.pyplot
  import torchvision.transforms
  import torchvision.models
  import copy
  from clearml import Task
label_desc: Use image node_id 4 for calling a global function with example usage: get_style_model_and_losses(cnn, normalization_mean, normalization_std, style_img, content_img, content_layers, style_layers) and returns: model,  style_losses,  content_losses