Cara menggunakan Python untuk melakukan pemindahan gaya pada imej

Cara menggunakan Python untuk melakukan pemindahan gaya pada imej

Pengenalan:
Pemindahan gaya ialah tugas yang menarik dan mencabar dalam bidang penglihatan komputer, yang boleh mensintesis kandungan satu imej dengan gaya imej lain, mencipta kesan artistik yang unik dan digunakan secara meluas dalam pemprosesan imej, reka bentuk, hiburan dan bidang lain. Artikel ini akan memperkenalkan cara menggunakan bahasa pengaturcaraan Python, digabungkan dengan algoritma pembelajaran mendalam, untuk mencapai pemindahan gaya gambar.

Langkah 1: Import perpustakaan yang diperlukan
Pertama, kita perlu mengimport beberapa perpustakaan Python yang diperlukan, termasuk TensorFlow, Keras, NumPy dan Matplotlib. Jalankan kod berikut:

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

Langkah 2: Muatkan model pra-latihan
Dalam pemindahan gaya, kita boleh menggunakan model rangkaian saraf konvolusi terlatih, seperti VGG19. Model ini berfungsi dengan baik pada tugas pengecaman imej dan juga digunakan secara meluas dalam tugas pemindahan gaya. Jalankan kod berikut:

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

Langkah 3: Tentukan kehilangan kandungan
Kehilangan kandungan digunakan untuk mengukur perbezaan kandungan antara dua imej. Kita boleh menggunakan lapisan tengah model VGG untuk mengekstrak ciri kandungan imej. Secara khusus, kita boleh memilih lapisan konvolusi model VGG tertentu sebagai lapisan kandungan dan membandingkan perwakilan ciri imej input dan imej sasaran pada lapisan ini. Jalankan kod berikut:

content_layers = ['block5_conv2']
content_extractor = keras.Model(inputs=vgg.input, outputs=[vgg.get_layer(name).output for name in content_layers])

Langkah 4: Tentukan kehilangan gaya
Kehilangan gaya digunakan untuk mengukur perbezaan gaya antara dua imej. Kita boleh menggunakan matriks Gram untuk mewakili korelasi antara saluran yang berbeza dalam gambar, dan kemudian mengukur ciri-ciri gambar dari segi tekstur, warna, dsb. Jalankan kod berikut:

style_layers = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1']
style_extractor = keras.Model(inputs=vgg.input, outputs=[vgg.get_layer(name).output for name in style_layers])

def gram_matrix(input_tensor):
    channels = int(input_tensor.shape[-1])
    a = tf.reshape(input_tensor, [-1, channels])
    n = tf.shape(a)[0]
    gram = tf.matmul(a, a, transpose_a=True)
    return gram / tf.cast(n, tf.float32)

Langkah 5: Tentukan jumlah kehilangan variasi
Jumlah kehilangan variasi digunakan untuk memastikan imej sintetik lancar. Dengan menjumlahkan perbezaan antara setiap piksel imej komposit dan piksel jirannya, kita boleh mengurangkan hingar dan tepi tidak berterusan. Laksanakan kod berikut:

def total_variation_loss(image):
    x = tf.image.image_gradients(image)
    return tf.reduce_sum(tf.abs(x[0])) + tf.reduce_sum(tf.abs(x[1]))

Langkah 6: Tentukan fungsi objektif
Kami menggabungkan kehilangan kandungan, kehilangan gaya dan jumlah kehilangan variasi untuk membentuk fungsi objektif yang komprehensif. Fungsi objektif akan digunakan untuk meminimumkan perbezaan antara kandungan dan gaya imej dan menghasilkan imej komposit yang memenuhi kekangan. Laksanakan kod berikut:

def compute_loss(image, content_features, style_features):
    content_output = content_extractor(image)
    style_output = style_extractor(image)
    content_loss = tf.reduce_mean(tf.square(content_output - content_features))
    style_loss = tf.add_n([tf.reduce_mean(tf.square(style_output[i] - style_features[i])) for i in range(len(style_output))])
    content_loss *= content_weight
    style_loss *= style_weight
    tv_loss = total_variation_loss(image) * total_variation_weight
    loss = content_loss + style_loss + tv_loss
    return loss

@tf.function()
def train_step(image, content_features, style_features, optimizer):
    with tf.GradientTape() as tape:
        loss = compute_loss(image, content_features, style_features)
    gradients = tape.gradient(loss, image)
    optimizer.apply_gradients([(gradients, image)])
    image.assign(tf.clip_by_value(image, 0.0, 1.0))

Langkah 7: Lakukan pemindahan gaya
Selepas melengkapkan definisi model, kita boleh menggunakan fungsi latihan tersuai untuk mengoptimumkan imej sintetik secara berulang supaya ia sama mungkin dengan imej sasaran dalam kandungan dan gaya. Laksanakan kod berikut:

def style_transfer(content_path, style_path, num_iteration=1000, content_weight=1e3, style_weight=1e-2, total_variation_weight=30):
    content_image = load_image(content_path)
    style_image = load_image(style_path)
    content_features = content_extractor(content_image)
    style_features = style_extractor(style_image)
    opt = keras.optimizers.Adam(learning_rate=0.02, beta_1=0.99, epsilon=1e-1)
    image = tf.Variable(content_image)
    start_time = time.time()
    for i in range(num_iteration):
        train_step(image, content_features, style_features, opt)
        if i % 100 == 0:
            elapsed_time = time.time() - start_time
            print('Iteration: %d, Time: %.2fs' % (i, elapsed_time))
            plt.imshow(image.read_value()[0])
            plt.axis('off')
            plt.show()
    image = image.read_value()[0]
    return image

Langkah 8: Lakukan pemindahan gaya
Akhir sekali, kami memilih imej kandungan dan imej gaya, dan kemudian memanggil fungsi style_transfer() untuk melakukan pemindahan gaya. Jalankan kod berikut:

content_path = 'content.jpg'
style_path = 'style.jpg'
output_image = style_transfer(content_path, style_path)
plt.imshow(output_image)
plt.axis('off')
plt.show()

Kesimpulan:
Artikel ini memperkenalkan cara menggunakan bahasa pengaturcaraan Python, digabungkan dengan algoritma pembelajaran mendalam, untuk mencapai pemindahan gaya gambar. Dengan memuatkan model pra-latihan, mentakrifkan kehilangan kandungan, kehilangan gaya dan jumlah kehilangan variasi, dan menggabungkannya dengan fungsi latihan tersuai, kami boleh mensintesis imej kandungan dan imej gaya ke dalam imej baharu yang menggabungkan ciri-cirinya. Melalui pengoptimuman berulang berterusan, kita boleh mendapatkan imej komposit akhir yang memenuhi kekangan yang diberikan. Diharapkan pembaca dapat memahami prinsip asas dan kaedah pelaksanaan pemindahan gaya melalui pengenalan artikel ini, dan seterusnya meneroka dan mengaplikasikan potensi teknologi ini dalam bidang seperti pemprosesan imej dan penciptaan artistik.

Atas ialah kandungan terperinci Cara menggunakan Python untuk melakukan pemindahan gaya pada imej. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!