tensorflow.keras搭建gan神经网络，可直接运行

最新推荐文章于 2024-07-19 14:39:32 发布
最新推荐文章于 2024-07-19 14:39:32 发布
阅读量1.5k 收藏 20
点赞数 6
分类专栏： 深度学习 文章标签： 深度学习 python tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42995327/article/details/110219613
版权

tensorflow.keras搭建gan神经网络，可直接运行

文章目录

前言

keras是tensorflow的一个高级API库之一，代码简洁，可读性强。本文采用tensorflow.keras来实现gan网络。具体的原理在本文不作过多阐述，只作为一个案例交流

#####keras中文参考文档

正文

一、tf.keras搭建gan网络大致步骤

1.首先我们需要将所有的图像数据装换为tensorflow提供的tfrecords的格式，利用creat_tfrecords.py文件生成即可（这个文件是我原来用作图像分类的标签生成的脚本文件，如果做gan网络不需要将标签也保存）
2.利用生成的tfrecords文件来建立数据集，利用tf.data.TFRecordDataset来进行设置，本文还提供了另一种方法来对tfrecords数据进行获取，但是殊途同归，方法都差不多
3.搭建generator网络
4.搭建discriminator网络，整合为gan网络（需要在gan网络compile之前将discriminator网络设置为不可训练）
5.建立循环体分别训练generator网络和discriminator网络
6.保存网络gan.model

二、使用步骤

1.制作tfrecords数据集

creat_tfrecords.py
默认生成tfrecords位置为 filename_train="./data/train.tfrecords"
终端输入：python creat_tfrecords.py --data [数据集位置]
生成train.tfrecords，也可以自己动手添加验证集和测试集的数据

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt 
import os
from PIL import Image
import random

objects = ['cat','dog']#'cat'0,'dog'1

filename_train="./data/train.tfrecords"
writer_train= tf.python_io.TFRecordWriter(filename_train)

tf.app.flags.DEFINE_string(
    'data', 'None', 'where the datas?.')
FLAGS = tf.app.flags.FLAGS

if(FLAGS.data == None):
    os._exit(0)

dim = (224,224)
object_path = FLAGS.data
total = os.listdir(object_path)
for index in total:
    img_path=os.path.join(object_path,index)
    img=Image.open(img_path)
    img=img.resize(dim)
    img_raw=img.tobytes()
    for i in range(len(objects)):
        if objects[i] in index:
            value = i
        else:
            continue
    example = tf.train.Example(features=tf.train.Features(feature={
                'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[value])),
                'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
                }))
    print([index,value])
    writer_train.write(example.SerializeToString())  #序列化为字符串
writer_train.close()

2.读入数据

利用tf.data.TFRecordDataset建立
代码如下：（load_image函数用来作为map的输入，对数据集进行解码），在main函数中调用：
train_datas,iter = dataset_tfrecords(tfrecords_path,use_keras_fit=False)

def load_image(serialized_example):   
    features={
        'label': tf.io.FixedLenFeature([], tf.int64),
        'img_raw' : tf.io.FixedLenFeature([], tf.string)}
    parsed_example = tf.io.parse_example(serialized_example,features)
    image = tf.decode_raw(parsed_example['img_raw'],tf.uint8)
    image = tf.reshape(image,[-1,224,224,3])
    image = tf.cast(image,tf.float32)*(1./255)
    label = tf.cast(parsed_example['label'], tf.int32)
    label = tf.reshape(label,[-1,1])
    return image,label
 
def dataset_tfrecords(tfrecords_path,use_keras_fit=True): 
    #是否使用tf.keras
    if use_keras_fit:
        epochs_data = 1
    else:
        epochs_data = epochs
    dataset = tf.data.TFRecordDataset([tfrecords_path])#这个可以有多个组成[tfrecords_name1,tfrecords_name2,...],可以用os.listdir(tfrecords_path):
    dataset = dataset\
                .repeat(epochs_data)\
                .shuffle(1000)\ 
                .batch(batch_size)\
                .map(load_image,num_parallel_calls = 2)
                #注意一定要将shuffle操作放在batch前
                

    iter = dataset.make_initializable_iterator()#make_one_shot_iterator()
    train_datas = iter.get_next() #用train_datas[0],[1]的方式得到值
    return train_datas,iter

3.搭建gan网络

