import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
import os
from keras.layers import Dense, Flatten, Reshape, LeakyReLU, Dropout
from keras.models import Sequential
from keras.optimizers import Adam
from keras.layers import BatchNormalization, Activation
from keras.layers import Activation, BatchNormalization
from keras.layers import Conv2D, Conv2DTranspose
import cv2

width = 144
height = 144
channels = 1
shape = (width, height, channels)
noise_dim = 100



def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 18 * 18, input_dim=noise_dim))
    model.add(Reshape((18, 18, 256)))

    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    
    model.add(Conv2DTranspose(32, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    
    return model


def discriminator_model(shape):
    model = Sequential()

    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(256, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(512, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(1024, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    return model



def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),#0.0001→0.0002,
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))#0.0003→0.0004

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./gray_144_face")
    X_train = X_train / 127.5 - 1.0
    X_train=np.expand_dims(X_train,axis=3)#グレースケールだから
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)


        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)


def save_images(generator, iteration, directory='144x144x_face_gray_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

def load_images(directory):#グレースケール用に変換する
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  
            img = cv2.resize(img, (width, height))
            if len(img.shape) == 3:  # チャンネルが3の場合はグレースケールに変換
                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)



iterations = 20000
batch_size = 128
sample_interval = 1  

train(iterations, batch_size, sample_interval)
generator.save('Face-gene.keras')
discriminator.save('Face-dis.keras')
gan.save('Face-gan.keras')

import matplotlib.pyplot as plt
import numpy as np
from keras.layers import Dense, Flatten,Reshape, LeakyReLU 
from keras.models import Sequential
from keras.optimizers import Adam
import os
from keras.layers import Activation,Dropout,BatchNormalization
from keras.layers import Conv2D
from keras.layers import UpSampling2D
import cv2
#上記↑は『衝撃簡単7』と同じ
from keras.layers import Conv2DTranspose

width = 144
height = 144
channels = 1
shape = (width, height, channels)
noise_dim = 100

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 18 * 18, input_dim=noise_dim))
    model.add(Reshape((18, 18, 256)))

    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    
    model.add(Conv2DTranspose(32, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    
    return model

def discriminator_model(shape):
    model = Sequential()

    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(256, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(512, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(1024, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    return model

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./gray_144_face")
    X_train = X_train / 127.5 - 1.0
    X_train=np.expand_dims(X_train,axis=3)#グレースケールだから
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)


        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

def load_images(directory):#グレースケール用に変換する
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  
            img = cv2.resize(img, (width, height))
            if len(img.shape) == 3:  # チャンネルが3の場合はグレースケールに変換
                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)

def save_images(generator, iteration, directory='144x144x_face_gray_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

iterations = 20000
batch_size = 128
sample_interval = 100 

train(iterations, batch_size, sample_interval)
generator.save('144Face-gene.keras')
discriminator.save('144Face-dis.keras')
gan.save('144Face-gan.keras')

ファイル名.py

import numpy as np
import matplotlib.pyplot as plt
from keras.models import load_model
import os

noise_dim=100
def generate_and_save_images(generator, noise_dim, save_directory='generated_images', num_images=10):
    if not os.path.exists(save_directory):
        os.makedirs(save_directory)
    
    for i in range(num_images):
        noise = np.random.normal(0, 1, (1, noise_dim))
        generated_image = generator.predict(noise)
        generated_image = 0.5 * generated_image + 0.5  # 画像のスケーリングを元に戻す
        generated_image = np.squeeze(generated_image)  # 不要な次元を削除
        plt.imshow(generated_image, cmap='gray')
        plt.axis('off')
        plt.savefig(f"{save_directory}/generated_image_{i+1}.png")
        plt.close()

# 生成器モデルをロードする
generator = load_model('144Face-gene.keras')

# 10枚の画像を生成して保存する
generate_and_save_images(generator, noise_dim)

from keras.layers import Input, Dense, Reshape, Flatten, Dropout
from keras.layers import BatchNormalization, Activation, ZeroPadding2D
from keras.layers import LeakyReLU
from keras.layers import UpSampling2D, Conv2D
from keras.models import Sequential, Model
from keras.optimizers import Adam
import matplotlib.pyplot as plt
import os
import cv2
import numpy as np

width = 40
height = 40
channels = 3
shape = (width, height, channels)
noise_dim = 100


def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(10 * 10 * 256, activation="relu", input_dim=noise_dim))
    model.add(Reshape((10, 10, 256)))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())

    model.add(Conv2D(128, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())


    model.add(Conv2D(64, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))

    model.add(Conv2D(3, kernel_size=3, padding="same"))
    model.add(Activation("tanh"))
    return model



def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model




def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model


discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))



losses = []
accuracies = []
iteration_checkpoints = []



def train(iterations, batch_size, sample_interval):
    X_train = load_images("./resized_images_40")
    X_train = X_train / 127.5 - 1.0
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx_real = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        idx_fake = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        batch_images_real = X_train[idx_real]
        batch_images_fake = X_train[idx_fake]
        
        # ノイズの生成時に正しい次元数を使用する
        z = np.random.normal(0, 1, (batch_size, noise_dim))  # 修正
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)  # 修正
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)

        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)


