借势AI系列：机器学习驱动的艺术革新-AI艺术展览的未来【代码实战】

pip install tensorflow
pip install matplotlib

import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Flatten, BatchNormalization, LeakyReLU
from tensorflow.keras.layers import Conv2D, Conv2DTranspose
from tensorflow.keras.models import Sequential
import numpy as np
import matplotlib.pyplot as plt

# 生成器模型
def build_generator():
    model = Sequential()
    model.add(Dense(256, input_dim=100))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(512))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(1024))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(28 * 28 * 1, activation='tanh'))
    model.add(Reshape((28, 28, 1)))
    return model

# 判别器模型
def build_discriminator():
    model = Sequential()
    model.add(Flatten(input_shape=(28, 28, 1)))
    model.add(Dense(512))
    model.add(LeakyReLU(0.2))
    model.add(Dense(256))
    model.add(LeakyReLU(0.2))
    model.add(Dense(1, activation='sigmoid'))
    return model

# 编译GAN模型
generator = build_generator()
discriminator = build_discriminator()
discriminator.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
discriminator.trainable = False
gan_input = tf.keras.Input(shape=(100,))
generated_image = generator(gan_input)
gan_output = discriminator(generated_image)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(loss='binary_crossentropy', optimizer='adam')

def train_gan(gan, generator, discriminator, epochs=10000, batch_size=64):
    for epoch in range(epochs):
        noise = np.random.normal(0, 1, (batch_size, 100))
        generated_images = generator.predict(noise)
        real_images = np.random.rand(batch_size, 28, 28, 1) # 使用真实数据

        # 标签
        real_labels = np.ones((batch_size, 1))
        fake_labels = np.zeros((batch_size, 1))

        # 训练判别器
        d_loss_real = discriminator.train_on_batch(real_images, real_labels)
        d_loss_fake = discriminator.train_on_batch(generated_images, fake_labels)

        # 训练生成器
        noise = np.random.normal(0, 1, (batch_size, 100))
        g_loss = gan.train_on_batch(noise, real_labels)
        
        # 每1000步显示生成的图像
        if epoch % 1000 == 0:
            print(f"Epoch: {epoch}, Discriminator Loss: {d_loss_real[0]}, Generator Loss: {g_loss}")
            generate_images(generator)

# 生成图像并显示
def generate_images(generator, examples=10):
    noise = np.random.normal(0, 1, (examples, 100))
    generated_images = generator.predict(noise)
    for i in range(examples):
        plt.subplot(1, examples, i+1)
        plt.imshow(generated_images[i].reshape(28, 28), cmap='gray')
        plt.axis('off')
    plt.show()

train_gan(gan, generator, discriminator)

import tensorflow as tf
import numpy as np
from PIL import Image

# 加载预训练的InceptionV3模型
model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet')

# 图像预处理函数
def preprocess_image(image_path):
    img = Image.open(image_path)
    img = img.resize((299, 299))
    img = np.array(img) / 255.0
    return img[np.newaxis, ...]

# 生成Dream图像
def deep_dream(image):
    dream = tf.Variable(image)
    optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)
    
    for step in range(100):  # 迭代次数
        with tf.GradientTape() as tape:
            loss = tf.reduce_mean(model(dream))
        gradients = tape.gradient(loss, dream)
        optimizer.apply_gradients([(gradients, dream)])
        
        # 添加一些“梦”的元素
        dream.assign(tf.clip_by_value(dream + gradients, 0.0, 1.0))
        
        if step % 10 == 0:
            print(f'Step {step}, Loss: {loss.numpy()}')
    
    return dream.numpy()

# 使用示例
image_path = 'path_to_your_image.jpg'  # 替换为你的图像路径
input_image = preprocess_image(image_path)
dream_image = deep_dream(input_image)

# 保存结果
result_image = (dream_image[0] * 255).astype(np.uint8)
Image.fromarray(result_image).save('dream_result.jpg')

import openai

# OpenAI API密钥设置
openai.api_key = 'your_api_key'  # 替换为你的API密钥

# 使用DALL-E生成图像
def generate_image(prompt):
    response = openai.Image.create(
        prompt=prompt,
        n=1,
        size="1024x1024"
    )
    image_url = response['data'][0]['url']
    return image_url

# 示例
prompt = "A futuristic cityscape with flying cars and neon lights"
image_url = generate_image(prompt)
print("Generated Image URL:", image_url)

for epoch in range(num_epochs):
    # 训练判别器
    real_images = get_real_images(batch_size)
    noise = generate_noise(batch_size)
    fake_images = generator.predict(noise)

    d_loss_real = discriminator.train_on_batch(real_images, labels_real)
    d_loss_fake = discriminator.train_on_batch(fake_images, labels_fake)

    # 训练生成器
    noise = generate_noise(batch_size)
    g_loss = gan.train_on_batch(noise, labels_real)

import tensorflow as tf
from tensorflow.keras import layers

# 定义生成器模型
def build_generator():
    model = tf.keras.Sequential([
        layers.Dense(128, activation='relu', input_shape=(100,)),
        layers.Dense(784, activation='tanh')
    ])
    return model

# 定义判别器模型
def build_discriminator():
    model = tf.keras.Sequential([
        layers.Dense(128, activation='relu', input_shape=(784,)),
        layers.Dense(1, activation='sigmoid')
    ])
    return model

# 实例化模型
generator = build_generator()
discriminator = build_discriminator()

# 结合生成器和判别器
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
discriminator.trainable = False
gan_input = layers.Input(shape=(100,))
gan_output = discriminator(generator(gan_input))
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest'
)

# 使用示例
datagen.fit(training_images)

from scipy.linalg import sqrtm
from numpy import cov
from numpy import trace

def calculate_fid(real_images, fake_images):
    mu_real, sigma_real = real_images.mean(axis=0), cov(real_images, rowvar=False)
    mu_fake, sigma_fake = fake_images.mean(axis=0), cov(fake_images, rowvar=False)
    
    ssdiff = np.sum((mu_real - mu_fake)**2)
    covmean = sqrtm(sigma_real.dot(sigma_fake))
    fid = ssdiff + trace(sigma_real + sigma_fake - 2 * covmean)
    return fid