pip install tensorflow keras

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.applications import vgg19
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg19 import preprocess_input
from tensorflow.keras.models import Model

# 加载预训练的 VGG19 模型
base_model = vgg19.VGG19(weights='imagenet')
model = Model(inputs=base_model.input, outputs=base_model.get_layer('block4_conv2').output)

# 加载图像并进行预处理
def load_and_process_image(image_path):
    img = image.load_img(image_path, target_size=(224, 224))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array = preprocess_input(img_array)
    return img_array

# 将图像转换为风格矩阵
def get_style_matrix(img_array):
    style_layers = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1']
    style_outputs = [model.get_layer(name).output for name in style_layers]
    style_model = Model(inputs=model.input, outputs=style_outputs)
    
    style_matrices = style_model(img_array)
    return style_matrices

# 计算风格损失
def compute_style_loss(style_matrix, generated_matrix):
    loss = 0
    for i in range(len(style_matrix)):
        loss += np.mean(np.square(style_matrix[i] - generated_matrix[i]))
    return loss / len(style_matrix)

# 生成艺术风格图像
def generate_artistic_image(content_path, style_path, num_iterations=100, alpha=10, beta=1e-3):
    content_array = load_and_process_image(content_path)
    style_array = load_and_process_image(style_path)

    generated_array = content_array.copy()
    generated_array = tf.Variable(generated_array, dtype=tf.float32)

    opt = tf.optimizers.Adam(learning_rate=5)

    for _ in range(num_iterations):
        with tf.GradientTape() as tape:
            content_output = model(content_array)
            generated_output = model(generated_array)
            style_output = model(style_array)

            content_loss = tf.reduce_sum(tf.square(content_output - generated_output))
            style_loss = compute_style_loss(style_output, generated_output)

            total_loss = alpha * content_loss + beta * style_loss

        grad = tape.gradient(total_loss, generated_array)
        opt.apply_gradients([(grad, generated_array)])

    generated_image = generated_array.numpy().squeeze()
    generated_image = deprocess_image(generated_image)
    return generated_image

# 将图像反处理为有效图像
def deprocess_image(processed_image):
    x = processed_image.copy()
    if len(x.shape) == 4:
        x = np.squeeze(x, 0)
    assert len(x.shape) == 3, ("Input to deprocess image must be an image of "
                             "dimension [1, height, width, channel] or [height, width, channel]")
    if len(x.shape) != 3:
        raise ValueError("Invalid input to deprocessing image")
    # perform the inverse of the preprocessiing step
    x[:, :, 0] += 103.939
    x[:, :, 1] += 116.779
    x[:, :, 2] += 123.68
    x = x[:, :, ::-1]

    x = np.clip(x, 0, 255).astype('uint8')
    return x

# 选择一张内容图像和一种艺术风格
content_image_path = 'path_to_your_content_image.jpg'
style_image_path = 'path_to_your_style_image.jpg'

# 生成艺术风格图像
generated_image = generate_artistic_image(content_image_path, style_image_path)

# 显示图像
plt.imshow(generated_image)
plt.show()