def save_images(generator, iteration, directory='face-gan_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt])
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)


def load_images(directory):
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  # 画像の読み込みが成功した場合のみ処理を続行
            img = cv2.resize(img, (width, height))
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)


iterations = 20000
batch_size = 128
sample_interval = 1  
train(iterations, batch_size, sample_interval)
generator.save('40x40color-Face-gene.keras')
discriminator.save('40x40color-Face-dis.keras')
gan.save('40x40color-Face-gan.keras')

import matplotlib.pyplot as plt
import numpy as np
from keras.layers import Dense, Flatten,Reshape, LeakyReLU 
from keras.models import Sequential
from keras.optimizers import Adam
import os
from keras.layers import Activation,Dropout,BatchNormalization
#上記↑は『衝撃簡単５』と同じ
from keras.layers import Conv2D
from keras.layers import UpSampling2D
import cv2

width = 40
height = 40
channels = 3
shape = (width, height, channels)
noise_dim = 100

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(10 * 10 * 256, activation="relu", input_dim=noise_dim))
    model.add(Reshape((10, 10, 256)))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())

    model.add(Conv2D(128, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())


    model.add(Conv2D(64, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))

    model.add(Conv2D(3, kernel_size=3, padding="same"))
    model.add(Activation("tanh"))
    return model

def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./resized_images_40")
    X_train = X_train / 127.5 - 1.0
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx_real = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        idx_fake = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        batch_images_real = X_train[idx_real]
        batch_images_fake = X_train[idx_fake]
        
        # ノイズの生成時に正しい次元数を使用する
        z = np.random.normal(0, 1, (batch_size, noise_dim))  # 修正
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)  # 修正
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)

        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

def load_images(directory):
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  # 画像の読み込みが成功した場合のみ処理を続行
            img = cv2.resize(img, (width, height))
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)

def save_images(generator, iteration, directory='face-gan_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt])
            #カラーなので前回までのgene_imgs[cnt, :, :, 0], cmap='gray'は不要
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

iterations = 20000
batch_size = 128
sample_interval = 100 
train(iterations, batch_size, sample_interval)
generator.save('40x40color-Face-gene.keras')
discriminator.save('40x40color-Face-dis.keras')
gan.save('40x40color-Face-gan.keras')

ファイル名.py

import numpy as np
import matplotlib.pyplot as plt
from keras.models import load_model
import os
import cv2
noise_dim=100
# 保存したGANモデルの読み込み
generator = load_model('40x40color-Face-gene.keras')

def generate_images(generator, save_directory, num_images=10):
    if not os.path.exists(save_directory):
        os.makedirs(save_directory)

    noise = np.random.normal(0, 1, (num_images, noise_dim))
    generated_images = generator.predict(noise)

    for i in range(num_images):
        img = (generated_images[i] + 1) / 2  # 画像のスケーリングを元に戻す
        plt.imshow(img)
        plt.axis('off')
        plt.savefig(f"{save_directory}/generated_image_{i+1}.png")
        plt.close()

# 画像を保存するディレクトリと生成する画像の枚数を指定して実行
generate_images(generator, "generated_images", num_images=40)

import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
import os
from keras.layers import Dense, Flatten, Reshape, LeakyReLU, Dropout
from keras.models import Sequential
from keras.optimizers import Adam

from keras.layers import Activation, BatchNormalization
from keras.layers import Conv2D, Conv2DTranspose

width = 28
height = 28
channels = 1
shape = (width, height, channels)
noise_dim = 100

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 7 * 7, input_dim=noise_dim))
    model.add(Reshape((7, 7, 256)))
    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization())

    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    return model



