code: def main(unused_argv=None):
      tf.logging.set_verbosity(tf.logging.INFO)
      if not tf.gfile.Exists(FLAGS.output_dir):
          tf.gfile.MkDir(FLAGS.output_dir)
  
      with tf.Graph().as_default(), tf.Session() as sess:
          # Defines place holder for the style image.
          style_img_ph = tf.placeholder(
              tf.float32, shape=[None, None, 3]
          )
          if FLAGS.style_square_crop:
              style_img_preprocessed = (
                  image_utils.center_crop_resize_image(
                      style_img_ph, FLAGS.style_image_size
                  )
              )
          else:
              style_img_preprocessed = image_utils.resize_image(
                  style_img_ph, FLAGS.style_image_size
              )
  
          # Defines place holder for the content image.
          content_img_ph = tf.placeholder(
              tf.float32, shape=[None, None, 3]
          )
          if FLAGS.content_square_crop:
              content_img_preprocessed = (
                  image_utils.center_crop_resize_image(
                      content_img_ph, FLAGS.image_size
                  )
              )
          else:
              content_img_preprocessed = image_utils.resize_image(
                  content_img_ph, FLAGS.image_size
              )
  
          # Defines the model.
          (
              stylized_images,
              _,
              _,
              bottleneck_feat,
          ) = build_model.build_model(
              content_img_preprocessed,
              style_img_preprocessed,
              trainable=False,
              is_training=False,
              inception_end_point="Mixed_6e",
              style_prediction_bottleneck=100,
              adds_losses=False,
          )
  
          if tf.gfile.IsDirectory(FLAGS.checkpoint):
              checkpoint = tf.train.latest_checkpoint(FLAGS.checkpoint)
          else:
              checkpoint = FLAGS.checkpoint
              tf.logging.info(
                  "loading latest checkpoint file: {}".format(
                      checkpoint
                  )
              )
  
          init_fn = slim.assign_from_checkpoint_fn(
              checkpoint, slim.get_variables_to_restore()
          )
          sess.run([tf.local_variables_initializer()])
          init_fn(sess)
  
          # Gets the list of the input style images.
          style_img_list = tf.gfile.Glob(FLAGS.style_images_paths)
          if len(style_img_list) > FLAGS.maximum_styles_to_evaluate:
              np.random.seed(1234)
              style_img_list = np.random.permutation(style_img_list)
              style_img_list = style_img_list[
                  : FLAGS.maximum_styles_to_evaluate
              ]
  
          # Gets list of input content images.
          content_img_list = tf.gfile.Glob(FLAGS.content_images_paths)
  
          for content_i, content_img_path in enumerate(
              content_img_list
          ):
              content_img_np = image_utils.load_np_image_uint8(
                  content_img_path
              )[:, :, :3]
              content_img_name = os.path.basename(content_img_path)[:-4]
  
              # Saves preprocessed content image.
              inp_img_croped_resized_np = sess.run(
                  content_img_preprocessed,
                  feed_dict={content_img_ph: content_img_np},
              )
              image_utils.save_np_image(
                  inp_img_croped_resized_np,
                  os.path.join(
                      FLAGS.output_dir, "%s.jpg" % (content_img_name)
                  ),
              )
  
              # Computes bottleneck features of the style prediction network for the
              # identity transform.
              identity_params = sess.run(
                  bottleneck_feat,
                  feed_dict={style_img_ph: content_img_np},
              )
  
              for style_i, style_img_path in enumerate(style_img_list):
                  if style_i > FLAGS.maximum_styles_to_evaluate:
                      break
                  style_img_name = os.path.basename(style_img_path)[:-4]
                  style_image_np = image_utils.load_np_image_uint8(
                      style_img_path
                  )[:, :, :3]
  
                  if style_i % 10 == 0:
                      tf.logging.info(
                          "Stylizing (%d) %s with (%d) %s"
                          % (
                              content_i,
                              content_img_name,
                              style_i,
                              style_img_name,
                          )
                      )
  
                  # Saves preprocessed style image.
                  style_img_croped_resized_np = sess.run(
                      style_img_preprocessed,
                      feed_dict={style_img_ph: style_image_np},
                  )
                  image_utils.save_np_image(
                      style_img_croped_resized_np,
                      os.path.join(
                          FLAGS.output_dir, "%s.jpg" % (style_img_name)
                      ),
                  )
  
                  # Computes bottleneck features of the style prediction network for the
                  # given style image.
                  style_params = sess.run(
                      bottleneck_feat,
                      feed_dict={style_img_ph: style_image_np},
                  )
  
                  interpolation_weights = ast.literal_eval(
                      FLAGS.interpolation_weights
                  )
                  # Interpolates between the parameters of the identity transform and
                  # style parameters of the given style image.
                  for interp_i, wi in enumerate(interpolation_weights):
                      stylized_image_res = sess.run(
                          stylized_images,
                          feed_dict={
                              bottleneck_feat: identity_params
                              * (1 - wi)
                              + style_params * wi,
                              content_img_ph: content_img_np,
                          },
                      )
  
                      # Saves stylized image.
                      image_utils.save_np_image(
                          stylized_image_res,
                          os.path.join(
                              FLAGS.output_dir,
                              "%s_stylized_%s_%d.jpg"
                              % (
                                  content_img_name,
                                  style_img_name,
                                  interp_i,
                              ),
                          ),
                      )
  
file_path: magenta/magenta/models/arbitrary_image_stylization/arbitrary_image_stylization_with_weights.py
imports: import ast
  import os
  from magenta.models.arbitrary_image_stylization import arbitrary_image_stylization_build_model
  from magenta.models.image_stylization import image_utils
  import numpy
  import tensorflow.compat.v1
  import tf_slim
label_desc: Use image node_id 1 for calling a global function with example usage: main(unused_argv) without return types