def on_train_end(self, logs=None): del logs # unused self._write_summary( summary.session_end_pb(api_pb2.STATUS_SUCCESS), step=0, ) self._writer = None
def _write_session_end(): global _writer with _writer.as_default(): protob = summary.session_end_pb(api_pb2.STATUS_SUCCESS) raw_pb = protob.SerializeToString() tf.summary.experimental.write_raw_pb(raw_pb, step=0) _writer = None
def _experiment_impl(args): alpha, alpha_decay, gamma, init_epsilon, n_exploration_episodes = args hparams = { 'alpha': alpha, 'alpha_decay': alpha_decay, 'gamma': gamma, 'init_epsilon': init_epsilon, 'n_exploration_episodes': n_exploration_episodes } parent_self._alpha_list.append(alpha) parent_self._alpha_decay_list.append(alpha_decay) parent_self._gamma_list.append(gamma) parent_self._init_epsilon_list.append(init_epsilon) parent_self._n_exploration_episodes.append(n_exploration_episodes) writer = tf.summary.create_file_writer( log_dir + "/alpha_{}_alpha_decay_{}_gamma_{:.3f}_init_eps{}_n_explor_{}". format(alpha, alpha_decay, gamma, init_epsilon, n_exploration_episodes)) with writer.as_default(): summary_start = hparams_summary.session_start_pb( hparams=hparams) reinforce = ActorCriticNetworkTD(env, alpha=alpha, alpha_decay=alpha_decay, gamma=gamma, init_epsilon=init_epsilon, min_epsilon=0.0, batch_normalization=False, writer=writer) num_episodes = 1000 episode_length = 200 for episode in range(num_episodes): reinforce.training_episode( episode_lenght=episode_length, num_exploration_episodes=n_exploration_episodes, debug=False) average_sum_reward = reinforce.evaluate_average_sum_reward(5) print( 'Average sum reward after episode:{} for alpha: {}, alpha_decay: {}, gamma: {}, init_eps: {}, n_exploration_episodes: {}, reward: {}' .format(episode, alpha, alpha_decay, gamma, init_epsilon, n_exploration_episodes, average_sum_reward)) tf.summary.scalar('sum_reward', average_sum_reward, step=1, description="Average sum reward") summary_end = hparams_summary.session_end_pb( api_pb2.STATUS_SUCCESS) tf.summary.import_event( tf.compat.v1.Event( summary=summary_start).SerializeToString()) tf.summary.import_event( tf.compat.v1.Event( summary=summary_end).SerializeToString()) # hyperopt needs negative value to minimize provided function properly based on fmin (no fmax alternative yet..) return -average_sum_reward
def test_session_end_pb(self): end_time_secs = 1234.0 self.assertEqual( summary.session_end_pb(api_pb2.STATUS_SUCCESS, end_time_secs), tf.compat.v1.Summary( value=[ tf.compat.v1.Summary.Value( tag="_hparams_/session_end_info", tensor=summary._TF_NULL_TENSOR, metadata=tf.compat.v1.SummaryMetadata( plugin_data=tf.compat.v1.SummaryMetadata.PluginData( plugin_name="hparams", content=( plugin_data_pb2.HParamsPluginData( version=0, session_end_info=( plugin_data_pb2.SessionEndInfo( status=api_pb2.STATUS_SUCCESS, end_time_secs=end_time_secs, ) ), ).SerializeToString() ), ) ), ) ] ), )
def run_quess(sess, params): PS = params ds_train = dataset_for('train', PS) ds_test = dataset_for('test', PS) # with tf.distribute.MirroredStrategy().scope(): model = model_for(PS) model.compile(**compile_args_for(PS)) model.train_on_batch(ds_train[:1]) save_p = pth.Path(PS.dir_save) if save_p.exists(): model.load_weights(save_p) model.summary() p = PS.log_dir + '/train/' + sess writer = tf.summary.create_file_writer(p) sum_s = hparams.session_start_pb(hparams=PS.hparams) cbacks = [ # kcb.LambdaCallback(on_epoch_end=log_confusion_matrix), kcb.History(), kcb.BaseLogger(), kcb.TensorBoard(log_dir=p, histogram_freq=1, embeddings_freq=0, update_freq='epoch'), # kcb.EarlyStopping( # monitor='val_loss', min_delta=1e-2, patience=2, verbose=True), ] if save_p.exists(): cbacks.append( kcb.ModelCheckpoint(model_save_path=save_p, save_best_only=True, monitor='val_loss', verbose=True)) hist = model.fit( ds_train, epochs=PS.train_steps // PS.eval_frequency, steps_per_epoch=PS.eval_frequency, validation_data=ds_test, validation_steps=PS.eval_steps, callbacks=cbacks, ) print(f'History: {hist.history}') if save_p.exists(): model.save_weights(save_p, save_format='tf') loss, acc = model.evaluate(ds_test) print(f'\nTest loss, acc: {loss}, {acc}') with writer.as_default(): e = tf.compat.v1.Event(summary=sum_s).SerializeToString() tf.summary.import_event(e) tf.summary.scalar('accuracy', acc, step=1, description='Accuracy') sum_e = hparams.session_end_pb(api_pb2.STATUS_SUCCESS) e = tf.compat.v1.Event(summary=sum_e).SerializeToString() tf.summary.import_event(e)
def train_and_test(hparams): datasets = get_dataset(hparams) model = Model(hparams) optimizer = get_optimizer(hparams) loss_fn = keras.losses.SparseCategoricalCrossentropy() logger = Logger(hparams, optimizer) summary_start = hparams_summary.session_start_pb(hparams=hparams.__dict__) for epoch in range(hparams.epochs): start = time.time() for images, labels in datasets['train']: loss, predictions = train_step(images, labels, model, optimizer, loss_fn) logger.log_progress(loss, labels, predictions, mode='train') elapse = time.time() - start logger.write_scalars(mode='train') for images, labels in datasets['test']: logger.write_images(images, mode='test') loss, predictions = test_step(images, labels, model, loss_fn) logger.log_progress(loss, labels, predictions, mode='test') logger.write_scalars(mode='test', elapse=elapse) logger.print_progress(epoch, elapse) summary_end = hparams_summary.session_end_pb(api_pb2.STATUS_SUCCESS) logger.write_hparams_summary(summary_start, summary_end, elapse)
def on_train_end(self, logs=None): del logs # unused with self._get_writer().as_default(): pb = summary.session_end_pb(api_pb2.STATUS_SUCCESS) raw_pb = pb.SerializeToString() tf.compat.v2.summary.experimental.write_raw_pb(raw_pb, step=0) self._writer = None
def run_squad(sess, params): # with tf.distribute.MirroredStrategy().scope(): model = model_for(params) model.compile( optimizer=params.optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy']) ds_train = dataset_for('train', params) ds_test = dataset_for('test', params) save_p = pth.Path(params.dir_save) if save_p.exists(): model.train_on_batch(ds_train[:1]) model.load_weights(save_p) model.summary() p = params.log_dir + '/train/' + sess writer = tf.summary.create_file_writer(p) sum_s = hparams.session_start_pb(hparams=params.hparams) cbacks = [ kcb.TensorBoard( log_dir=p, histogram_freq=1, embeddings_freq=0, update_freq='epoch'), # kcb.EarlyStopping( # monitor='val_loss', min_delta=1e-2, patience=2, verbose=True), ] if save_p.exists(): cbacks.append( kcb.ModelCheckpoint( model_save_path=save_p, save_best_only=True, monitor='val_loss', verbose=True)) hist = model.fit( ds_train, callbacks=cbacks, epochs=params.train_epochs, validation_data=ds_test) print(f'History: {hist.history}') if save_p.exists(): model.save_weights(save_p, save_format='tf') loss, acc = model.evaluate(ds_test) print(f'\nTest loss, acc: {loss}, {acc}') with writer.as_default(): e = tf.compat.v1.Event(summary=sum_s).SerializeToString() tf.summary.import_event(e) tf.summary.scalar('accuracy', acc, step=1, description='Accuracy') sum_e = hparams.session_end_pb(api_pb2.STATUS_SUCCESS) e = tf.compat.v1.Event(summary=sum_e).SerializeToString() tf.summary.import_event(e)
def close(self): """ Close the file writer object, wrapping up the hyperparameters table. """ # Close the hyperparameters writing: if not (len(self._static_hyperparameters) == 0 and len(self._dynamic_hyperparameters) == 0): with self._file_writer.as_default(): pb = hp_summary.session_end_pb(hp_api_pb2.STATUS_SUCCESS) raw_pb = pb.SerializeToString() tf.compat.v2.summary.experimental.write_raw_pb(raw_pb, step=0) # Flush and close the writer: self.flush() self._file_writer.close()
def on_train_begin(self, logs): # TODO: v2 of the callback has a "writers" object with cb._writers["train"].as_default(): exp = create_experiment_summary( [16, 32], [0.1, 0.5], ['adam', 'sgd']) tf.summary.import_event(tf.compat.v1.Event( summary=exp).SerializeToString()) summary_start = hparams_summary.session_start_pb( hparams={'num_units': 16, 'dropout_rate': 0.5, 'optimizer': 'adam'}) summary_end = hparams_summary.session_end_pb( api_pb2.STATUS_SUCCESS) tf.summary.import_event(tf.compat.v1.Event( summary=summary_start).SerializeToString()) tf.summary.import_event(tf.compat.v1.Event( summary=summary_end).SerializeToString())
def run(data, base_logdir, session_id, group_id, hparams): """Run a training/validation session. Flags must have been parsed for this function to behave. Args: data: The data as loaded by `prepare_data()`. base_logdir: The top-level logdir to which to write summary data. session_id: A unique string ID for this session. group_id: The string ID of the session group that includes this session. hparams: A dict mapping hyperparameters in `HPARAMS` to values. """ model = model_fn(hparams=hparams, seed=session_id) logdir = os.path.join(base_logdir, session_id) # We need a manual summary writer for writing hparams metadata. writer = tf.summary.create_file_writer(logdir) with writer.as_default(): pb = hparams_summary.session_start_pb( {h.name: hparams[h] for h in hparams}, group_name=group_id, ) tf.summary.experimental.write_raw_pb(pb.SerializeToString(), step=0) writer.flush() callback = tf.keras.callbacks.TensorBoard( logdir, update_freq=flags.FLAGS.summary_freq, profile_batch=0, # workaround for issue #2084 ) ((x_train, y_train), (x_test, y_test)) = data result = model.fit( x=x_train, y=y_train, epochs=flags.FLAGS.num_epochs, shuffle=False, validation_data=(x_test, y_test), callbacks=[callback], ) with writer.as_default(): pb = hparams_summary.session_end_pb(api_pb2.STATUS_SUCCESS) tf.summary.experimental.write_raw_pb(pb.SerializeToString(), step=0) writer.flush() writer.close()
def test_session_end_pb(self): end_time_secs = 1234.0 self.assertEqual( summary.session_end_pb(api_pb2.STATUS_SUCCESS, end_time_secs), tf.Summary( value=[ tf.Summary.Value( tag="_hparams_/session_end_info", metadata=tf.SummaryMetadata( plugin_data=tf.SummaryMetadata.PluginData( plugin_name="hparams", content=(plugin_data_pb2.HParamsPluginData( version=0, session_end_info=( plugin_data_pb2.SessionEndInfo( status=api_pb2.STATUS_SUCCESS, end_time_secs=end_time_secs, )) ).SerializeToString())))) ]))
def _experiment(self, args): alpha, gamma = args hparams = {'alpha': alpha, 'gamma': gamma} self._alpha_list.append(alpha) self._gamma_list.append(gamma) writer = tf.summary.create_file_writer( self._log_dir + "/alpha_{}_gamma_{:.3f}".format(alpha, gamma)) with writer.as_default(): summary_start = hparams_summary.session_start_pb(hparams=hparams) env = CartPoleRewardWrapper(gym.make('CartPole-v1')) q_learning = DeepQNetwork(env, alpha=alpha, gamma=gamma, writer=writer) num_episodes = 10 episode_lenth = 50 for episode in range(num_episodes): q_learning.training_episode(num_exploration_episodes=int( num_episodes * 2 / 3), episode_lenght=episode_lenth) average_cmulative_reward = q_learning.evaluate_average_cumulative_reward( 100) print( 'Average cumulative reward after episode:{} for alpha: {} and gamma: {} is: {}' .format(episode, alpha, gamma, average_cmulative_reward)) summary_end = hparams_summary.session_end_pb( api_pb2.STATUS_SUCCESS) tf.summary.scalar('cummulative_reward', average_cmulative_reward, step=1, description="Average cummulative reward") tf.summary.import_event( tf.compat.v1.Event(summary=summary_start).SerializeToString()) tf.summary.import_event( tf.compat.v1.Event(summary=summary_end).SerializeToString()) # hyperopt needs negative value to minimize provided function properly based on fmin (no fmax alternative yet..) return -average_cmulative_reward
def run(logdir, session_id, hparams, group_name): """Runs a temperature simulation. This will simulate an object at temperature `initial_temperature` sitting at rest in a large room at temperature `ambient_temperature`. The object has some intrinsic `heat_coefficient`, which indicates how much thermal conductivity it has: for instance, metals have high thermal conductivity, while the thermal conductivity of water is low. Over time, the object's temperature will adjust to match the temperature of its environment. We'll track the object's temperature, how far it is from the room's temperature, and how much it changes at each time step. Arguments: logdir: the top-level directory into which to write summary data session_id: an id for the session. hparams: A dictionary mapping a hyperparameter name to its value. group_name: an id for the session group this session belongs to. """ tf.reset_default_graph() tf.set_random_seed(0) initial_temperature = hparams["initial_temperature"] ambient_temperature = hparams["ambient_temperature"] heat_coefficient = HEAT_COEFFICIENTS[hparams["material"]] session_dir = os.path.join(logdir, session_id) writer = tf.summary.FileWriter(session_dir) writer.add_summary( summary.session_start_pb(hparams=hparams, group_name=group_name)) writer.flush() with tf.name_scope("temperature"): # Create a mutable variable to hold the object's temperature, and # create a scalar summary to track its value over time. The name of # the summary will appear as 'temperature/current' due to the # name-scope above. temperature = tf.Variable(tf.constant(initial_temperature), name="temperature") scalar_summary.op( "current", temperature, display_name="Temperature", description="The temperature of the object under " "simulation, in Kelvins.", ) # Compute how much the object's temperature differs from that of its # environment, and track this, too: likewise, as # 'temperature/difference_to_ambient'. ambient_difference = temperature - ambient_temperature scalar_summary.op( "difference_to_ambient", ambient_difference, display_name="Difference to ambient temperature", description=("The difference between the ambient " "temperature and the temperature of the " "object under simulation, in Kelvins."), ) # Newton suggested that the rate of change of the temperature of an # object is directly proportional to this `ambient_difference` above, # where the proportionality constant is what we called the heat # coefficient. But in real life, not everything is quite so clean, so # we'll add in some noise. (The value of 50 is arbitrary, chosen to # make the data look somewhat interesting. :-) ) noise = 50 * tf.random.normal([]) delta = -heat_coefficient * (ambient_difference + noise) scalar_summary.op( "delta", delta, description="The change in temperature from the previous " "step, in Kelvins.", ) # Collect all the scalars that we want to keep track of. summ = tf.summary.merge_all() # Now, augment the current temperature by this delta that we computed, # blocking the assignment on summary collection to avoid race conditions # and ensure that the summary always reports the pre-update value. with tf.control_dependencies([summ]): update_step = temperature.assign_add(delta) sess = tf.Session() sess.run(tf.global_variables_initializer()) for step in range(FLAGS.num_steps): # By asking TensorFlow to compute the update step, we force it to # change the value of the temperature variable. We don't actually # care about this value, so we discard it; instead, we grab the # summary data computed along the way. (s, _) = sess.run([summ, update_step]) if (step % FLAGS.summary_freq) == 0: writer.add_summary(s, global_step=step) writer.add_summary(summary.session_end_pb(api_pb2.STATUS_SUCCESS)) writer.close()
def end_session(): write_summary( summary.session_end_pb(api_pb2.Status.Value(FLAGS.status), FLAGS.end_time_secs))
def eager_quess(sess, params): PS = params ds_train = dataset_for('train', PS) ds_test = dataset_for('test', PS) # with tf.distribute.MirroredStrategy().scope(): model = model_for(PS) model.compile(**compile_args_for(PS)) # model.train_on_batch(ds_train[:1]) save_p = pth.Path(PS.dir_save) if save_p.exists(): model.load_weights(save_p) model.summary() p = PS.log_dir + '/train/' + sess writer = tf.summary.create_file_writer(p) sum_s = hparams.session_start_pb(hparams=PS.hparams) cbacks = [ # kcb.LambdaCallback(on_epoch_end=log_confusion_matrix), kcb.History(), kcb.BaseLogger(), kcb.TensorBoard(log_dir=p, histogram_freq=1, embeddings_freq=0, update_freq='epoch'), # kcb.EarlyStopping( # monitor='val_loss', min_delta=1e-2, patience=2, verbose=True), ] if save_p.exists(): cbacks.append( kcb.ModelCheckpoint(model_save_path=save_p, save_best_only=True, monitor='val_loss', verbose=True)) opt = opt_fn(PS) for e in range(3): print(f'Start of epoch {e}') for s, (src, tgt, agree) in enumerate(ds_train): with tf.GradientTape() as tape: r = model([src, tgt]) loss = loss_fn(agree, r) # loss += sum(model.losses) gs = tape.gradient(loss, model.trainable_variables) opt.apply_gradients(zip(gs, model.trainable_variables)) # acc_metric(fit, f) if s % 200 == 0: print(f'Loss at step {s}: {loss}') # a = acc_metric.result() # acc_metric.reset_states() # print(f'Train acc over epoch: {float(a)}') for src, tgt, agree in ds_test: r = model([src, tgt]) # acc_metric(fit, f) # a = acc_metric.result() # acc_metric.reset_states() # print(f'Test acc: {float(a)}') if save_p.exists(): model.save_weights(save_p, save_format='tf') with writer.as_default(): e = tf.compat.v1.Event(summary=sum_s).SerializeToString() tf.summary.import_event(e) # tf.summary.scalar('accuracy', acc, step=1, description='Accuracy') sum_e = hparams.session_end_pb(api_pb2.STATUS_SUCCESS) e = tf.compat.v1.Event(summary=sum_e).SerializeToString() tf.summary.import_event(e)
def run(logdir, session_id, hparams, group_name): """Runs a temperature simulation. This will simulate an object at temperature `initial_temperature` sitting at rest in a large room at temperature `ambient_temperature`. The object has some intrinsic `heat_coefficient`, which indicates how much thermal conductivity it has: for instance, metals have high thermal conductivity, while the thermal conductivity of water is low. Over time, the object's temperature will adjust to match the temperature of its environment. We'll track the object's temperature, how far it is from the room's temperature, and how much it changes at each time step. Arguments: logdir: the top-level directory into which to write summary data session_id: an id for the session. hparams: A dictionary mapping an hyperparameter name to its value. group_name: an id for the session group this session belongs to. """ tf.reset_default_graph() tf.set_random_seed(0) initial_temperature = hparams['initial_temperature'] ambient_temperature = hparams['ambient_temperature'] heat_coefficient = hparams['heat_coefficient'] session_dir = os.path.join(logdir, session_id) writer = tf.summary.FileWriter(session_dir) writer.add_summary(summary.session_start_pb(hparams=hparams, group_name=group_name)) writer.flush() with tf.name_scope('temperature'): # Create a mutable variable to hold the object's temperature, and # create a scalar summary to track its value over time. The name of # the summary will appear as "temperature/current" due to the # name-scope above. temperature = tf.Variable(tf.constant(initial_temperature), name='temperature') scalar_summary.op('current', temperature, display_name='Temperature', description='The temperature of the object under ' 'simulation, in Kelvins.') # Compute how much the object's temperature differs from that of its # environment, and track this, too: likewise, as # "temperature/difference_to_ambient". ambient_difference = temperature - ambient_temperature scalar_summary.op('difference_to_ambient', ambient_difference, display_name='Difference to ambient temperature', description=('The difference between the ambient ' 'temperature and the temperature of the ' 'object under simulation, in Kelvins.')) # Newton suggested that the rate of change of the temperature of an # object is directly proportional to this `ambient_difference` above, # where the proportionality constant is what we called the heat # coefficient. But in real life, not everything is quite so clean, so # we'll add in some noise. (The value of 50 is arbitrary, chosen to # make the data look somewhat interesting. :-) ) noise = 50 * tf.random_normal([]) delta = -heat_coefficient * (ambient_difference + noise) scalar_summary.op('delta', delta, description='The change in temperature from the previous ' 'step, in Kelvins.') # Collect all the scalars that we want to keep track of. summ = tf.summary.merge_all() # Now, augment the current temperature by this delta that we computed, # blocking the assignment on summary collection to avoid race conditions # and ensure that the summary always reports the pre-update value. with tf.control_dependencies([summ]): update_step = temperature.assign_add(delta) sess = tf.Session() sess.run(tf.global_variables_initializer()) for step in xrange(STEPS): # By asking TensorFlow to compute the update step, we force it to # change the value of the temperature variable. We don't actually # care about this value, so we discard it; instead, we grab the # summary data computed along the way. (s, _) = sess.run([summ, update_step]) writer.add_summary(s, global_step=step) writer.add_summary(summary.session_end_pb(api_pb2.STATUS_SUCCESS)) writer.close()