kerasでの自作モデルで学習を始めることができない

Question

現在このようなモデルを作成しています．

import os
import glob
from PIL import Image
import numpy as np
import keras
# os.environ['CUDA_VISIBLE_DEVICES'] = '/job:localhost/replica:0/task:0/device:GPU:0'
# keras modules
from keras.preprocessing.image import load_img,img_to_array
os.environ["KERAS_BACKEND"] = "tensorflow"
kerasBKED = os.environ["KERAS_BACKEND"] 
from tensorflow.keras.models import load_model
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.layers import Input, Dense, Conv2D, Reshape,MaxPooling2D, UpSampling2D, ZeroPadding2D,BatchNormalization, Activation,AveragePooling2D,Dropout,Flatten
from tensorflow.keras.models import Model , Sequential
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.optimizers import Adam,SGD
from tensorflow.keras import layers
import tensorflow.keras.backend as K
import tensorflow as tf
from tqdm import tnrange
import matplotlib.pyplot as plt 
import matplotlib 
import cv2
from natsort import natsorted
from keras.preprocessing import image
import time

###############################################################
#residual block
###############################################################

def residual_block(x, filters_in, filters_out, k_size):
    shortcut = x
    x = layers.Conv2D(filters_in, kernel_size=(1, 1), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.LeakyReLU()(x)
    
    x = layers.Conv2D(filters_in, kernel_size=(k_size, k_size), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.LeakyReLU()(x)    
    
    x = layers.Conv2D(filters_out, kernel_size=(1, 1), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    
    shortcut_channel = x.shape.as_list()[-1]
    
    if shortcut_channel != filters_out:
        shortcut = layers.Conv2D(filters_out, kernel_size=(1, 1), strides=(1, 1), padding="same")(shortcut)
        
    x = layers.Add()([x, shortcut])
    return layers.LeakyReLU()(x)


###############################################################
#residual block
###############################################################    
mask_num = 4
input_image = Input(shape=(240,320,3))
x = Conv2D(16, (7, 7), padding='same')(input_image)
x = Conv2D(32, (3, 3), strides = 2, padding='same')(x)
x = Conv2D(64, (3, 3), strides = 2, padding='same')(x)
x = residual_block(x , 64, 64, 2)
x = residual_block(x , 64, 64, 2)
x = residual_block(x , 64, 64, 2)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(16, (3, 3), padding='same')(x)
x = Conv2D(mask_num, (3, 3),  padding='same')(x)
x = Activation('softmax')(x)
# x_r = np.array(x)
# x_r = cv2.bitwise_not(x_r)

residual = Model(input_image,x)
residual.summary()


###############################################################
#Segmentation
###############################################################

latent_dim = 1000
generator_input = Input(latent_dim, name='z_sampling')

x = Dense(latent_dim, activation='relu')(generator_input)
x = Reshape((15,20,3))(x)

x = BatchNormalization()(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(128, (3, 3), padding='same')(x)
x = Activation('relu')(x)

x = BatchNormalization()(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(64, (3, 3), padding='same')(x)
x = Activation('relu')(x)

x = BatchNormalization()(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), padding='same')(x)

x = BatchNormalization()(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(3, (3, 3), padding='same')(x)
x = Activation('sigmoid')(x)


generator = Model(generator_input,x)
generator.summary()


lst_mask = []
lst_gen = []


for i in range(mask_num):
    xi = residual.output[:,:,:,i]
    lst_mask.append(xi)


for i in range(mask_num):
    x = lst_mask[i]

    zi_1 = generator(generator_input)[:,:,:,0]
    zi_2 = generator(generator_input)[:,:,:,1]
    zi_3 = generator(generator_input)[:,:,:,2]

    Zi_1 = x*zi_1
    Zi_2 = x*zi_2
    Zi_3 = x*zi_3

    Zii_1 = Zi_1[:,:,:,tf.newaxis]
    Zii_2 = Zi_2[:,:,:,tf.newaxis]
    Zii_3 = Zi_3[:,:,:,tf.newaxis]

    Zi = tf.concat([Zii_1 ,Zii_2 ,Zii_3 ],axis = 3)

    lst_gen.append(Zi)

x_masked = np.array(lst_gen)
x_masked = np.sum(x_masked, axis = 0)

x_r   = np.array(lst_mask)
x_r   = np.sum(x_r, axis = 0)/mask_num*(-1)+1  

x_inf_1 = input_image[:,:,:,0]*x_r
x_inf_2 = input_image[:,:,:,1]*x_r
x_inf_3 = input_image[:,:,:,2]*x_r

X_inf_1 = x_inf_1[:,:,:,tf.newaxis]
X_inf_2 = x_inf_2[:,:,:,tf.newaxis]
X_inf_3 = x_inf_3[:,:,:,tf.newaxis]

x_inf   = tf.concat([X_inf_1,X_inf_2,X_inf_3],axis = 3)

x_out = x_masked + x_inf

mask_gen = Model([input_image,generator_input],x_out)
mask_gen.summary()

ReDO_optimizer = tf.keras.optimizers.RMSprop(lr=0.0004, clipvalue = 1.0, decay = 1e-8)
mask_gen.compile(optimizer = ReDO_optimizer , loss = 'binary_crossentropy')



inputs = Input(shape=(240,320,3))


x = Conv2D(16, (3, 3), padding='same')(inputs)
x = tf.nn.leaky_relu(x, alpha=0.01, name='Leaky_ReLU')
x = Dropout(0.25)(x)
x = Conv2D(16, (3, 3), padding='same')(x)
x = ZeroPadding2D(padding=((0,1),(1,0)))(x)
x = tf.nn.leaky_relu(x, alpha=0.01, name='Leaky_ReLU')
x = Dropout(0.25)(x)
x = BatchNormalization()(x)
x = Conv2D(16, (3, 3), padding='same')(x)
x = tf.nn.leaky_relu(x, alpha=0.01, name='Leaky_ReLU')
x = Dropout(0.25)(x)
x = BatchNormalization()(x)
x = Conv2D(16, (3, 3), padding='same')(x)
x = tf.nn.leaky_relu(x, alpha=0.01, name='Leaky_ReLU')
x = Dropout(0.25)(x)
x = Flatten()(x)
x = Dense(1)(x)
x = Activation('sigmoid')(x)

# discriminator
Discriminator = Model(inputs,x)
Discriminator.summary()
discriminator_optimizer = tf.keras.optimizers.RMSprop(lr = 0.0008, clipvalue = 1.0, decay = 1e-8)
Discriminator.compile(optimizer = discriminator_optimizer, loss = 'binary_crossentropy')
# redo
Discriminator.trainable = False

ReDO_input_1  = Input(shape=(240,320,3))
ReDO_input_2  = Input(shape=(latent_dim,))
                      
ReDO_output = Discriminator(mask_gen([ReDO_input_1,ReDO_input_2]))
ReDO = Model([ReDO_input_1,ReDO_input_2],ReDO_output)

ReDO_optimizer = tf.keras.optimizers.RMSprop(lr=0.0004, clipvalue = 1.0, decay = 1e-8)
ReDO.compile(optimizer = ReDO_optimizer , loss = 'binary_crossentropy')
ReDO.summary()

iteration = 5000 +1
batch_size = 10

base_dir = Path

save_dir_fake = base_dir + '/fig/fake'
os.makedirs(save_dir_fake,exist_ok = True)

save_dir_real = base_dir + '/fig/real'
os.makedirs(save_dir_real,exist_ok = True)

data = x_train
start = 0
discriminator_loss = []
adversarial_loss = []

for step in range(iteration):
    
    
    
    random_latent_vectors = np.random.normal(size = (batch_size,latent_dim))
    
    stop = start + batch_size
    
    generated_images = mask_gen.predict([data[start:stop],random_latent_vectors])
    real_images = x_train[start:stop]
    combined_images = np.concatenate([generated_images,real_images])
    labels = np.concatenate([np.ones((batch_size,1)),np.zeros((batch_size,1))])
    labels += 0.05 * np.random.random(labels.shape)
    d_loss = Discriminator.train_on_batch(combined_images , labels)
    
    random_latent_vectors = np.random.normal(size=(batch_size,240,320,3))
    
    misleading_targets = np.zeros((batch_size,1))
    
    a_loss = ReDO.train_on_batch(random_latent_vectors , misleading_targets)
    
    start += batch_size
    if start > len(x_train)-batch_size:
        start=0
    
    discriminator_loss.append(d_loss)
    adversarial_loss.append(a_loss)
    
    if step%10 == 0:

        print(f'step {step}/{iteration-1}')
        os.makedirs(base_dir + '/weight', exist_ok = True)
        GAN_VAE.save_weights(base_dir + '/weight/weights{step}.hdf5')
        
        print('discriminator loss at step %s: %s' % (step,d_loss))
        print('adversarial loss at step %s: %s' % (step,a_loss))
        
        img = plt.imshow(generated_images[0])
        plt.tick_params(labelbottom=False, labelleft=False, bottom=False, left=False)
        plt.subplots_adjust(left=0, right=1, bottom=0, top=1)
        plt.savefig(os.path.join(save_dir_fake, 'gen' + str(step) + '.png'), dpi=300)
        plt.close()
        
        img =  plt.imshow(real_images[0])
        plt.tick_params(labelbottom=False, labelleft=False, bottom=False, left=False)
        plt.subplots_adjust(left=0, right=1, bottom=0, top=1)
        plt.savefig(os.path.join(save_dir_real, 'real' + str(step) + '.png'), dpi=300)
        plt.close()
        
        
###################
### Plot losses ###
###################
x = np.arange(iteration)
plt.plot(x, discriminator_loss, "b", label = "Discriminator loss" )
plt.plot(x, adversarial_loss , "r", label = "Advsersarial loss")
plt.title("Losses")
plt.legend()
os.makedirs(base_dir + '/fig/loss' ,exist_ok = True)
plt.savefig(base_dir + '/fig/loss/loss_{iteration-1}.png')
plt.close()


###################
###  make GIF  ###
###################

im_1 = []
list_im_1 = natsorted(glob.glob(save_dir_fake+ '/*.png'))
for images_1 in list_im_1:
    img_g_1 = Image.open(images_1)
    im_1.append(img_g_1)
im_1[0].save(base_dir + f'/gif_{iteration-1}.gif'
           , save_all = True
           , append_images = im_1[1:]
           , optimize = False
           , duration = 100
           , loop = 0)

このようなエラーがでます

InvalidArgumentError:  Input to reshape is a tensor with 10000 values, but the requested shape has 9000
	 [[node model_2/model_1_5/reshape/Reshape (defined at C:\Users\eerg\Anaconda3\lib\site-packages\tensorflow_core\python\framework\ops.py:1751) ]] [Op:__inference_distributed_function_14347]

mask_gen.predictに入れるデータが分からないです．
モデルの定義上画像データとノイズを入力するようにしているのですが，うまくいっていないと思われます．
どのようなデータの入れ方をすればよいのでしょうか？

Comments

[toast-uz]

何かのコピペですか？こういうモデルの書き方はあまり見ないので、回答つきにくいと思います。

[退会済みユーザー]

エラーの末尾だけだとさらにコメントがもらいにくくなります。

あと、10000と9000という数字に心当たりはありますか？shapeが合っていなくてエラーが出ている、ですので、恐らくどこかの数字をこねくり回すだけで解決できるタイプのエラーと思います。

[siroto]

すみません．またちゃんと質問がまとまり次第再度質問したいと思います．ありがとうございました。