# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tree Tensor Network for the groundstate of the Transverse Ising chain.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import tensorflow as tf tf.enable_v2_behavior() from experiments.tree_tensor_network import ttn_1d_uniform if __name__ == "__main__": num_layers = 6 max_bond_dim = 16 dtype = tf.complex128 build_graphs = True num_sweeps = 1000 Ds = [min(2**i, max_bond_dim) for i in range(1,num_layers+1)] print("----------------------------------------------------")
def main(_): tf.enable_v2_behavior() output_path = FLAGS.converted_checkpoint_path v1_checkpoint = FLAGS.checkpoint_to_convert bert_config = configs.BertConfig.from_json_file(FLAGS.bert_config_file) convert_checkpoint(bert_config, output_path, v1_checkpoint)
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ functions for binary MERA optimization """ import tensorflow as tf import numpy as np import tensornetwork as tn import experiments.MERA.binary_mera_lib as bml import experiments.MERA.binary_mera as bm import experiments.MERA.misc_mera as misc_mera import pytest import copy tf.enable_v2_behavior() @pytest.mark.parametrize("chi", [4, 6]) @pytest.mark.parametrize("dtype", [tf.float64, tf.complex128]) def test_ascending_descending(chi, dtype): """ test if ascending and descending operations are doing the right thing """ wC, uC, rho_0 = bml.initialize_binary_MERA_random(phys_dim=2, chi=chi, dtype=dtype) wC, uC = bml.unlock_layer(wC, uC) #add a transitional layer wC, uC = bml.unlock_layer(wC, uC) #add a transitional layer ham_0 = bml.initialize_TFI_hams(dtype) rho = [0 for n in range(len(wC) + 1)] ham = [0 for n in range(len(wC) + 1)] rho[-1] = bml.steady_state_density_matrix(10, rho_0, wC[-1], uC[-1]) ham[0] = ham_0
# ============================================================================== """Test file to display the error message and verify it with FileCheck.""" # RUN: %p/saved_model_error | FileCheck %s from __future__ import absolute_import from __future__ import division from __future__ import print_function import sys from absl import app from tensorflow import enable_v2_behavior import tensorflow.compat.v2 as tf enable_v2_behavior() class TestModule(tf.Module): """The test model has supported op.""" @tf.function( input_signature=[tf.TensorSpec(shape=[3, 3], dtype=tf.float32)]) def model(self, x): y = tf.math.reciprocal(x) # Not supported return y + y class TestGraphDebugInfo(object): """Test stack trace can be displayed.""" def testSavedModelDebugInfo(self): """Save a saved model with unsupported ops, and then load and convert it."""
def main(argv): del argv # Unused if hasattr(tf, "enable_v2_behavior"): tf.enable_v2_behavior() tf.test.main()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Jun 12 11:49:04 2020 @author: nevena """ import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import numpy as np import tensorflow as tf import pickle tf.enable_v2_behavior() #for those like me who haven't yet installed TF2 #tf.config.optimizer.set_jit(True) #%% """parameters""" n = int(10000) #layer dim: s = 10 p = 50 m = 100 q = 100 r = 100 ni = 0.001 #optimizer Adam pu = 0.5 #initial condition percentage of points stdev = 0.1 mean = 0 #%%
def main(_): if FLAGS.use_tf2: tf.enable_v2_behavior() config_content = { 'action_type': FLAGS.action_type, 'obs_type': FLAGS.obs_type, 'reward_shape_val': FLAGS.reward_shape_val, 'use_subset_instruction': FLAGS.use_subset_instruction, 'frame_skip': FLAGS.frame_skip, 'use_polar': FLAGS.use_polar, 'suppress': FLAGS.suppress, 'diverse_scene_content': FLAGS.diverse_scene_content, 'buffer_size': FLAGS.buffer_size, 'use_movement_bonus': FLAGS.use_movement_bonus, 'reward_scale': FLAGS.reward_scale, 'scenario_type': FLAGS.scenario_type, 'img_resolution': FLAGS.img_resolution, 'render_resolution': FLAGS.render_resolution, # agent 'agent_type': FLAGS.agent_type, 'masking_q': FLAGS.masking_q, 'discount': FLAGS.discount, 'instruction_repr': FLAGS.instruction_repr, 'encoder_type': FLAGS.encoder_type, 'learning_rate': FLAGS.learning_rate, 'polyak_rate': FLAGS.polyak_rate, 'trainable_encoder': FLAGS.trainable_encoder, 'embedding_type': FLAGS.embedding_type, # learner 'num_episode': FLAGS.num_episode, 'optimization_steps': FLAGS.optimization_steps, 'batchsize': FLAGS.batchsize, 'sample_new_scene_prob': FLAGS.sample_new_scene_prob, 'max_episode_length': FLAGS.max_episode_length, 'record_atomic_instruction': FLAGS.record_atomic_instruction, 'paraphrase': FLAGS.paraphrase, 'relabeling': FLAGS.relabeling, 'k_immediate': FLAGS.k_immediate, 'future_k': FLAGS.future_k, 'negate_unary': FLAGS.negate_unary, 'min_epsilon': FLAGS.min_epsilon, 'epsilon_decay': FLAGS.epsilon_decay, 'collect_cycle': FLAGS.collect_cycle, 'use_synonym_for_rollout': FLAGS.use_synonym_for_rollout, 'reset_mode': FLAGS.reset_mode, 'maxent_irl': FLAGS.maxent_irl, # relabeler 'sampling_temperature': FLAGS.sampling_temperature, 'generated_label_num': FLAGS.generated_label_num, 'use_labeler_as_reward': FLAGS.use_labeler_as_reward, 'use_oracle_instruction': FLAGS.use_oracle_instruction } if FLAGS.maxent_irl: assert FLAGS.batchsize % FLAGS.irl_parallel_n == 0 config_content['irl_parallel_n'] = FLAGS.irl_parallel_n config_content['irl_sample_goal_n'] = FLAGS.irl_sample_goal_n config_content['relabel_proportion'] = FLAGS.relabel_proportion config_content['entropy_alpha'] = FLAGS.entropy_alpha cfg = Config(config_content) if FLAGS.experiment_confg: cfg.update(get_exp_config(FLAGS.experiment_confg)) save_home = FLAGS.save_dir if FLAGS.save_dir else tf.test.get_temp_dir() if FLAGS.varying: exp_name = 'exp-' for varied_var in FLAGS.varying.split(','): exp_name += str(varied_var) + '=' + str(FLAGS[varied_var].value) + '-' else: exp_name = 'SingleExperiment' save_dir = os.path.join(save_home, exp_name) try: gfile.MkDir(save_home) except gfile.Error as e: print(e) try: gfile.MkDir(save_dir) except gfile.Error as e: print(e) cfg.update(Config({'model_dir': save_dir})) print('############################################################') print(cfg) print('############################################################') env, learner, replay_buffer, agent, extra_components = experiment_setup( cfg, FLAGS.use_tf2, FLAGS.use_nn_relabeling) agent.init_networks() if FLAGS.use_tf2: logger = Logger2(save_dir) else: logger = Logger(save_dir) with gfile.GFile(os.path.join(save_dir, 'config.json'), mode='w+') as f: json.dump(cfg.as_dict(), f, sort_keys=True, indent=4) if FLAGS.save_model and tf.train.latest_checkpoint(save_dir): print('Loading saved weights from {}'.format(save_dir)) agent.load_model(save_dir) if FLAGS.save_model: video_dir = os.path.join(save_dir, 'rollout_cycle_{}.mp4'.format('init')) print('Saving video to {}'.format(video_dir)) learner.rollout( env, agent, video_dir, num_episode=FLAGS.rollout_episode, record_trajectory=FLAGS.record_trajectory) success_rate_ema = -1.0 # Training loop for epoch in range(FLAGS.num_epoch): for cycle in range(FLAGS.num_cycle): stats = learner.learn(env, agent, replay_buffer) if success_rate_ema < 0: success_rate_ema = stats['achieved_goal'] loss_dropped = stats['achieved_goal'] < 0.1 * success_rate_ema far_along_training = stats['global_step'] > 100000 if FLAGS.save_model and loss_dropped and far_along_training: print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') print('Step {}: Loading models due to sudden loss drop D:'.format( stats['global_step'])) print('Dropped from {} to {}'.format(success_rate_ema, stats['achieved_goal'])) agent.load_model(save_dir) print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') continue success_rate_ema = 0.95 * success_rate_ema + 0.05 * stats['achieved_goal'] at_save_interval = stats['global_step'] % FLAGS.save_interval == 0 better_reward = stats['achieved_goal'] > success_rate_ema if FLAGS.save_model and at_save_interval and better_reward: print('Saving model to {}'.format(save_dir)) agent.save_model(save_dir) if FLAGS.save_model and stats['global_step'] % FLAGS.video_interval == 0: video_dir = os.path.join(save_dir, 'rollout_cycle_{}.mp4'.format(cycle)) print('Saving video to {}'.format(video_dir)) test_success_rate = learner.rollout( env, agent, video_dir, record_video=FLAGS.save_video, num_episode=FLAGS.rollout_episode, record_trajectory=FLAGS.record_trajectory) stats['Test Success Rate'] = test_success_rate print('Test Success Rate: {}'.format(test_success_rate)) stats['ema success rate'] = success_rate_ema logger.log(epoch, cycle, stats)
def main(argv): if len(argv) > 1: raise app.UsageError('Too many command-line arguments.') tf.enable_v2_behavior() # TODO(b/139129100): Remove this once the local executor is the default. tff.framework.set_default_executor( tff.framework.local_executor_factory(max_fanout=25)) stackoverflow_train, stackoverflow_validation, stackoverflow_test = dataset.get_stackoverflow_datasets( vocab_tokens_size=FLAGS.vocab_tokens_size, vocab_tags_size=FLAGS.vocab_tags_size, client_batch_size=FLAGS.client_batch_size, client_epochs_per_round=FLAGS.client_epochs_per_round, max_training_elements_per_user=FLAGS.max_elements_per_user, num_validation_examples=FLAGS.num_validation_examples) sample_client_dataset = stackoverflow_train.create_tf_dataset_for_client( stackoverflow_train.client_ids[0]) # TODO(b/144382142): Sample batches cannot be eager tensors, since they are # passed (implicitly) to tff.learning.build_federated_averaging_process. sample_batch = tf.nest.map_structure(lambda x: x.numpy(), next(iter(sample_client_dataset))) model_builder = functools.partial( models.create_logistic_model, vocab_tokens_size=FLAGS.vocab_tokens_size, vocab_tags_size=FLAGS.vocab_tags_size) loss_builder = functools.partial(tf.keras.losses.BinaryCrossentropy, from_logits=False, reduction=tf.keras.losses.Reduction.SUM) training_process = iterative_process_builder.from_flags( dummy_batch=sample_batch, model_builder=model_builder, loss_builder=loss_builder, metrics_builder=metrics_builder) client_datasets_fn = training_utils.build_client_datasets_fn( stackoverflow_train, FLAGS.clients_per_round) evaluate_fn = training_utils.build_evaluate_fn( model_builder=model_builder, eval_dataset=stackoverflow_validation, loss_builder=loss_builder, metrics_builder=metrics_builder) test_fn = training_utils.build_evaluate_fn( model_builder=model_builder, # Use both val and test for symmetry with other experiments, which # evaluate on the entire test set. eval_dataset=stackoverflow_validation.concatenate(stackoverflow_test), loss_builder=loss_builder, metrics_builder=metrics_builder) logging.info('Training model:') logging.info(model_builder().summary()) training_loop.run(training_process, client_datasets_fn, evaluate_fn, test_fn=test_fn)