সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

নিউরাল স্টাইল স্থানান্তর

TensorFlow.org এ দেখুন GitHub এ দেখুন নোটবুক ডাউনলোড করুন TF হাব মডেল দেখুন

এই টিউটোরিয়ালটি একটি চিত্রকে অন্য চিত্রের শৈলীতে রচনা করার জন্য গভীর শিক্ষা ব্যবহার করে (কখনও যদি আপনি পিকাসো বা ভ্যান গগের মতো আঁকতে পারেন?) এই নিউরাল শৈলী হস্তান্তর হিসাবে পরিচিত হয় এবং কৌশল রূপরেখা করা হয় আর্টিস্টিক স্টাইল একটি স্নায়ুর অ্যালগরিদম (Gatys এট অল।)।

শৈলী স্থানান্তর একটি সহজ অ্যাপ্লিকেশনের জন্যই কেবল এই খুঁজে বার করো টিউটোরিয়াল কিভাবে pretrained ব্যবহার করতে সম্পর্কে আরো জানতে নির্বিচারে ভাবমূর্তি stylization মডেল থেকে TensorFlow হাব বা কিভাবে সঙ্গে একটি শৈলী হস্তান্তর মডেল ব্যবহার করতে TensorFlow লাইট

নিউরাল শৈলী হস্তান্তর একটি অপ্টিমাইজেশান দুটো চিত্রের-একটি কন্টেন্ট ইমেজ এবং একটি শৈলী রেফারেন্স ইমেজ (যেমন একটি বিখ্যাত চিত্রশিল্পী দ্বারা একটি আর্টওয়ার্ক হিসাবে) গ্রহণ -আর তাদের একসঙ্গে মিশান যাতে বিষয়বস্তু ইমেজ মত আউটপুট ইমেজ সৌন্দর্য করার জন্য ব্যবহৃত কৌশল কিন্তু "আঁকা" শৈলী রেফারেন্স ইমেজ শৈলী মধ্যে.

বিষয়বস্তু চিত্রের বিষয়বস্তু পরিসংখ্যান এবং শৈলী রেফারেন্স চিত্রের শৈলী পরিসংখ্যানের সাথে মেলে আউটপুট চিত্রটিকে অপ্টিমাইজ করে এটি বাস্তবায়িত হয়। এই পরিসংখ্যান একটি convolutional নেটওয়ার্ক ব্যবহার করে ছবি থেকে বের করা হয়.

উদাহরণস্বরূপ, আসুন এই কুকুরটির একটি চিত্র এবং ওয়াসিলি ক্যান্ডিনস্কির রচনা 7 নেওয়া যাক:

ইয়েলো ল্যাব্রাডোর খুঁজছি উইকিমিডিয়া কমন্স থেকে দ্বারা পরী । লাইসেন্স সিসি বাই-এসএ 3.0

এখন কেমন লাগবে যদি ক্যান্ডিনস্কি এই স্টাইল দিয়ে একচেটিয়াভাবে এই কুকুরের ছবি আঁকার সিদ্ধান্ত নেন? এটার মতো কিছু?

সেটআপ

মডিউল আমদানি এবং কনফিগার করুন

import os
import tensorflow as tf
# Load compressed models from tensorflow_hub
os.environ['TFHUB_MODEL_LOAD_FORMAT'] = 'COMPRESSED'
import IPython.display as display

import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['figure.figsize'] = (12, 12)
mpl.rcParams['axes.grid'] = False

import numpy as np
import PIL.Image
import time
import functools
def tensor_to_image(tensor):
  tensor = tensor*255
  tensor = np.array(tensor, dtype=np.uint8)
  if np.ndim(tensor)>3:
    assert tensor.shape[0] == 1
    tensor = tensor[0]
  return PIL.Image.fromarray(tensor)

ইমেজ ডাউনলোড করুন এবং একটি শৈলী ইমেজ এবং একটি বিষয়বস্তু ইমেজ চয়ন করুন:

