devbox
代码独立开发者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

利用keras框架搭建一个简单CGAN模型，制作一个数据集用作训练_使用cgan训练自己的数据集

作者：代码独立开发者 | 2024-01-28 23:42:26

赞

踩

使用cgan训练自己的数据集

目录

利用keras框架搭建一个CGAN模型是比较方便的，这里我就不多说什么了，直接上代码吧

        数据集的构建大致如下：

关于tag.txt:

关于tags.txt：

文本相似度的对比可以通过余弦相似度比较，例如以下代码：

        

        目前网络上搭建这种模型的文章已经很多了，在这里我会说一些在阅读其他作者的相关文章的同时进行搭建遇到的一系列问题以及数据集兼容的一点见解。

利用keras框架搭建一个CGAN模型是比较方便的，这里我就不多说什么了，直接上代码吧

  1. import matplotlib.pyplot as plt
  2. import numpy as np
  3. from keras.optimizers import Adam
  4. from keras.layers import Input, Dense, Reshape, Flatten, Dropout, multiply, LeakyReLU, Layer, BatchNormalization, \
  5.     Embedding
  6. from keras.models import Model, Sequential
  7. import tensorflow as tf
  8. from tensorflow.python.keras.models import save_model
  9. from keras.utils import plot_model
  10. import myDataToMnist
  11.  
  12.  
  13. class Mycgan():
  14.     def __init__(self):
  15.  
  16.         self.img_rows = 64  # 输入图像像素行
  17.         self.img_cols = 64  # 输入图像像素列
  18.         self.img_tag = 1  # 标签
  19.         self.channels = 3  # 管道数量，彩色图像rgb三个管道
  20.         self.img_shapes = (self.img_rows, self.img_cols, self.img_tag, self.channels)  # 将三个图像形象组合成一个shape
  21.         self.num_classes = 21  # 样本的数量
  22.         self.latent_dim = 100  # 特征向量的维度
  23.  
  24.         optimizer = Adam(0.0002, 0.5)  # 优化算法，自适应的梯度下降算法,参数为：学习速率，
  25.  
  26.         # 构建判别器
  27.         self.discriminator = self.build_Discriminator()
  28.         self.discriminator.compile(loss=['binary_crossentropy'], optimizer=optimizer, metrics=['accuracy'])
  29.  
  30.         # 构建生成器
  31.         self.generator = self.build_Generator()
  32.  
  33.         # 生成器的输入定义（噪声+标签）
  34.         noise = Input(shape=(self.latent_dim,), name='noise')
  35.         label = Input(shape=(1,), name='label')
  36.         img = self.generator([noise, label])  # 生成器生成图像的输入定义
  37.  
  38.         # 暂时仅训练生成器
  39.         self.discriminator.trainable = True
  40.  
  41.         # 鉴别器将生成图像与标签作为输入判别图像真实性
  42.  
  43.         valid = self.discriminator([img, label])
  44.  
  45.         # 组合模型
  46.         self.combined = Model([noise, label], valid, name='CGAN_Model')
  47.         self.combined.compile(loss=['binary_crossentropy'], optimizer=optimizer)
  48.  
  49.     def build_Generator(self):
  50.         # 堆叠模型，允许添加多个层构建深度神经网络
  51.  
  52.         model = Sequential()
  53.  
  54.         model.add(Dense(256, input_dim=self.latent_dim))  # 全连接层
  55.         model.add(LeakyReLU(alpha=0.2))  # 带泄露的RLU层，赋予模型一个起始较小的梯度
  56.         model.add(BatchNormalization(momentum=0.8))  # 批量标准化层，将输入张量的数据转换到0~1之间
  57.         model.add(Dense(512))
  58.         model.add(LeakyReLU(alpha=0.2))
  59.         model.add(BatchNormalization(momentum=0.8))
  60.         model.add(Dense(1024))
  61.         model.add(LeakyReLU(alpha=0.2))
  62.         model.add(BatchNormalization(momentum=0.8))
  63.         model.add(Dense(np.prod(self.img_shapes), activation='tanh'))  # 双曲正切激活函数
  64.         model.add(Reshape(self.img_shapes))  # 将转换并计算后张量转换到指定尺寸（此处为原图像尺寸）
  65.  
  66.         model.summary()  # 打印网络结构及各项参数
  67.  
  68.         noise = Input(shape=(self.latent_dim,))
  69.         label = Input(shape=(1,), dtype='float32')
  70.         label_embedding = Flatten()(Embedding(input_dim=self.num_classes, output_dim=self.latent_dim)(label))
  71.  
  72.         # label = Input(shape=(1,),dtype='string')
  73.         # label_embedding = Flatten()(Embedding(self.num_classes,self.latent_dim))  #将参数联合转换为稠密张量，再展平为一维张量
  74.  
  75.         model_input = multiply([noise, label_embedding])  # 通过将噪声与标签逐一乘积合成一个张量作为整个生成器的输入
  76.         img = model(model_input)  # 生成图像
  77.         save_model(Model([noise, label], img), 'generator.h5')
  78.         return Model([noise, label], img, name='generator')  # 将生成图像与合成的条件向量作为输出传入到判别器
  79.  
  80.     def build_Discriminator(self):
  81.  
  82.         model = Sequential()
  83.  
  84.         model.add(Dense(512, input_dim=np.prod(self.img_shapes)))
  85.         model.add(LeakyReLU(alpha=0.2))
  86.         model.add(Dense(512))
  87.         model.add(LeakyReLU(alpha=0.2))
  88.         model.add(Dropout(0.4))  # 防止过拟合
  89.         model.add(Dense(512))
  90.         model.add(LeakyReLU(alpha=0.2))
  91.         model.add(Dropout(0.4))
  92.         model.add(Dense(1, activation='sigmoid'))
  93.         model.summary()
  94.  
  95.         img = Input(shape=self.img_shapes)
  96.         label = Input(shape=(1,), dtype='int32')
  97.  
  98.         label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shapes))(label))
  99.         flat_img = Flatten()(img)
  100.  
  101.         model_input = multiply([flat_img, label_embedding])
  102.  
  103.         validity = model(model_input)
  104.  
  105.         save_model(Model([img, label], validity), 'discriminator.h5')
  106.         return Model([img, label], validity, name='discriminator')
  107.  
  108.     def train(self, epochs, batch_size=32, sample_interval=50):
  109.  
  110.         # 加载数据集
  111.         (X_train, Y_train) = (myDataToMnist.x_train, myDataToMnist.y_train)
  112.  
  113.         X_train = (X_train.astype(np.float32) - 127.5) / 127.5
  114.         X_train = np.expand_dims(X_train, axis=3)
  115.         Y_train = Y_train.reshape(-1, 1)
  116.  
  117.         valid = np.ones([batch_size, 1])
  118.         fake = np.zeros([batch_size, 1])
  119.  
  120.         for epochs in range(epochs):
  121.  
  122.             index = np.random.randint(0, X_train.shape[0], batch_size)
  123.             imgs, labels = X_train[index], Y_train[index]
  124.  
  125.             noise = np.random.normal(0, 1, (batch_size, 100))
  126.  
  127.             gen_img = self.generator.predict([noise, labels])
  128.  
  129.             d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
  130.             d_loss_fake = self.discriminator.train_on_batch([gen_img, labels], fake)
  131.             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
  132.  
  133.             sample_labels = np.random.randint(0, 20, batch_size).reshape(-1, 1)
  134.  
  135.             g_loss = self.combined.train_on_batch([noise, sample_labels], valid)
  136.  
  137.             print("%d [D 损失：%f, ACC.: %.2f%%]  [G 损失: %f]" % (epochs, d_loss[0], 100 * d_loss[1], g_loss))
  138.  
  139.             if epochs % sample_interval == 0:
  140.                 self.sample_images(epochs)
  141.         tf.keras.models.save_model(self.combined, 'my_cgan_model.h5')
  142.  
  143.         plot_model(self.combined, show_shapes=True, to_file='./model.png')
  144.  
  145.     def sample_images(self, epoch):
  146.         r, c = 4, 5
  147.         noise = np.random.normal(0, 1, (r * c, 100))
  148.         sample_labels = np.arange(0, 20).reshape(-1, 1)
  149.  
  150.         gen_image = self.generator.predict([noise, sample_labels])
  151.  
  152.         gen_image = 0.5 * gen_image + 0.5
  153.  
  154.         fig, axs = plt.subplots(r, c)
  155.         cnt = 0
  156.         for i in range(r):
  157.             for j in range(c):
  158.                 axs[i, j].imshow(gen_image[cnt, :, :, 0])
  159.                 axs[i, j].set_title("Digit:  %d" % sample_labels[cnt])
  160.                 axs[i, j].axis('off')
  161.                 cnt += 1
  162.         fig.savefig("images/%d.png" % epoch)
  163.         plt.close()
  164.  
  165.  
  166. if __name__ == '__main__':
  167.     cgan = Mycgan()
  168.     cgan.train(epochs=1500, batch_size=128, sample_interval=200)

        需要注意的是，此处数据集不再是mnist灰度图像数据集，而是我自己创建的一个类似格式的彩色图像数据集。

        数据集的构建大致如下：

  1. import os
  2. import numpy as np
  3. import pandas as pd
  4. from PIL import Image
  5.  
  6. # 定义数据集目录路径及相关信息
  7. data_dir = f"包含图像文件夹的文件夹"
  8. label_data_dir = f"标签文件夹名称"
  9. label_file = '标签，下面有解释'
  10. image_dir = f"图像文件夹名"
  11. label_dict = {}
  12. filename = '映射关联文本'
  13.  
  14. # 取图像文件夹，从0开始将图像名称作为对应值键入
  15. with open(filename, 'r') as f:
  16.     lines = f.readlines()
  17.     for line in lines:
  18.         key, value = line.strip().split(':')
  19.         label_dict[key] = value
  20.  
  21. print(label_dict.__len__())
  22.  
  23. # 读取标签文件，构建 y_train 数组
  24. with open(os.path.join(label_data_dir, label_file), "r") as f:
  25.     labels = f.readlines()
  26. y_train = np.array([int(label.strip()) for label in labels])  # 删除每个标签后面的换行符
  27.  
  28. # 读取图像文件，构建 x_train 数组
  29. image_paths = [os.path.join(data_dir, image_dir, fname) for fname in os.listdir(os.path.join(data_dir, image_dir)) if
  30.                fname.endswith(".jpg")]
  31.  
  32. x_train = []
  33.  
  34. for image_path in image_paths:
  35.     with Image.open(image_path) as img:
  36.         img = img.resize((64, 64))
  37.         img_arr = np.array(img)  # 将 PIL.Image 对象转换为 ndarray 数组
  38.         x_train.append(img_arr)
  39.  
  40. x_train = np.array(x_train)
  41.  
  42. y_train_desc = []
  43. for y in y_train:
  44.     y_train_desc.append(label_dict[str(y)])
  45.  
  46. train_df = pd.DataFrame({"data": list(x_train), "label": y_train_desc})
  47. train_df.to_csv("train.csv", index=False)
  48.  
  49. print(x_train.shape[1])