a.搭建generator网络

    generator = keras.models.Sequential([
            #fullyconnected nets
            keras.layers.Dense(256,activation='selu',input_shape=[coding_size]),
            keras.layers.Dense(64,activation='selu'),
            keras.layers.Dense(256,activation='selu'),
            keras.layers.Dense(1024,activation='selu'),
            keras.layers.Dense(7*7*64,activation='selu'),
            keras.layers.Reshape([7,7,64]),
            #7*7*64
            #反卷积
            keras.layers.Conv2DTranspose(64,kernel_size=3,strides=2,padding='same',activation='selu'),
            #14*14*64
            keras.layers.Conv2DTranspose(64,kernel_size=3,strides=2,padding='same',activation='selu'),
            #28*28*64
            keras.layers.Conv2DTranspose(32,kernel_size=3,strides=2,padding='same',activation='selu'),
            #56*56*32
            keras.layers.Conv2DTranspose(16,kernel_size=3,strides=2,padding='same',activation='selu'),
            #112*112*16
            keras.layers.Conv2DTranspose(3,kernel_size=3,strides=2,padding='same',activation='tanh'),#使用tanh代替sigmoid
            #224*224*3
            keras.layers.Reshape([224,224,3])
            ])

b.搭建discriminator网络

    discriminator = keras.models.Sequential([
            keras.layers.Conv2D(128,kernel_size=3,padding='same',strides=2,activation='selu',input_shape=[224,224,3]),
            keras.layers.MaxPool2D(pool_size=2),
            #56*56*128
            keras.layers.Conv2D(64,kernel_size=3,padding='same',strides=2,activation='selu'),
            keras.layers.MaxPool2D(pool_size=2),
            #14*14*64
            keras.layers.Conv2D(32,kernel_size=3,padding='same',strides=2,activation='selu'),
            #7*7*32
            keras.layers.Flatten(),
            #dropout 0.4
            keras.layers.Dropout(0.4),
            keras.layers.Dense(512,activation='selu'),
            keras.layers.Dropout(0.4),
            keras.layers.Dense(64,activation='selu'),
            keras.layers.Dropout(0.4),
            #the last net
            keras.layers.Dense(1,activation='sigmoid')
            ])

c.整合generator，discriminator网络为gan网络

gan = keras.models.Sequential([generator,discriminator])

4.complie编译（建立loss和optimizer优化器）

    #compile the net
    discriminator.compile(loss="binary_crossentropy",optimizer='rmsprop')# metrics=['accuracy'])
    discriminator.trainable=False
    gan.compile(loss="binary_crossentropy",optimizer='rmsprop')# metrics=['accuracy'])

5.训练网络（建立循环）

获取数据集：

train_datas,iter = dataset_tfrecords(tfrecords_path,use_keras_fit=False)

循环体：（在里面使用cv2来对generator网络查看）

    sess = tf.Session()
    sess.run(iter.initializer)
    #打开线程协调器
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess,coord=coord)
    
    generator,discriminator = gan.layers
    print("-----------------start---------------")
    for step in range(num_steps):
        try:
            #get the time
            start_time = time.time()
            #phase 1 - training the discriminator
            noise = np.random.normal(size=batch_size*coding_size).reshape([batch_size,coding_size])
            noise = np.cast[np.float32](noise)
            generated_images = generator.predict(noise)
            train_datas_ = sess.run(train_datas)
            x_fake_and_real = np.concatenate([generated_images,train_datas_[0]],axis = 0)#np.concatenate
            #千万不能再循环体内用tf.concat,不能用tf相关的函数在循环体内定义
            #否则内存会被耗尽，而且训练速度越来越慢
            y1 = np.array([[0.]]*batch_size+[[1.]]*len(train_datas_[0]))
            discriminator.trainable = True
            dis_loss = discriminator.train_on_batch(x_fake_and_real,y1)
            #将keras 的train_on_batch函数放在gan网络中是明智之举
            #phase 2 - training the generator
            noise = np.random.normal(size=batch_size*coding_size).reshape([batch_size,coding_size])
            noise = np.cast[np.float32](noise)
            y2 = np.array([[1.]]*batch_size)
            discriminator.trainable = False
            ad_loss = gan.train_on_batch(noise,y2)
            duration = time.time()-start_time
            if step % 5 == 0:
                #gan.save_weights('gan.h5')
                print("The step is %d,discriminator loss:%.3f,adversarial loss:%.3f"%(step,dis_loss,ad_loss),end=' ')
                print('%.2f s/step'%(duration))
            if step % 30 == 0 and step != 0:
                noise = np.random.normal(size=[1,coding_size])
                noise = np.cast[np.float32](noise)
                fake_image = generator.predict(noise,steps=1)
                #复原图像
                #1.乘以255后需要映射成uint8的类型
                #2.也可以保持[0,1]的float32类型，依然可以直接输出
                arr_img = np.array([fake_image],np.float32).reshape([224,224,3])*255
                arr_img = np.cast[np.uint8](arr_img)
                #保存为tfrecords用的是PIL.Image,即打开为RGB，所以在用cv显示时需要转换为BGR
                arr_img = cv2.cvtColor(arr_img,cv2.COLOR_RGB2BGR)
                cv2.imshow('fake image',arr_img)
                cv2.waitKey(1500)#show the fake image 1.5s
                cv2.destroyAllWindows()
        #在迭代完以后会抛出这个错误OutOfRangeError，所以需要将迭代器初始化
        except tf.errors.OutOfRangeError: 
            sess.run(iter.initializer)
    #关闭线程协调器
    coord.request_stop()
    coord.join(threads)