def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    (X_train, _), (_, _) = mnist.load_data()
    X_train = X_train / 127.5 - 1.0
    X_train = np.expand_dims(X_train, axis=3)
    real_label = np.ones((batch_size, 1))
    fake_label = np.zeros((batch_size, 1))

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)


        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)



def save_images(generator, iteration, directory='dcgan_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

iterations = 20000
batch_size = 128
sample_interval = 50  

train(iterations, batch_size, sample_interval)
generator.save('DC_generator.keras')
discriminator.save('DC_discriminator.keras')
gan.save('dcgan_model.keras')

import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist

from keras.layers import Dense, Flatten, Reshape,LeakyReLU
from keras.models import Sequential
from keras.optimizers import Adam
import os
#上記↑は前回と同じ
from keras.layers import Activation, Dropout,BatchNormalization
from keras.layers import Conv2D, Conv2DTranspose

width=28
height=28
channels=1
shape=(width,height,channels)
noise_dim=100

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 7 * 7, input_dim=noise_dim))
    model.add(Reshape((7, 7, 256)))
    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization())

    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    return model

def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

def gan_model(generator,discriminator):
    model=Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)#前回と同じ
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])#追加コード

generator = generator_model(noise_dim)#前回と同じ
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))#追加コード

discriminator.trainable = False#前回と同じ

gan = gan_model(generator, discriminator)#前回と同じ
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))#追加コード

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    (X_train, _), (_, _) = mnist.load_data()
    X_train = X_train / 127.5 - 1.0
    X_train = np.expand_dims(X_train, axis=3)
    real_label = np.ones((batch_size, 1))
    fake_label = np.zeros((batch_size, 1))

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))#前回と違って今回はこれを追加する
        #前回はここにdiscriminator.trainable = Falseを入れたが今回は削除

        g_loss = gan.train_on_batch(z, real_label)
        #前回はここにdiscriminator.trainable = True を入れたが今回は削除

        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

def save_images(generator, iteration, directory='dcgan_directory', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

iterations=20000
batch_size=128
sample_interval=1000
train(iterations,batch_size,sample_interval)

#モデルの保存
generator.save('DCGAN_generator.keras')
discriminator.save('DCGAN_discriminator.keras')
gan.save('DCGAN_model.keras')

#モデルのロード方法
from keras.models import load_model

# 保存されたモデルをロード
loaded_model = load_model('DCGAN_generator.keras')

import matplotlib.pyplot as plt
import numpy as np
import os
from keras.datasets import mnist
from keras.layers import Dense, Flatten, Reshape, LeakyReLU
from keras.models import Sequential
from keras.optimizers import Adam

width = 28
height = 28
channels = 1
shape = (width, height, channels)
noise_dim = 100

def generator_model(shape, noise_dim):
    model = Sequential()
    model.add(Dense(128, input_dim=noise_dim))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dense(28 * 28 * 1, activation='tanh'))
    model.add(Reshape(shape))
    return model

def discriminator_model(shape):
    model = Sequential()
    model.add(Flatten(input_shape=shape))
    model.add(Dense(128))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dense(1, activation='sigmoid'))
    return model

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(), metrics=['accuracy'])
generator = generator_model(shape, noise_dim)
discriminator.trainable = False
gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam())

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    #前処理
    (X_train, _), (_, _) = mnist.load_data()
    X_train = X_train / 127.5 - 1.0
    X_train = np.expand_dims(X_train, axis=3)
    real_label = np.ones((batch_size, 1))
    fake_label = np.zeros((batch_size, 1))

    #訓練
    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)
        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)
        discriminator.trainable = False
        g_loss = gan.train_on_batch(z, real_label)
        discriminator.trainable = True

        #データ確認
        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

def save_images(generator, iteration, directory='gan_directory', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

iterations = 40000
batch_size = 128
sample_interval = 500
train(iterations, batch_size, sample_interval)

generator.save('generator.keras')
discriminator.save('discriminator.keras')
gan.save('gan_model.keras')