content_path = tf.keras.utils.get_file('YellowLabradorLooking_new.jpg', 'https://storage.googleapis.com/download.tensorflow.org/example_images/YellowLabradorLooking_new.jpg')
style_path = tf.keras.utils.get_file('kandinsky5.jpg','https://storage.googleapis.com/download.tensorflow.org/example_images/Vassily_Kandinsky%2C_1913_-_Composition_7.jpg')
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/Vassily_Kandinsky%2C_1913_-_Composition_7.jpg
196608/195196 [==============================] - 0s 0us/step

ইনপুট কল্পনা করুন

একটি চিত্র লোড করার জন্য একটি ফাংশন সংজ্ঞায়িত করুন এবং এর সর্বাধিক মাত্রা 512 পিক্সেলের মধ্যে সীমাবদ্ধ করুন।

def load_img(path_to_img):
  max_dim = 512
  img = tf.io.read_file(path_to_img)
  img = tf.image.decode_image(img, channels=3)
  img = tf.image.convert_image_dtype(img, tf.float32)

  shape = tf.cast(tf.shape(img)[:-1], tf.float32)
  long_dim = max(shape)
  scale = max_dim / long_dim

  new_shape = tf.cast(shape * scale, tf.int32)

  img = tf.image.resize(img, new_shape)
  img = img[tf.newaxis, :]
  return img

একটি চিত্র প্রদর্শন করার জন্য একটি সাধারণ ফাংশন তৈরি করুন:

def imshow(image, title=None):
  if len(image.shape) > 3:
    image = tf.squeeze(image, axis=0)

  plt.imshow(image)
  if title:
    plt.title(title)
content_image = load_img(content_path)
style_image = load_img(style_path)

plt.subplot(1, 2, 1)
imshow(content_image, 'Content Image')

plt.subplot(1, 2, 2)
imshow(style_image, 'Style Image')

png

TF-হাব ব্যবহার করে দ্রুত শৈলী স্থানান্তর

এই টিউটোরিয়ালটি মূল স্টাইল-ট্রান্সফার অ্যালগরিদম প্রদর্শন করে, যা একটি নির্দিষ্ট শৈলীতে ছবির বিষয়বস্তুকে অপ্টিমাইজ করে। বিস্তারিত মধ্যে চাওয়ার আগে, দেখি কিভাবে দিন TensorFlow হাব মডেল এই আছে:

import tensorflow_hub as hub
hub_model = hub.load('https://hub.tensorflow.google.cn/google/magenta/arbitrary-image-stylization-v1-256/2')
stylized_image = hub_model(tf.constant(content_image), tf.constant(style_image))[0]
tensor_to_image(stylized_image)

png

বিষয়বস্তু এবং শৈলী উপস্থাপনা সংজ্ঞায়িত করুন

মডেল মাধ্যমিক স্তর ব্যবহার ইমেজ বিষয়বস্তু এবং শৈলী উপস্থাপনা জন্য। নেটওয়ার্কের ইনপুট স্তর থেকে শুরু করে, প্রথম কয়েকটি স্তর সক্রিয়করণ প্রান্ত এবং টেক্সচারের মতো নিম্ন-স্তরের বৈশিষ্ট্যগুলিকে উপস্থাপন করে। আপনি নেটওয়ার্কের মাধ্যমে পদক্ষেপ হিসেবে চূড়ান্ত কয়েক স্তর উচ্চ স্তরের কায়দা বা চোখ মত বৈশিষ্ট্য-বস্তুর অংশের প্রতিনিধিত্ব করে। এই ক্ষেত্রে, আপনি VGG19 নেটওয়ার্ক আর্কিটেকচার ব্যবহার করছেন, একটি পূর্বপ্রশিক্ষিত চিত্র শ্রেণীবিভাগ নেটওয়ার্ক৷ এই মধ্যবর্তী স্তরগুলি চিত্রগুলি থেকে বিষয়বস্তু এবং শৈলীর উপস্থাপনা সংজ্ঞায়িত করার জন্য প্রয়োজনীয়। একটি ইনপুট চিত্রের জন্য, এই মধ্যবর্তী স্তরগুলিতে সংশ্লিষ্ট শৈলী এবং বিষয়বস্তু লক্ষ্য উপস্থাপনাগুলি মেলানোর চেষ্টা করুন৷

