GAN model 训练中的损失 function 不变

Question

from keras.preprocessing.image import ImageDataGenerator
import tensorflow as tf
import numpy as n

# gene model define
class gene(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5],
                                           input_shape=(150,150,1))
        self.leak1 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv2 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak2 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv3 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[4,4])
        self.leak3 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv4 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[4,4])
        self.leak4 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv5 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[4,4])
        self.leak5 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv6 = tf.keras.layers.Conv2D(filters=64,
                                           kernel_size=[3,3])
        self.leak6 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv7 = tf.keras.layers.Conv2D(filters=64,
                                           kernel_size=[3,3])
        self.leak7 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.conv8 = tf.keras.layers.Conv2D(filters=64,
                                           kernel_size=[3,3])
        self.leak8 = tf.keras.layers.LeakyReLU(alpha =0.4)

        self.deconv1 = tf.keras.layers.Conv2DTranspose(64,
                                        kernel_size=[3,3])
        self.deleak1 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add1 = tf.keras.layers.Add()
        self.deconv2 = tf.keras.layers.Conv2DTranspose(64,
                                        kernel_size=[3,3])
        self.deleak2 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add2 = tf.keras.layers.Add()
        self.deconv3 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[3,3])
        self.deleak3 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add3 = tf.keras.layers.Add()
        self.deconv4 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[4,4])
        self.deleak4 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add4 = tf.keras.layers.Add()
        self.deconv5 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[4,4])
        self.deleak5 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add5 = tf.keras.layers.Add()
        self.deconv6 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[4,4])
        self.deleak6 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add6 = tf.keras.layers.Add()
        self.deconv7 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[5,5])
        self.deleak7 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.add7= tf.keras.layers.Add()
        self.deconv8 = tf.keras.layers.Conv2DTranspose(128,
                                        kernel_size=[5,5])
        self.deleak8 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.dense = tf.keras.layers.Dense(1,
                                           activation=tf.nn.relu)
        self.add = tf.keras.layers.Add()


    def call(self,inputs):
        x1 = self.conv1(inputs)
        x1 = self.leak1(x1)
        x2 = self.conv2(x1)
        x2 = self.leak2(x2)
        x3 = self.conv3(x2)
        x3 = self.leak3(x3)
        x4 = self.conv4(x3)
        x4 = self.leak4(x4)
        x5 = self.conv5(x4)
        x5 = self.leak5(x5)
        x6 = self.conv6(x5)
        x6 = self.leak6(x6)
        x7 = self.conv7(x6)
        x7 = self.leak7(x7)
        x8 = self.conv8(x7)
        x8 = self.leak8(x8)
        y1 = self.deconv1(x8)
        y1 = self.deleak1(y1)
        y1 = self.add1([x7,y1])
        y2 = self.deconv2(y1)
        y2 = self.deleak2(y2)
        y2 = self.add2([x6,y2])
        y3 = self.deconv3(y2)
        y3 = self.deleak3(y3)
        y3 = self.add3([x5,y3])
        y4 = self.deconv4(y3)
        y4 = self.deleak4(y4)
        y4 = self.add4([x4,y4])
        y5 = self.deconv5(y4)
        y5 = self.deleak5(y5)
        y5 = self.add5([x3,y5])
        y6 = self.deconv6(y5)
        y6 = self.deleak6(y6)
        y6 = self.add6([x2,y6])
        y7 = self.deconv7(y6)
        y7 = self.deleak7(y7)
        y7 = self.add7([x1,y7])
        y8 = self.deconv8(y7)
        y8 = self.deleak8(y8)
        x = self.dense(y8)
        output = self.add([x,inputs])
        return output