关于tag.txt:

 序号，长度为你要构建的图像集的图像数

关于tags.txt：

        映射关系，具体为于当前序号相关联的图像的名称

        大致就是这样，如果想通过控制台输入控制图像生成的话，可以将生成器中label封装一层文本相似度比较的程序，通过比较输入文本与数据集中映射文本的相似度选取最高相似度的文本对应的序号作为随机条件噪声输入，只需要把sample_labels = np.arrange(0,20).reshape(-1,1)改为np.array(输入的随机条件噪声值).reshape(-1,1)就行，当然本代码中的图像展示只是训练结果，如果需要测试结果必须通过读取保存好的模型.h5文件进行predict().

文本相似度的对比可以通过余弦相似度比较，例如以下代码：

  1. # 输入文本进行清洗
  2. import jieba
  3. import myDataToMnist
  4. from sklearn.feature_extraction.text import TfidfVectorizer
  5. from sklearn.metrics.pairwise import cosine_similarity
  6.  
  7. def text_compare():
  8.     # 1.对文本进行分词
  9.     print("请输入一些描述词，类似“紫色的花”：")
  10.     text1 = input()
  11.     len1 = len(text1)
  12.     text2 = ""
  13.     sim = 0.0
  14.     label = ""
  15.     for tex2 in  myDataToMnist.y_train_desc:
  16.         len2 = len(tex2)
  17.         if len1 > len2:
  18.             text2 += ' ' * (len1 - len2)
  19.         else:
  20.             text1 += ' ' * (len1 - len2)
  21.  
  22.         sen1 = jieba.lcut(text1)
  23.         sen2 = jieba.lcut(tex2)
  24.  
  25.         seg_str1 = ",".join(sen1)
  26.         seg_str2 = ",".join(sen2)
  27.  
  28.         vectorizer = TfidfVectorizer()
  29.         vectorizer.fit([seg_str1,seg_str2])
  30.         vector1,vector2 = vectorizer.transform([seg_str1,seg_str2])
  31.  
  32.         similarity = cosine_similarity(vector1,vector2)[0][0]
  33.         if similarity > sim:
  34.             sim = similarity
  35.             label = tex2
  36.     print("文本相似度：",sim)
  37.     print("相似文本：",label)
  38.     print("噪声编号：", myDataToMnist.y_train_desc.index(label))
  39.  
  40.  
  41. # 通过值找到键
  42. def get_key(key, value):
  43.     return list(key.keys())[list(key.values()).index(value)]
  44.  
  45.  
  46. text_compare()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/42280
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号