লোড একটি VGG19 এবং পরীক্ষা আমাদের ইমেজ তে এটি চালানোর নিশ্চিত করার এটি সঠিকভাবে ব্যবহৃত হচ্ছে:

x = tf.keras.applications.vgg19.preprocess_input(content_image*255)
x = tf.image.resize(x, (224, 224))
vgg = tf.keras.applications.VGG19(include_top=True, weights='imagenet')
prediction_probabilities = vgg(x)
prediction_probabilities.shape
Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels.h5
574717952/574710816 [==============================] - 12s 0us/step
TensorShape([1, 1000])
predicted_top_5 = tf.keras.applications.vgg19.decode_predictions(prediction_probabilities.numpy())[0]
[(class_name, prob) for (number, class_name, prob) in predicted_top_5]
[('Labrador_retriever', 0.493171),
 ('golden_retriever', 0.2366529),
 ('kuvasz', 0.036357544),
 ('Chesapeake_Bay_retriever', 0.024182785),
 ('Greater_Swiss_Mountain_dog', 0.0186461)]

এখন একটি লোড VGG19 শ্রেণীবিন্যাস মাথা ছাড়া আর লেয়ার নাম তালিকাবদ্ধ

vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')

print()
for layer in vgg.layers:
  print(layer.name)
Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5
80142336/80134624 [==============================] - 2s 0us/step

input_2
block1_conv1
block1_conv2
block1_pool
block2_conv1
block2_conv2
block2_pool
block3_conv1
block3_conv2
block3_conv3
block3_conv4
block3_pool
block4_conv1
block4_conv2
block4_conv3
block4_conv4
block4_pool
block5_conv1
block5_conv2
block5_conv3
block5_conv4
block5_pool

ছবির শৈলী এবং বিষয়বস্তু উপস্থাপন করতে নেটওয়ার্ক থেকে মধ্যবর্তী স্তর নির্বাচন করুন:

content_layers = ['block5_conv2'] 

style_layers = ['block1_conv1',
                'block2_conv1',
                'block3_conv1', 
                'block4_conv1', 
                'block5_conv1']

num_content_layers = len(content_layers)
num_style_layers = len(style_layers)

শৈলী এবং বিষয়বস্তুর জন্য মধ্যবর্তী স্তর

তাহলে কেন আমাদের পূর্বপ্রশিক্ষিত চিত্র শ্রেণীবিভাগ নেটওয়ার্কের মধ্যে এই মধ্যবর্তী আউটপুটগুলি আমাদের শৈলী এবং বিষয়বস্তু উপস্থাপনা সংজ্ঞায়িত করার অনুমতি দেয়?

একটি উচ্চ স্তরে, একটি নেটওয়ার্কের জন্য ইমেজ শ্রেণীবিভাগ (যা করার জন্য এই নেটওয়ার্ককে প্রশিক্ষিত করা হয়েছে) সঞ্চালনের জন্য, এটি অবশ্যই চিত্রটি বুঝতে হবে। এর জন্য কাঁচা ছবিকে ইনপুট পিক্সেল হিসাবে নেওয়া এবং একটি অভ্যন্তরীণ উপস্থাপনা তৈরি করতে হবে যা কাঁচা চিত্রের পিক্সেলগুলিকে চিত্রের মধ্যে উপস্থিত বৈশিষ্ট্যগুলির একটি জটিল বোঝার মধ্যে রূপান্তরিত করে।

