def testLinearSolverConstruction(self, x1, y1, x2, y2, a, b): """Verifies that a TFLinearEquationSolver is constructed correctly.""" solver = clustering_centroids.TFLinearEquationSolver( float(x1), float(y1), float(x2), float(y2)) solver_a = solver.a self.assertAlmostEqual(K.batch_get_value([solver_a])[0], a) self.assertAlmostEqual(K.batch_get_value([solver.b])[0], b)
def F(inputs): self.count += 1 R = fast_train_function(inputs) if self.count % self.k == 0: K.batch_get_value(slow_updates) K.batch_get_value(copy_updates) return R
def apply_ema_weights(self): """ store origin model weights, then apply the ema_weights to model """ self.old_weights = K.batch_get_value(self.model.weights) ema_weights = K.batch_get_value(self.ema_weights) K.batch_set_value(zip(self.model.weights, ema_weights))
def create_generator(config): dataset = create_dataset(config) iter = dataset.make_one_shot_iterator() batch = iter.get_next() while True: yield K.batch_get_value(batch)
def save_optimizer_weights(model, filepath, epoch, batch): symbolic_weights = getattr(model.optimizer, 'weights') if symbolic_weights is None: return weight_values = K.batch_get_value(symbolic_weights) with open(filepath + '_optimizer.pkl', 'wb') as f: pickle.dump((weight_values, epoch, batch), f)
def testCDFValues(self, weights, point, probability): """Verifies that TFCumulativeDistributionFunction yields the expected output for the inputs provided.""" cdf_calc = clustering_centroids.TFCumulativeDistributionFunction( weights) self.assertAlmostEqual( probability, K.batch_get_value([cdf_calc.get_cdf_value(point)])[0])
def testLinearSolverSolveForY(self, x1, y1, x2, y2, x, y): solver = clustering_centroids.TFLinearEquationSolver(float(x1), float(y1), float(x2), float(y2)) for_y = solver.solve_for_y(x) self.assertAlmostEqual(K.batch_get_value([for_y])[0], y)
def save_opt_weights(model, filepath): with h5py.File(filepath, 'w') as f: # Save optimizer weights. symbolic_weights = getattr(model.optimizer, 'weights') if symbolic_weights: optimizer_weights_group = f.create_group('optimizer_weights') weight_values = K.batch_get_value(symbolic_weights) weight_names = [] for i, (w, val) in enumerate(zip(symbolic_weights, weight_values)): # Default values of symbolic_weights is /variable for theano if K.backend() == 'theano': if hasattr(w, 'name') and w.name != "/variable": name = str(w.name) else: name = 'param_' + str(i) else: if hasattr(w, 'name') and w.name: name = str(w.name) else: name = 'param_' + str(i) weight_names.append(name.encode('utf8')) optimizer_weights_group.attrs['weight_names'] = weight_names for name, val in zip(weight_names, weight_values): param_dset = optimizer_weights_group.create_dataset( name, val.shape, dtype=val.dtype) if not val.shape: # scalar param_dset[()] = val else: param_dset[:] = val
def testClusterCentroids(self, weights, number_of_clusters, centroids): dbci = clustering_centroids.DensityBasedCentroidsInitialisation( weights, number_of_clusters ) calc_centroids = K.batch_get_value([dbci.get_cluster_centroids()])[0] self.assertSequenceAlmostEqual(centroids, calc_centroids, places=4)
def save_integrated_agent(self, vissim_working_directory, model_name, agent_type, Session_ID, episode): if self.type == 'AC': Weights_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,"Agent{}".format(self.ID),'Episode'+ str(episode) +'Agent'+str(self.ID)+'_Weights'+'.h5') Optimizer_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,"Agent{}".format(self.ID),'Episode'+ str(episode) +'Agent'+str(self.ID)+'_Optimizer'+'.h5') print('Saving architecture, weights, optimizer state for agent-{}'.format(self.ID)) symbolic_weights = getattr(self.model.optimizer, 'weights') weight_values = K.batch_get_value(symbolic_weights) with open(Optimizer_Filename, 'wb') as f: pickle.dump(weight_values, f) # little change to save weight instead of the all agent self.model.save_weights(Weights_Filename) else : folder = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID, "Agent{}".format(self.ID)) if not os.path.exists(folder): os.makedirs(folder) Filename = os.path.join(folder,'Episode'+ str(episode) +'Agent'+str(self.ID)+'.h5') print('Saving architecture, weights and optimizer state for agent-{}'.format(self.ID)) self.model.save(Filename) Memory_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,"Agent{}".format(self.ID),'Episode'+ str(episode) +'Agent'+str(self.ID)+'_Memory'+'.p') print('Dumping agent-{} memory into pickle file'.format(self.ID)) pickle.dump(self.memory, open(Memory_Filename, 'wb')) Training_Progress_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,"Agent{}".format(self.ID),'Episode'+ str(episode) +'Agent'+str(self.ID)+'_Train'+'.p') print('Dumping Training Results into pickle file.') pickle.dump(self.reward_storage, open(Training_Progress_Filename, 'wb')) Loss_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,"Agent{}".format(self.ID),'Episode'+ str(episode) +'Agent'+str(self.ID)+'_Loss'+'.p') print('Dumping Loss Results into pickle file.') pickle.dump(self.loss, open(Loss_Filename, 'wb'))
def best_agent(self, vissim_working_directory, model_name, agent_type, Session_ID): # Chech if suitable folder exists folder = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID) if not os.path.exists(folder): os.makedirs(folder) if self.average_reward >= np.max(self.reward_storage): best_agent_memory = self.memory print('Saving architecture, weights, optimizer state for best agent-{}'.format(self.ID)) if self.type == 'AC' : best_agent_weights = self.model.get_weights() Weights_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'BestAgent'+str(self.ID)+'_Weights'+'.h5') Optimizer_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'BestAgent'+str(self.ID)+'_Optimizer'+'.h5') symbolic_weights = getattr(self.model.optimizer, 'weights') weight_values = K.batch_get_value(symbolic_weights) with open(Optimizer_Filename, 'wb') as f: pickle.dump(weight_values, f) self.model.save_weights(Weights_Filename) else : best_agent_weights = self.model Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'BestAgent'+str(self.ID)+'.h5') self.model.save(Filename) Memory_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'BestAgent'+str(self.ID)+'_Memory'+'.p') pickle.dump(best_agent_memory, open(Memory_Filename, 'wb')) #print("New best agent found. Saved in {}".format(Memory_Filename)) Training_Progress_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'Agent'+str(self.ID)+'_Train'+'.p') #print('Dumping Training Results into pickle file.') Loss_Filename = os.path.join(vissim_working_directory, model_name, "Agents_Results", agent_type, Session_ID,'Agent'+str(self.ID)+'_Loss'+'.p') #print('Dumping Loss Results into pickle file.') pickle.dump(self.loss, open(Loss_Filename, 'wb'))
def on_epoch_end(self, epoch, logs=None): # if epoch < 50: return # 评估较慢,前50个epoch先不进行评估 acc, f1, final = self.evaluate() print(f'acc={acc},f1={f1},final={final}') self.metrics.append((epoch, acc, f1, final)) json.dump(self.metrics, open('train.log', 'w'), indent=4) if final > self.best: self.best = final self.model.save_weights('best_model.weights') print('learning rate: %s' % (tk.eval(self.model.optimizer.lr))) print('acc: %.4f, f1: %.4f, final: %.4f, best final: %.4f\n' % (acc, f1, final, self.best)) if epoch + 1 == 30 or (self.stage == 0 and epoch > 15 and (final < 0.5 or np.argmax(self.metrics, 0)[3] < len(self.metrics) - 5)): """达到30个epoch,或者final开始下降到0.5以下(开始发散), 或者连续5个epoch都没提升,就降低学习率。 """ self.stage = 1 self.model.load_weights('best_model.weights') tk.set_value(self.model.optimizer.lr, 1e-4) tk.set_value(self.model.optimizer.iterations, 0) opt_weights = tk.batch_get_value(self.model.optimizer.weights) opt_weights = [w * 0. for w in opt_weights] tk.batch_set_value(zip(self.model.optimizer.weights, opt_weights))
def on_epoch_end(self, epoch, logs=None): train_loss = round(logs.get('loss'), 4) val_loss = round(logs.get('val_loss'), 4) # Save model as h5 file model_filepath = f'{self.model_dir}/model-{epoch + 1}-{train_loss}-{val_loss}.h5' save_model(self.model, model_filepath) # Save model weights as h5 file weights_filepath = f'{self.model_dir}/model-weights-{epoch + 1}-{train_loss}-{val_loss}.h5' self.model.save_weights(weights_filepath) # Save optimizer state as pickle file optimizer_weights_filepath = f'{self.model_dir}/optimizer-weights-{epoch + 1}-{train_loss}-{val_loss}.pkl' with open(optimizer_weights_filepath, 'wb') as f: pickle.dump( K.batch_get_value(getattr(self.model.optimizer, 'weights')), f) # Update the checkpoint epoch self.checkpoint['epoch'] += 1 if val_loss < self.best_val_loss: self.checkpoint['best_model'] = model_filepath self.best_val_loss = val_loss self.checkpoint['last_model'] = model_filepath self.checkpoint['last_weights'] = weights_filepath self.checkpoint['last_optimizer_weights'] = optimizer_weights_filepath with open(f"{self.checkpoint['checkpoint_dir']}/checkpoint.json", "w") as f: json.dump(self.checkpoint, f, indent=4)
def initialize(self): """ema_weights初始化跟原模型初始化一致。 """ self.old_weights = K.batch_get_value(self.model.weights) self.mv_trainable_weights_vals = { x.name: K.get_value(x) for x in self.model.trainable_weights }
def mnist_generator(filenames): dataset = mnist_dataset(filenames) iter = dataset.make_one_shot_iterator() batch = iter.get_next() while True: yield K.batch_get_value(batch)
def _pull_values(self, ca, pulling_indices, expected_output): pulling_indices_np = np.array(pulling_indices) res_tf = ca.get_clustered_weight(pulling_indices_np) res_np = K.batch_get_value([res_tf])[0] res_np_list = res_np.tolist() self.assertSequenceEqual(res_np_list, expected_output)
def _get_cell_weights(rnn_cell, as_tensors=True, concat_gates=True): """Retrieves RNN layer weights from their cell(s). NOTE: if CuDNNLSTM or CuDNNGRU cell, `rnn_cell` must be the layer instead, where non-CuDNN cell attributes are stored. """ def _get_cell_info(rnn_cell): rnn_type = type(rnn_cell).__name__.replace('Cell', '') if rnn_type in ['SimpleRNN', 'IndRNN']: gate_names = [''] elif rnn_type in ['LSTM', 'CuDNNLSTM']: gate_names = ['i', 'f', 'c', 'o'] elif rnn_type in ['GRU', 'CuDNNGRU']: gate_names = ['z', 'r', 'h'] if ('CuDNN' in rnn_type) or rnn_cell.use_bias: kernel_types = ['kernel', 'recurrent_kernel', 'bias'] else: kernel_types = ['kernel', 'recurrent_kernel'] return rnn_type, gate_names, kernel_types rnn_type, gate_names, kernel_types = _get_cell_info(rnn_cell) if TF_KERAS and not concat_gates: print(warn_str + "getting weights per-gate not supported for tf.keras " + "implementations; fetching per concat_gates==True instead") concat_gates = True if not concat_gates and gate_names[0] == '': print(warn_str + rnn_type + " is not a gated RNN; fetching per " + "concat_gates==True instead") concat_gates = True if concat_gates: if as_tensors: return [getattr(rnn_cell, w_type) for w_type in kernel_types] try: return rnn_cell.get_weights() except: return K.batch_get_value(rnn_cell.weights) if 'GRU' in rnn_type: kernel_types = ['kernel', 'recurrent_kernel', 'input_bias'] rnn_weights = [] for w_type in kernel_types: rnn_weights.append([]) for g_name in gate_names: rnn_weights[-1].append(getattr(rnn_cell, w_type + '_' + g_name)) if as_tensors: return rnn_weights else: for weight_idx in range(len(rnn_weights)): for gate_idx in range(len(rnn_weights[weight_idx])): rnn_weights[weight_idx][gate_idx] = K.eval( rnn_weights[weight_idx][gate_idx]) return rnn_weights
def testLinearSolverSolveForX(self, x1, y1, x2, y2, x, y): """ Verifies that TFLinearEquationSolver solves the given equations correctly for X. """ solver = clustering_centroids.TFLinearEquationSolver( float(x1), float(y1), float(x2), float(y2)) for_x = solver.solve_for_x(y) self.assertAlmostEqual(K.batch_get_value([for_x])[0], x)
def testRandomClusterCentroidsWithSparsityPreservation( self, weights, number_of_clusters): dbci = clustering_centroids.RandomCentroidsInitialisation( weights, number_of_clusters, True) calc_centroids = K.batch_get_value([dbci.get_cluster_centroids()])[0] self.assertContainsSubset( [0.], calc_centroids, msg="The centroids must include the zero-point cluster")
def _save_model(self, epoch, logs): # Save the model with super super(ModelCheckpointWorkAround, self)._save_model(epoch, logs) if self.save_optimizer: # Save the optimizer folder = os.path.dirname(self._get_file_path(epoch, logs)) symbolic_weights = getattr(self.model.optimizer, 'weights') weight_values = K.batch_get_value(symbolic_weights) with open(os.path.join(folder, 'optimizer.pkl'), 'wb') as f: pkl.dump(weight_values, f)
def set_model(self, model): """绑定模型,并初始化参数 """ super(ExponentialMovingAverage, self).set_model(model) self.ema_weights = [K.zeros(K.shape(w)) for w in model.weights] self.old_weights = K.batch_get_value(model.weights) K.batch_set_value(zip(self.ema_weights, self.old_weights)) self.updates = [] for w1, w2 in zip(self.ema_weights, model.weights): op = K.moving_average_update(w1, w2, self.momentum) self.updates.append(op)
def set_kernal(self, kernal_values): params = self.kernel if not params: return weight_value_tuples = [] param_values = K.batch_get_value(params) if param_values.shape != kernal_values.shape: raise ValueError('Layer kernel shape ' + str(param_values.shape) + ' not compatible with ' 'provided kernel shape ' + str(kernal_values.shape)) weight_value_tuples.append((params, kernal_values)) K.batch_set_value(weight_value_tuples)
def set_bias(self, kernal_bias): if not self.use_bias: return params = self.bias if not params: return weight_value_tuples = [] param_values = K.batch_get_value(params) if param_values.shape != kernal_bias.shape: raise ValueError('Layer bias shape ' + str(param_values.shape) + ' not compatible with ' 'provided bias shape ' + str(kernal_bias.shape)) weight_value_tuples.append((params, kernal_bias)) K.batch_set_value(weight_value_tuples)
def save_weights(cfg, submodel_settings, mdl, ticker_name=''): print(f"model> trying to save weights ...") pth_submodel = pathlib.Path( f"{cfg.model.base_dir}/{submodel_settings.id}/{ticker_name}") f_model_weights = pth_submodel.joinpath(cfg.model.model_weights_file_name) f_optimizer_weights = pth_submodel.joinpath( cfg.model.optimizer_weights_file_name) mkdirs(pth_submodel) mdl.save_weights(os.fspath(f_model_weights)) print(f"model> saved model weights to '{f_model_weights.resolve()}'") with open(f_optimizer_weights.resolve(), 'wb') as f: pickle.dump(K.batch_get_value(getattr(mdl.optimizer, 'weights')), f) print( f"model> saved optimizer weights to '{f_optimizer_weights.resolve()}'" )
def get_weight_grad(model, x, y, sample_weight=None, learning_phase=0): def _process_input_data(x, y, sample_weight, model): iterator = data_adapter.single_batch_iterator( model.distribute_strategy, x, y, sample_weight, class_weight=None) data = next(iterator) data = data_adapter.expand_1d(data) x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data) return x, y, sample_weight def _clip_scale_grads(strategy, tape, optimizer, loss, params): with tape: if isinstance(optimizer, lso.LossScaleOptimizer): loss = optimizer.get_scaled_loss(loss) gradients = tape.gradient(loss, params) aggregate_grads_outside_optimizer = ( optimizer._HAS_AGGREGATE_GRAD and not isinstance( strategy.extended, parameter_server_strategy.ParameterServerStrategyExtended)) if aggregate_grads_outside_optimizer: gradients = optimizer._aggregate_gradients(zip(gradients, params)) if isinstance(optimizer, lso.LossScaleOptimizer): gradients = optimizer.get_unscaled_gradients(gradients) gradients = optimizer._clip_gradients(gradients) return gradients x, y, sample_weight = _process_input_data(x, y, sample_weight, model) with tf.GradientTape() as tape: y_pred = model(x, training=bool(learning_phase)) loss = tf.keras.losses.CategoricalCrossentropy()(y, y_pred) # loss = model.compiled_loss(y, y_pred, sample_weight, # regularization_losses=model.losses) gradients = _clip_scale_grads(model.distribute_strategy, tape, model.optimizer, loss, model.trainable_weights) gradients = K.batch_get_value(gradients) return gradients
def train(self, env_name, batch_size=500, policy_epsilon=0.2): """Train a model""" # initiate training loop train_vars = { 'batch_size': batch_size, 'policy_epsilon': policy_epsilon } timestr = time.strftime("%Y%m%d-%H%M%S") + "_" + str(env_name) tensorboard = TensorBoard(log_dir='./Graph/{}'.format(timestr), histogram_freq=0, write_graph=True, write_images=False) self.dqn.fit(self.env, nb_max_start_steps=nb_max_start_steps, nb_steps=nb_steps, visualize=False, verbose=2, start_step_policy=self.start_step_policy, callbacks=[tensorboard]) self.policy.eps = policy_epsilon self.dqn.save_weights("dqn_{}_model.h5".format(env_name), overwrite=True) # Save memory pickle.dump(self.dqn.memory, open("train_memory_{}.p".format(env_name), "wb")) # Save optimizer weights symbolic_weights = getattr(self.dqn.trainable_model.optimizer, 'weights') optim_weight_values = K.batch_get_value(symbolic_weights) pickle.dump(optim_weight_values, open('optimizer_weights_{}.p'.format(env_name), "wb")) # # Dump dqn # pickle.dump(self.dqn, open( "dqn_{}.p".format(env_name), "wb" )) # Finally, evaluate our algorithm for 5 episodes. self.dqn.test(self.env, nb_episodes=5, visualize=False)
def save_weights_as_checkpoint(self, filename, mapping=None): """根据mapping将权重保存为checkpoint格式 """ mapping = mapping or self.variable_mapping() mapping = {self.prefixed(k): v for k, v in mapping.items()} mapping = {k: v for k, v in mapping.items() if k in self.layers} with tf.Graph().as_default(): all_variables, all_values = [], [] for layer, variables in mapping.items(): layer = self.layers[layer] values = K.batch_get_value(layer.trainable_weights) for name, value in zip(variables, values): variable, value = self.create_variable(name, value) all_variables.append(variable) all_values.append(value) with tf.Session() as sess: K.batch_set_value(zip(all_variables, all_values)) saver = tf.train.Saver() saver.save(sess, filename)
def saveOptimizer(self, optimizer, fname): f = h5py.File(fname, mode='w') optimizer_weights_group = f.create_group('optimizer_weights') symbolic_weights = getattr(optimizer, 'weights') weight_values = K.batch_get_value(symbolic_weights) weight_names = [] for w, val in zip(symbolic_weights, weight_values): name = str(w.name) weight_names.append(name.encode('utf8')) optimizer_weights_group.attrs['weight_names'] = weight_names for name, val in zip(weight_names, weight_values): param_dset = optimizer_weights_group.create_dataset( name, val.shape, dtype=val.dtype) if not val.shape: # scalar param_dset[()] = val else: param_dset[:] = val f.flush() f.close()
def __init__(self, layer): ''' # Arguments layer: an instance of Convolution2D layer, whose configuration will be used to initiate DConvolution2D(input_shape, output_shape, weights) ''' self.layer = layer #weights = layer.get_weights() weights = K.batch_get_value(layer.weights) # WORK-AROUND FOR TF BUG W = weights[0] b = weights[1] nb_up_filter = W.shape[3] nb_up_row = W.shape[0] nb_up_col = W.shape[1] input = Input(shape=layer.input_shape[1:]) output = Conv2D(filters=nb_up_filter, kernel_size=(nb_up_row, nb_up_col), padding='same', weights=[W, b])(input) self.up_func = K.function([input, K.learning_phase()], output) # Flip W horizontally and vertically, # and set down_func for DConvolution2D # For TF2.2 W=(kernel_row,kernel_col,in_channels,out_channels) W = np.transpose(W, (0, 1, 3, 2)) #swap in/out channels W = W[::-1, ::-1, :, :] # reverse elements in kernel nb_down_filter = W.shape[3] nb_down_row = W.shape[0] nb_down_col = W.shape[1] b = np.zeros(nb_down_filter) input = Input(shape=layer.output_shape[1:]) output = Conv2D(filters=nb_down_filter, kernel_size=(nb_down_row, nb_down_col), padding='same', weights=[W, b])(input) self.down_func = K.function([input, K.learning_phase()], output)
def modify_set_weights(new_model, weights): if len(new_model.weights) != len(weights): raise ValueError('You called `set_weights(weights)` on layer "' + new_model.name + '" with a weight list of length ' + str(len(weights)) + ', but the layer was expecting ' + str(len(new_model.weights)) + ' weights. Provided weights: ' + str(weights)[:50] + '...') if not new_model.weights: return weight_value_tuples = [] param_values = backend.batch_get_value(new_model.weights) r = 0 l = len(new_model.weights) for pv, p, w in zip(param_values, new_model.weights, weights): if r == l - 2: # 手动调整最后两层的weight的赋值 new_18 = w old_18 = p # layer_18 = pv # weight_value_tuples.append((w, p)) elif r == l - 1: new_19 = w old_19 = p # layer_19 = pv weight_value_tuples.append((old_18, new_19)) weight_value_tuples.append((old_19, new_18)) break elif pv.shape != w.shape: raise ValueError('Layer weight shape ' + str(pv.shape) + ' not compatible with ' 'provided weight shape ' + str(w.shape)) else: weight_value_tuples.append((p, w)) r += 1 backend.batch_set_value(weight_value_tuples) return new_model