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)
