نقل النمط العصبي

عرض على TensorFlow.org

تشغيل في Google Colab

عرض على جيثب

تحميل دفتر

انظر نموذج TF Hub

يستخدم هذا البرنامج التعليمي التعلم العميق لتكوين صورة واحدة بأسلوب صورة أخرى (هل تتمنى أن ترسم مثل بيكاسو أو فان جوخ؟). يُعرف هذا باسم نقل النمط العصبي وقد تم تحديد التقنية في A Neural Algorithm of Artistic Style (Gatys et al.).

للحصول على تطبيق بسيط لنقل النمط ، راجع هذا البرنامج التعليمي لمعرفة المزيد حول كيفية استخدام نموذج Stylization الصورة التعسفي الذي تم اختباره مسبقًا من TensorFlow Hub أو كيفية استخدام نموذج نقل النمط مع TensorFlow Lite .

يُعد نقل النمط العصبي تقنية تحسين تُستخدم لالتقاط صورتين - صورة محتوى وصورة مرجعية للنمط (مثل عمل فني لرسام مشهور) - ودمجهما معًا بحيث تبدو الصورة الناتجة مثل صورة المحتوى ، ولكن "مرسومة" في نمط الصورة المرجعية للنمط.

يتم تنفيذ ذلك عن طريق تحسين صورة الإخراج لمطابقة إحصائيات محتوى صورة المحتوى وإحصائيات النمط للصورة المرجعية للنمط. يتم استخراج هذه الإحصائيات من الصور باستخدام شبكة تلافيفية.

على سبيل المثال ، لنأخذ صورة لهذا الكلب والتكوين 7 لفاسيلي كاندينسكي:

Yellow Labrador looking ، من ويكيميديا ​​كومنز بواسطة Elf . الترخيص CC BY-SA 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
204800/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')

نقل سريع للنمط باستخدام TF-Hub

يوضح هذا البرنامج التعليمي خوارزمية نقل النمط الأصلية ، والتي تعمل على تحسين محتوى الصورة إلى نمط معين. قبل الدخول في التفاصيل ، دعنا نرى كيف يقوم نموذج TensorFlow Hub بهذا:

import tensorflow_hub as hub
hub_model = hub.load('https://tfhub.dev/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)

تحديد تمثيلات المحتوى والأسلوب

استخدم الطبقات الوسيطة للنموذج للحصول على المحتوى وتمثيل النمط للصورة. بدءًا من طبقة إدخال الشبكة ، تمثل عمليات تنشيط الطبقة القليلة الأولى ميزات منخفضة المستوى مثل الحواف والأنسجة. أثناء التنقل عبر الشبكة ، تمثل الطبقات القليلة الأخيرة ميزات ذات مستوى أعلى - أجزاء كائن مثل العجلات أو العيون . في هذه الحالة ، فأنت تستخدم بنية شبكة 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 [==============================] - 17s 0us/step
574726144/574710816 [==============================] - 17s 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
80150528/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 الوظيفية.

لتحديد نموذج باستخدام واجهة برمجة التطبيقات الوظيفية ، حدد المدخلات والمخرجات:

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 باستخدام صورة المحتوى (يجب أن يكون متغير tf بنفس شكل صورة المحتوى):

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)

نظرًا لأنه يعمل ، قم بإجراء تحسين أطول:

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))

Train step: 1000
Total time: 21.3

إجمالي خسارة التباين

أحد الجوانب السلبية لهذا التطبيق الأساسي هو أنه ينتج الكثير من القطع الأثرية عالية التردد. قم بتقليل هذه باستخدام مصطلح تنظيم صريح على المكونات عالية التردد للصورة. في نقل النمط ، يُسمى هذا غالبًا بالخسارة الإجمالية للتباين :

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")

يوضح هذا كيف زادت مكونات التردد العالي.

أيضًا ، هذا المكون عالي التردد هو في الأساس كاشف حافة. يمكنك الحصول على مخرجات مماثلة من كاشف الحواف 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")

خسارة التنظيم المرتبطة بهذا هي مجموع مربعات القيم:

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()

149402.94

هذا أظهر ما يفعله. ولكن ليست هناك حاجة لتنفيذه بنفسك ، يتضمن TensorFlow تطبيقًا قياسيًا:

tf.image.total_variation(image).numpy()

array([149402.94], 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))

Train step: 1000
Total time: 22.4

أخيرًا ، احفظ النتيجة:

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 Hub .