def iW_D(D, img_shape, cond_dim=2400, lmbd=10.):
real_img = Input(shape=img_shape, name='REAL_IMG')
fake_img = Input(shape=img_shape, name='FAKE_IMG')
right_cond = Input(shape=(cond_dim, ), name='RIGHT_COND')
wrong_cond = Input(shape=(cond_dim, ),
name='WRONG_COND') # w.r.t. real_img.
pos = D([real_img, right_cond])
neg1 = D([fake_img, right_cond])
neg2 = D([real_img, wrong_cond])
neg = Average()([neg1, neg2])
score = Subtract(name='Score_by_D')([pos, neg])
fuzzy_img = Interpolation(name='FUZZY_IMG')([real_img, fake_img])
penalty1 = D([fuzzy_img, right_cond])
gradnorm1 = GradNorm()([penalty1, fuzzy_img, right_cond])
fuzzy_cond = Interpolation(name='FUZZY_COND')([right_cond, wrong_cond])
penalty2 = D([real_img, fuzzy_cond])
gradnorm2 = GradNorm()([penalty2, real_img, fuzzy_cond])
model = Model(inputs=[real_img, fake_img, right_cond, wrong_cond],
outputs=[score, gradnorm1, gradnorm2])
D.trainable = True
model.compile(loss=[loss_for_D, 'mse', 'mse'],
optimizer=myOpt,
loss_weights=[1.0, lmbd / 2., lmbd / 2.])
return model
def inception_net(_input):
#x = Reshape((28, 28, 1))(_input)
#x = Conv2D(32, (3, 3), strides=((1, 1)))(x)
#x = Activation('relu')(x)
x = Conv2D(16, (3, 3),strides=(2, 2))(_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(48, (3, 3),strides=((1, 1)))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
#x = MaxPooling2D(((3, 3)), strides=(2,2))(x)
x = mniny_inception_module(x, 1)
x = mniny_inception_module(x, 2)
#x = MaxPooling2D(((3, 3)), strides=(2,2))(x)
x = mniny_inception_module(x, 2)
x, soft1 = mniny_inception_module(x, 3, True)
x = mniny_inception_module(x, 3)
x = mniny_inception_module(x, 3)
x, soft2 = mniny_inception_module(x, 4, True)
x = MaxPooling2D(((3, 3)), strides=(2,2))(x)
x = mniny_inception_module(x, 4)
x = mniny_inception_module(x, 5)
x = AveragePooling2D(((5, 5)), strides=((1, 1)))(x)
x = Dropout(0.4)(x)
x = Flatten()(x)
x = Dense(17)(x)
soft3 = Activation('hard_sigmoid')(x)
out = Average()([soft1, soft2, soft3])
return out
def inception_net(_input):
'''
My version of the 'inception net',
tailored specifically for MNIST
'''
x = Reshape((28, 28, 1))(_input)
x = Conv2D(16, (3, 3), strides=(2, 2))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(48, (3, 3), strides=(1, 1))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = mniny_inception_module(x, 1)
x = mniny_inception_module(x, 2)
x = mniny_inception_module(x, 2)
x, soft1 = mniny_inception_module(x, 3, True)
x = mniny_inception_module(x, 3)
x = mniny_inception_module(x, 3)
x, soft2 = mniny_inception_module(x, 4, True)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = mniny_inception_module(x, 4)
x = mniny_inception_module(x, 5)
x = AveragePooling2D((5, 5), strides=(1, 1))(x)
x = Dropout(0.4)(x)
x = Flatten()(x)
x = Dense(10)(x)
soft3 = Activation('softmax')(x)
out = Average()([soft1, soft2, soft3])
return out
def M8_M5_average_merge(models_folder):
truncated_models_outputs = []
models = []
for model_file in os.listdir(models_folder):
# Load single model
model_path = os.path.join(models_folder, model_file)
current_model = load_model(model_path)
models.append(current_model)
# Get rid of softmax activation layer so we get raw percentages
current_model.pop()
truncated_models_outputs.append(current_model.layers[-1].output)
new_models = []
input_layer = Input(shape=(SEQUENCE_LENGTH - 1, len(labels)))
for model in models:
model = model(input_layer)
new_models.append(model)
# Merge all truncated models and add softmax at the end
output = Average()([model for model in new_models])
output = Activation("softmax", name="predictions")(output)
model = Model(input_layer, output)
optimizer = RMSprop(lr=0.01)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=["accuracy"])
return model
def inception_model(X):
x = Reshape((img_cols, img_rows, 1))(X)
x = Conv2D(16, (3, 3), strides=(2, 2))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(48, (3, 3), strides=(1, 1))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = inception_module(x, 1)
x = inception_module(x, 2)
x = inception_module(x, 2)
x, soft1 = inception_module(x, 3, True)
x = inception_module(x, 3)
x = inception_module(x, 3)
x, soft2 = inception_module(x, 4, True)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = inception_module(x, 4)
x = inception_module(x, 5)
x = AveragePooling2D((5, 5), strides=(1, 1))(x)
x = Dropout(0.4)(x)
x = Flatten()(x)
x = Dense(num_classes)(x)
soft3 = Activation('softmax')(x)
out = Average()([soft1, soft2, soft3])
return out
def load_defense_model(models=['xception','resnet50'], \
dist_pairs = [('xception', 'resnet50')], \
aug_or_rotate='aug', \
make_model=False, \
grad_dict=None):
if grad_dict is not None:
grad_dict.clear()
input_img = Input(shape=(299, 299, 3), name='src_input_img')
noise_input = Input(batch_shape=(1, ), name='augmentation_scale')
if aug_or_rotate not in ['aug', 'rot', 'none']:
raise ValueError('invalid value for aug_or_rotate')
model_outputs = []
model_outputs_dict = {}
for model_name in models:
print('preparing', model_name)
model_pred = load_branch(model_name,
input_img,
aug_or_rotate,
noise_input,
False,
load_weights=True)
model_outputs.append(model_pred)
model_outputs_dict[model_name] = model_pred
# print(tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES))
print('preparing avg pred')
model_outputs_avg = Average()(model_outputs)
print('preparing gradients')
pred_diff = None
for m1, m2 in dist_pairs:
tv = TotalVariationDistance(name='dist_{0}_{1}'.format(m1,m2))(\
[model_outputs_dict[m1], model_outputs_dict[m2]])
grad = Gradients(-1, name='grad_{0}_{1}'.format(m1,
m2))([input_img, tv])
if grad_dict is not None:
if make_model:
grad_dict[(m1, m2)] = grad
else:
grad_dict[(m1,m2)] = K.function(\
[input_img, noise_input, K.learning_phase()], \
[grad])
if make_model:
grad_dict['PRED'] = model_outputs_avg
else:
grad_dict['PRED'] = K.function(
[input_img, noise_input,
K.learning_phase()], [model_outputs_avg])
if make_model:
return Model(inputs=[input_img, noise_input], \
outputs=[grad_dict[(m1,m2)] for m1,m2 in dist_pairs]+[grad_dict['PRED']])
else:
return None
def pred_ensemble():
_, _, val, val_label = get_data()
ensemble = []
for weights in glob.glob("models/keras/*.h5"):
model = build_network()
model.load_weights(weights)
ensemble.append(model)
x = Input((img_rows * img_cols, ))
outputs = [model(x) for model in ensemble]
y = Average()(outputs)
ensemble_model = Model(x, y)
preds = ensemble_model.predict(val)
preds = np.argmax(preds, axis=1)
print(preds)
print(val_labels)
metrics = [accuracy_score, recall_score, precision_score, f1_score]
for metric in metrics:
if str(metric.__name__) == "accuracy_score":
print(metric.__name__, ":", metric(np.array(val_label), preds))
else:
print(metric.__name__, ":",
metric(np.array(val_label), preds, average='macro'))
def __init__(self, image_shape, structure, data,
v_noise=0.1, n_pack=2, pre_epochs=3, activation="relu",
model_dir="./defensive_models/"):
"""
Train different autoencoders.
Demo code for graybox scenario.
pre_epochs: How many epochs do we train before fine-tuning.
n_pack: Number of autoencoders we want to train at once.
"""
self.v_noise = v_noise
self.n_pack = n_pack
self.model_dir = model_dir
pack = []
for i in range(n_pack):
dae = DenoisingAutoEncoder(image_shape, structure, v_noise=v_noise,
activation=activation, model_dir=model_dir)
dae.train(data, "", if_save=False, num_epochs=pre_epochs)
pack.append(dae.model)
shared_input = Input(shape=image_shape, name="shared_input")
outputs = [dae(shared_input) for dae in pack]
avg_output = Average()(outputs)
delta_outputs = [add([avg_output, Lambda(lambda x: -x)(output)])
for output in outputs]
self.model = Model(inputs=shared_input, outputs=outputs+delta_outputs)
def discriminator_model():
# PatchGAN
inputs = Input(shape=patch_shape)
x = Convolution2D(filters=channel_rate,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(inputs)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Convolution2D(filters=2 * channel_rate,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Convolution2D(filters=4 * channel_rate,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Convolution2D(filters=4 * channel_rate,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = non_local_block(x, mode='embedded', compression=2)
x = Flatten()(x)
outputs = Dense(units=1, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=outputs, name='PatchGAN')
# model.summary()
# discriminator
inputs = Input(shape=image_shape)
list_row_idx = [(i * channel_rate, (i + 1) * channel_rate)
for i in range(int(image_shape[0] / patch_shape[0]))]
list_col_idx = [(i * channel_rate, (i + 1) * channel_rate)
for i in range(int(image_shape[1] / patch_shape[1]))]
list_patch = []
for row_idx in list_row_idx:
for col_idx in list_col_idx:
x_patch = Lambda(lambda z: z[:, row_idx[0]:row_idx[1], col_idx[0]:
col_idx[1], :])(inputs)
list_patch.append(x_patch)
x = [model(patch) for patch in list_patch]
outputs = Average()(x)
model = Model(inputs=inputs, outputs=outputs, name='Discriminator')
#model.summary()
return model
def train():
imgs = np.load(train_set)
print imgs.shape
sals = np.load(sal_set)
print sals.shape
input_dim = (img_size, img_size, 1)
saliency_network = base_network(input_dim)
input_img = Input(shape=input_dim)
out1 = saliency_network(input_img)
input_img2 = AveragePooling2D(pool_size=(2, 2))(input_img)
out2 = saliency_network(input_img2)
out2 = UpSampling2D(size=(2, 2))(out2)
out2 = Convolution2D(1, 3, 3, border_mode='same', activation='relu')(out2)
input_img3 = AveragePooling2D(pool_size=(2, 2))(input_img2)
out3 = saliency_network(input_img3)
out3 = UpSampling2D(size=(2, 2))(out3)
out3 = Convolution2D(1, 3, 3, border_mode='same', activation='relu')(out3)
out3 = UpSampling2D(size=(2, 2))(out3)
out3 = Convolution2D(1, 3, 3, border_mode='same', activation='relu')(out3)
output_sal = Average()([out1, out2, out3])
model = Model(input=input_img, output=output_sal)
model.summary()
# train
model_checkpoint = ModelCheckpoint(checkpoint_file, monitor='loss')
rms = RMSprop()
model.compile(loss='mse', optimizer=rms)
lr = 1e-3
for i in range(1): # num times to drop learning rate
print('Learning rate: {0}'.format(lr))
K.set_value(model.optimizer.lr, lr)
model_data = np.expand_dims(imgs, axis=3)
saliency_data = np.expand_dims(sals, axis=3)
history = model.fit([model_data], [saliency_data],
validation_split=0.1,
batch_size=128,
nb_epoch=nb_epoch,
callbacks=[model_checkpoint])
lr = lr * .1
print(history.history.keys())
# summarize history for accuracy
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()
def two_stream_model(spatial_weights, temporal_weights):
spatial_stream = finetuned_resnet(include_top=True, weights_dir=spatial_weights)
temporal_stream = CNN(input_shape, temporal_weights)
spatial_output = spatial_stream.output
temporal_output = temporal_stream.output
fused_output = Average(name='fusion_layer')([spatial_output, temporal_output])
model = Model(inputs=[spatial_stream.input, temporal_stream.input],
outputs=fused_output, name=two_stream)
return model
def ensemble(models, model_input):
ymodels = [model(model_input) for model in models]
yAvg = Average()(ymodels)
modelENS = Model(inputs=model_input, outputs=yAvg, name='ensemble')
adam = Adam()
modelENS.compile(loss='sparse_categorical_crossentropy', optimizer=adam)
print("model summary: ")
print(modelENS.summary())
# outputs = [model.outputs for model in models]
# Y = Average()(outputs)
# model = Model(model_input, Y, name='ensemble')
return modelENS
def __build_model(self):
input_layer_positive = Input(shape=(1, ), name='input_node_positive')
input_layer_negative = Input(shape=(self._model_params.num_negative +
1, ),
name='input_node_negative')
input_layer_relation = Input(shape=(1, ), name='input_relation')
# keep track of all input and output layers
input_layer_list = [
input_layer_positive, input_layer_negative, input_layer_relation
]
output_layer_list = []
# build
input_layers, score_layer, l2_offset_layer = self._doubler.build_model(
self._model_params, self._gp, input_layer_positive,
input_layer_negative, input_layer_relation)
output_layer_list.append(score_layer)
input_layer_list.extend(input_layers)
# combine score layers
if len(output_layer_list) > 1:
score_layer_total = Average()(output_layer_list)
else:
score_layer_total = output_layer_list[0]
# build model
score_layer_total = Activation(
self._model_params.activation_fn,
name='output_overall_score')(score_layer_total)
if l2_offset_layer is not None:
l2_offset_layer = Activation(
'relu', name='output_overall_offset')(l2_offset_layer)
self._model = Model(inputs=input_layer_list,
outputs=[score_layer_total, l2_offset_layer])
self._model.compile(loss=self.__custom_loss,
optimizer=self._model_params.optimizer)
else:
self._model = Model(inputs=input_layer_list,
outputs=[score_layer_total])
self._model.compile(loss=self._model_params.loss,
optimizer=self._model_params.optimizer)
# print model
print(self._model.summary())
def difCNN(depth, filters=64):
# first input model
inpt3 = Input(shape=(None, None, 1))
inpt1 = Input(shape=(None, None, 1))
# 1st layer, Conv+relu
x1 = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1),
padding='same')(inpt1)
x1 = Activation('relu')(x1)
# 15 layers, Conv+BN+relu
for i in range(depth):
x1 = Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same')(x1)
x1 = BatchNormalization(axis=-1, epsilon=1e-3)(x1)
x1 = Activation('relu')(x1)
# last layer, Conv
x1 = Conv2D(filters=1, kernel_size=(3, 3), strides=(1, 1),
padding='same')(x1)
# first input model
inpt2 = Input(shape=(None, None, 1))
# 1st layer, Conv+relu
x2 = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1),
padding='same')(inpt2)
x2 = Activation('relu')(x2)
# 15 layers, Conv+BN+relu
for ii in range(depth):
x2 = Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same')(x2)
x2 = BatchNormalization(axis=-1, epsilon=1e-3)(x2)
x2 = Activation('relu')(x2)
# last layer, Conv
x2 = Conv2D(filters=1, kernel_size=(3, 3), strides=(1, 1),
padding='same')(x2)
sub = Average()([x1, x2])
#sub = Subtract()([inpt3, added]) # input - noise
model = Model(inputs=[inpt1, inpt2, inpt3], outputs=sub)
return model
def get_output_2D_hal(input_2D, model_2D, model_hal, extract_2D_hal, n_classes):
intermediate_model_2D = Model(inputs = model_2D.layers[0].input,
outputs = model_2D.layers[extract_2D_hal].output)
intermediate_model_2D.name = "2D_EXTRACT_MDL"
in_2D = intermediate_model_2D(input_2D)
intermediate_model_hal = Model(inputs = model_hal.layers[0].input,
outputs = model_hal.layers[extract_2D_hal].output)
intermediate_model_hal.name = "HAL_EXTRACT_MDL"
# intermediate_model_hal.layers[len(intermediate_model_hal.layers)-1].name = "HAL_SOFTMAX_OUT"
in_hal = intermediate_model_hal(input_2D)
pool_window_shape = K.int_shape(in_2D)
output_2D_hal = Average()([in_2D, in_hal])
# output_2D_hal = AveragePooling1D(pool_window_shape[ROW_AXIS],
# strides=1)(output_2D_hal)
# output_2D_hal = Flatten()(output_2D_hal)
# output_2D_hal = Dense(units=n_classes,
# kernel_initializer="he_normal",
# activation="softmax", name = '2DHAL_AVE_OUT')(output_2D_hal)
output_2D_hal = Activation("softmax", name = '2DHAL')(output_2D_hal)
return output_2D_hal
print('error:', str((1. - score[1]) * 100) + '%')
return score
if __name__ == "__main__":
model, val, val_label = train(True)
ensemble = []
for weights in glob.glob("models/keras/*.h5"):
model = build_network()
model.load_weights(weights)
ensemble.append(model)
x = Input((img_rows * img_cols, ))
outputs = [model(x) for model in ensemble]
y = Average()(outputs)
ensemble_model = Model(x, y)
preds = ensemble_model.predict(val)
preds = np.argmax(preds, axis=1)
val_label = np.argmax(val_label, axis=1)
metrics = [accuracy_score]
#, recall_score, precision_score, f1_score]
for metric in metrics:
print(type(metric).__name__, ":", metric(np.array(val_label), preds))
#for i in range(20):
# train()
def load_source_model(models=['xception','resnet50'], \
pred_models=None, \
is_targeted=False, \
# output_avg_pred=False, \
loss_pow=None, \
aug_or_rotate='aug', \
grad_dict=None, \
make_model=False, \
load_weights=True):
# the gradients are supposed to be subtracted
grad_sign = 1 if is_targeted else -1
if grad_dict is not None:
grad_dict.clear()
input_img = Input(shape=(299, 299, 3), name='src_input_img')
noise_input = Input(batch_shape=(1, ), name='augmentation_scale')
if aug_or_rotate not in ['aug', 'rot', 'none']:
raise ValueError('invalid value for aug_or_rotate')
target_labels = Input(shape=(1000, ), name='target_labels')
pred_max = Lambda(lambda x: K.max(x, axis=1, keepdims=True),
name='target_labels_pred_max')(target_labels)
y = Equal(name='target_pred_equal')([target_labels, pred_max])
y = Lambda(lambda x: K.cast(x, K.floatx()), name='type_cast')(y)
y = Lambda(lambda x: x / K.sum(x, axis=1, keepdims=True),
name='pseudo_label')(y)
model_outputs = []
for model_name in models:
print('preparing', model_name)
model_pred = load_branch(model_name,
input_img,
aug_or_rotate,
noise_input,
False,
load_weights=load_weights)
if pred_models is not None and model_name in pred_models:
model_outputs.append(model_pred)
print('preparing gradients', model_name)
branch_loss = CategoricalCrossEntropy(from_logits=False,
name=model_name +
'_ce')([y, model_pred])
#if loss_pow:
# branch_loss = K.pow(branch_loss, loss_pow)
branch_grads = Gradients(grad_sign, name='grad_' +
model_name)([input_img, branch_loss])
if grad_dict is not None:
if make_model:
grad_dict[model_name] = branch_grads
else:
grad_dict[model_name] = K.function(\
[input_img, noise_input, target_labels, K.learning_phase()], \
[branch_grads])
print('finished', model_name)
print('loading of source models finished')
if pred_models and grad_dict is not None:
if make_model:
if len(model_outputs) == 1:
grad_dict['PRED'] = Lambda(lambda x: x,
name='PRED')(model_outputs[0])
else:
grad_dict['PRED'] = Average(name='PRED')(model_outputs)
else:
pred_func = K.function(
[input_img, noise_input,
K.learning_phase()],
[sum(model_outputs) / len(model_outputs)])
grad_dict['PRED'] = pred_func
if make_model:
output_list = models
if pred_models:
output_list.append('PRED')
#learning_phase = Input(batch_shape=(), \
# dtype='bool', \
# tensor=K.learning_phase(), \
# name='learning_phase')
#grad_inputs = [input_img, noise_input, target_labels, learning_phase]
grad_inputs = [input_img, noise_input, target_labels]
model = Model(inputs=grad_inputs, \
outputs=[grad_dict[m] \
for m in output_list])
else:
model = None
print('gradient computation finished')
return model
def neighModule(self,
kpm=True,
neighEnc=True,
visEnc=False,
socPool=False,
vStt=False):
self.obsModule(kpm=kpm, neighEnc=neighEnc, visEnc=visEnc, vStt=vStt)
self.weight = []
self.modeN_all = []
self.pose_all = []
self.gaze_all = []
self.pose_stt = []
self.gaze_stt = []
self.visP_all = []
self.visG_all = []
observations = []
for n in range(self.n_neighbors):
obs_input = []
if (kpm):
shape = (self.n_kpm, 2) if (self.n_kpm > 1) else (2, )
self.pose_all.append(Input(shape=shape, name='pose_%d' % n))
self.gaze_all.append(Input(shape=shape, name='gaze_%d' % n))
obs_input.append(self.pose_all[n])
obs_input.append(self.gaze_all[n])
if (vStt):
self.pose_stt.append(
Input(shape=(self.n_enc, 2), name='pStt_%d' % n))
self.gaze_stt.append(
Input(shape=(self.n_enc, 2), name='gStt_%d' % n))
obs_input.append(self.pose_stt[n])
obs_input.append(self.gaze_stt[n])
if (neighEnc):
self.modeN_all.append(
Input(shape=(self.n_enc, self.n_states),
name='mode_%d' % n))
obs_input.append(self.modeN_all[n])
if (visEnc):
self.visP_all.append(
Input(shape=(self.n_vis, 2), name='visP_%d' % n))
self.visG_all.append(
Input(shape=(self.n_vis, 2), name='visG_%d' % n))
obs_input.append(self.visP_all[n])
obs_input.append(self.visG_all[n])
observations.append(self.obs_mod(obs_input))
if (socPool):
observations = Cat(axis=2)([
Reshape((int_shape(observations[i])[1], 1))(observations[i])
for i in range(len(observations))
])
self.weight = [
Input(shape=(self.n_neighbors, ))
for _ in range(self.d_socPool**2)
]
neigh_avg = Cat()([
Flatten()(Dot(2)([
observations,
Reshape((1, self.n_neighbors))(self.weight[i])
])) for i in range(self.d_socPool**2)
])
else:
neigh_avg = Average()(observations)
self.nmod_input = (self.weight + self.pose_stt + self.gaze_stt +
self.pose_all + self.gaze_all + self.visP_all +
self.visG_all + self.modeN_all)
self.neigh_mod = Container(self.nmod_input, neigh_avg)
def get_model(I, E, M=5):
"""Returns a compiled model described in Appendix section C.
Arguments:
I (int): number of inputs in each program. input count is
padded to I with null type and vals.
E (int): embedding dimension
M (int): number of examples per program. default 5.
Returns:
keras.model compiled keras model as described in Appendix
section C
"""
embed = Embedding(constants.NULL + 1, E, input_length=1, name='embedding')
l1 = Dense(K, activation='sigmoid', name='layer1')
l2 = Dense(K, activation='sigmoid', name='layer2')
l3 = Dense(K, activation='sigmoid', name='layer3')
input_layers = []
concat_layers = []
for i in range(M):
# example inputs
for j in range(I):
type_input = Input(shape=(2, ),
name=encoding.get_input_typename(i, j))
val_inputs = []
for k in range(L):
val_input = Input(shape=(1, ),
name=encoding.get_input_valname(i, j, k))
val_inputs.append(val_input)
input_layers += [type_input] + val_inputs
embed_list = [embed(x) for x in val_inputs]
flattened_list = [Flatten()(x) for x in embed_list]
concat_layer = Concatenate()([type_input] + flattened_list)
concat_layers.append(concat_layer)
# example output
type_input = Input(shape=(2, ), name=encoding.get_output_typename(i))
val_inputs = []
for j in range(L):
val_input = Input(shape=(1, ),
name=encoding.get_output_valname(i, j))
val_inputs.append(val_input)
input_layers += [type_input] + val_inputs
embed_list = [embed(x) for x in val_inputs]
flattened_list = [Flatten()(x) for x in embed_list]
concat_layer = Concatenate()([type_input] + flattened_list)
concat_layers.append(concat_layer)
l1_layers = [l1(x) for x in concat_layers]
l2_layers = [l2(x) for x in l1_layers]
l3_layers = [l3(x) for x in l2_layers]
ave = Average()(l3_layers)
pred = Dense(len(impl.FUNCTIONS), activation='softmax')(ave)
model = Model(inputs=input_layers, outputs=pred)
model.compile('adam', 'categorical_crossentropy')
return model
], Y_batch
counter += 1
if counter % 50 == 0:
print("i=" + str(counter))
if counter == int((1 - splits) * num_batches):
counter = 0
if shuffle:
np.random.shuffle(smp_idx)
nb_hidden = 1000
input1 = Input(shape=(1000, ))
input2 = Input(shape=(1000, ))
input3 = Input(shape=(1000, ))
avgL = Average()([input1, input2, input3])
maxL = Maximum()([input1, input2, input3])
minL = Minimum()([input1, input2, input3])
concatL = Concatenate()([avgL, maxL])
layer1 = Dense(nb_hidden,
kernel_regularizer=regularizers.l1(0.00001),
bias_initializer='zeros',
activation='relu')(concatL)
#layer1=Dropout(0.5)(layer1)
out = Dense(nb_classes,
kernel_regularizer=regularizers.l1(0.00001),
bias_initializer='zeros',
kernel_initializer='identity',
activation='softmax')(layer1)
model = Model([input1, input2, input3], out)
#model=load_model('genFit_ens450.h5');
Conv1D(filters=nb_filter1, kernel_size=filter_len1, activation='relu'),
#Dropout(dropout_cnn),
GlobalMaxPooling1D(),
# https://github.com/fchollet/keras/issues/1920
# https://stats.stackexchange.com/questions/257321/what-is-global-max-pooling-layer-and-what-is-its-advantage-over-maxpooling-layer
#MaxPooling1D(pool_len1),
Dropout(dropout_pool),
#Flatten(),
Dense(nb_dense, activation='relu'),
Dropout(dropout_dense),
Dense(1, activation='sigmoid')
]
forward_output = get_output(forward_input, hidden_layers)
reverse_output = get_output(reverse_input, hidden_layers)
#output = merge([forward_output, reverse_output], mode='ave')
output = Average()([forward_output, reverse_output])
model = Model(inputs=[forward_input, reverse_input], outputs=output)
model.compile(Adam(lr=learningrate),
'binary_crossentropy',
metrics=['accuracy'])
#model.summary()
print("...fitting model...")
print(contigLengthk + 'k_fl' + str(filter_len1) + '_fn' + str(nb_filter1) +
'_dn' + str(nb_dense) + '_ep' + str(epochs))
model.fit(x = [X_tr_shuf_fw, X_tr_shuf_bw], y = Y_tr_shuf, \
batch_size=batch_size, epochs=epochs, verbose=1, \
validation_data=([X_val_shuf_fw, X_val_shuf_bw], Y_val_shuf), \
callbacks=[checkpointer, earlystopper])
### produce AUC ###
def load_source_model(models=['xception','resnet50'], \
pred_models=None, \
is_targeted=False, \
aug_or_rotate='aug', \
grad_dict=None, \
make_model=False, \
load_weights=True):
"""
Loads the models and set up grad_dict. grad_dict is a dictionary
indexed by model names, and the values are tuples
(input, output, K.function(input, output)). There is a special
entry PRED that is for the prediction function. All other
functions are gradients w.r.t. input pixels.
The gradients are always supposed to be subtracted, so the sign
will be different depending on whether it is a targeted attack.
Arguments
models models used in the ensemble
pred_models models used for prediction
is_targeted
aug_or_rotate
grad_dict the main output of this function
make_model
load_weights
"""
grad_sign = 1 if is_targeted else -1
ph = K.learning_phase()
if grad_dict is not None:
grad_dict.clear()
input_img = Input(shape=(299, 299, 3), name='src_input_img')
noise_input = Input(batch_shape=(1, ), name='augmentation_scale')
if aug_or_rotate not in ['aug', 'rot', 'none']:
raise ValueError('invalid value for aug_or_rotate')
target_labels = Input(shape=(1000, ), name='target_labels')
pred_max = Lambda(lambda x: K.max(x, axis=1, keepdims=True),
name='target_labels_pred_max')(target_labels)
y = Equal(name='target_pred_equal')([target_labels, pred_max])
y = Lambda(lambda x: K.cast(x, K.floatx()), name='type_cast')(y)
y = Lambda(lambda x: x / K.sum(x, axis=1, keepdims=True),
name='pseudo_label')(y)
model_outputs = []
for model_name in models:
print('preparing', model_name)
model_pred = load_branch(model_name,
input_img,
aug_or_rotate,
noise_input,
False,
load_weights=load_weights)
if pred_models is not None and model_name in pred_models:
model_outputs.append(model_pred)
print('preparing gradients', model_name)
branch_loss = CategoricalCrossEntropy(from_logits=False,
name=model_name +
'_ce')([y, model_pred])
branch_grads = Gradients(grad_sign, name='grad_' +
model_name)([input_img, branch_loss])
if grad_dict is not None:
if make_model:
grad_dict[model_name] = branch_grads
else:
grad_dict[model_name] = (\
[input_img, noise_input, target_labels, ph], \
[branch_grads], \
K.function(\
[input_img, noise_input, target_labels, ph], \
[branch_grads]))
print('finished', model_name)
print('loading of source models finished')
if pred_models and grad_dict is not None:
if make_model:
if len(model_outputs) == 1:
grad_dict['PRED'] = Lambda(lambda x: x,
name='PRED')(model_outputs[0])
else:
grad_dict['PRED'] = Average(name='PRED')(model_outputs)
else:
pred_avg = sum(model_outputs) / len(model_outputs)
pred_func = K.function([input_img, noise_input, K.learning_phase()], \
[pred_avg])
grad_dict['PRED'] = ([input_img, noise_input, K.learning_phase()], \
[pred_avg], pred_func)
if make_model:
output_list = models
if pred_models:
output_list.append('PRED')
grad_inputs = [input_img, noise_input, target_labels]
model = Model(inputs=grad_inputs, \
outputs=[grad_dict[m] \
for m in output_list])
else:
model = None
print('gradient computation finished')
return model