এটিও একটি কারণ যে কনভোল্যুশনাল নিউরাল নেটওয়ার্কগুলি ভালভাবে সাধারণীকরণ করতে সক্ষম হয়: তারা ক্লাসের মধ্যে (যেমন বিড়াল বনাম কুকুর) অভ্যন্তরীণ বৈশিষ্ট্যগুলি ক্যাপচার করতে সক্ষম হয় যা পটভূমির শব্দ এবং অন্যান্য উপদ্রবগুলির জন্য অজ্ঞেয়বাদী। এইভাবে, মডেল এবং আউটপুট শ্রেণীবিভাগ লেবেলের মধ্যে যেখানে কাঁচা চিত্র দেওয়া হয়, মডেলটি একটি জটিল বৈশিষ্ট্য নিষ্কাশনকারী হিসাবে কাজ করে। মডেলের মধ্যবর্তী স্তরগুলি অ্যাক্সেস করে, আপনি ইনপুট চিত্রগুলির বিষয়বস্তু এবং শৈলী বর্ণনা করতে সক্ষম হন৷

মডেল তৈরি করুন

মধ্যে নেটওয়ার্ক tf.keras.applications ডিজাইন করা হয় যাতে আপনি সহজেই Keras কার্মিক API ব্যবহার করে মধ্যবর্তী স্তর মান নিষ্কাশন করতে পারেন।

কার্যকরী API ব্যবহার করে একটি মডেল সংজ্ঞায়িত করতে, ইনপুট এবং আউটপুটগুলি নির্দিষ্ট করুন:

model = Model(inputs, outputs)

এই নিম্নলিখিত ফাংশনটি একটি VGG19 মডেল তৈরি করে যা মধ্যবর্তী স্তর আউটপুটগুলির একটি তালিকা প্রদান করে:

def vgg_layers(layer_names):
  """ Creates a vgg model that returns a list of intermediate output values."""
  # Load our model. Load pretrained VGG, trained on imagenet data
  vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')
  vgg.trainable = False

  outputs = [vgg.get_layer(name).output for name in layer_names]

  model = tf.keras.Model([vgg.input], outputs)
  return model

এবং মডেল তৈরি করতে:

style_extractor = vgg_layers(style_layers)
style_outputs = style_extractor(style_image*255)

#Look at the statistics of each layer's output
for name, output in zip(style_layers, style_outputs):
  print(name)
  print("  shape: ", output.numpy().shape)
  print("  min: ", output.numpy().min())
  print("  max: ", output.numpy().max())
  print("  mean: ", output.numpy().mean())
  print()
block1_conv1
  shape:  (1, 336, 512, 64)
  min:  0.0
  max:  835.5256
  mean:  33.97525

block2_conv1
  shape:  (1, 168, 256, 128)
  min:  0.0
  max:  4625.8857
  mean:  199.82687

block3_conv1
  shape:  (1, 84, 128, 256)
  min:  0.0
  max:  8789.239
  mean:  230.78099

block4_conv1
  shape:  (1, 42, 64, 512)
  min:  0.0
  max:  21566.135
  mean:  791.24005

block5_conv1
  shape:  (1, 21, 32, 512)
  min:  0.0
  max:  3189.2542
  mean:  59.179478

শৈলী গণনা

একটি চিত্রের বিষয়বস্তু মধ্যবর্তী বৈশিষ্ট্য মানচিত্রের মান দ্বারা প্রতিনিধিত্ব করা হয়।

এটি সক্রিয় আউট, একটি চিত্রের শৈলী বিভিন্ন বৈশিষ্ট্য মানচিত্র জুড়ে উপায় এবং পারস্পরিক সম্পর্ক দ্বারা বর্ণনা করা যেতে পারে. একটি গ্রাম ম্যাট্রিক্স গণনা করুন যা প্রতিটি অবস্থানে বৈশিষ্ট্য ভেক্টরের বাইরের পণ্যটি নিজের সাথে নিয়ে এবং সমস্ত অবস্থানে সেই বাইরের পণ্যের গড় করে এই তথ্যটি অন্তর্ভুক্ত করে। এই গ্রাম ম্যাট্রিক্স একটি নির্দিষ্ট স্তরের জন্য গণনা করা যেতে পারে যেমন:

\[G^l_{cd} = \frac{\sum_{ij} F^l_{ijc}(x)F^l_{ijd}(x)}{IJ}\]