6.保存网络

	#tensorflow 2.0版本
    #save the models 
    model_vision = '0001'
    model_name = 'gans'
    model_path = os.path.join(model_name,model_name)
    tf.saved_model.save(gan,model_path)
    #tensorflow 1.13.1版本
    #save the models 
    model_vision = '0001'
    gan.save_weights(model_vision)

7.完整的gans.py（可运行）

# -*- coding: utf-8 -*-
'''
    @author:zyl
    author is zouyuelin
    a Master of Tianjin University(TJU)
'''

import tensorflow as tf
from tensorflow import keras
#tf.enable_eager_execution()
import numpy as np
from PIL import Image
import os
import cv2
import time

batch_size = 32
epochs = 120
num_steps = 2000
coding_size = 30
tfrecords_path = 'data/train.tfrecords'

#--------------------------------------datasetTfrecord----------------   
def load_image(serialized_example):   
    features={
        'label': tf.io.FixedLenFeature([], tf.int64),
        'img_raw' : tf.io.FixedLenFeature([], tf.string)}
    parsed_example = tf.io.parse_example(serialized_example,features)
    image = tf.decode_raw(parsed_example['img_raw'],tf.uint8)
    image = tf.reshape(image,[-1,224,224,3])
    image = tf.cast(image,tf.float32)*(1./255)
    label = tf.cast(parsed_example['label'], tf.int32)
    label = tf.reshape(label,[-1,1])
    return image,label
 
def dataset_tfrecords(tfrecords_path,use_keras_fit=True): 
    #是否使用tf.keras
    if use_keras_fit:
        epochs_data = 1
    else:
        epochs_data = epochs
    dataset = tf.data.TFRecordDataset([tfrecords_path])#这个可以有多个组成[tfrecords_name1,tfrecords_name2,...],可以用os.listdir(tfrecords_path):
    dataset = dataset\
                .repeat(epochs_data)\
                .shuffle(1000)\ 
                .batch(batch_size)\
                .map(load_image,num_parallel_calls = 2)
                #注意一定要将shuffle操作放在batch前

    iter = dataset.make_initializable_iterator()#make_one_shot_iterator()
    train_datas = iter.get_next() #用train_datas[0],[1]的方式得到值
    return train_datas,iter

#------------------------------------tf.TFRecordReader-----------------
def read_and_decode(tfrecords_path):
    #根据文件名生成一个队列
    filename_queue = tf.train.string_input_producer([tfrecords_path],shuffle=True) 
    reader = tf.TFRecordReader()
    _,  serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example,features={
        'label': tf.FixedLenFeature([], tf.int64),
        'img_raw' : tf.FixedLenFeature([], tf.string)})

    image = tf.decode_raw(features['img_raw'], tf.uint8)
    image = tf.reshape(image,[224,224,3])#reshape 200*200*3
    image = tf.cast(image,tf.float32)*(1./255)#image张量可以除以255，*(1./255)
    label = tf.cast(features['label'], tf.int32)
    img_batch, label_batch = tf.train.shuffle_batch([image,label],
                    batch_size=batch_size,
                    num_threads=4,
                    capacity= 640,
                    min_after_dequeue=5)
    return [img_batch,label_batch]

