def initialize_uninitialized(sess): global_vars = tf.global_variables() #for i in global_vars: # print(i) is_not_initialized = sess.run( [tf.is_variable_initialized(var) for var in global_vars]) not_initialized_vars = [ v for (v, f) in zip(global_vars, is_not_initialized) if not f ] if len(not_initialized_vars): sess.run(tf.variables_initializer(not_initialized_vars))
def initialize_uninitialized(sess): global_vars = tf.global_variables() is_not_initialized = sess.run([tf.is_variable_initialized(var) for var in global_vars]) not_initialized_vars = [v for (v, f) in zip(global_vars, is_not_initialized) if not f] # for i in not_initialized_vars: # only for testing # print(i.name) if len(not_initialized_vars): sess.run(tf.variables_initializer(not_initialized_vars)) return
def collect_variables(self, vs): """Collects model variables. Args: vs: Tensorflow variables. Populates self.var_list with model variables and self.init_op with variables' initializer. This function is only called once with __call__. """ # All variables. self.var_list = vs self.init_op = tf.variables_initializer(var_list=self.var_list)
def start_interaction(self, env_fns, dynamics, nlump=2): self.loss_names, self._losses = zip(*list(self.to_report.items())) params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) if MPI.COMM_WORLD.Get_size() > 1: trainer = MpiAdamOptimizer(learning_rate=self.ph_lr, comm=MPI.COMM_WORLD) else: trainer = tf.train.AdamOptimizer(learning_rate=self.ph_lr) gradsandvars = trainer.compute_gradients(self.total_loss, params) self._train = trainer.apply_gradients(gradsandvars) if MPI.COMM_WORLD.Get_rank() == 0: getsess().run( tf.variables_initializer( tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES))) bcast_tf_vars_from_root( getsess(), tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)) self.all_visited_rooms = [] self.all_scores = [] self.nenvs = nenvs = len(env_fns) self.nlump = nlump self.lump_stride = nenvs // self.nlump self.envs = [ VecEnv(env_fns[l * self.lump_stride:(l + 1) * self.lump_stride], spaces=[self.ob_space, self.ac_space]) for l in range(self.nlump) ] self.rollout = Rollout(ob_space=self.ob_space, ac_space=self.ac_space, nenvs=nenvs, nsteps_per_seg=self.nsteps_per_seg, nsegs_per_env=self.nsegs_per_env, nlumps=self.nlump, envs=self.envs, policy=self.stochpol, int_rew_coeff=self.int_coeff, ext_rew_coeff=self.ext_coeff, record_rollouts=self.use_recorder, dynamics=dynamics) self.buf_advs = np.zeros((nenvs, self.rollout.nsteps), np.float32) self.buf_rets = np.zeros((nenvs, self.rollout.nsteps), np.float32) if self.normrew: self.rff = RewardForwardFilter(self.gamma) self.rff_rms = RunningMeanStd() self.step_count = 0 self.t_last_update = time.time() self.t_start = time.time()
def collect_variables(self): """Collects model variables. Populates self.var_list with model variables and self.init_op with variables' initializer. This function is only called once with __call__. """ self.var_list = [ v for v in tf.global_variables() if "classification_network" in v.name ] self.init_op = tf.variables_initializer(var_list=self.var_list)
def collect_variables(self): """Collects model variables. Populates variable lists with model variables and self.init_op with variables' initializer. This function is only called once with __call__. """ self.var_list_classification += self.dram_cell.var_list_classification self.var_list_location += self.dram_cell.var_list_location self.var_list = ( self.var_list_classification + self.var_list_location) self.init_op = tf.variables_initializer(var_list=self.var_list)
def __init__(self, game): self.nnet = onnet(game, args) self.board_x, self.board_y = game.getBoardSize() self.action_size = game.getActionSize() self.sess = tf.Session(graph=self.nnet.graph) self.saver = None with tf.Session() as temp_sess: temp_sess.run(tf.global_variables_initializer()) self.sess.run( tf.variables_initializer( self.nnet.graph.get_collection('variables')))
def get_opt_reinit_op(opt, var_list, global_step): opt_slots = [ opt.get_slot(var, name) for name in opt.get_slot_names() for var in var_list ] if isinstance(opt, tf.train.AdamOptimizer): beta_powers = opt._get_beta_accumulators() opt_slots.extend( beta_powers ) #[opt._beta1_power, opt._beta2_power]) #pylint: disable = W0212 all_opt_variables = opt_slots + var_list + [global_step] opt_reinit_op = tf.variables_initializer(all_opt_variables) return opt_reinit_op
def fit(self, X): self.n_visible_units = X.shape[1] # Initialize RBM parameters self._build_model() sess.run(tf.variables_initializer([self.W, self.c, self.b])) if self.optimization_algorithm == 'sgd': self._stochastic_gradient_descent(X) else: raise ValueError("Invalid optimization algorithm.") return
def create_reset_metric(metric, variable_scope, **metric_args): """ Creates tensors of a metric (e.g., running mean), its update, and reset operation. :param metric: The metric and its tensors to create. :param variable_scope: The variable scope which is needed to create the reset operation. :param metric_args: The args used for generating the metric. :return: Tensors of the metric, its update, and reset operation. """ with tf.variable_scope(variable_scope): metric_op, update_op = metric(**metric_args) vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, variable_scope) reset_op = tf.variables_initializer(vars) return metric_op, update_op, reset_op
def create_optimizer(self): self.learning_rate = tf.train.exponential_decay(self.lr_init, self.global_step, self.n_epoch, self.lr_decay, name="learning_rate") optimizer = tf.train.AdagradOptimizer(self.learning_rate) gradients, variables = zip(*optimizer.compute_gradients(self.loss)) gradients, _ = tf.clip_by_global_norm(gradients, self.clip_norm) self.train_step = optimizer.apply_gradients(zip(gradients, variables), name="train_step") self.reset_optimizer_op = tf.variables_initializer( optimizer.variables(), name="reset_optimizer")
def load_ckpt(self): """Load a model checkpoint In train mode, load the latest checkpoint from the checkpoint folder if it exists; otherwise, run initializer. In other modes, load from the specified checkpoint file. """ if self.mode in ['train_noval', 'train_with_val']: self.last_ckpt = None if self.opts['train_mode'] == 'fine-tune': # In fine-tuning mode, we just want to load the trained params from the file and that's it... assert(tf.train.checkpoint_exists(self.opts['ckpt_path'])) if self.opts['verbose']: print(f"Initializing from pre-trained model at {self.opts['ckpt_path']} for finetuning...\n") # ...however, the AdamOptimizer also stores variables in the graph, so reinitialize them as well self.sess.run(tf.variables_initializer(self.optim.variables())) # Now initialize the trained params with actual values from the checkpoint _saver = tf.train.Saver(var_list=tf.trainable_variables()) _saver.restore(self.sess, self.opts['ckpt_path']) if self.opts['verbose']: print("... model initialized") self.last_ckpt = self.opts['ckpt_path'] else: # In training mode, we either want to start a new training session or resume from a previous checkpoint self.last_ckpt = self.saver.best_checkpoint(self.opts['ckpt_dir'], maximize=False) if self.last_ckpt is None: self.last_ckpt = tf.train.latest_checkpoint(self.opts['ckpt_dir']) if self.last_ckpt: # We're resuming a session -> initialize the graph with the content of the checkpoint if self.opts['verbose']: print(f"Initializing model from previous checkpoint {self.last_ckpt} to resume training...\n") self.saver.restore(self.sess, self.last_ckpt) if self.opts['verbose']: print("... model initialized") else: # Initialize all the variables of the graph if self.opts['verbose']: print(f"Initializing model with random values for initial training...\n") assert (self.mode in ['train_noval', 'train_with_val']) self.sess.run(tf.global_variables_initializer()) if self.opts['verbose']: print("... model initialized") else: # Initialize the graph with the content of the checkpoint self.last_ckpt = self.opts['ckpt_path'] assert(self.last_ckpt is not None) if self.opts['verbose']: print(f"Loading model checkpoint {self.last_ckpt} for eval or testing...\n") self.saver.restore(self.sess, self.last_ckpt) if self.opts['verbose']: print("... model loaded")
def from_dict(cls, dct_to_load): weights = {var_name: dct_to_load.pop(var_name) for var_name in cls._get_weight_variables_names()} unsupervised_dbn_dct = dct_to_load.pop('unsupervised_dbn') num_classes = dct_to_load.pop('num_classes') instance = cls(**dct_to_load) setattr(instance, 'unsupervised_dbn', instance.unsupervised_dbn_class.from_dict(unsupervised_dbn_dct)) setattr(instance, 'num_classes', num_classes) # Initialize RBM parameters instance._build_model(weights) sess.run(tf.variables_initializer([getattr(instance, name) for name in cls._get_weight_variables_names()])) return instance
def update(self, num_training_epochs=10, batch_size=128, verbose=False): """Trains the neural net. Randomly sampls data from the replay buffer. An update resets the optimizer state. Args: num_training_epochs: An epoch represents one pass over the training data. The total number training iterations this corresponds to is num_training_epochs * len(replay_buffer)/batch_size. batch_size: the number of examples sampled from the replay buffer and used for each net training iteration. verbose: whether to print training metrics during training. Returns: A list of length num_training_epochs. Each element of this list is another list containing LossValues tuples, one for every training iteration. """ # The AlphaZero pseudocode resets the optimizer state before training. optim = self.bot.evaluator.optimizer tf.variables_initializer(optim.variables()) tf.train.get_or_create_global_step().assign(0) num_epoch_iters = math.ceil(len(self.replay_buffer) / float(batch_size)) losses = [] for epoch in range(num_training_epochs): epoch_losses = [] for _ in range(num_epoch_iters): train_data = self.replay_buffer.sample(batch_size) epoch_losses.append(self.bot.evaluator.update(train_data)) losses.append(epoch_losses) if verbose: self._print_mean_epoch_losses(epoch, epoch_losses) return losses
def initialize_uninitialized_variables(sess): """ Only initialize the weights that have not yet been initialized by other means, such as importing a metagraph and a checkpoint. It's useful when extending an existing model. """ uninit_vars = [] uninit_tensors = [] for var in tf.global_variables(): uninit_vars.append(var) uninit_tensors.append(tf.is_variable_initialized(var)) uninit_bools = sess.run(uninit_tensors) uninit = zip(uninit_bools, uninit_vars) uninit = [var for init, var in uninit if not init] sess.run(tf.variables_initializer(uninit))
def from_dict(cls, dct_to_load): weights = {var_name: dct_to_load.pop(var_name) for var_name in cls._get_weight_variables_names()} _activation_function_class = dct_to_load.pop('_activation_function_class') n_visible_units = dct_to_load.pop('n_visible_units') instance = cls(**dct_to_load) setattr(instance, '_activation_function_class', _activation_function_class) setattr(instance, 'n_visible_units', n_visible_units) # Initialize RBM parameters instance._build_model(weights) sess.run(tf.variables_initializer([getattr(instance, name) for name in cls._get_weight_variables_names()])) return instance
def _fine_tuning(self, data, _labels): self.num_classes = self._determine_num_output_neurons(_labels) if self.num_classes == 1: _labels = np.expand_dims(_labels, -1) self._build_model() sess.run(tf.variables_initializer([self.W, self.b])) labels = self._transform_labels_to_network_format(_labels) if self.verbose: print("[START] Fine tuning step:") self._stochastic_gradient_descent(data, labels) if self.verbose: print("[END] Fine tuning step")
def do_optimizer_initializations(self, optimizer): """Initializes gradient-based TF optimizers.""" self.optimizer_weights = [optimizer] opt_library = optimizer.split(':')[0] opt_method = optimizer.split(':')[1] # optimization step self.opt, self.optim_step = self.optimizers_options[opt_library]( opt_method) self.opt_vars = self.opt.variables() self.reset_optimizer_op = tf.variables_initializer(self.opt_vars) self.dice_sess.run(self.reset_optimizer_op)
def embedding(vlist, rlist, metaPath, spSize): vs = [] for i in range(0, len(vlist)): v = tf.Variable(rlist[i], name=vlist[i].name.split('/')[0]) # x/relu vs.append(v) with tf.Session() as sess: tf.variables_initializer(vs).run() # assign to vs saver = tf.train.Saver(vs) saver.save(sess, './log/model.ckpt', 0) # only contain vs # get writer and config summary_writer = tf.summary.FileWriter('./log/') config = projector.ProjectorConfig() # set config for v in vs: embed = config.embeddings.add() embed.tensor_name = v.name embed.metadata_path = metaPath + 'meta.tsv' embed.sprite.image_path = metaPath + 'meta.png' embed.sprite.single_image_dim.extend(spSize) # write projector.visualize_embeddings(summary_writer, config)
def ir2tf(imp_resp, shape, sess, dim=None, is_real=True): """Compute the transfer function of an impulse response (IR). This function makes the necessary correct zero-padding, zero convention, correct fft2, etc... to compute the transfer function of IR. To use with unitary Fourier transform for the signal (ufftn or equivalent). Parameters ---------- imp_resp : ndarray The impulse responses. shape : tuple of int A tuple of integer corresponding to the target shape of the transfer function. dim : int, optional The last axis along which to compute the transform. All axes by default. is_real : boolean, optional If True (default), imp_resp is supposed real and the Hermitian property is used with rfftn Fourier transform. Returns ------- y : complex ndarray The transfer function of shape ``shape``. """ if not dim: dim = len(imp_resp.shape) # Zero padding and fill irpadded = tf.Variable(tf.zeros(shape)) sess.run(tf.variables_initializer([irpadded])) sess.run( tf.assign(irpadded[tuple([slice(0, s) for s in imp_resp.shape])], imp_resp)) # Roll for zero convention of the fft to avoid the phase # problem. Work with odd and even size. for axis, axis_size in enumerate(imp_resp.shape): if axis >= len(imp_resp.shape) - dim: irpadded = tf.roll( irpadded, shift=-tf.cast(tf.floor(tf.cast(axis_size, tf.int32) / 2), tf.int32), axis=axis) if is_real: return tf.signal.rfft2d(irpadded) else: return tf.fft2d(tf.cast(irpadded, tf.complex64))
def initialize_uninitilized_global_variables(sess): # from https://github.com/tensorflow/cleverhans/tree/master/cleverhans # List all global variables global_vars = tf.global_variables() # Find initialized status for all variables is_var_init = [tf.is_variable_initialized(var) for var in global_vars] is_initialized = sess.run(is_var_init) # List all variables that were not initialialized previously not_initialized_vars = [ var for (var, init) in zip(global_vars, is_initialized) if not init ] # Initialize all uninitialized variables found, if any if len(not_initialized_vars): sess.run(tf.variables_initializer(not_initialized_vars))
def restore(path: RichPath, is_train: bool, hyper_overrides: Optional[Dict[str, Any]] = None) -> Model: saved_data = path.read_as_pickle() if hyper_overrides is not None: saved_data['hyperparameters'].update(hyper_overrides) model_class = get_model_class_from_name(saved_data['model_type']) model = model_class(saved_data['hyperparameters'], saved_data.get('run_name')) model.query_metadata.update(saved_data['query_metadata']) for (language, language_metadata ) in saved_data['per_code_language_metadata'].items(): model.per_code_language_metadata[language] = language_metadata model.make_model(is_train=is_train) variables_to_initialize = [] with model.sess.graph.as_default(): with tf.name_scope("restore"): restore_ops = [] used_vars = set() for variable in sorted(model.sess.graph.get_collection( tf.GraphKeys.GLOBAL_VARIABLES), key=lambda v: v.name): used_vars.add(variable.name) if variable.name in saved_data['weights']: # print('Initializing %s from saved value.' % variable.name) restore_ops.append( variable.assign(saved_data['weights'][variable.name])) else: print( 'Freshly initializing %s since no saved value was found.' % variable.name) variables_to_initialize.append(variable) for var_name in sorted(saved_data['weights']): if var_name not in used_vars: if var_name.endswith('Adam:0') or var_name.endswith( 'Adam_1:0') or var_name in [ 'beta1_power:0', 'beta2_power:0' ]: continue print('Saved weights for %s not used by model.' % var_name) restore_ops.append( tf.variables_initializer(variables_to_initialize)) model.sess.run(restore_ops) return model
def train(self, num_iterations=100, learning_rate=1.0, plot_results=True, optimizer=tf.train.GradientDescentOptimizer): with self._loss.graph.as_default(): opt = optimizer(learning_rate) train_op = opt.minimize(self._loss) local_init_op = tf.group( tf.variables_initializer(opt.variables()), tf.local_variables_initializer()) if self._session is None: self._session = tf.Session() with self._session.as_default(): self._session.run(tf.global_variables_initializer()) self._session.run(tf.tables_initializer()) tf.train.start_queue_runners() with self._session.as_default(): local_init_op.run() iterations = [] metrics = self._metrics or ({},) metrics_vals = [collections.defaultdict(list) for _ in self._metrics] for i in range(num_iterations + 1): _, results = self._session.run((train_op, metrics)) if (i % 10 == 0) or i == num_iterations: print("\r iteration %d: " % i + ", ".join( ["%s=%f" % (k, v) for r in results for k, v in r.items()]), end='') iterations.append(i) for metric_val, result in zip(metrics_vals, results): for k, v in result.items(): metric_val[k].append(v) for k, v in self._embedding_vars.items(): self._embeddings[k] = v.eval() if plot_results: num_subplots = len(metrics)+1 fig = plt.figure() fig.set_size_inches(num_subplots*10, 8) for i, metric_vals in enumerate(metrics_vals): ax = fig.add_subplot(1, num_subplots, i+1) for k, v in metric_vals.items(): ax.plot(iterations, v, label=k) ax.set_xlim([1, num_iterations]) ax.legend() return results
def build_graph(self): self.build_datapipeline() xb, yb = self.dataset_iterator.get_next() logits = self.model(xb) self.loss = self.loss_func(yb, logits) self.variables = [(v, i) for i, v in enumerate(tf.trainable_variables()) if 'dense' in v.name] # dont apply to last dense layer self.variables.pop(-1) self.vs = [ tf.random.normal((v.shape.as_list()[-1], 1), mean=0., stddev=1.) for v, _ in self.variables ] assert len(self.variables) > 0 # spectral norm reg grads = tf.gradients(self.loss, tf.trainable_variables()) new_vs = [] for (var, idx), v in zip(self.variables, self.vs): original_shape = grads[idx].shape W_grad = tf.reshape(grads[idx], [-1, var.shape[-1]]) W = tf.reshape(var, [-1, var.shape[-1]]) u = W @ v v = tf.transpose(W) @ u sigma = tf.norm(u, 2) / tf.norm(v, 2) reg_value = sigma * (u @ tf.transpose(v)) W_grad += self.reg_constant * reg_value grads[idx] = tf.reshape(W_grad, original_shape) new_vs.append(v) self.vs = new_vs self.acc, self.acc_op = tf.metrics.accuracy(tf.argmax(yb, 1), tf.argmax(logits, 1), name='acc') self.acc_vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, scope="acc") self.acc_initializer = tf.variables_initializer(var_list=self.acc_vars) self.train_op = self.optimizer.apply_gradients( zip(grads, tf.trainable_variables()))
def testCreateRegularizer_Sliced(self): # Call handler to create regularizer. handler = batch_norm_source_op_handler.BatchNormSourceOpHandler( _GAMMA_THRESHOLD) batch_norm_op_slice = orm.OpSlice(self.batch_norm_op, orm.Slice(0, 3)) regularizer = handler.create_regularizer(batch_norm_op_slice) # Verify regularizer is the gamma tensor. with self.cached_session(): # Initialize the gamma tensor to check value equality. with tf.variable_scope('', reuse=tf.AUTO_REUSE): gamma_tensor = tf.get_variable('conv1/BatchNorm/gamma') init = tf.variables_initializer([gamma_tensor]) init.run() # Verify regularizer is the sliced gamma tensor. self.assertAllEqual(gamma_tensor.eval()[0:3], regularizer._gamma.eval())
def fit(self, X): """ Fit a model given data. :param X: array-like, shape = (n_samples, n_features) :return: """ self.n_visible_units = X.shape[1] # Initialize RBM parameters self._build_model() sess.run(tf.variables_initializer([self.W, self.c, self.b])) if self.optimization_algorithm == 'sgd': self._stochastic_gradient_descent(X) else: raise ValueError("Invalid optimization algorithm.") return
def update_loss(self, n_task): if n_task == 0: return loss = self.vars['losses'][0] if self.use_orig_loss else self.vars[ 'losses'][n_task - 1] penalties = [] old_vars = self.objs[ 'fisher_old_ws'] if self.use_latest_theta_star else self.saved_wts[ n_task - 1] fisher_vars = self.objs[ 'fisher_diags'] if self.use_latest_theta_star else self.saved_fishers[ n_task - 1] for var, old_var, fisher in zip(self.objs['fisher_ws'], old_vars, fisher_vars): penalties += [ tf.multiply(fisher, tf.square(tf.subtract(var, old_var))) ] ewc_penalty = tf.add_n( [tf.reduce_sum(penalty) for penalty in penalties]) new_loss = tf.add( loss, tf.multiply(tf.constant(self.ewc_const, tf.float32), ewc_penalty)) self.vars['loss'] = new_loss self.vars['losses'][n_task] = new_loss orig_var_list = self.vars['orig_var_list'] # print("Trainable vars: %s" % str(orig_var_list)) print("Trainable vars:") self.print_vars(orig_var_list) if self.reset_opt: print('Reset opt') self.objs['sess'].run( tf.variables_initializer(self.objs['opt'].variables())) op = self.objs['opt'].minimize(new_loss, var_list=orig_var_list) self.vars['train_op'] = op self.vars['train_ops'][n_task] = op print('Updated train_op and loss')
def build(self, num_inputs, num_outputs, num_targets): # build a new graph and session in which training will take place self.graph = tf.Graph() self.sess = tf.Session(graph=self.graph) with self.graph.as_default(): # variables common to all neurons self.targets = tf.placeholder(dtype=dtype, shape=[None, num_targets], name='targets') self.inputs, self.losses, self.neurons, self.train_ops, variables = [], [], [], [], [] # group neurons based on their inputs for each_num_inputs in num_inputs: inputs = tf.placeholder(dtype=dtype, shape=[None, each_num_inputs], name='inputs') self.inputs.append(inputs) # group neurons based on their activations for activation in self.activations: # construct prediction of neuron y_pred, weights = self._build_perceptron( inputs, num_outputs, activation, self.weight_init) self.neurons.append((weights, activation)) # construct loss function loss = reg_loss = self.loss_function(self.targets, y_pred) self.losses.append(loss) if self.regularizer is not None: reg_loss = reg_loss + self.reg_penalty * self.regularizer( weights[0]) # construct optimizer sgd = self.optimizer(**self.optimizer_args) self.train_ops.append( sgd.minimize(reg_loss, var_list=weights)) variables.extend(weights + sgd.variables()) # group training ops and initialize variables self.train_ops = tf.group(self.train_ops) self.sess.run(tf.variables_initializer(variables))
def initialize_interdependent_variables(session, vars_list, feed_dict): """Initialize a list of variables one at a time, which is useful if initialization of some variables depends on initialization of the others. """ vars_left = vars_list while len(vars_left) > 0: new_vars_left = [] for v in vars_left: try: session.run(tf.variables_initializer([v]), feed_dict) except tf.errors.FailedPreconditionError: new_vars_left.append(v) if len(new_vars_left) >= len(vars_left): # This can happen if the variables all depend on each other, or more likely if there's # another variable outside of the list, that still needs to be initialized. This could be # detected here, but life's finite. raise Exception("Cycle in variable dependencies, or extenrnal precondition unsatisfied.") else: vars_left = new_vars_left
def yolo_non_max_suppression(scores, boxes, classes, max_boxes=10, iou_threshold=0.5): max_boxes_tensor = K.variable( max_boxes, dtype="int32") # 用于tf.image.non_max_suppression() K.get_session().run(tf.variables_initializer([max_boxes_tensor ])) # 初始化变量max_boxes_tensor # 使用使用tf.image.non_max_suppression()来获取与我们保留的框相对应的索引列表 nms_indices = tf.image.non_max_suppression(boxes, scores, max_boxes, iou_threshold) scores = K.gather(scores, nms_indices) boxes = K.gather(boxes, nms_indices) classes = K.gather(classes, nms_indices) return scores, boxes, classes