def __init__(self, steps=1, lr=0.0001, decay=0.00001): #Models self.D = None self.S = None self.G = None self.GE = None self.SE = None self.DM = None self.AM = None #Config self.LR = lr self.steps = steps self.beta = 0.999 #Init Models self.discriminator() self.generator() self.GMO = Adam(lr=self.LR, beta_1=0, beta_2=0.999) self.DMO = Adam(lr=self.LR, beta_1=0, beta_2=0.999) self.GE = clone_model(self.G) self.GE.set_weights(self.G.get_weights()) self.SE = clone_model(self.S) self.SE.set_weights(self.S.get_weights())
def clone(self): clone = copy(self) if isinstance(self._model, list): clone._model = [clone_model(model) for model in self._model] else: clone._model = clone_model(self._model) return clone
def __init__(self, env_name, env, Actor_net, Critic_net, act_dim, obs_dim ,lam = 0.97, Actor_lr = 0.0001, gamma = 0.99, delta = 0.01, Critic_lr = 0.001, render = False, epoch_steps = 2000, value_train_iterations = 5, memory_size = 100000, polyak_const = 0.995, minibatch_size = 100): self.env_name = env_name self.env = env self.gamma = gamma self.Actor = Actor_net self.Critic = Critic_net self.act_dim = act_dim self.obs_dim = obs_dim self.Actor_optimizer = optimizers.Adam(lr = Actor_lr) self.Critic_optimizer = optimizers.Adam(lr = Critic_lr) self.render = render self.lam = lam self.value_train_iterations = value_train_iterations self.Experience = namedtuple('Experience', ['states','actions', 'rewards', 'next_states', 'dones']) self.memory_size = memory_size self.memory = ReplayMemory(self.memory_size) self.Target_Actor = models.clone_model(self.Actor) self.Target_Critic = models.clone_model(self.Critic) self.minibatch_size = minibatch_size self.polyak_const = polyak_const self.act_limit = self.env.action_space.high[0]
def __init__(self, name, global_network_P, global_network_dqn, global_optimizer_P, global_optimizer_dqn, global_counter, env, max_global_steps, returns_list, n_steps=10, gamma=0.99): self.name = name self.global_network_P = global_network_P self.global_network_dqn = global_network_dqn self.global_optimizer_P = global_optimizer_P self.global_optimizer_dqn = global_optimizer_dqn self.global_counter = global_counter self.env = env self.allow_submit = env.allow_submit self.state = self.env.reset() self.max_global_steps = max_global_steps self.global_step = 0 self.returns_list = returns_list self.n_steps = n_steps self.gamma = gamma self.noise = OUActionNoise( mu=np.zeros(env.continuous_action_space.shape[0])) self.n_discrete_actions = env.discrete_action_space.n self.start_time = time.time() self.local_param_model = clone_model(global_network_P) self.local_param_model.set_weights(global_network_P.get_weights()) self.local_dqn_model = clone_model(global_network_dqn) self.local_dqn_model.set_weights(global_network_dqn.get_weights())
def copy(self, prev_scholar): self.sol = models.clone_model(prev_scholar.sol) self.sol.set_weights(prev_scholar.sol.get_weights()) self.gen = models.clone_model(prev_scholar.gen) self.gen.set_weights(prev_scholar.gen.get_weights()) self.disc = models.clone_model(prev_scholar.disc) self.disc.set_weights(prev_scholar.disc.get_weights())
def copy_and_compile(self, learning_rate=0.0001, TPU=None): boundaries = [20, 40, 60, 80, 100] values = [0.0] * (len(boundaries) + 1) n = learning_rate for i in range(len(boundaries)): values[i] = n n *= 0.25 if TPU: with TPU.scope(): nnet_copy = AlphaNNet() nnet_copy.v_net = clone_model(self.v_net) nnet_copy.v_net.build(self.v_net.layers[0].input_shape) nnet_copy.v_net.set_weights(self.v_net.get_weights()) lr = schedules.PiecewiseConstantDecay(boundaries, values) nnet_copy.v_net.compile(optimizer=Adam(learning_rate=lr), loss='mean_squared_error') else: nnet_copy = AlphaNNet() nnet_copy.v_net = clone_model(self.v_net) nnet_copy.v_net.build(self.v_net.layers[0].input_shape) nnet_copy.v_net.set_weights(self.v_net.get_weights()) lr = schedules.PiecewiseConstantDecay(boundaries, values) nnet_copy.v_net.compile(optimizer=Adam(learning_rate=lr), loss='mean_squared_error') return nnet_copy
def __init__(self, capacity=100, max_step=0, networks=None, batch_size=32, update=1, backend='Tensorflow', verbose=1, **kwargs): # Initialize parameters super(DDPGAgent, self).__init__(**kwargs) self.memory = deque(maxlen=capacity) self.batch_size = batch_size self.target_update = update self.max_step = max_step self.batch_size = batch_size if 0 < update < 1: self.target_update = update # Soft update elif update >= 1: self.target_update = int(update) # Hard update else: raise ValueError( 'Target update should be greater than 0. (0, 1) for soft update, [1, inf] for hard update.' ) self.backend = backend.upper() self.verbose = verbose # Initialize the agent try: self.load_brain(self.brain) except: assert len(networks) == 2 actor_path = networks[0]['PATH'] critic_path = networks[1]['PATH'] if self.backend == 'TENSORFLOW': self.Actor = TFutils.ModelBuilder(actor_path) self.Critic = TFutils.ModelBuilder(critic_path) try: if self.backend == 'TENSORFLOW': self.ActorTarget = clone_model(self.Actor) self.CriticTarget = clone_model(self.Critic) actor_optimizer = TFutils.get_optimizer( name=networks[0]['OPTIMIZER'], learning_rate=float(networks[0]['LEARNING_RATE'])) critic_optimizer = TFutils.get_optimizer( name=networks[1]['OPTIMIZER'], learning_rate=float(networks[1]['LEARNING_RATE'])) self.ActorOptimizer = actor_optimizer self.Critic.compile(optimizer=critic_optimizer, loss='mse') self._init_action_train_fn() except: print('Test mode, fail to initialize the network otherwise')
def __init__(self, input_shape=None, action_num=None, alpha=0.0001, beta=0.0005, gamma=0.99, eta=10, entropy_coef=0.1, entropy_decay=0.99, actor_loss_epsilon=0.2, actor_file=None, critic_file=None, training=True): if actor_file == None: if input_shape == None or action_num == None: raise Exception('input_shape and action_num are required when no actor file is specified.') self.actor = self._get_actor(input_shape, action_num, [64]) else: self.actor = load_model(actor_file) if training: self.grad_tape = tf.GradientTape(persistent=True) self.experiences = [] self.gamma = gamma self.eta = eta self.entropy_coef = entropy_coef self.entropy_decay = entropy_decay self.actor_loss_epsilon = actor_loss_epsilon self.actor_optimizer = Adam(learning_rate=alpha) self.critic_optimizer = Adam(learning_rate=beta) self.critic_loss_func = MeanSquaredError() #self.icm = IntrinsicCuriosityModule( # input_shape, # action_num, # 64 #) if critic_file == None: if input_shape == None: raise Exception('input_shape is required when no critic file is specified.') self.critic = self._get_critic(input_shape, [64]) else: self.critic = load_model(critic_file) self.prev_actor = clone_model(self.actor) self.prev_actor.set_weights(self.actor.get_weights())
def test_parsing(self, _model_2, _config): # Parsing removes BatchNorm layers, so we make a copy of the model. input_model = models.clone_model(_model_2) input_model.set_weights(_model_2.get_weights()) input_model.compile(_model_2.optimizer.__class__.__name__, _model_2.loss, _model_2.metrics) num_to_test = 10000 batch_size = 100 _config.set('simulation', 'batch_size', str(batch_size)) _config.set('simulation', 'num_to_test', str(num_to_test)) _, testset = get_dataset(_config) dataflow = testset['dataflow'] model_lib = import_module('snntoolbox.parsing.model_libs.' + _config.get('input', 'model_lib') + '_input_lib') model_parser = model_lib.ModelParser(input_model, _config) model_parser.parse() model_parser.build_parsed_model() _, acc, _ = model_parser.evaluate(batch_size, num_to_test, dataflow=dataflow) _, target_acc = _model_2.evaluate(dataflow, steps=int(num_to_test / batch_size)) assert acc == target_acc
def build_model(self, model, gpus=1, **compile_kwargs): """ Compile a Keras Functional model. :param model: keras.models.Model: Keras functional model :param gpus: int: number of GPU units on which to parallelize the Keras model :param compile_kwargs: kwargs passed to the 'compile' method of the Keras model """ # Test the parameters if type(gpus) is not int: raise TypeError("'gpus' argument must be an int") # Self-explanatory util.make_keras_picklable() # Build a model, either on a single GPU or on a CPU to control multiple GPUs self.base_model = model self._n_steps = len(model.outputs) if gpus > 1: import tensorflow as tf with tf.device('/cpu:0'): self.base_model = models.clone_model(self.base_model) self.model = multi_gpu_model(self.base_model, gpus=gpus) self.gpus = gpus else: self.model = self.base_model self.model.compile(**compile_kwargs)
def _fit_terminal_node(self, classes, node): self.print('\n\n', '-' * 50, sep='') self.print(f"Fitting terminal node with classes {classes}") mask = create_mask(self.y, classes) y = self.y[mask].copy() encoder = OneHotEncoder(categories='auto', sparse=False) encoder.fit(y.reshape(-1, 1)) y = encoder.transform(y.reshape(-1, 1)) self.encoders[node.name] = encoder self.class_maps[node.name] = dict(zip(classes, classes)) model = self._build_model( self.units, (len(classes), ), self.input_shape, clone_model(self.backbone) if self.backbone is not None else None) model.fit(self.X[mask], y, epochs=self.end_fit, verbose=self.verbose > 1, batch_size=self.batch_size) self.models[node.name] = model for a_class in classes: self.node_counter += 1 self.node_to_class[self.node_counter] = a_class Node(self.node_counter, parent=node) self.node_to_classes[self.node_counter] = [a_class]
def __init__(self, actions, starting_mem_len, max_mem_len, starting_epsilon, learn_rate, epsilon_decay=.9 / 100000, gamma=0.95, directory=None, debug=False): self.gamma = gamma self.actions = actions self.eps = starting_epsilon self.epsilon_decay = epsilon_decay self.epsilon_min = .05 self.memory = Memory(max_mem_len) self.lr = learn_rate if directory: self.model = self._load_model(directory) else: self.model = self._build_model() self.model_target = clone_model(self.model) self.total_timesteps = 0 self.starting_mem_len = starting_mem_len / 100 self.starting_mem_len = self.starting_mem_len * 100 self.learn_steps = 0
def apply_pruning(model: Any) -> Any: """ Aplica pruning a un modelo de tensorflow. Args: model: Model de TensorFlow al que se aplica pruning. Returns: Model de TensorFlow con pruning aplicado. """ def apply_pruning_to_layer(layer: Any) -> Any: """ Aplica low magnitude pruning a las capas compatibles. Args: layer: Layer de TensorFlow a la que se le aplica pruning. Returns: Layer de TensorFlow a la que se ha aplicado pruning si es compatible. """ for prunable_layer in PRUNABLE_LAYERS: if isinstance(layer, prunable_layer): return tfmot.sparsity.keras.prune_low_magnitude(layer) return layer pruned_model = clone_model(model, clone_function=apply_pruning_to_layer) return pruned_model
def __init__(self, env_name, env, policy_net, value_net = None,lam = 0.97, value_lr = 0.01, gamma = 0.99, delta = 0.01, cg_damping = 0.001, cg_iters = 10, residual_tol = 1e-5, backtrack_coeff = 0.6, policy_lr = 0.01, backtrack_iters = 10, render = False,local_steps_per_epoch = 2000, value_train_iterations = 5): self.env_name = env_name self.envs = [] self.gamma = gamma self.cg_iters = cg_iters self.cg_damping = cg_damping self.residual_tol = residual_tol self.model = policy_net self.tmp_model = models.clone_model(self.model) self.value_net = value_net self.policy_optimizer = optimizers.Adam(lr=policy_lr) if self.value_net: self.value_optimizer = optimizers.Adam(lr=value_lr) self.value_net.compile(self.value_optimizer, loss = losses.MSE) self.delta = delta self.backtrack_coeff = backtrack_coeff self.backtrack_iters = backtrack_iters self.render = render self.local_steps_per_epoch = local_steps_per_epoch self.lam = lam self.value_train_iterations = value_train_iterations self.N_PATHS = 15 self.N_THREADS = 2 self.epsilon = 0.2 for i in range(self.N_PATHS): self.envs.append(copy.deepcopy(env))
def _load_pretrained_net(modelname, new_input_shape): filename = PRETRAINED_MODELS[modelname]["file"] urlname = PRETRAINED_MODELS[modelname]["url"] #model_path = get_file(fname=filename, origin=urlname) #TODO: FIX! corrupts the file? model_path = os.path.expanduser( '~') + "/.tensorflow.keras/models/" + filename #workaround the more elegant, but dysfunctional solution. if not os.path.isfile(model_path): model_dir = os.path.dirname(model_path) if not os.path.isdir(model_dir): os.makedirs(model_dir) os.system("wget {} && mv -v {} {}".format(urlname, filename, model_path)) model = load_model(model_path) #create replacement input layer with new shape. model.layers[0] = tensorflow.keras.layers.InputLayer( input_shape=new_input_shape, name="input_1") for l in model.layers: l.name = "%s_workaround" % l.name model = tensorflow.keras.models.Sequential(layers=model.layers) model_w_sm = clone_model(model) #NOTE: perform forward pass to fix a tensorflow.keras 2.2.0 related issue with improper weight initialization #See: https://github.com/albermax/innvestigate/issues/88 x_dummy = np.zeros(new_input_shape)[None, ...] model_w_sm.predict(x_dummy) model_w_sm.set_weights(model.get_weights()) model_w_sm.add(tensorflow.keras.layers.Activation("softmax")) return model, model_w_sm
def __init__(self, state_size, strategy="t-dqn", reset_every=1000, pretrained=False, model_name=None): self.strategy = strategy # agent config self.state_size = state_size # normalized previous days self.action_size = 3 # [sit, buy, sell], 0 hold, 1 buy, 2 sell self.model_name = model_name self.inventory = [] self.memory = deque(maxlen=10000) self.first_iter = True # model config self.model_name = model_name self.gamma = 0.95 # affinity for long term reward self.epsilon = 1.0 self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.loss = huber_loss self.custom_objects = {"huber_loss": huber_loss} # important for loading the model from memory self.optimizer = Adam(lr=self.learning_rate) if pretrained and self.model_name is not None: self.model = self.load() else: self.model = self._model() # strategy config if self.strategy in ["t-dqn", "double-dqn"]: self.n_iter = 1 self.reset_every = reset_every # target network self.target_model = clone_model(self.model) self.target_model.set_weights(self.model.get_weights())
def apply_wrapper_to_layer(model_to_clone, layer_names, wrapper, sprasity_sched, clone=False): if clone: model = clone_model(model_to_clone) model.set_weights(model_to_clone.get_weights()) else: model = model_to_clone layers = [l for l in model.layers] if not isinstance(model.layers[0], tf.python.keras.engine.input_layer.InputLayer): prunned_model_layers = [] for layer in model.layers: if layer.name in layer_names: prunned_model_layers.append(wrapper(layer, sprasity_sched)) else: prunned_model_layers.append(layer) new_model = Sequential(prunned_model_layers) else: in_shape = model.layers[0].input_shape[0] layers = layers[1:] inp = Input(shape=in_shape[1:]) x = inp for layer in layers: if layer.name in layer_names: x = wrapper(layer, sprasity_sched)(x) else: x = layer(x) new_model = Model(inp, x) return new_model
def initialize_sparse_model(trained_model, pruned_model_with_mask, pm): """ Given a filename (or a model) with weights and a pruned model with its mask, returns a new model with weights in filename and pruned with mask """ model = clone_model(trained_model) model.set_weights(trained_model.get_weights()) sparcity = 1 - pm sprasity_sched = ConstantSparsity( sparcity, 0, # Do sparcity calculation in the first step end_step=0, frequency=10000000) prunned_model_layers = [] for i, layer in enumerate(pruned_model_with_mask.layers): if isinstance(layer, pruning_wrapper.PruneLowMagnitude): l_weights = model.layers[i].get_weights() l_weights[0] = l_weights[0] * layer.pruning_vars[0][1].numpy() model.layers[i].set_weights(l_weights) prunned_model_layers.append( prune_low_magnitude(model.layers[i], sprasity_sched)) else: prunned_model_layers.append(model.layers[i]) prunned_model = Sequential(prunned_model_layers) prunned_model.compile(optimizer=optimizers.SGD(lr=0), loss='sparse_categorical_crossentropy', metrics='accuracy') return prunned_model
def TrainModel(self, protein, model): Params = self.ModelParams[protein] #copy the model Model = clone_model(model) #read training data and #get the data with open('temporary/DataForCNN_' + protein + '.txt', 'rb') as fp: FullData = pickle.load(fp) #get the scores Y = FullData['Y'] #reshape the data so the model could load it X_train = np.asarray(FullData['X']) X_train = np.swapaxes(X_train, 1, 2) Y_train = np.array(Y) #there is an option to not use the structur data if not self.struct: X_train = X_train[:, 0:4, :] X_train = np.swapaxes(X_train, 2, 1) #fit the model Model.compile(optimizer='adam', loss='mse') Model.fit(X_train, Y_train, batch_size=Params['batchsize'], epochs=Params['epochs']) #save the trained model filename = protein + '_model.h5' Model.save(filename) return Model
def init_critic(self, options): # create the critic x = state_input = layers.Input(shape=(options['state_count'], )) for hidden_layer_size in options['critic_state_hidden_layers']: x = layers.Dense(hidden_layer_size, activation="relu")(x) x = layers.BatchNormalization()(x) state_x = x x = action_input = layers.Input(shape=(options['action_count'], )) for hidden_layer_size in options['critic_action_hidden_layers']: x = layers.Dense(hidden_layer_size, activation="relu")(x) x = layers.BatchNormalization()(x) action_x = x x = layers.Concatenate()([state_x, action_x]) for hidden_layer_size in options['critic_final_hidden_layers']: x = layers.Dense(hidden_layer_size, activation="relu")(x) x = layers.BatchNormalization()(x) x = layers.Dense(1, activation='linear')(x) self.critic_model = tf.keras.Model([state_input, action_input], x) self.critic_model_target = models.clone_model(self.critic_model)
def test_normalizing(self, _model_2, _config): # Parsing removes BatchNorm layers, so we make a copy of the model. input_model = models.clone_model(_model_2) input_model.set_weights(_model_2.get_weights()) input_model.compile(_model_2.optimizer.__class__.__name__, _model_2.loss, _model_2.metrics) num_to_test = 10000 batch_size = 100 _config.set('simulation', 'batch_size', str(batch_size)) _config.set('simulation', 'num_to_test', str(num_to_test)) normset, testset = get_dataset(_config) x_test = testset['x_test'] y_test = testset['y_test'] x_norm = normset['x_norm'] model_lib = import_module('snntoolbox.parsing.model_libs.' + _config.get('input', 'model_lib') + '_input_lib') model_parser = model_lib.ModelParser(input_model, _config) model_parser.parse() parsed_model = model_parser.build_parsed_model() normalize_parameters(parsed_model, _config, x_norm=x_norm) _, acc, _ = model_parser.evaluate(batch_size, num_to_test, x_test, y_test) _, target_acc = _model_2.evaluate(x_test, y_test, batch_size) assert acc == target_acc
def load_model(filename=None, model=None, weights_file=None, custom_objects={}): """Loads model architecture from JSON and instantiates the model. filename: path to JSON file specifying model architecture model: (or) a Keras model to be cloned weights_file: path to HDF5 file containing model weights custom_objects: A Dictionary of custom classes used in the model keyed by name""" import_keras() from tensorflow.keras.models import model_from_json, clone_model if filename is not None: with open(filename) as arch_f: json_str = arch_f.readline() new_model = model_from_json(json_str, custom_objects=custom_objects) logging.info(f"Load model from filename") elif model is not None: new_model = clone_model(model) logging.info(f"Load model from model") elif weights_file is not None: new_model.load_weights(weights_file) logging.info(f"Load model from weights_file") else: logging.error( f"Cannot load model: filename, model and weights_file are None") return new_model
def dropout_test(): def dropout_model(rate=0.): inp = layers.Input((10,)) out = layers.Dropout(rate)(inp) model = Model(inp, out) return model def get_layer_output(model, xs, which=-1): l_out = K.function([model.layers[0].input, K.learning_phase()], [model.layers[which].output]) # output in train mode = 1 layer_output = l_out([xs, 1])[0] return layer_output model0 = dropout_model(0.) model1 = dropout_model(0.99) xs = np.ones((3, 10)) print("no drop\n", get_layer_output(model0, xs)) print("\nmax drop\n", get_layer_output(model1, xs)) model1.layers[-1].rate = 0. print("\nchanged max drop to zero\n", model1.layers[-1].get_config()) print(get_layer_output(model1, xs)) model1_clone = clone_model(model1) print("\n clone changed model\n", get_layer_output(model1_clone, xs))
def dropout_model(model, dropout): """ Create a keras function to predict with dropout Credits to https://github.com/keras-team/keras/issues/8826 and to sfblake: https://medium.com/hal24k-techblog/how-to-generate-neural-network- confidence-intervals-with-keras-e4c0b78ebbdf model : keras model dropout : fraction dropout to apply to all layers Returns model_new : model with updated dropout rate """ # 1. Use keras.models.clone_model model_new = clone_model(model) # 2. change dropout rate for layer in model_new.layers: if isinstance(layer, Dropout): layer.rate = dropout # 3. Compile the model # model_new.compile(optimizer="Adam", loss="mse") # 4. set_weights of cloned model with get_weights model_new.set_weights(model.get_weights()) return model_new
def on_epoch_end(self, epoch, logs=None): self.current_epoch += 1 if (epoch + 1) % self.eval_period == 0: results = evaluate_model(self.model, self.data_generator, self.hparams) f1_eval = {} f1_eval["sum"] = sum([ results[x + "_f1"] for x in self.data_generator.selected_tasks ]) f1_eval["geo"] = reduce(lambda x, y: x * y, [ results[x + "_f1"] for x in self.data_generator.selected_tasks ]) for k in f1_eval: if f1_eval[k] > self.best_models[k]["score"]: print( "\n", "*** New Best {} {} Evaluation: ".format(k, self.name), results) self.best_models[k]["results"] = results self.best_models[k]["score"] = f1_eval[k] self.best_models[k]["model"] = clone_model(self.model) self.best_models[k]["model"].set_weights( self.model.get_weights()) self.best_models[k]["epoch"] = self.current_epoch
def export_to_dir(dirname): if len(model.inputs) > 1 or len(model.outputs) > 1: warnings.warn('Found multiple input or output layers.') def _export(model): if IS_TF_1: from tensorflow import saved_model from keras.backend import get_session else: from tensorflow.compat.v1 import saved_model from tensorflow.compat.v1.keras.backend import get_session builder = saved_model.builder.SavedModelBuilder(dirname) # use name 'input'/'output' if there's just a single input/output layer inputs = dict(zip(model.input_names,model.inputs)) if len(model.inputs) > 1 else dict(input=model.input) outputs = dict(zip(model.output_names,model.outputs)) if len(model.outputs) > 1 else dict(output=model.output) signature = saved_model.signature_def_utils.predict_signature_def(inputs=inputs, outputs=outputs) signature_def_map = { saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature } builder.add_meta_graph_and_variables(get_session(), [saved_model.tag_constants.SERVING], signature_def_map=signature_def_map) builder.save() if IS_TF_1: _export(model) else: from tensorflow.keras.models import clone_model weights = model.get_weights() with tf.Graph().as_default(): # clone model in new graph and set weights _model = clone_model(model) _model.set_weights(weights) _export(_model) if meta is not None and len(meta) > 0: save_json(meta, os.path.join(dirname,'meta.json'))
def _gradient_backprop_eager(self, grad_fn, layer_name, images, mode='max', output_index=0, loss_fn=None): # save current weight weights = self.model.get_weights() new_model = clone_model(self.model) # Apply weights new_model.set_weights(weights) for layer in new_model.layers: if 'activation' in layer.get_config(): if 'relu' in layer.activation.__name__: layer.activation = grad_fn guided_model = KerasModel(new_model.inputs, new_model.get_layer(layer_name).output) img_tensor = tf.Variable(tf.cast(images, K.floatx())) with tf.GradientTape() as tape: tape.watch(img_tensor) output = guided_model(img_tensor) loss = self._get_backprop_loss(output, mode, output_index, loss_fn) grads = tape.gradient(loss, img_tensor) del guided_model del new_model return grads.numpy()
def copy_model(self): """ Returns a copy of the networks model compiled. """ model_copy = clone_model(self.model) self.compile_model(model_copy) model_copy.set_weights(self.model.get_weights()) return model_copy
def copy_model(model, optimiser, set_weights, learning_rate=0.001): model_copy = clone_model(model) opt = Adam(learning_rate=learning_rate) model_copy.compile(loss=cross_entropy, optimizer=opt, metrics=["acc"]) if set_weights: model_copy.set_weights(model.get_weights()) return model_copy
def create_model_clone(self, model): model_copy = clone_model(model) model_copy.build( model.layers[0].input_shape ) # replace 10 with number of variables in input layer model_copy.compile(optimizer=optimizer, loss=loss, metrics=['mae']) model_copy.set_weights(model.get_weights()) return model_copy