Trjtdtk

In the code below, I'm using a VAE with a seq-to-seq approach for translation. At the beginning I sarted only by using a simple seq-to-seq approach which implements a RNN-AE, until this step I had not errors. When I try to use a VAE by adding the two layers for mean and deviation , and by changing the loss function, I get this error :

tensorflow.python.framework.errors_impl.InvalidArgumentError: Incompatible shapes [32,153] vs [32]

In this line of code:

Traceback (most recent call last):
in module validation_steps = 1

I get this error even when I change th validation_steps value or the batch-size

# Train - Test Split
X, y = lines.eng, lines.fr
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1)
print(X_train.shape, X_test.shape)

"""fonction pour charger le data par lot (batch size)"""
def generate_batch(X = X_train, y = y_train, batch_size = 32):
''' Generate a batch of data '''
while True:
 for j in range(0, len(X), batch_size):
 encoder_input_data = np.zeros((batch_size, 
 max_len_eng),dtype='float32')
 decoder_input_data = 
 np.zeros((batch_size,max_len_fr),dtype='float32')
 decoder_target_data = np.zeros((batch_size,max_len_fr, 
 num_decoder_tokens),
 dtype='float32')
 #for i, (input_text, target_text) in enumerate(zip(lines.eng, lines.fr)):
 for i, (input_text, target_text) in enumerate(zip(X[j:j+batch_size], 
 y[j:j+batch_size])):
 for t, word in enumerate(input_text.split()):
 encoder_input_data[i, t] = input_token_index[word]
 for t, word in enumerate(target_text.split()):
 # decoder_target_data is ahead of decoder_input_data by one timestep
 if t<len(target_text.split())-1:
 decoder_input_data[i, t] = target_token_index[word] 
 # decoder input seq
 if t > 0:
 # decoder_target_data will be ahead by one timestep
 # and will not include the start character.
 decoder_target_data[i, t - 1, target_token_index[word]] = 1
 yield([encoder_input_data, decoder_input_data], 
 decoder_target_data)

encoder_inputs = Input(shape=(None,)) 
en_x= Embedding(num_encoder_tokens, embedding_size,mask_zero = 
 True)(encoder_inputs)
encoder = LSTM(50, return_state=True)
encoder_outputs, state_h, state_c = encoder(en_x) #initialisé à 0
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]
""" ---------------Here change for VAE----------------- """
""" ___________________________________________________ """
latent_dim =embedding_size
# output layer for mean and log variance
z_mu = Dense(latent_dim)(encoder_outputs) #remplacer h
z_log_var = Dense(latent_dim)(encoder_outputs)

def sampling(args):
batch_size=32
z_mean, z_log_sigma = args
epsilon = K.random_normal(shape=(batch_size, latent_dim),
 mean=0., stddev=1.)
return z_mean + K.exp(z_log_sigma) * epsilon

# note that "output_shape" isn't necessary with the TensorFlow backend
# so you could write `Lambda(sampling)([z_mean, z_log_sigma])`
z = Lambda(sampling, output_shape=(latent_dim,))([z_mu, z_log_var])
z1 = Lambda(sampling, output_shape=(latent_dim,))([z_mu, z_log_var])

#loss function with VAE
 def vae_loss(y_true, y_pred):
 # E[log P(X|z)]
 recon = K.sum(K.binary_crossentropy(y_pred, y_true), axis=1)
# D_KL(Q(z|X) || P(z|X)); calculate in closed form as both dist. are 
Gaussian
kl = 0.5 * K.sum(K.exp(z_log_var) + K.square(z_mu) - 1. - z_log_var, axis=1)

return recon + kl
""" ----------------------------------------------------"""
""" ----------------------------------------------------"""
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None,))
dex= Embedding(num_decoder_tokens, embedding_size,mask_zero = True)
final_dex= dex(decoder_inputs)
decoder_lstm = LSTM(50, return_sequences=True, return_state=True)

decoder_outputs, _, _ = decoder_lstm(final_dex,initial_state=[z, z1])
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='rmsprop', loss=vae_loss, metrics=['acc'])
model.summary()
train_samples = len(X_train)
val_samples = len(X_test)
batch_size = 32
epochs = 10

 model.fit_generator(generator = generate_batch(X_train, y_train, batch_size 
 = batch_size),
 steps_per_epoch = train_samples//batch_size,
 epochs=epochs,
 validation_data = generate_batch(X_test, y_test, batch_size 
 = batch_size),
 validation_steps = 1)

 encoder_model = Model(encoder_inputs, encoder_states)

this is the model summary:

Thank you in advance for your help.