def train_temporal(batch_size=6, epoch=1000): raw_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM/' flowimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticflow_image/' strainimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticalstrain_image/' best_model_file = "./models/VGG_16_5_channels_temporal.h5" train_data_list_path = './train_list.txt' f1 = open(train_data_list_path, 'r') train_data_list = f1.readlines() steps_per_epoch = int(ceil(len(train_data_list) * 1.0 / batch_size)) test_data_list_path = './test_list.txt' f2 = open(test_data_list_path, 'r') test_data_list = f2.readlines() validation_steps = int(ceil(len(test_data_list) * 1.0 / batch_size)) vgg_model = load_model('./models/VGG_16_5_channels.h5') model = Model(inputs=vgg_model.input, outputs=vgg_model.layers[35].output) model.predict_on_batch(np.zeros( (10, 224, 224, 5))) #https://www.jianshu.com/p/c84ae0527a3f best_model = ModelCheckpoint(best_model_file, monitor='val_acc', verbose=1, save_best_only=True) reduce_lr = ReduceLROnPlateau(monitor='val_acc', factor=0.5, patience=3, verbose=1, min_lr=0.00001) temporal_model = temporal_module(data_dim=4096) temporal_model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.00001, decay=0.000001), metrics=["accuracy"]) temporal_model.fit_generator( generator_batch_feature(model, raw_path, flowimg_path, strainimg_path, train_data_list, batch_size=batch_size), steps_per_epoch=steps_per_epoch, epochs=epoch, verbose=1, validation_data=generator_batch_feature(model, raw_path, flowimg_path, strainimg_path, test_data_list, batch_size=batch_size), validation_steps=validation_steps, class_weight=None, callbacks=[best_model, reduce_lr]) f1.close() f2.close()
def predict(model: Model, domains: np.ndarray) -> np.ndarray: """ Given a list of domains as input, returns a list of booleans, where True means it is predicted to be a DGA, and false means it is predicted to be benign """ predictions = model.predict_on_batch(prep_data(domains)) return predictions
def compute_word_embeddings(model_dir, epoch): path_to_model = to_model_path(model_dir, epoch) """ lookup model vocabulary """ vocabulary = Vocabulary.create_vocabulary_from_vocabulary_json( model_dir, "", use_nltk=False) """ prepare and load model """ vinput = Input((196, 512)) model = create_shatt_model_v2(image_features_graph=(vinput, vinput), caption_max_length=16, vocabulary_size=len(vocabulary), dropout_rate=0., start_encoding=vocabulary.get_start_symbol(), image_features_dimensions=196, embedding_size=512, hidden_size=1024, inference_mode=True, attention_graph=None, return_attention=True, use_max_sampler=True) model.load_weights(path_to_model, by_name=True) """ establish embedding model """ layer_name = "shatt_word_embeddings" layer = model.get_layer(layer_name) if layer == None: raise Exception("Cannot find layer with name " + layer_name) input_words = Input(shape=(1, ), name="embedding_callback_input_words") layer_output = layer(input_words) layer_output = Flatten(name="embedding_callback_flatten")(layer_output) embedding_model = Model(inputs=input_words, outputs=layer_output) """ write metadata.tsv """ word_sequence = vocabulary.get_word_sequence(padding_symbol="<PAD>") store_json_to(word_sequence, model_dir, lookup_filename="word_sequence.json") """ encode sequence""" encoded_word_sequence = vocabulary.get_encoded_word_sequence( include_padding=True) sequence = WordSequence(encoded_word_sequence, 64) processed_count = 0 expected_num_batches = sequence.get_num_batches() results = [] try: for words in sequence.one_shot_iterator(): words = np.expand_dims(words, axis=-1) word_embeddings = embedding_model.predict_on_batch(words) results.extend(word_embeddings) processed_count = processed_count + 1 print(">> Computing word embeddings {:d}/{:d} ({:3.0f}%)".format( processed_count, expected_num_batches, processed_count / expected_num_batches * 100), end="\r") except Exception as e: print("Exception: ", e) results = np.array(results) store_numpy_to(results, model_dir, lookup_file_name="word_embeddings.npy")
def train_frcnn(options): if options.parser == 'pascal_voc': from utils import voc_parser as get_data elif options.parser == 'simple': from utils import simple_parser as get_data else: raise ValueError( "Command line option parser must be one of 'pascal_voc' or 'simple'" ) # pass the settings from the command line, and persist them in the config object C = Config() C.use_horizontal_flips = bool(options.horizontal_flips) C.use_vertical_flips = bool(options.vertical_flips) C.rot_90 = bool(options.rot_90) C.model_path = options.output_weight_path.format(options.network) C.num_rois = int(options.num_rois) if options.network == 'resnet50': C.network = 'resnet50' from utils import rpn_res as rpn from utils import classifier_res as classifier_func from utils import get_img_output_length_res as get_img_output_length from utils import nn_base_res as nn_base elif options.network == 'vgg': C.network = 'vgg' from utils import rpn_vgg as rpn from utils import classifier_vgg as classifier_func from utils import get_img_output_length_vgg as get_img_output_length from utils import nn_base_vgg as nn_base else: print('Not a valid model') raise ValueError # check if weight path was passed via command line if options.input_weight_path: C.base_net_weights = options.input_weight_path else: # set the path to weights based on backend and model C.base_net_weights = get_weight_path(options.network) all_imgs, classes_count, class_mapping = get_data(options.path) if 'bg' not in classes_count: classes_count['bg'] = 0 class_mapping['bg'] = len(class_mapping) C.class_mapping = class_mapping inv_map = {v: k for k, v in class_mapping.items()} print('Training images per class:') pprint.pprint(classes_count) print('Num classes (including bg) = {}'.format(len(classes_count))) config_output_filename = options.config_filename with open(config_output_filename, 'wb') as config_f: pickle.dump(C, config_f) print( 'Config has been written to {}, and can be loaded when testing to ensure correct results' .format(config_output_filename)) # random.shuffle(all_imgs) train_imgs = [s for s in all_imgs if s['imageset'] == 'trainval'] val_imgs = [s for s in all_imgs if s['imageset'] == 'test'] print('Num train samples {}'.format(len(train_imgs))) print('Num val samples {}'.format(len(val_imgs))) data_gen_train = get_anchor_gt(train_imgs, classes_count, C, get_img_output_length, K.backend(), mode='train') data_gen_val = get_anchor_gt(val_imgs, classes_count, C, get_img_output_length, K.backend(), mode='val') if K.backend() == "theano": input_shape_img = (3, None, None) else: input_shape_img = (None, None, 3) img_input = Input(shape=input_shape_img) roi_input = Input(shape=(None, 4)) # define the base network (resnet here, can be VGG, Inception, etc) shared_layers = nn_base(img_input, trainable=True) # define the RPN, built on the base layers num_anchors = len(C.anchor_box_scales) * len(C.anchor_box_ratios) rpn = rpn(shared_layers, num_anchors) classifier = classifier_func(shared_layers, roi_input, C.num_rois, nb_classes=len(classes_count), trainable=True) model_rpn = Model(img_input, rpn[:2]) model_classifier = Model([img_input, roi_input], classifier) # this is a model that holds both the RPN and the classifier, used to load/save weights for the models model_all = Model([img_input, roi_input], rpn[:2] + classifier) try: print('loading weights from {}'.format(C.base_net_weights)) model_rpn.load_weights(C.base_net_weights + "rpn.h5", by_name=True) model_classifier.load_weights(C.base_net_weights + "classifier.h5", by_name=True) except Exception as e: model_rpn.load_weights(C.base_net_weights, by_name=True) model_classifier.load_weights(C.base_net_weights, by_name=True) print('Exception: {}'.format(e)) optimizer = Adam(lr=1e-5, decay=2e-7) optimizer_classifier = Adam(lr=1e-5, decay=2e-7) model_rpn.compile( optimizer=optimizer, loss=[rpn_loss_cls(num_anchors), rpn_loss_regr(num_anchors)]) model_classifier.compile( optimizer=optimizer_classifier, loss=[class_loss_cls, class_loss_regr(len(classes_count) - 1)], metrics={'dense_class_{}'.format(len(classes_count)): 'accuracy'}) model_all.compile(optimizer='sgd', loss='mae') epoch_length = options.epoch_length num_epochs = int(options.num_epochs) iter_num = 0 losses = np.zeros((epoch_length, 5)) rpn_accuracy_rpn_monitor = [] rpn_accuracy_for_epoch = [] start_time = time.time() best_loss = np.Inf print('Starting training') for epoch_num in range(num_epochs): progbar = generic_utils.Progbar(epoch_length) print('Epoch {}/{}'.format(epoch_num + 1, num_epochs)) while True: try: if len(rpn_accuracy_rpn_monitor) == epoch_length and C.verbose: mean_overlapping_bboxes = float( sum(rpn_accuracy_rpn_monitor)) / len( rpn_accuracy_rpn_monitor) rpn_accuracy_rpn_monitor = [] print( 'Average number of overlapping bounding boxes from RPN = {} for {} previous iterations' .format(mean_overlapping_bboxes, epoch_length)) if mean_overlapping_bboxes == 0: print( 'RPN is not producing bounding boxes that overlap the ground truth boxes. ' 'Check RPN settings or keep training.') X, Y, img_data = next(data_gen_train) loss_rpn = model_rpn.train_on_batch(X, Y) P_rpn = model_rpn.predict_on_batch(X) R = rpn_to_roi(P_rpn[0], P_rpn[1], C, K.backend(), use_regr=True, overlap_thresh=0.7, max_boxes=300) # note: calc_iou converts from (x1,y1,x2,y2) to (x,y,w,h) format X2, Y1, Y2, IouS = calc_iou(R, img_data, C, class_mapping) if X2 is None: rpn_accuracy_rpn_monitor.append(0) rpn_accuracy_for_epoch.append(0) continue neg_samples = np.where(Y1[0, :, -1] == 1) pos_samples = np.where(Y1[0, :, -1] == 0) if len(neg_samples) > 0: neg_samples = neg_samples[0] else: neg_samples = [] if len(pos_samples) > 0: pos_samples = pos_samples[0] else: pos_samples = [] rpn_accuracy_rpn_monitor.append(len(pos_samples)) rpn_accuracy_for_epoch.append((len(pos_samples))) if C.num_rois > 1: if len(pos_samples) < C.num_rois // 2: selected_pos_samples = pos_samples.tolist() else: selected_pos_samples = np.random.choice( pos_samples, C.num_rois // 2, replace=False).tolist() try: selected_neg_samples = np.random.choice( neg_samples, C.num_rois - len(selected_pos_samples), replace=False).tolist() except: selected_neg_samples = np.random.choice( neg_samples, C.num_rois - len(selected_pos_samples), replace=True).tolist() sel_samples = selected_pos_samples + selected_neg_samples else: # in the extreme case where num_rois = 1, we pick a random pos or neg sample selected_pos_samples = pos_samples.tolist() selected_neg_samples = neg_samples.tolist() if np.random.randint(0, 2): sel_samples = random.choice(selected_neg_samples) else: sel_samples = random.choice(selected_pos_samples) loss_class = model_classifier.train_on_batch( [X, X2[:, sel_samples, :]], [Y1[:, sel_samples, :], Y2[:, sel_samples, :]]) losses[iter_num, 0] = loss_rpn[1] losses[iter_num, 1] = loss_rpn[2] losses[iter_num, 2] = loss_class[1] losses[iter_num, 3] = loss_class[2] losses[iter_num, 4] = loss_class[3] progbar.update(iter_num + 1, [('rpn_cls', losses[iter_num, 0]), ('rpn_regr', losses[iter_num, 1]), ('detector_cls', losses[iter_num, 2]), ('detector_regr', losses[iter_num, 3])]) iter_num += 1 if iter_num == epoch_length: loss_rpn_cls = np.mean(losses[:, 0]) loss_rpn_regr = np.mean(losses[:, 1]) loss_class_cls = np.mean(losses[:, 2]) loss_class_regr = np.mean(losses[:, 3]) class_acc = np.mean(losses[:, 4]) mean_overlapping_bboxes = float(sum( rpn_accuracy_for_epoch)) / len(rpn_accuracy_for_epoch) rpn_accuracy_for_epoch = [] if C.verbose: print( 'Mean number of bounding boxes from RPN overlapping ground truth boxes: {}' .format(mean_overlapping_bboxes)) print( 'Classifier accuracy for bounding boxes from RPN: {}' .format(class_acc)) print('Loss RPN classifier: {}'.format(loss_rpn_cls)) print('Loss RPN regression: {}'.format(loss_rpn_regr)) print('Loss Detector classifier: {}'.format( loss_class_cls)) print('Loss Detector regression: {}'.format( loss_class_regr)) print('Elapsed time: {}'.format(time.time() - start_time)) curr_loss = loss_rpn_cls + loss_rpn_regr + loss_class_cls + loss_class_regr iter_num = 0 start_time = time.time() if curr_loss < best_loss: if C.verbose: print( f'Total loss decreased from {best_loss:.3f} to {curr_loss:.3f}, saving weights to ' f'{C.model_path}') best_loss = curr_loss model_classifier.save_weights(C.model_path + "classifier.h5") model_rpn.save_weights(C.model_path + "rpn.h5") break except Exception as e: print('Exception: {}'.format(e)) continue print('Training complete, exiting.')
class A2C(Agent): """Advantage Actor-Critic (A2C) A2C is a synchronous version of A3C which gives equal or better performance. For more information on A2C refer to the OpenAI blog post: https://blog.openai.com/baselines-acktr-a2c/. The A3C algorithm is described in "Asynchronous Methods for Deep Reinforcement Learning" (Mnih et al., 2016) Since this algorithm is on-policy, it can and should be trained with multiple simultaneous environment instances. The parallelism decorrelates the agents' data into a more stationary process which aids learning. """ def __init__(self, model, actions, optimizer=None, policy=None, test_policy=None, gamma=0.99, instances=8, nsteps=1, value_loss=0.5, entropy_loss=0.01): """ TODO: Describe parameters """ self.actions = actions self.optimizer = Adam(lr=3e-3) if optimizer is None else optimizer self.memory = memory.OnPolicy(steps=nsteps, instances=instances) if policy is None: # Create one policy per instance, with varying exploration parameters self.policy = [Greedy()] + [ GaussianEpsGreedy(eps, 0.1) for eps in np.arange(0, 1, 1 / (instances - 1)) ] else: self.policy = policy self.test_policy = Greedy() if test_policy is None else test_policy self.gamma = gamma self.instances = instances self.nsteps = nsteps self.value_loss = value_loss self.entropy_loss = entropy_loss self.training = True # Create output model layers based on number of actions raw_output = model.layers[-1].output actor = Dense(actions, activation='softmax')( raw_output) # Actor (Policy Network) critic = Dense(1, activation='linear')( raw_output) # Critic (Value Network) output_layer = Concatenate()([actor, critic]) self.model = Model(inputs=model.input, outputs=output_layer) def a2c_loss(targets_actions, y_pred): # Unpack input targets, actions = targets_actions[:, 0], targets_actions[:, 1:] # Unpack probs, values = y_pred[:, :-1], y_pred[:, -1] # Compute advantages and logprobabilities adv = targets - values logprob = tf.math.log( tf.reduce_sum(probs * actions, axis=1, keepdims=False) + 1e-10) # Compute composite loss loss_policy = -adv * logprob loss_value = self.value_loss * tf.square(adv) entropy = self.entropy_loss * tf.reduce_sum( probs * tf.math.log(probs + 1e-10), axis=1, keepdims=False) return tf.reduce_mean(loss_policy + loss_value + entropy) self.model.compile(optimizer=self.optimizer, loss=a2c_loss) def save(self, filename, overwrite=False): """Saves the model parameters to the specified file.""" self.model.save_weights(filename, overwrite=overwrite) def act(self, state, instance=0): """Returns the action to be taken given a state.""" qvals = self.model.predict(np.array([state]))[0][:-1] if self.training: return self.policy[instance].act(qvals) if isinstance( self.policy, list) else self.policy.act(qvals) else: return self.test_policy[instance].act(qvals) if isinstance( self.test_policy, list) else self.test_policy.act(qvals) def push(self, transition, instance=0): """Stores the transition in memory.""" self.memory.put(transition, instance) def train(self, step): """Trains the agent for one step.""" if len(self.memory) < self.instances: return state_batch, action_batch, reward_batches, end_state_batch, not_done_mask = self.memory.get( ) # Compute the value of the last next states target_qvals = np.zeros(self.instances) non_final_last_next_states = [ es for es in end_state_batch if es is not None ] if len(non_final_last_next_states) > 0: non_final_mask = list(map(lambda s: s is not None, end_state_batch)) target_qvals[non_final_mask] = self.model.predict_on_batch( np.array(non_final_last_next_states))[:, -1].squeeze() # Compute n-step discounted return # If episode ended within any sampled nstep trace - zero out remaining rewards for n in reversed(range(self.nsteps)): rewards = np.array([b[n] for b in reward_batches]) target_qvals *= np.array([t[n] for t in not_done_mask]) target_qvals = rewards + (self.gamma * target_qvals) # Prepare loss data: target Q-values and actions taken (as a mask) ran = np.arange(self.instances) targets_actions = np.zeros((self.instances, self.actions + 1)) targets_actions[ran, 0] = target_qvals targets_actions[ran, np.array(action_batch) + 1] = 1 self.model.train_on_batch(np.array(state_batch), targets_actions)