#Autodecode 解码器
def autoencode():
        encoder = keras.models.Sequential([
            keras.layers.Conv2D(32,kernel_size=3,padding='same',strides=2,activation='selu',input_shape=[224,224,3]),
            #112*112*32
            keras.layers.MaxPool2D(pool_size=2),
            #56*56*32
            keras.layers.Conv2D(64,kernel_size=3,padding='same',strides=2,activation='selu'),
            #28*28*64
            keras.layers.MaxPool2D(pool_size=2),
            #14*14*64
            keras.layers.Conv2D(128,kernel_size=3,padding='same',strides=2,activation='selu'),
            #7*7*128
            #反卷积
            keras.layers.Conv2DTranspose(128,kernel_size=3,strides=2,padding='same',activation='selu'),
            #14*14*128
            keras.layers.Conv2DTranspose(64,kernel_size=3,strides=2,padding='same',activation='selu'),
            #28*28*64
            keras.layers.Conv2DTranspose(32,kernel_size=3,strides=2,padding='same',activation='selu'),
            #56*56*32
            keras.layers.Conv2DTranspose(16,kernel_size=3,strides=2,padding='same',activation='selu'),
            #112*112*16
            keras.layers.Conv2DTranspose(3,kernel_size=3,strides=2,padding='same',activation='tanh'),#使用tanh代替sigmoid
            #224*224*3
            keras.layers.Reshape([224,224,3])
            ])
        return encoder