এই সংক্ষেপে ব্যবহার করে বাস্তবায়ন করা যেতে পারে tf.linalg.einsum ফাংশন:

def gram_matrix(input_tensor):
  result = tf.linalg.einsum('bijc,bijd->bcd', input_tensor, input_tensor)
  input_shape = tf.shape(input_tensor)
  num_locations = tf.cast(input_shape[1]*input_shape[2], tf.float32)
  return result/(num_locations)

শৈলী এবং বিষয়বস্তু নির্যাস

একটি মডেল তৈরি করুন যা শৈলী এবং বিষয়বস্তু টেনসর প্রদান করে।

class StyleContentModel(tf.keras.models.Model):
  def __init__(self, style_layers, content_layers):
    super(StyleContentModel, self).__init__()
    self.vgg = vgg_layers(style_layers + content_layers)
    self.style_layers = style_layers
    self.content_layers = content_layers
    self.num_style_layers = len(style_layers)
    self.vgg.trainable = False

  def call(self, inputs):
    "Expects float input in [0,1]"
    inputs = inputs*255.0
    preprocessed_input = tf.keras.applications.vgg19.preprocess_input(inputs)
    outputs = self.vgg(preprocessed_input)
    style_outputs, content_outputs = (outputs[:self.num_style_layers],
                                      outputs[self.num_style_layers:])

    style_outputs = [gram_matrix(style_output)
                     for style_output in style_outputs]

    content_dict = {content_name: value
                    for content_name, value
                    in zip(self.content_layers, content_outputs)}

    style_dict = {style_name: value
                  for style_name, value
                  in zip(self.style_layers, style_outputs)}

    return {'content': content_dict, 'style': style_dict}

যখন একটি ছবিতে বলা হয়, এই মডেল আয় গ্রাম ম্যাট্রিক্স (শৈলী) style_layers এবং বিষয়বস্তুর content_layers :

extractor = StyleContentModel(style_layers, content_layers)

results = extractor(tf.constant(content_image))

print('Styles:')
for name, output in sorted(results['style'].items()):
  print("  ", name)
  print("    shape: ", output.numpy().shape)
  print("    min: ", output.numpy().min())
  print("    max: ", output.numpy().max())
  print("    mean: ", output.numpy().mean())
  print()

print("Contents:")
for name, output in sorted(results['content'].items()):
  print("  ", name)
  print("    shape: ", output.numpy().shape)
  print("    min: ", output.numpy().min())
  print("    max: ", output.numpy().max())
  print("    mean: ", output.numpy().mean())
Styles:
   block1_conv1
    shape:  (1, 64, 64)
    min:  0.0055228462
    max:  28014.557
    mean:  263.79022

   block2_conv1
    shape:  (1, 128, 128)
    min:  0.0
    max:  61479.496
    mean:  9100.949

   block3_conv1
    shape:  (1, 256, 256)
    min:  0.0
    max:  545623.44
    mean:  7660.976

   block4_conv1
    shape:  (1, 512, 512)
    min:  0.0
    max:  4320502.0
    mean:  134288.84

   block5_conv1
    shape:  (1, 512, 512)
    min:  0.0
    max:  110005.37
    mean:  1487.0378

Contents:
   block5_conv2
    shape:  (1, 26, 32, 512)
    min:  0.0
    max:  2410.8796
    mean:  13.764149

গ্রেডিয়েন্ট ডিসেন্ট চালান

এই স্টাইল এবং কন্টেন্ট এক্সট্র্যাক্টর দিয়ে, আপনি এখন স্টাইল ট্রান্সফার অ্যালগরিদম বাস্তবায়ন করতে পারেন। প্রতিটি টার্গেটের সাপেক্ষে আপনার ছবির আউটপুটের গড় বর্গাকার ত্রুটি গণনা করে এটি করুন, তারপর এই ক্ষতিগুলির ওজনযুক্ত যোগফল নিন।

আপনার শৈলী এবং বিষয়বস্তু লক্ষ্য মান সেট করুন:

