Neural Style Transfer & Fast Style Transfer

Welcome to Mashykom WebSite

≡ Deep Learning site map

Neural Style Transfer と Fast Neural Style Transfer のページ

　敵対的生成ネットワーク (GAN, Generative Adversarial Networks) は、機械学習の分野で最も興味深いアルゴリズムの一つです。このネットワーク・モデルには、Generator と Discriminator という2 つのネットワークが組み込まれています。この２種類のネットワークが敵対するような関係になることからこの名称で呼ばれます。generator (「芸術家」the artist) がリアルに見える画像（フェイク画像）を作成することを学習し、その一方で、 discriminator (「芸術評論家」 the art critic」) がフェイク画像からリアル画像を識別することを学習します。現在、こうした GANs のモデルをさまざまに拡張したディープラーニングのモデルが提案されています。

特に、CycleGAN と類似していますが、上で見たように、ある画像を別のスタイルの画像に変換する、写真をモネ風やゴッホ風の画像に変換する便利な手法が提案されています。

　このページでは、Neural Style Transfer およびその拡張版のFast Neural Style Transfer モデルの Python 実装について説明します。使用する Python API は Pytorch と TensorFlow です。これらのコードを実行するには、GPU を使用できないノートPCでは時間がかかり過ぎるので、Google Colab などの無料GPU サービスを利用する方が便利です。

　この理由から、このページで取り上げるコードはGoogle Colabで実証できるように準備しました。また、私のGithub Repoに４種類のコード neural_style、 neural style transfer 、 fast-style-transfer、および、fast_neural_styleを用意しましたので、ご利用ください。

　私の GitHub Repo からローカル PC にフォルダーを git clone して、この PC でコードを利用する方法では、トラブルは少ないと思います。Google Colab の /My Drive/ にフォルダーを git clone する方法も、ファイルの中身が見えるので、問題は少ないと思います。Google Colab の /content/ に直接 git clone するケースでは、ファイルのコードを編集するなどの操作をするためには、Linux の知識が必要となりますので、ご注意ください。

Last updated: 2020.4.4 (first uploaded 2020.3.8)

Deep Dream の使用法

　最初に、最も分かりやすいスタイル変換プログラムである DeepDream というソフトを取り上げます。言うまでもなく、DeepDream は、 GoogleのエンジニアであるAlexander Mordvintsevによって作成されたコンピュータービジョンのプログラムです。「このソフトウエアは、畳み込みニューラルネットワークを使用し、アルゴリズムのパレイドリアを介して画像の中にパターンを検出および強化し、意図的に過剰処理することで、夢のような幻覚的な画像を生成する。このGoogleのプログラムは、「深く夢見る (deep dreaming)」という用語を普及させ、訓練されたディープネットワークにより望みの活性化処理を施し、画像を生成することを指すようになった。」（Wikipedia から引用） Google が公開したコードは、このGitHub Repoにあります。

　この DeepDream のコードは、Tensorflow の Tutorials からアクセスできます。この Google Colab でも実行できます。

　DeepDream の骨格は以下のようになっています。


base_model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet')

# Maximize the activations of these layers
names = ['mixed3', 'mixed5']
layers = [base_model.get_layer(name).output for name in names]

# Create the feature extraction model
dream_model = tf.keras.Model(inputs=base_model.input, outputs=layers)

　このコードから理解されるとおり、DeepDream が採用しているネットワーク構成は InceptionV3 と呼ばれるモデルです。generator と discrinimator から構成されるGANs のような構成にはなっていません。周知の通り、InceptionV3 は Google が開発した CNN モデルです。以下のコードが損失の計算最適化のモジュールとなっています。学習用のモジュールを説明することは詳細は省略します。

class DeepDream(tf.Module):
  def __init__(self, model):
    self.model = model

  @tf.function(
      input_signature=(
        tf.TensorSpec(shape=[None,None,3], dtype=tf.float32),
        tf.TensorSpec(shape=[], dtype=tf.int32),
        tf.TensorSpec(shape=[], dtype=tf.float32),)
  )
  def __call__(self, img, steps, step_size):
      print("Tracing")
      loss = tf.constant(0.0)
      for n in tf.range(steps):
        with tf.GradientTape() as tape:
          # This needs gradients relative to `img`
          # `GradientTape` only watches `tf.Variable`s by default
          tape.watch(img)
          loss = calc_loss(img, self.model)

        # Calculate the gradient of the loss with respect to the pixels of the input image.
        gradients = tape.gradient(loss, img)

        # Normalize the gradients.
        gradients /= tf.math.reduce_std(gradients) + 1e-8 
        
        # In gradient ascent, the "loss" is maximized so that the input image increasingly "excites" the layers.
        # You can update the image by directly adding the gradients (because they're the same shape!)
        img = img + gradients*step_size
        img = tf.clip_by_value(img, -1, 1)

      return loss, img