def training_keras():
    '''
        卷积和池化输出公式：
            output_size = (input_size-kernel_size+2*padding)/strides+1
            
        keras的反卷积输出计算，一般不用out_padding
        1.若padding = 'valid':
            output_size = (input_size - 1)*strides + kernel_size
        2.若padding = 'same:
            output_size = input_size * strides
    '''
    generator = keras.models.Sequential([
            #fullyconnected nets
            keras.layers.Dense(256,activation='selu',input_shape=[coding_size]),
            keras.layers.Dense(64,activation='selu'),
            keras.layers.Dense(256,activation='selu'),
            keras.layers.Dense(1024,activation='selu'),
            keras.layers.Dense(7*7*64,activation='selu'),
            keras.layers.Reshape([7,7,64]),
            #7*7*64
            #反卷积
            keras.layers.Conv2DTranspose(64,kernel_size=3,strides=2,padding='same',activation='selu'),
            #14*14*64
            keras.layers.Conv2DTranspose(64,kernel_size=3,strides=2,padding='same',activation='selu'),
            #28*28*64
            keras.layers.Conv2DTranspose(32,kernel_size=3,strides=2,padding='same',activation='selu'),
            #56*56*32
            keras.layers.Conv2DTranspose(16,kernel_size=3,strides=2,padding='same',activation='selu'),
            #112*112*16
            keras.layers.Conv2DTranspose(3,kernel_size=3,strides=2,padding='same',activation='tanh'),#使用tanh代替sigmoid
            #224*224*3
            keras.layers.Reshape([224,224,3])
            ])
            
    discriminator = keras.models.Sequential([
            keras.layers.Conv2D(128,kernel_size=3,padding='same',strides=2,activation='selu',input_shape=[224,224,3]),
            keras.layers.MaxPool2D(pool_size=2),
            #56*56*128
            keras.layers.Conv2D(64,kernel_size=3,padding='same',strides=2,activation='selu'),
            keras.layers.MaxPool2D(pool_size=2),
            #14*14*64
            keras.layers.Conv2D(32,kernel_size=3,padding='same',strides=2,activation='selu'),
            #7*7*32
            keras.layers.Flatten(),
            #dropout 0.4
            keras.layers.Dropout(0.4),
            keras.layers.Dense(512,activation='selu'),
            keras.layers.Dropout(0.4),
            keras.layers.Dense(64,activation='selu'),
            keras.layers.Dropout(0.4),
            #the last net
            keras.layers.Dense(1,activation='sigmoid')
            ])
    #gans network        
    gan = keras.models.Sequential([generator,discriminator])
    
    #compile the net
    discriminator.compile(loss="binary_crossentropy",optimizer='rmsprop')# metrics=['accuracy'])
    discriminator.trainable=False
    gan.compile(loss="binary_crossentropy",optimizer='rmsprop')# metrics=['accuracy'])
    
    #dataset
    #train_datas = read_and_decode(tfrecords_path)
    train_datas,iter = dataset_tfrecords(tfrecords_path,use_keras_fit=False)
    
    sess = tf.Session()
    sess.run(iter.initializer)
    
    #打开线程协调器
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess,coord=coord)
    
    generator,discriminator = gan.layers
    print("-----------------start---------------")
    for step in range(num_steps):
        try:
            #get the time
            start_time = time.time()
            #phase 1 - training the discriminator
            noise = np.random.normal(size=batch_size*coding_size).reshape([batch_size,coding_size])
            noise = np.cast[np.float32](noise)
            generated_images = generator.predict(noise)
            train_datas_ = sess.run(train_datas)
            x_fake_and_real = np.concatenate([generated_images,train_datas_[0]],axis = 0)#np.concatenate
            #千万不能再循环体内用tf.concat,不能用tf相关的函数在循环体内定义
            #否则内存会被耗尽，而且训练速度越来越慢
            y1 = np.array([[0.]]*batch_size+[[1.]]*len(train_datas_[0]))
            discriminator.trainable = True
            dis_loss = discriminator.train_on_batch(x_fake_and_real,y1)
            #将keras 的train_on_batch函数放在gan网络中是明智之举
            #phase 2 - training the generator
            noise = np.random.normal(size=batch_size*coding_size).reshape([batch_size,coding_size])
            noise = np.cast[np.float32](noise)
            y2 = np.array([[1.]]*batch_size)
            discriminator.trainable = False
            ad_loss = gan.train_on_batch(noise,y2)
            duration = time.time()-start_time
            if step % 5 == 0:
                #gan.save_weights('gan.h5')
                print("The step is %d,discriminator loss:%.3f,adversarial loss:%.3f"%(step,dis_loss,ad_loss),end=' ')
                print('%.2f s/step'%(duration))
            if step % 30 == 0 and step != 0:
                noise = np.random.normal(size=[1,coding_size])
                noise = np.cast[np.float32](noise)
                fake_image = generator.predict(noise,steps=1)
                #复原图像
                #1.乘以255后需要映射成uint8的类型
                #2.也可以保持[0,1]的float32类型，依然可以直接输出
                arr_img = np.array([fake_image],np.float32).reshape([224,224,3])*255
                arr_img = np.cast[np.uint8](arr_img)
                #保存为tfrecords用的是PIL.Image,即打开为RGB，所以在用cv显示时需要转换为BGR
                arr_img = cv2.cvtColor(arr_img,cv2.COLOR_RGB2BGR)
                cv2.imshow('fake image',arr_img)
                cv2.waitKey(1500)#show the fake image 1.5s
                cv2.destroyAllWindows()
        #在迭代完以后会抛出这个错误OutOfRangeError，所以需要将迭代器初始化
        except tf.errors.OutOfRangeError: 
            sess.run(iter.initializer)
            
    #关闭线程协调器
    coord.request_stop()
    coord.join(threads)
    #save the models tf2.0版本使用
    model_vision = '0001'
    model_name = 'gans'
    model_path = os.path.join(model_name,model_name)
    tf.saved_model.save(gan,model_path)
    #save the models tensorflow 1.13.1版本
    model_vision = '0001'
    gan.save_weights(model_vision)
    
def main():
    training_keras()
main()

至此便完成了简单的gan训练

参考资料

论文：《Generative Adversarial Networks》
参考源码：
https://github.com/eriklindernoren/Keras-GAN/blob/master/gan/gan.py
参考博客:
https://blog.csdn.net/u010138055/article/details/94441812

最后的话

深度学习、机器学习的学渣小硕一枚，刚起步，不足的地方还请大家多多指教。

