def build_decoder(self): inputs = Input(shape=(self.hidden_dim, )) repeat = RepeatVector(self.max_sequence_len)(inputs) lstm_layer = GRU(self.hidden_dim, return_sequences=True) hidden_rep = lstm_layer(repeat) time_dist_dense_layer = TimeDistributed( Dense(self.vocab_size, activation='softmax')) outputs = time_dist_dense_layer(hidden_rep) lstm_layer.set_weights( [self.sequence_autoencoder.layers[4].get_weights()]) time_dist_dense_layer.set_weights( [self.sequence_autoencoder.layers[5].get_weights()]) decoder = Model(inputs, outputs) decoder.summary() return decoder
class HydraNet(object): def __init__(self, **kwargs): self.verbose = False # training configuration self.training_scheme = DEFAULT_TRAIN_SCHEME self.training_scheme.update(kwargs) self.clear_batches = self.training_scheme['clear_batches'] self.lr_initial = self.training_scheme['lr_initial'] self.guaranteed_percepts = self.training_scheme['guaranteed_percepts'] self.uncertain_percepts = self.training_scheme['uncertain_percepts'] self.p_levels = copy.deepcopy(self.training_scheme['p_levels']) self.p_level_batches = self.training_scheme['p_level_batches'] self.p_final = self.training_scheme['p_final'] self.lr_final = self.training_scheme['lr_final'] self.final_batches = self.training_scheme['final_batches'] self.max_until_convergence = self.training_scheme['max_until_convergence'] # loss trackers self.pred_loss_train = [] self.pred_loss_test = [] # network configuration self.v_size = self.training_scheme['v_size'] # modules of network self.encoder = None self.decoder = None self.state_pred_train = None self.err_pred = None # special layers self.gru_replay = None # full networks self.pred_ae = None self.pred_ae_state = None # outputs also state self.stepper = None # build network self.build_modules() # self.load_modules() self.build_heads() # gru_replay purposely skipped (weights are copied from gru_train) self.modules = [self.encoder, self.decoder, self.state_pred_train, self.err_pred] def build_modules(self): # build encoder input_im = Input(shape=IM_SHAPE) h = Convolution2D(16, 5, 5, subsample=(2, 2), activation='relu', border_mode='same')(input_im) h = Convolution2D(8, 3, 3, subsample=(2, 2), activation='relu', border_mode='same')(h) h = Reshape((392,))(h) v = Dense(self.v_size, activation='relu')(h) m = Model(input_im, v, name='encoder') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.encoder = m # build decoder input_v = Input(shape=(self.v_size,)) h = Dense(8 * 7 * 7, activation='relu')(input_v) h = Reshape((7, 7, 8))(h) h = UpSampling2D((2, 2))(h) h = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(h) h = UpSampling2D((2, 2))(h) output_im = Convolution2D(1, 5, 5, activation='sigmoid', border_mode='same')(h) m = Model(input_v, output_im, name='decoder') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.decoder = m # gru for training input_vs = Input(shape=(EP_LEN - SERIES_SHIFT, self.v_size,)) # output_vs = LSTM(self.v_size, return_sequences=True)(input_vs) output_vs = GRU(self.v_size, return_sequences=True)(input_vs) # mulitple parallel grus # GRU_SPLIT = 4 # outputs = [] # for _ in range(GRU_SPLIT): # outputs.append(GRU(self.v_size // GRU_SPLIT, return_sequences=True)(input_vs)) # # output_vs = merge(outputs, mode='concat') # multiple layers # h = GRU(self.v_size, return_sequences=True)(input_vs) # h = GRU(self.v_size, return_sequences=True)(h) # output_vs = GRU(self.v_size, return_sequences=True)(h) m = Model(input_vs, output_vs, name='state_pred_train') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.state_pred_train = m # gru for replays self.gru_replay = GRU(self.v_size, stateful=True) # error pred input_s = Input(shape=(self.v_size,)) h = Dense(10, activation='sigmoid')(input_s) # h = Dense(10, activation='sigmoid')(h) err = Dense(1, activation='sigmoid')(h) m = Model(input_s, err, name='error_pred') m.compile(optimizer='adam', loss='mse') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.err_pred = m # TODO: aux variables: loss, position, velocity # TODO: generator (decoder with noise) def load_modules(self, folder=FOLDER_MODELS, tag='0'): for module in self.modules: fpath = '{}/{}-{}.hdf5'.format(folder, module.name, tag) print('Loading {} from {}'.format(module.name, fpath)) try: module.load_weights(fpath) except Exception: print('Failed to load module {}'.format(module)) self.gru_replay.set_weights(self.state_pred_train.get_weights()) def save_modules(self, folder=FOLDER_MODELS, tag='0'): for module in self.modules: fpath = '{}/{}-{}.hdf5'.format(folder, module.name, tag) print('Saving {} to {}'.format(module.name, fpath)) module.save_weights(fpath) def load_model(self, fpath): self.pred_ae.load_weights(fpath) self.gru_replay.set_weights(self.state_pred_train.get_weights()) def build_heads(self): # build predictive autoencoder input_ims = Input(shape=(EP_LEN - SERIES_SHIFT, IM_WIDTH, IM_HEIGHT, IM_CHANNELS)) td1 = TimeDistributed(self.encoder, input_shape=(EP_LEN - SERIES_SHIFT, IM_WIDTH, IM_HEIGHT, IM_CHANNELS)) h = td1(input_ims) h = self.state_pred_train(h) td2 = TimeDistributed(self.decoder, input_shape=(EP_LEN, self.v_size)) output_preds = td2(h) m = Model(input_ims, output_preds, name='pred_ae_train') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() m.compile(optimizer=Adam(lr=0.001), loss='mse') self.pred_ae = m # build pae with state output m = Model(input_ims, output=[h, output_preds], name='pred_ae_state') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.pred_ae_state = m # build replayer input_im = Input(batch_shape=(1, IM_WIDTH, IM_HEIGHT, IM_CHANNELS)) h = self.encoder(input_im) h = Reshape((1, self.v_size))(h) state = self.gru_replay(h) output_recon = self.decoder(state) m = Model(input_im, output=(output_recon, state), name='stepper') draw_network(m, to_file='{0}/{1}.png'.format(FOLDER_DIAGRAMS, m.name), show_layer_names=True, show_shapes=True) if self.verbose: m.summary() self.stepper = m # --------------------- TRAINING ------------------------------- def mask_percepts(self, images, p, return_indices=False): images_masked = np.copy(images) for_removal = np.random.random(EP_LEN) < p if self.uncertain_percepts > 0: clear_percepts = self.guaranteed_percepts + np.random.randint(0, self.uncertain_percepts) else: clear_percepts = self.guaranteed_percepts for_removal[0:clear_percepts] = False images_masked[:, for_removal, ...] = 0 if return_indices: return images_masked, for_removal else: return images_masked def train_batch_pred_ae(self, image_getter, p=0.0, test=False): images = image_getter() if p > 0.0: images_masked = self.mask_percepts(images, p) else: images_masked = images if test: # loss = self.pred_ae.test_on_batch(images_masked[:, 0:-SERIES_SHIFT, ...], loss = self.pred_ae.test_on_batch(images_masked[:, :, ...], images[:, SERIES_SHIFT:, ...]) else: # loss = self.pred_ae.train_on_batch(images_masked[:, 0:-SERIES_SHIFT, ...], loss = self.pred_ae.train_on_batch(images_masked[:, :, ...], images[:, SERIES_SHIFT:, ...]) return loss def execute_scheme(self, train_getter, test_getter): self.pred_ae.compile(optimizer=Adam(lr=self.lr_initial), loss='mse') postfix = {} if self.clear_batches > 0: current_p = 0.0 print('Current p:', current_p) bar = trange(self.clear_batches) for i in bar: self.pred_loss_train.append(self.train_batch_pred_ae(train_getter, p=current_p)) smooth_loss = np.mean(self.pred_loss_train[-10:]) postfix['L train'] = smooth_loss if i % TEST_EVERY_N_BATCHES == 0: self.pred_loss_test.append(self.train_batch_pred_ae(test_getter, p=current_p, test=True)) smooth_loss = np.mean(self.pred_loss_test[-4:]) postfix['L test'] = smooth_loss bar.set_postfix(**postfix) # self.save_modules() while len(self.p_levels) > 0: current_p = self.p_levels.pop(0) print('Current p:', current_p) bar = trange(self.p_level_batches) for i in bar: self.pred_loss_train.append(self.train_batch_pred_ae(train_getter, p=current_p)) smooth_loss = np.mean(self.pred_loss_train[-10:]) postfix['L train'] = smooth_loss if i % TEST_EVERY_N_BATCHES == 0: self.pred_loss_test.append(self.train_batch_pred_ae(test_getter, p=current_p, test=True)) smooth_loss = np.mean(self.pred_loss_test[-4:]) postfix['L test'] = smooth_loss bar.set_postfix(**postfix) tmp_unc_percepts = self.uncertain_percepts self.uncertain_percepts = 0 if self.final_batches > 0: self.pred_ae.compile(optimizer=Adam(lr=self.lr_final), loss='mse') current_p = self.p_final print('Current p:', current_p) bar = trange(self.final_batches) for i in bar: self.pred_loss_train.append(self.train_batch_pred_ae(train_getter, p=current_p)) smooth_loss = np.mean(self.pred_loss_train[-10:]) postfix['L train'] = smooth_loss if i % TEST_EVERY_N_BATCHES == 0: self.pred_loss_test.append(self.train_batch_pred_ae(test_getter, p=current_p, test=True)) smooth_loss = np.mean(self.pred_loss_test[-4:]) postfix['L test'] = smooth_loss bar.set_postfix(**postfix) self.uncertain_percepts = tmp_unc_percepts if self.max_until_convergence > 0: self.pred_ae.compile(optimizer=Adam(lr=self.lr_final), loss='mse') current_p = self.p_final print('Current p:', current_p) bar = trange(self.max_until_convergence) lowest_valid_loss = np.inf last_update = 0 for i in bar: self.pred_loss_train.append(self.train_batch_pred_ae(train_getter, p=current_p)) smooth_loss = np.mean(self.pred_loss_train[-10:]) postfix['L train'] = smooth_loss if i % TEST_EVERY_N_BATCHES == 0: self.pred_loss_test.append(self.train_batch_pred_ae(test_getter, p=current_p, test=True)) lookback = np.minimum(int(1 + i/TEST_EVERY_N_BATCHES), 10) smooth_loss = np.mean(self.pred_loss_test[-lookback:]) postfix['L test'] = smooth_loss if smooth_loss < lowest_valid_loss: lowest_valid_loss = smooth_loss last_update = i if i - last_update > EXIT_AFTER_NO_IMPROVEMENT_UPDATES: print('Training converged.') break postfix.update({'lowest': lowest_valid_loss}) bar.set_postfix(**postfix) print('Finished before reaching convergence') # ------------------------- DISPLAYING -------------------------------- def plot_losses(self, folder_plots=FOLDER_PLOTS, tag=0, image_getter=None): plt.clf() if len(self.pred_loss_test) < 1: print('Not enough loss measurements to plot') return # compute baseline loss if image_getter is not None: images = image_getter() av_pixel_intensity = np.mean(images) baseline_level = np.mean((images-av_pixel_intensity)**2) else: baseline_level = 0.1 plt.plot(self.pred_loss_train) batches = np.arange(len(self.pred_loss_test)) * TEST_EVERY_N_BATCHES plt.plot(batches, self.pred_loss_test) baseline = np.ones(len(self.pred_loss_test)) * baseline_level plt.plot(batches, baseline, '--') stages = [self.clear_batches] for _ in self.training_scheme['p_levels']: stages.append(self.p_level_batches) stages.append(self.final_batches) stages = np.cumsum(np.array(stages)) plt.plot(stages, np.ones(len(stages)) * baseline_level, 'd') plt.title('Loss') plt.ylabel('mse loss') plt.ylim(ymax=1.2*baseline_level) plt.xlabel('updates') plt.legend(['train', 'valid', 'baseline', 'stages']) fpath = '{}/loss-{}.png'.format(folder_plots, tag) plt.savefig(fpath) return baseline_level def draw_pred_gif(self, full_getter, p=1.0, use_pf=False, sim_config=None, use_stepper=False, folder_plots=FOLDER_PLOTS, tag=0, normalize=False): ep_images, poses, eps_vels = full_getter() ep_images = ep_images[0, ...].reshape((1,) + ep_images.shape[1:]) ep_images_masked, removed_percepts = self.mask_percepts(ep_images, p, return_indices=True) # net_preds = self.pred_ae.predict(ep_images_masked[:, 0:-SERIES_SHIFT, ...]) net_preds = self.pred_ae.predict(ep_images_masked[:, :, ...]) # stepper predictions # stepper_pred = [] # if use_stepper: # self.stepper.reset_states() # for t in range(EP_LEN-SERIES_SHIFT): # im = ep_images_masked[:, t, ...] # stepper_pred.append(self.stepper.predict(im)) pf_pred = [] if use_pf: pf = ParticleFilter(sim_config, n_particles=3000) init_poses = poses[0][0] init_vels = eps_vels[0][0] pf.warm_start(init_poses, init_vels) for t in range(EP_LEN-SERIES_SHIFT): if not removed_percepts[t]: measurements = poses[0][t] # print(measurements) pf.update(measurements) pf.resample() pf_pred.append(pf.draw()) pf.predict() # combine predictions percepts = [] truths = [] pae_preds = [] pf_preds = [] pae_losses = [] pf_losses = [] for t in range(EP_LEN - SERIES_SHIFT): percepts.append(ep_images_masked[0, t+SERIES_SHIFT, :, :, 0]) truths.append(ep_images[0, t+SERIES_SHIFT, :, :, 0]) pae_preds.append(net_preds[0, t, :, :, 0]) if use_pf: pf_preds.append(pf_pred[t][:, :, 0]) pae_losses.append(np.mean((truths[-1] - pae_preds[-1])**2)) pf_losses.append(np.mean((truths[-1] - pf_preds[-1])**2)) if normalize: pae_preds[-1] /= np.max(pae_preds[-1]) if use_pf: pf_preds[-1] /= np.max(pf_preds[-1]) # if use_stepper: # if normalize: # stepper_pred[t][0, :, :, 0] /= np.max(stepper_pred[t][0, :, :, 0]) # images.append(stepper_pred[t][0, :, :, 0]) imageio.mimsave('{}/percepts-{}.gif'.format(folder_plots, tag), percepts) imageio.mimsave('{}/truths-{}.gif'.format(folder_plots, tag), truths) imageio.mimsave('{}/pae_preds-{}.gif'.format(folder_plots, tag), pae_preds) if use_pf: imageio.mimsave('{}/pf_preds-{}.gif'.format(folder_plots, tag), pf_preds) return {'pae_losses': pae_losses, 'pf_losses': pf_losses} def draw_pred_gif_old(self, full_getter, p=1.0, use_pf=False, sim_config=None, use_stepper=False, folder_plots=FOLDER_PLOTS, tag=0, normalize=False, nice_start=True): ep_images, poses = full_getter() ep_images = ep_images[0, ...].reshape((1,) + ep_images.shape[1:]) ep_images_masked, removed_percepts = self.mask_percepts(ep_images, p, return_indices=True) # net_preds = self.pred_ae.predict(ep_images_masked[:, 0:-SERIES_SHIFT, ...]) net_preds = self.pred_ae.predict(ep_images_masked[:, :, ...]) # stepper predictions stepper_pred = [] if use_stepper: self.stepper.reset_states() for t in range(EP_LEN-SERIES_SHIFT): im = ep_images_masked[:, t, ...] stepper_pred.append(self.stepper.predict(im)) pf_pred = [] if use_pf: pf = ParticleFilter(sim_config, n_particles=4000, nice_start=nice_start) for t in range(EP_LEN-SERIES_SHIFT): if not removed_percepts[t]: pose = poses[0, t, 0, :] pf.update(pose) pf.resample() # add noise only if next percept is available # if t+1 < EP_LEN-SERIES_SHIFT and not removed_percepts[t+1]: # pf.resample() # pf.add_noise() pf.predict() pf_pred.append(pf.draw()) # create header with labels col = np.zeros((HEADER_HEIGHT, 1)) labels = [] labels.append(create_im_label('Ob')) labels.append(create_im_label('GT')) labels.append(create_im_label('AE')) if use_stepper: labels.append(create_im_label('ST')) if use_pf: labels.append(create_im_label('PF')) header = [col] for label in labels: header.append(label) header.append(col) header = np.concatenate(header, axis=1) # combine predictions col = np.ones((IM_HEIGHT, 1)) frames = [] for t in range(EP_LEN - SERIES_SHIFT): images = [] images.append(ep_images_masked[0, t+SERIES_SHIFT, :, :, 0]) images.append(ep_images[0, t+SERIES_SHIFT, :, :, 0]) if normalize: net_preds[0, t, :, :, 0] /= np.max(net_preds[0, t, :, :, 0]) images.append(net_preds[0, t, :, :, 0]) if use_stepper: if normalize: stepper_pred[t][0, :, :, 0] /= np.max(stepper_pred[t][0, :, :, 0]) images.append(stepper_pred[t][0, :, :, 0]) if use_pf: if normalize: pf_pred[t][:, :, 0] /= np.max(pf_pred[t][:, :, 0]) images.append(pf_pred[t][:, :, 0]) table = [col] for image in images: table.append(image) table.append(col) frame = np.concatenate(table, axis=1) # print(frame.shape) width = frame.shape[1] row = np.ones((1, width)) frame = np.concatenate([header, frame, row], axis=0) frames.append(frame) fpath = '{}/predictions-{}.gif'.format(folder_plots, tag) imageio.mimsave(fpath, frames)
with open('network_config.pickle', 'rb') as file: config = pickle.load(file) #Encoder encoder_input_layer = Input(shape=(None, )) encoder_embedding_layer = Embedding(config['vocab_size'], config['thought_vector_size']) encoder_gru_layer = GRU(config['thought_vector_size'], return_state=True) encoder = encoder_embedding_layer(encoder_input_layer) encoder, encoder_state = encoder_gru_layer(encoder) encoder_model = Model([encoder_input_layer], encoder_state) encoder_model.compile(optimizer='rmsprop', loss='categorical_crossentropy') encoder_embedding_layer.set_weights(config['weights']['encoder_embedding']) encoder_gru_layer.set_weights(config['weights']['encoder_gru']) #Decoder decoder_input_layer = Input(shape=(None, )) decoder_thought_vector_input_layer = Input( shape=(config['thought_vector_size'], )) decoder_embedding_layer = Embedding(config['vocab_size'], config['thought_vector_size']) decoder_gru_layer = GRU(config['thought_vector_size'], return_sequences=True, return_state=True) decoder_dense_layer = Dense(config['vocab_size'], activation='softmax') decoder = decoder_embedding_layer(decoder_input_layer) decoder, decoder_state = decoder_gru_layer( decoder, initial_state=decoder_thought_vector_input_layer)