deepdream = DeepDream(dream_model)

このノートブックを実行すると、処理される画像としてラブラドール犬の写真（YellowLabradorLooking new.jpg）が読み込まれます。その後で、変換された後の画像は以下のように表示されます。

　現在、画像変換のDeep Dream を web 上で利用可能にした Deep Dream Generatorの公式サイトはこちらです。

　この Deep Dream Generator の利用の仕方について説明します。（取説がどこにもないので、自己流です）上記の Deep Dream Generator の web site に行きます。ログインをします。Facebook などのアカウントを持っていれば、新しく登録しなくてもログインできます。ログインしたら、右上にある「Generate」をクリックします。次に、「Upload Image」をクリックしたら、PC内にある好みの写真画像を選択して、アップロードします。「Deep Style」「Thin Style」「Deep Dream」のどれかを選びます。その後、「Choose Style Image」の中から好みのものを選択して、「Generate」します。「Access?」は取り敢えず「Keep it private」にして下さい。しばらくすると、編集された画像が表示されます。これで完了です。

トップページ（Home）に表示されている以下の画像はこの Deep Dream Generator を用いて作成したものです。

江ノ島に落ちる夕日

ゴッホ風の画像

　上記のサイトで使用できる画像生成の種類は固定されています。もっと自由度の高い画像編集を実現するためには、以下に説明する CycleGANs の変形バージョンである Style Transfer を活用する方が便利です。

Neural Style Transfer の Tensorflow 実装

　CycleGAN と類似していますが、上で見たように、ある画像を別のスタイルの画像に変換する、例えば、写真をゴッホ風や浮世絵風の画像に変換する便利な手法が、2015年にA Neural Algorithm of Artistic Style (by Leon A. Gatys, Alexander S. Ecker, and Matthias Bethge)と言うタイトルの論文で提案されています。このアルゴリズムは、CycleGAN に比較すると、学習済みCNNを使用することから、何百倍も処理時間が早くなります。使用される代表的なCNN は VGG19 です。このアルゴリズムは、省略形で、Style Transfer または Neural Transfer などとも呼ばれています。CycleGAN と Style Transfer の関係については、この解説を参照ください。

　このアルゴリズムを Python で実装した例は、Tensorflow の公式Tutorials および Pytorch 公式ページに説明があります。Tensorflow を用いた例は、このColabにコピーしてあります。また、Pytorch の例はこのColab で実行できる形にしています。

　簡単な説明をします。Gatys らのモデルは、畳み込みニューラルネットワーク（convolutional neural network, CNN）を使用していて、VGG モデルがベースになっています。アルゴリズムのキーとなるアイデアは、画像のコンテンツとスタイルの分離です。スタイル抽出には、このVGGから全結合層を取り除いたものを使用します。

　以下の図を見てみください。CNNの各層において画像がどのように特徴表現されているかを表す図です。

Gatys et al. 2016より引用

　上段はスタイル画像、下段はコンテンツ画像の特徴マップに対応します。a, b, c, d, eはそれぞれconv1_2, conv2_2, conv3_2, conv4_2, conv5_2に対応する特徴画像です。

　まずは、下段を見てみます。これらの画像はそれぞれの層において、入力画像を復元したものです。a, b, cまでは元の入力画像とほとんど変わらないように見えますが、d, eでは詳細な情報が落ちてきているように見えます。VGGは元々画像を分類する目的で訓練されています。深い層に行くにつれて、分類するにあたって重要なコンテンツが残り、それとはあまり関係のない詳細な見た目などの情報は落ちていっています。これはコンテンツとスタイルをある程度分離することができているとも考えられます。

　この性質をうまく利用し、コンテンツを保ったままスタイルを別のものと入れ替えることを考えます。画像のコンテンツ表現とスタイル表現を用いることで、画像間のコンテンツとスタイルの類似度(損失)を別々に求めることができます。VGG を使ってコンテンツ画像のコンテンツとスタイル画像のスタイルに類似する画像を生成するようにホワイトノイズを更新して、画像を再生成します。

　したがって、この問題はコンテンツとスタイルの損失を最小化する最適化問題として解くことができます。コンテンツの損失は、conv4_2において、コンテンツ画像と生成画像を比較することによって計算します。このプロセスを図式化したのが下の図です。