机器人学渣
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基础GAN实例（pytorch代码实现）
weixin_51781852的博客
07-16 7695
输出是长度为100的噪声（正态分布随机数）输出为（1，28，28）的图片linear1100---256linear2256--512linear3reshapenn.Tanh()#对于生成器，最后一个激活函数是tanh,值域-1到1)#定义前向传播#x表示长度为100的noise输入img=img.view(-1,28,28)#转换成图片的形式输入为为（1，28，28）的图片，输出为二分类的概率值，输出使用sigmoid的激活0-1BCEloss计算交叉熵损失。...
GAN学习：Keras入门
Cream_Cicilian的博客
03-11 5679
Keras入门1.环境配置2.搭建一个简单的网络3.多元线性回归3.1 准备数据集3.2 环境配置3.2代码3.4 结果 学习视频：来自bilibili 1.环境配置 在annaconda下创建一个新的虚拟环境 配置： tensorflow需要指定为2.0版本，注意tensorflow和keras的版本一定要对应，对应查看 pip install tensorflow==2.0 pip install keras==2.3.1 2.搭建一个简单的网络 搭建一个网络，去得到公式y=3*x+7，为一元线性回归
初次运行gan，运行vanilla_gan过程中踩的坑
Allstruct的博客
10-17 883
matplotlib/mat1 and mat2 shapes cannot be multiplied (64x2352 and 784x512)/Using a target size (torch.Size([64])) that is different to the input size (torch.Size([192, 1])) is deprecated./No module named 'tensorflow'/No module named 'tensorflow.examples'
利用深度学习进行黑白照片着色：使用 Keras 构建 GAN 进行照片自动上色的详细实践指南
qq_38334677的博客
07-16 3386
在我们深入到构建模型的具体过程之前，让我们先来理解一下什么是生成对抗网络（GAN）。GAN 是深度学习领域的一种革命性技术，它由两部分组成：生成器和判别器。生成器的任务是生成逼真的假数据，而判别器的任务是尽可能地区分真实数据和假数据。这两个网络的竞争和合作推动了 GAN 的训练过程，使其能够生成越来越逼真的假数据。在我们的场景中，我们将利用 GAN 的这种能力，让它学习如何为黑白照片上色。换句话说，生成器的任务是将黑白照片转换为彩色照片，判别器的任务则是区分真实的彩色照片和生成器生成的彩色照片。
可直接运行的gan小项目（详细注释）结合代码通俗理解gan的原理
weixin_40015791的博客
05-01 2969
大家先看底下对这个gan小项目来源和介绍，然后再看代码，copy下来可直接运行。中文注释是我自己理解的过程中加的，对好不了解gan但是想直接上手的同志比较友好，如果注释有不合理的地方欢迎指出～ 这个小项目有利于不了解gan原理的同志迅速上手和了解gan原理 #-*-coding= utf-8 -*- import tensorflow as tf import numpy as np #i...
tensorflow 搭建神经网络框架
sinat_36391198的博客
11-23 276
1）准备数据，打开文件夹读取数据 def read_data(data_dir): datas = [] labels = [] for fname in os.listdir(data_dir): fpath = os.path.join(data_dir, fname) image = Image.open(fpath) ...
tensorflow入门（简单神经网络实现）
NFMSR的博客
10-14 2418
tensorflow 详细的介绍可以看极客学院的tensorflow的官网： http://wiki.jikexueyuan.com/project/tensorflow-zh/get_started/introduction.html 官网上讲解的比较清楚。。。 这里采用一个简单的神经网络的实现，来对tensorflow基本语法进行介绍，同时也想让大家对用tensorflow实现神经网络有
gan-master.zip_GaN_tensorflow_样本生成_深度学习_深度学习gan
07-14
4. **深度学习GAN**：这里的“深度学习gan”指的是使用深度神经网络结构来构建GAN的生成器和判别器。深度神经网络通常包含多层隐藏层，可以学习到更复杂的数据表示，从而生成更精细、更真实的样本。 5. **...
Keras深度学习与神经网络.7z
05-30
Keras是建立在TensorFlow、Theano和CNTK等后端之上的高级API，它使得构建和训练复杂的神经网络模型变得简单易行。以下是对这个压缩包中可能包含的详细知识点的解析： 一、深度学习基础 深度学习是机器学习的一个...
neuralNets:在pytorch tensorflow keras框架中探索和试验神经网络
03-20
在神经网络领域，PyTorch、TensorFlow和Keras是三种主流的深度学习框架，它们为数据科学家和机器学习工程师提供了强大的工具来构建和训练复杂的神经网络模型。本项目"neuralNets"旨在深入探索和试验这些框架的特性与...
Spine-GAN_spine_keras_GaN_
10-04
Keras是一个流行的开源深度学习库，它用Python编写，可以运行在TensorFlow、Theano或CNTK等后端上，使得构建和训练神经网络变得简单。 GANs（生成对抗网络）是由两部分组成的深度学习模型：生成器（Generator）和...
GAN对抗网络(原始版).zip
08-19
GAN，全称为Generative Adversarial Networks（生成对抗网络），是由Ian Goodfellow在2014年提出的一种深度学习框架，它由两个神经网络构成：生成器（Generator）和判别器（Discriminator）。生成器尝试模拟真实数据...
GAN入门教程 | 从0开始，手把手教你学会最火的神经网络
zh538438的博客
06-18 1374
生成式对抗网络是20年来机器学习领域最酷的想法，这是一篇来自量子位翻译整理的学习方法，特地整理和转载分享给各位。
GAN的介绍和简单代码的实现
weixin_43979090的博客
09-19 5382
GAN是什么，其全称是Generative Adversarial Networks,即生成式对抗网络，这是一种深度学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。模型中有两大模块，生成模型(Generative Model,我们用G来简称)，和判别模型(Discriminative，我们用D来简称)，GAN的学习过程便是这两个过程之间的博弈对抗，在GAN的理论中，并不要求G和D都是神经...
GAN入门实例【个人理解】
qq_44149057的博客
03-29 2407
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 @GAN入门实例【个人理解】 前言 本文记录了B站[GAN生成对抗网络精讲 tensorflow2.0代码实战]，相关理解(https://b23.tv/jlDcosT) 代码流程 1.引入库 import tensorflow as tf from tensorflow import keras from tensorflow .keras import layers import matplotlib.pyplot as plt .
深度学习自学记录（5）——简单明了地实现Keras的生成对抗网络（GAN）（含代码）
qq_40784418的博客
04-27 1574
深度学习自学记录（5）——简单明了地实现Keras的生成式对抗网络（GAN）1、生成式对抗网络（GAN）的原理2、GAN的训练思路3、GAN的Keras实现 1、生成式对抗网络（GAN）的原理 2、GAN的训练思路 3、GAN的Keras实现 ...
keras 实现GAN（生成对抗网络）
cchangcs
11-18 1万+
本文将介绍如何在Keras中以最小的形式实现GAN。具体实现是一个深度卷积GAN，或DCGAN：一个GAN，其中generator和discriminator是深度卷积网络，它利用`Conv2DTranspose`层对generator中的图像上采样。 然后将在CIFAR10的图像上训练GAN，CIFAR10数据集由属于10个类别（每个类别5,000个图像）的50,000个32x32 RGB图像构...
GAN（生成对抗网络）的系统全面介绍（醍醐灌顶）
热门推荐
m0_61878383的博客
01-18 12万+
本文是关于GAN学习的较为系统全面的介绍，主要针对初学者，希望能够对大家带来帮助。
【深度学习图像】拼接图的切分
最新发布
q742971636的博客
07-19 256
如果将这张图拆为多个子图，下面是一种opencv的办法，后面要训练一个模型来识别边缘更为准确。用户常常将多张图拼成一张图。
解释一下这段代码，import os from model import unet import tensorflow as tf from tensorflow.keras.callbacks import ReduceLROnPlateau from tensorflow.keras import backend as K from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.
06-12
这段代码是针对使用 TensorFlow 搭建 U-Net 模型进行图像分割任务的代码。下面是对代码中每行的简单解释： - `import os`：导入 Python 的 os 模块，用于操作文件和目录。 - `from model import unet`：从名为 model 的 Python 模块中导入名为 unet 的 U-Net 模型。 - `import tensorflow as tf`：导入 TensorFlow 库。 - `from tensorflow.keras.callbacks import ReduceLROnPlateau`：从 TensorFlow 的 Keras 子库中导入名为 ReduceLROnPlateau 的学习率调整回调函数。 - `from tensorflow.keras import backend as K`：从 TensorFlow 的 Keras 子库中导入名为 backend 的模块，并将其重命名为 K。 - `from tensorflow.keras.preprocessing.image import ImageDataGenerator`：从 TensorFlow 的 Keras 子库中导入名为 ImageDataGenerator 的图像数据生成器。 - `from tensorflow.keras.`：因为代码被截断，无法继续解释。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值