class dis(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.con1 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5],
                                           input_shape=(150,150,1))
        self.leak1 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con2 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak2 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con3 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak3 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con4 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak4 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con5 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak5 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con6 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak6 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con7 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak7 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.con8 = tf.keras.layers.Conv2D(filters=128,
                                           kernel_size=[5,5])
        self.leak8 = tf.keras.layers.LeakyReLU(alpha =0.4)
        self.flatten = tf.keras.layers.Flatten()

        self.dense1 = tf.keras.layers.Dense(1,
                                         activation=tf.nn.softmax)
    def call(self,inputs):
        x = self.con1(inputs)
        x = self.leak1(x)
        x = self.con2(x)
        x = self.leak2(x)
        x = self.con3(x)
        x = self.leak3(x)
        x = self.con4(x)
        x = self.leak4(x)
        x = self.con5(x)
        x = self.leak5(x)
        x = self.con6(x)
        x = self.leak6(x)
        x = self.con7(x)
        x = self.leak7(x)
        x = self.con8(x)
        x = self.leak8(x)
        x = self.flatten(x)
        x = tf.nn.dropout(x, 0.5)
        output = self.dense1(x)
        return output





gene1 = gene()
dis1 = dis()

这是 model 定义

#imagegenerator 
num=0
learning_rate = 0.001
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)

train_datagen = ImageDataGenerator(rescale=1./255)
train_gene = train_datagen.flow_from_directory(
    'data/',
    color_mode='grayscale',
    target_size=(150, 150),
    batch_size=10,
    class_mode=None)

图像生成器

from undersample import undersample
for num in range(1000):
    for x in train_gene:
        x_u = []
        for i in range(x.shape[0]):
            x_u.append(undersample(x[i,:,:,:],0.7))
        x_u = n.array(x_u)
        x_r = gene1(x_u)
        D_train = n.vstack((x,x_r)) 
        D_label = n.vstack((n.zeros((x.shape[0],1)),n.ones((x.shape[0],1))))
        with tf.GradientTape() as tape:
            D = dis1(D_train)

            loss = tf.keras.losses.binary_crossentropy(y_true=D_label,y_pred=D)
            loss = tf.reduce_mean(loss)
            print("batch %d: D_loss %f" % (num, loss.numpy()))
        grads = tape.gradient(loss , dis1.variables)
        optimizer.apply_gradients(grads_and_vars=zip(grads , dis1.variables))
        break
    for x in train_gene:
        x_u = []
        for i in range(x.shape[0]):
            x_u.append(undersample(x[i,:,:,:],0.7))
        x_u = n.array(x_u)
        with tf.GradientTape(watch_accessed_variables=False) as tape:
            tape.watch(gene1.variables)
            D = dis1(gene1(x_u))
            loss = tf.keras.losses.binary_crossentropy(y_true=n.zeros((x.shape[0],1)),y_pred=D)
            loss = tf.reduce_mean(loss)
            print('batch %d: G_loss %f' % (num, loss.numpy()))
        grads = tape.gradient(loss , gene1.variables)
        optimizer.apply_gradients(grads_and_vars=zip(grads , gene1.variables))
        break    

火车损失

我想训练一个 gan model 将欠采样 MRI 图像重建为正常 MRI 图像。 但是当我用上面的代码训练 model 时，我得到的 D_loss/G_loss 是 7.666619/15.333239 并且永远不会改变。 这是一个代码问题器官 model 火车不这样工作吗？

Answer 1

您想要的是提供发生器噪声并要求生成 MRI 图像。 但是，据我所知，您正在输入 MRI 图像，然后要求它检查 MRI 图像。

您需要生成器中的噪声，当它出现时，您需要使用原始图像获取 mean_squared_error，然后，您还需要使用原始 label 和您使用鉴别器获得的 label 获取 binary_crossentropy。

经过一些时期后，您将看到良好的图像，因为您的 model 是健全的。

当您开始时，鉴别器将具有很高的准确性，并且时间应该会减少。 这就是你想要的。

https://towardsdatascience.com/gan-by-example-using-keras-on-tensorflow-backend-1a6d515a60d0