style_targets = extractor(style_image)['style']
content_targets = extractor(content_image)['content']

একটি নির্ধারণ tf.Variable নিখুত ইমেজ ধারণ। এই দ্রুত করতে, বিষয়বস্তু ইমেজের সাথে এটি আরম্ভ ( tf.Variable বিষয়বস্তু ইমেজ হিসাবে একই আকৃতি হতে হবে):

image = tf.Variable(content_image)

যেহেতু এটি একটি ফ্লোট ইমেজ, পিক্সেল মান 0 এবং 1 এর মধ্যে রাখতে একটি ফাংশন সংজ্ঞায়িত করুন:

def clip_0_1(image):
  return tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0)

একটি অপ্টিমাইজার তৈরি করুন। কাগজ LBFGS বিশেষ পরামর্শ দেওয়া হচ্ছে, কিন্তু Adam ঠিক আছে কাজ করে খুব:

opt = tf.optimizers.Adam(learning_rate=0.02, beta_1=0.99, epsilon=1e-1)

এটি অপ্টিমাইজ করতে, মোট ক্ষতি পেতে দুটি ক্ষতির একটি ওজনযুক্ত সমন্বয় ব্যবহার করুন:

style_weight=1e-2
content_weight=1e4
def style_content_loss(outputs):
    style_outputs = outputs['style']
    content_outputs = outputs['content']
    style_loss = tf.add_n([tf.reduce_mean((style_outputs[name]-style_targets[name])**2) 
                           for name in style_outputs.keys()])
    style_loss *= style_weight / num_style_layers

    content_loss = tf.add_n([tf.reduce_mean((content_outputs[name]-content_targets[name])**2) 
                             for name in content_outputs.keys()])
    content_loss *= content_weight / num_content_layers
    loss = style_loss + content_loss
    return loss

ব্যবহার করুন tf.GradientTape ইমেজ আপডেট করার জন্য।

@tf.function()
def train_step(image):
  with tf.GradientTape() as tape:
    outputs = extractor(image)
    loss = style_content_loss(outputs)

  grad = tape.gradient(loss, image)
  opt.apply_gradients([(grad, image)])
  image.assign(clip_0_1(image))

এখন পরীক্ষা করার জন্য কয়েকটি ধাপ চালান:

train_step(image)
train_step(image)
train_step(image)
tensor_to_image(image)

png

যেহেতু এটি কাজ করছে, একটি দীর্ঘ অপ্টিমাইজেশান সঞ্চালন করুন:

import time
start = time.time()

epochs = 10
steps_per_epoch = 100

step = 0
for n in range(epochs):
  for m in range(steps_per_epoch):
    step += 1
    train_step(image)
    print(".", end='', flush=True)
  display.clear_output(wait=True)
  display.display(tensor_to_image(image))
  print("Train step: {}".format(step))

end = time.time()
print("Total time: {:.1f}".format(end-start))

png

Train step: 1000
Total time: 20.5

মোট প্রকরণ ক্ষতি

এই মৌলিক বাস্তবায়নের একটি নেতিবাচক দিক হল এটি প্রচুর উচ্চ ফ্রিকোয়েন্সি আর্টিফ্যাক্ট তৈরি করে। চিত্রের উচ্চ ফ্রিকোয়েন্সি উপাদানগুলিতে একটি সুস্পষ্ট নিয়মিতকরণ শব্দ ব্যবহার করে এগুলি হ্রাস করুন৷ শৈলী হস্তান্তর, এই প্রায়ই মোট প্রকরণ ক্ষতি বলা হয়:

def high_pass_x_y(image):
  x_var = image[:, :, 1:, :] - image[:, :, :-1, :]
  y_var = image[:, 1:, :, :] - image[:, :-1, :, :]

  return x_var, y_var
x_deltas, y_deltas = high_pass_x_y(content_image)

plt.figure(figsize=(14, 10))
plt.subplot(2, 2, 1)
imshow(clip_0_1(2*y_deltas+0.5), "Horizontal Deltas: Original")