Gatys et al. 2016より引用

　左側には、各レイヤーで style 画像のスタイル表現が抽出、保存される様子が図式化されています。右側には、各レイヤーで content 画像のコンテンツ表現が保存される過程を描いています。中央には、ノイズ画像から新しい画像を生成する学習過程を図式化しています。

　Gatys らの論文で発表された画像変換の結果は以下の画像です

Gatys et al. 2016より引用

　ここで、Keras を用いて neural style transfer のアルゴリズムを実装したコードを取り上げます。Keras の公式 GitHub Repo でアップされている例を見てみましょう。ただ、このコードはTensorflow 2.0 には対応していません。Tensorflow 1.15 にダウングレードして下さい。

手持ちのPCで実装するときは、https://keras.io/examples/neural_style_transfer/の Python コードをコピペして、 neural_style_transfer.py を作成します。neural_style_transfer.py の中は以下のようのコードで構成されています。内容の説明は省略します。

# nutral_style_transfer.py

from __future__ import print_function
from keras.preprocessing.image import load_img, save_img, img_to_array
import numpy as np
from scipy.optimize import fmin_l_bfgs_b
import time
import argparse

from keras.applications import vgg19
from keras import backend as K

parser = argparse.ArgumentParser(description='Neural style transfer with Keras.')
parser.add_argument('base_image_path', metavar='base', type=str,
                    help='Path to the image to transform.')
parser.add_argument('style_reference_image_path', metavar='ref', type=str,
                    help='Path to the style reference image.')
parser.add_argument('result_prefix', metavar='res_prefix', type=str,
                    help='Prefix for the saved results.')
parser.add_argument('--iter', type=int, default=10, required=False,
                    help='Number of iterations to run.')
parser.add_argument('--content_weight', type=float, default=0.025, required=False,
                    help='Content weight.')
parser.add_argument('--style_weight', type=float, default=1.0, required=False,
                    help='Style weight.')
parser.add_argument('--tv_weight', type=float, default=1.0, required=False,
                    help='Total Variation weight.')

args = parser.parse_args()
base_image_path = args.base_image_path
style_reference_image_path = args.style_reference_image_path
result_prefix = args.result_prefix
iterations = args.iter

# these are the weights of the different loss components
total_variation_weight = args.tv_weight
style_weight = args.style_weight
content_weight = args.content_weight

# dimensions of the generated picture.
width, height = load_img(base_image_path).size
img_nrows = 400
img_ncols = int(width * img_nrows / height)

# util function to open, resize and format pictures into appropriate tensors

def preprocess_image(image_path):
    img = load_img(image_path, target_size=(img_nrows, img_ncols))
    img = img_to_array(img)
    img = np.expand_dims(img, axis=0)
    img = vgg19.preprocess_input(img)
    return img

# util function to convert a tensor into a valid image

def deprocess_image(x):
    if K.image_data_format() == 'channels_first':
        x = x.reshape((3, img_nrows, img_ncols))
        x = x.transpose((1, 2, 0))
    else:
        x = x.reshape((img_nrows, img_ncols, 3))
    # Remove zero-center by mean pixel
    x[:, :, 0] += 103.939
    x[:, :, 1] += 116.779
    x[:, :, 2] += 123.68
    # 'BGR'->'RGB'
    x = x[:, :, ::-1]
    x = np.clip(x, 0, 255).astype('uint8')
    return x

# get tensor representations of our images
base_image = K.variable(preprocess_image(base_image_path))
style_reference_image = K.variable(preprocess_image(style_reference_image_path))

# this will contain our generated image
if K.image_data_format() == 'channels_first':
    combination_image = K.placeholder((1, 3, img_nrows, img_ncols))
else:
    combination_image = K.placeholder((1, img_nrows, img_ncols, 3))

# combine the 3 images into a single Keras tensor
input_tensor = K.concatenate([base_image,
                              style_reference_image,
                              combination_image], axis=0)

# build the VGG19 network with our 3 images as input
# the model will be loaded with pre-trained ImageNet weights
model = vgg19.VGG19(input_tensor=input_tensor,
                    weights='imagenet', include_top=False)
print('Model loaded.')

# get the symbolic outputs of each "key" layer (we gave them unique names).
outputs_dict = dict([(layer.name, layer.output) for layer in model.layers])

# compute the neural style loss
# first we need to define 4 util functions

# the gram matrix of an image tensor (feature-wise outer product)

