Trjtdtk

I'm working on a sequence to sequence model using LSTM, the model worked perfectly with an autoencoder, but when I try to use a Variational autoencoder by adding the mean and deviation layer and changing the loss function , I get this error:

InvalidArgumentError: Incompatible shapes: [32,153] vs [32,5]

 # 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)

 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') #max_len_eng = 3
 decoder_input_data = np.zeros((batch_size, 
 max_len_fr),dtype='float32') 
 #max_len_french =5
 decoder_target_data = np.zeros((batch_size,max_len_fr, 
 num_decoder_tokens), dtype='float32')

 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] 
 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
 encoder_states = [state_h, state_c]

 """ -------- ADD 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=1
 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

 z = Lambda(sampling, output_shape=(latent_dim,))([z_mu, z_log_var])

 state_h= z
 state_c = z
 encoder_states = [state_h, state_c]
 #loss function with VAE
 def vae_loss(y_true, y_pred):
 """ Calculate loss = reconstruction loss + KL loss for each data in 
 minibatch """
 # 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[:, None]


 # 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) 
 #num_decoder_tokens = 152
 final_dex= dex(decoder_inputs)
 decoder_lstm = LSTM(50, return_sequences=True, return_state=True)
 decoder_outputs, _, _ = 
 decoder_lstm(final_dex,initial_state=encoder_states)
 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 = 5
 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)

 end = time.time()
 print("temp d'exec:", end-start)

I tried all solutions suggested on other posts, but no one helped me.
Thanks.