plt.subplot(2, 2, 2)
imshow(clip_0_1(2*x_deltas+0.5), "Vertical Deltas: Original")

x_deltas, y_deltas = high_pass_x_y(image)

plt.subplot(2, 2, 3)
imshow(clip_0_1(2*y_deltas+0.5), "Horizontal Deltas: Styled")

plt.subplot(2, 2, 4)
imshow(clip_0_1(2*x_deltas+0.5), "Vertical Deltas: Styled")

png

এটি দেখায় কিভাবে উচ্চ ফ্রিকোয়েন্সি উপাদান বৃদ্ধি পেয়েছে।

এছাড়াও, এই উচ্চ ফ্রিকোয়েন্সি উপাদানটি মূলত একটি প্রান্ত সনাক্তকারী। আপনি Sobel প্রান্ত আবিষ্কারক থেকে অনুরূপ আউটপুট পেতে পারেন, উদাহরণস্বরূপ:

plt.figure(figsize=(14, 10))

sobel = tf.image.sobel_edges(content_image)
plt.subplot(1, 2, 1)
imshow(clip_0_1(sobel[..., 0]/4+0.5), "Horizontal Sobel-edges")
plt.subplot(1, 2, 2)
imshow(clip_0_1(sobel[..., 1]/4+0.5), "Vertical Sobel-edges")

png

এর সাথে সম্পর্কিত নিয়মিতকরণ ক্ষতি হল মানের বর্গক্ষেত্রের সমষ্টি:

def total_variation_loss(image):
  x_deltas, y_deltas = high_pass_x_y(image)
  return tf.reduce_sum(tf.abs(x_deltas)) + tf.reduce_sum(tf.abs(y_deltas))
total_variation_loss(image).numpy()
149298.19

যে এটা কি প্রমান. তবে এটি নিজে বাস্তবায়ন করার দরকার নেই, টেনসরফ্লোতে একটি আদর্শ বাস্তবায়ন অন্তর্ভুক্ত রয়েছে:

tf.image.total_variation(image).numpy()
array([149298.19], dtype=float32)

অপ্টিমাইজেশান পুনরায় চালান

জন্য একটি ওজন চয়ন করুন total_variation_loss :

total_variation_weight=30

এখন তা অন্তর্ভুক্ত train_step ফাংশন:

@tf.function()
def train_step(image):
  with tf.GradientTape() as tape:
    outputs = extractor(image)
    loss = style_content_loss(outputs)
    loss += total_variation_weight*tf.image.total_variation(image)

  grad = tape.gradient(loss, image)
  opt.apply_gradients([(grad, image)])
  image.assign(clip_0_1(image))

অপ্টিমাইজেশন ভেরিয়েবল পুনরায় চালু করুন:

image = tf.Variable(content_image)

এবং অপ্টিমাইজেশান চালান:

import time
start = time.time()

epochs = 10
steps_per_epoch = 100

step = 0
for n in range(epochs):
  for m in range(steps_per_epoch):
    step += 1
    train_step(image)
    print(".", end='', flush=True)
  display.clear_output(wait=True)
  display.display(tensor_to_image(image))
  print("Train step: {}".format(step))

end = time.time()
print("Total time: {:.1f}".format(end-start))

png

Train step: 1000
Total time: 21.5

অবশেষে, ফলাফল সংরক্ষণ করুন:

file_name = 'stylized-image.png'
tensor_to_image(image).save(file_name)

try:
  from google.colab import files
except ImportError:
   pass
else:
  files.download(file_name)

আরও জানুন

এই টিউটোরিয়ালটি মূল স্টাইল-ট্রান্সফার অ্যালগরিদম প্রদর্শন করে। শৈলী স্থানান্তর একটি সহজ অ্যাপ্লিকেশনের জন্যই কেবল এই খুঁজে বার করো টিউটোরিয়াল কিভাবে থেকে নির্বিচারে ইমেজ শৈলী হস্তান্তর মডেল ব্যবহার করতে সম্পর্কে আরো জানতে TensorFlow হাব