def gram_matrix(x):
    assert K.ndim(x) == 3
    if K.image_data_format() == 'channels_first':
        features = K.batch_flatten(x)
    else:
        features = K.batch_flatten(K.permute_dimensions(x, (2, 0, 1)))
    gram = K.dot(features, K.transpose(features))
    return gram

# the "style loss" is designed to maintain
# the style of the reference image in the generated image.
# It is based on the gram matrices (which capture style) of
# feature maps from the style reference image
# and from the generated image

def style_loss(style, combination):
    assert K.ndim(style) == 3
    assert K.ndim(combination) == 3
    S = gram_matrix(style)
    C = gram_matrix(combination)
    channels = 3
    size = img_nrows * img_ncols
    return K.sum(K.square(S - C)) / (4.0 * (channels ** 2) * (size ** 2))

# an auxiliary loss function
# designed to maintain the "content" of the
# base image in the generated image

def content_loss(base, combination):
    return K.sum(K.square(combination - base))

# the 3rd loss function, total variation loss,
# designed to keep the generated image locally coherent

def total_variation_loss(x):
    assert K.ndim(x) == 4
    if K.image_data_format() == 'channels_first':
        a = K.square(
            x[:, :, :img_nrows - 1, :img_ncols - 1] - x[:, :, 1:, :img_ncols - 1])
        b = K.square(
            x[:, :, :img_nrows - 1, :img_ncols - 1] - x[:, :, :img_nrows - 1, 1:])
    else:
        a = K.square(
            x[:, :img_nrows - 1, :img_ncols - 1, :] - x[:, 1:, :img_ncols - 1, :])
        b = K.square(
            x[:, :img_nrows - 1, :img_ncols - 1, :] - x[:, :img_nrows - 1, 1:, :])
    return K.sum(K.pow(a + b, 1.25))

# combine these loss functions into a single scalar
loss = K.variable(0.0)
layer_features = outputs_dict['block5_conv2']
base_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
loss = loss + content_weight * content_loss(base_image_features,
                                            combination_features)

feature_layers = ['block1_conv1', 'block2_conv1',
                  'block3_conv1', 'block4_conv1',
                  'block5_conv1']
for layer_name in feature_layers:
    layer_features = outputs_dict[layer_name]
    style_reference_features = layer_features[1, :, :, :]
    combination_features = layer_features[2, :, :, :]
    sl = style_loss(style_reference_features, combination_features)
    loss = loss + (style_weight / len(feature_layers)) * sl
loss = loss + total_variation_weight * total_variation_loss(combination_image)

# get the gradients of the generated image wrt the loss
grads = K.gradients(loss, combination_image)

outputs = [loss]
if isinstance(grads, (list, tuple)):
    outputs += grads
else:
    outputs.append(grads)

f_outputs = K.function([combination_image], outputs)

def eval_loss_and_grads(x):
    if K.image_data_format() == 'channels_first':
        x = x.reshape((1, 3, img_nrows, img_ncols))
    else:
        x = x.reshape((1, img_nrows, img_ncols, 3))
    outs = f_outputs([x])
    loss_value = outs[0]
    if len(outs[1:]) == 1:
        grad_values = outs[1].flatten().astype('float64')
    else:
        grad_values = np.array(outs[1:]).flatten().astype('float64')
    return loss_value, grad_values

# this Evaluator class makes it possible
# to compute loss and gradients in one pass
# while retrieving them via two separate functions,
# "loss" and "grads". This is done because scipy.optimize
# requires separate functions for loss and gradients,
# but computing them separately would be inefficient.

class Evaluator(object):

def __init__(self):
        self.loss_value = None
        self.grads_values = None

def loss(self, x):
        assert self.loss_value is None
        loss_value, grad_values = eval_loss_and_grads(x)
        self.loss_value = loss_value
        self.grad_values = grad_values
        return self.loss_value

def grads(self, x):
        assert self.loss_value is not None
        grad_values = np.copy(self.grad_values)
        self.loss_value = None
        self.grad_values = None
        return grad_values

evaluator = Evaluator()

# run scipy-based optimization (L-BFGS) over the pixels of the generated image
# so as to minimize the neural style loss
x = preprocess_image(base_image_path)

for i in range(iterations):
    print('Start of iteration', i)
    start_time = time.time()
    x, min_val, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(),
                                     fprime=evaluator.grads, maxfun=20)
    print('Current loss value:', min_val)
    # save current generated image
    img = deprocess_image(x.copy())
    fname = result_prefix + '_at_iteration_%d.png' % i
    save_img(fname, img)
    end_time = time.time()
    print('Image saved as', fname)
    print('Iteration %d completed in %ds' % (i, end_time - start_time))