def __init__(self, params, restore = None, session=None, use_log=False, image_size=28, image_channel=1):
self.image_size = image_size
self.num_channels = image_channel
self.num_labels = 10
model = Sequential()
model.add(Flatten(input_shape=(image_size, image_size, image_channel)))
# list of all hidden units weights
self.U = []
for param in params:
# add each dense layer, and save a reference to list U
self.U.append(Dense(param))
model.add(self.U[-1])
# ReLU activation
model.add(Activation('relu'))
self.W = Dense(10)
model.add(self.W)
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def LoadModel():
global D
D=None
D=load_model('./tdoa1.h5')
if D==None:
i=Input(shape=(M,4))
print("1=====",i)
a=Flatten()(i)
a=Dense(200,activation='relu')(a)
a=Dense(160,activation='relu')(a)
a=Dense(120,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(20,activation='relu')(a)
a=Dense(10,activation='relu')(a)
o=Dense(2,activation='tanh')(a)
D=Model(inputs=i,outputs=o)
D.compile(loss='mse',optimizer='adam',metrics=['accuracy'])
def create_model(activation, bn, data, filters, init, kernels,
use_padding_same):
model = Sequential()
if use_padding_same:
model.add(
Conv2D(filters[0],
kernels[0],
input_shape=data.train_data.shape[1:],
padding="same"))
else:
model.add(
Conv2D(filters[0],
kernels[0],
input_shape=data.train_data.shape[1:]))
if bn:
apply_bn(data, model)
# model.add(Activation(activation))
model.add(Lambda(activation))
for f, k in zip(filters[1:], kernels[1:]):
if use_padding_same:
model.add(Conv2D(f, k, padding="same"))
else:
model.add(Conv2D(f, k))
if bn:
apply_bn(data, model)
# model.add(Activation(activation))
# ReLU activation
model.add(Lambda(activation))
# the output layer
model.add(Flatten())
model.add(Dense(data.train_labels.shape[1]))
# load initial weights when given
if init != None:
model.load_weights(init)
return model
def __init__(self, restore=None, session=None, use_softmax=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_softmax:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
self.model = model
def build_discriminator(self):
model = Sequential()
model.add(
Conv2D(32,
kernel_size=3,
strides=2,
input_shape=self.img_shape,
padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def __init__(self, restore=None, session=None, use_softmax=False):
self.num_channels = 3
self.image_size = 32
self.num_labels = 10
model = Sequential()
model.add(Conv2D(64, (3, 3), input_shape=(32, 32, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(128, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(10))
if use_softmax:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
self.model = model
def __init__(self, restore=None, session=None, use_log=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Flatten(input_shape=(28, 28, 1)))
model.add(Dense(1024))
model.add(Lambda(lambda x: x * 10))
model.add(Activation('softplus'))
model.add(Lambda(lambda x: x * 0.1))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def forward(self, x):
if self.transform_input:
x = x.clone()
x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5
x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5
x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5
# 299 x 299 x 3
x = self.Conv2d_1a_3x3.forward(x) #x = self.Conv2d_1a_3x3(x)
# 149 x 149 x 32
x = self.Conv2d_2a_3x3.forward(x) #x = self.Conv2d_2a_3x3(x)
# 147 x 147 x 32
x = self.Conv2d_2b_3x3.forward(x) #x = self.Conv2d_2b_3x3(x)
# 147 x 147 x 64
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(
x) #x = F.max_pool2d(x, kernel_size=3, stride=2)
# 73 x 73 x 64
x = self.Conv2d_3b_1x1.forward(x) #x = self.Conv2d_3b_1x1(x)
# 73 x 73 x 80
x = self.Conv2d_4a_3x3.forward(x) #x = self.Conv2d_4a_3x3(x)
# 71 x 71 x 192
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(
x) #x = F.max_pool2d(x, kernel_size=3, stride=2)
# 35 x 35 x 192
x = self.Mixed_5b.forward(x) #x = self.Mixed_5b(x)
# 35 x 35 x 256
x = self.Mixed_5c.forward(x) #x = self.Mixed_5c(x)
# 35 x 35 x 288
x = self.Mixed_5d.forward(x) #x = self.Mixed_5d(x)
# 35 x 35 x 288
x = self.Mixed_6a.forward(x) #x = self.Mixed_6a(x)
# 17 x 17 x 768
x = self.Mixed_6b.forward(x) #x = self.Mixed_6b(x)
# 17 x 17 x 768
x = self.Mixed_6c.forward(x) #x = self.Mixed_6c(x)
# 17 x 17 x 768
x = self.Mixed_6d.forward(x) #x = self.Mixed_6d(x)
# 17 x 17 x 768
x = self.Mixed_6e.forward(x) #x = self.Mixed_6e(x)
# 17 x 17 x 768
# if self.aux_logits:
# aux = self.AuxLogits.forward(x) #aux = self.AuxLogits(x)
# 17 x 17 x 768
x = self.Mixed_7a.forward(x) #x = self.Mixed_7a(x)
# 8 x 8 x 1280
x = self.Mixed_7b.forward(x) #x = self.Mixed_7b(x)
# 8 x 8 x 2048
x = self.Mixed_7c.forward(x) #x = self.Mixed_7c(x)
# 8 x 8 x 2048
x = AveragePooling2D(pool_size=(8, 8))(
x) #x = F.avg_pool2d(x, kernel_size=8)
# 1 x 1 x 2048
x = Dropout(0.5)(x) #x = F.dropout(x, training=self.training)
# 1 x 1 x 2048
x = Flatten()(x) #x = x.view(x.size(0), -1)
# 2048
x = self.fc(x)
# 1000 (num_classes)
# if self.aux_logits:
# return x, aux
return x
def __init__(self, restore = None, session=None, use_softmax=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
self.shape = [None, 28, 28, self.num_channels]
model = Sequential()
model.add(Conv2D(6, (5, 5), padding='valid', activation='relu', kernel_initializer='he_normal',
input_shape=(28,28,1), name='l1'))
model.add(MaxPooling2D((2, 2), strides=(2, 2), name='l2'))
model.add(Conv2D(16, (5, 5), padding='valid', activation='relu', kernel_initializer='he_normal', name='l3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2), name='l4'))
model.add(Flatten())
model.add(Dense(120, activation='relu', kernel_initializer='he_normal', name='l5'))
model.add(Dense(84, activation='relu', kernel_initializer='he_normal', name='l6'))
model.add(Dense(10, activation='softmax', kernel_initializer='he_normal', name='l7'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def conv_3d(self):
"""
Build a 3D convolutional network, based loosely on C3D.
https://arxiv.org/pdf/1412.0767.pdf
"""
# Model.
model = Sequential()
model.add(
Conv3D(32, (3, 3, 3),
activation='relu',
input_shape=self.input_shape))
model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))
model.add(Conv3D(64, (3, 3, 3), activation='relu'))
model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))
model.add(Conv3D(128, (3, 3, 3), activation='relu'))
model.add(Conv3D(128, (3, 3, 3), activation='relu'))
model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))
model.add(Conv3D(256, (2, 2, 2), activation='relu'))
model.add(Conv3D(256, (2, 2, 2), activation='relu'))
model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))
model.add(Flatten())
model.add(Dense(1024))
model.add(Dropout(0.5))
model.add(Dense(1024))
model.add(Dropout(0.5))
model.add(Dense(self.nb_classes, activation='softmax'))
return model
def get_clf():
"""
Standard neural network training procedure.
"""
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(200))
model.add(Activation('relu'))
model.add(Dense(10))
model.load_weights("./models/mnist")
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct, logits=predicted)
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
return model
def build_local_model(self):
input = Input(shape=self.state_size)
conv = TimeDistributed(
Conv2D(32, (8, 8), strides=(4, 4), activation="elu"))(input)
conv = TimeDistributed(
Conv2D(32, (4, 4), strides=(2, 2), activation="elu"))(conv)
conv = TimeDistributed(
Conv2D(32, (3, 3), strides=(1, 1), activation='elu'))(conv)
conv = TimeDistributed(
Conv2D(8, (1, 1), strides=(1, 1), activation='elu'))(conv)
conv = TimeDistributed(Flatten())(conv)
conv = BatchNormalization()(conv)
lstm = GRU(256, activation='tanh')(conv)
policy = Dense(self.action_size, activation="softmax")(lstm)
value = Dense(1, activation='linear')(lstm)
local_actor = Model(inputs=input, outputs=policy)
local_critic = Model(inputs=input, outputs=value)
local_actor._make_predict_function()
local_critic._make_predict_function()
local_actor.set_weights(self.actor.get_weights())
local_critic.set_weights(self.critic.get_weights())
return local_actor, local_critic
def __init__(self, restore = None, session=None, use_softmax=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
self.shape = [None, 28, 28, self.num_channels]
model = Sequential()
kernel_size = (5, 5)
drop_rate = 0.3
model.add(Conv2D(32, kernel_size, activation='relu',
padding='same', name='block1_conv1', input_shape=(28,28,1))) # 1
model.add(MaxPooling2D(pool_size=(2, 2), name='block1_pool1')) # 2
model.add(Dropout(drop_rate))
# block2
model.add(Conv2D(64, kernel_size, activation='relu', padding='same', name='block2_conv1')) # 4
model.add(MaxPooling2D(pool_size=(2, 2), name='block2_pool1')) # 5
model.add(Dropout(drop_rate))
model.add(Flatten(name='flatten'))
model.add(Dense(120, activation='relu', name='fc1')) # -5
model.add(Dropout(drop_rate))
model.add(Dense(84, activation='relu', name='fc2')) # -3
model.add(Dense(10, name='before_softmax')) # -2
model.add(Activation('softmax', name='predictions')) #
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def train(data,
file_name,
params,
num_epochs=50,
batch_size=128,
train_temp=1,
init=None,
lr=0.01,
decay=1e-5,
momentum=0.9):
"""
Train a n-layer simple network for MNIST and CIFAR
"""
# create a Keras sequential model
model = Sequential()
# reshape the input (28*28*1) or (32*32*3) to 1-D
model.add(Flatten(input_shape=data.train_data.shape[1:]))
# dense layers (the hidden layer)
for param in params:
model.add(Dense(param))
# ReLU activation
model.add(Activation('relu'))
# the output layer, with 10 classes
model.add(Dense(10))
# load initial weights when given
if init != None:
model.load_weights(init)
# define the loss function which is the cross entropy between prediction and true label
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted /
train_temp)
# initiate the SGD optimizer with given hyper parameters
sgd = SGD(lr=lr, decay=decay, momentum=momentum, nesterov=True)
# compile the Keras model, given the specified loss and optimizer
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
model.summary()
print("Traing a {} layer model, saving to {}".format(
len(params) + 1, file_name))
# run training with given dataset, and print progress
history = model.fit(data.train_data,
data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data,
data.validation_labels),
epochs=num_epochs,
shuffle=True)
# save model to a file
if file_name != None:
model.save(file_name)
return {'model': model, 'history': history}
def train(data, file_name, params, num_epochs=50, batch_size=256, train_temp=1, init=None, lr=0.01, decay=1e-5, momentum=0.9, activation="relu", optimizer_name="sgd"):
"""
Train a n-layer simple network for MNIST and CIFAR
"""
# create a Keras sequential model
model = Sequential()
# reshape the input (28*28*1) or (32*32*3) to 1-D
model.add(Flatten(input_shape=data.train_data.shape[1:]))
# dense layers (the hidden layer)
n = 0
for param in params:
n += 1
model.add(Dense(param, kernel_initializer='he_uniform'))
# ReLU activation
if activation == "arctan":
model.add(Lambda(lambda x: tf.atan(x), name=activation+"_"+str(n)))
else:
model.add(Activation(activation, name=activation+"_"+str(n)))
# the output layer, with 10 classes
model.add(Dense(10, kernel_initializer='he_uniform'))
# load initial weights when given
if init != None:
model.load_weights(init)
# define the loss function which is the cross entropy between prediction and true label
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted/train_temp)
if optimizer_name == "sgd":
# initiate the SGD optimizer with given hyper parameters
optimizer = SGD(lr=lr, decay=decay, momentum=momentum, nesterov=True)
elif optimizer_name == "adam":
optimizer = Adam(lr=lr, beta_1 = 0.9, beta_2 = 0.999, epsilon = None, decay=decay, amsgrad=False)
# compile the Keras model, given the specified loss and optimizer
model.compile(loss=fn,
optimizer=optimizer,
metrics=['accuracy'])
model.summary()
print("Traing a {} layer model, saving to {}".format(len(params) + 1, file_name))
# run training with given dataset, and print progress
history = model.fit(data.train_data, data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data, data.validation_labels),
epochs=num_epochs,
shuffle=True)
# save model to a file
if file_name != None:
model.save(file_name)
print('model saved to ', file_name)
return {'model':model, 'history':history}
def train(data,
file_name,
params,
num_epochs=50,
batch_size=128,
train_temp=1,
init=None,
lr=0.01,
decay=1e-5,
momentum=0.9):
"""
Train a 2-layer simple network for MNIST and CIFAR
"""
# create a Keras sequential model
model = Sequential()
# reshape the input (28*28*1) or (32*32*3) to 1-D
model.add(Flatten(input_shape=data.train_data.shape[1:]))
# first dense layer (the hidden layer)
model.add(Dense(params[0]))
# \alpha = 10 in softplus, multiply input by 10
model.add(Lambda(lambda x: x * 10))
# in Keras the softplus activation cannot set \alpha
model.add(Activation('softplus'))
# so manually add \alpha to the network
model.add(Lambda(lambda x: x * 0.1))
# the output layer, with 10 classes
model.add(Dense(10))
# load initial weights when given
if init != None:
model.load_weights(init)
# define the loss function which is the cross entropy between prediction and true label
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted /
train_temp)
# initiate the SGD optimizer with given hyper parameters
sgd = SGD(lr=lr, decay=decay, momentum=momentum, nesterov=True)
# compile the Keras model, given the specified loss and optimizer
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
# run training with given dataset, and print progress
model.fit(data.train_data,
data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data, data.validation_labels),
epochs=num_epochs,
shuffle=True)
# save model to a file
if file_name != None:
model.save(file_name)
return model
def train(data,
file_name,
params,
num_epochs=50,
batch_size=128,
train_temp=1,
init=None):
"""
Standard neural network training procedure.
"""
model = Sequential()
print(data.train_data.shape)
model.add(Conv2D(params[0], (3, 3), input_shape=data.train_data.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(params[1], (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(params[2], (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(params[3], (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(params[4]))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(params[5]))
model.add(Activation('relu'))
model.add(Dense(10))
if init != None:
model.load_weights(init)
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted /
train_temp)
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
model.fit(data.train_data,
data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data, data.validation_labels),
epochs=num_epochs,
shuffle=True)
if file_name != None:
model.save(file_name)
return model
def get_dae_clf():
model1 = Sequential()
model1.add(Lambda(lambda x_: x_ + 0.5, input_shape=(28, 28, 1)))
# Encoder
model1.add(Conv2D(3, (3, 3), activation="sigmoid", padding="same", activity_regularizer=regs.l2(1e-9)))
model1.add(AveragePooling2D((2, 2), padding="same"))
model1.add(Conv2D(3, (3, 3), activation="sigmoid", padding="same", activity_regularizer=regs.l2(1e-9)))
# Decoder
model1.add(Conv2D(3, (3, 3), activation="sigmoid", padding="same", activity_regularizer=regs.l2(1e-9)))
model1.add(UpSampling2D((2, 2)))
model1.add(Conv2D(3, (3, 3), activation="sigmoid", padding="same", activity_regularizer=regs.l2(1e-9)))
model1.add(Conv2D(1, (3, 3), activation='sigmoid', padding='same', activity_regularizer=regs.l2(1e-9)))
model1.add(Lambda(lambda x_: x_ - 0.5))
model1.load_weights("./dae/mnist")
model1.compile(loss='mean_squared_error', metrics=['mean_squared_error'], optimizer='adam')
model2 = Sequential()
model2.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model2.add(Activation('relu'))
model2.add(Conv2D(32, (3, 3)))
model2.add(Activation('relu'))
model2.add(MaxPooling2D(pool_size=(2, 2)))
model2.add(Conv2D(64, (3, 3)))
model2.add(Activation('relu'))
model2.add(Conv2D(64, (3, 3)))
model2.add(Activation('relu'))
model2.add(MaxPooling2D(pool_size=(2, 2)))
model2.add(Flatten())
model2.add(Dense(200))
model2.add(Activation('relu'))
model2.add(Dropout(0.5))
model2.add(Dense(200))
model2.add(Activation('relu'))
model2.add(Dense(10))
model2.load_weights("./models/mnist")
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct, logits=predicted)
model2.compile(loss=fn, optimizer=SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True), metrics=['accuracy'])
model = Sequential()
model.add(model1)
model.add(model2)
model.compile(loss=fn, optimizer=SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True), metrics=['accuracy'])
return model
def forward(self, x):
for value in self.features:
x = value(x)
features = self.feature(x)
features = self.BN_last(features)
out = Activation('relu')(features) #out = F.relu(features, inplace=True)
out = AveragePooling2D(pool_size=(7,7))(out) #out = F.avg_pool2d(out, kernel_size=7).view(features.size(0), -1)
out = Flatten()(out)
out = self.classifier(out)
return out
def __init__(self,
restore=None,
session=None,
use_softmax=False,
use_brelu=False,
activation="relu"):
def bounded_relu(x):
return K.relu(x, max_value=1)
if use_brelu:
activation = bounded_relu
else:
activation = activation
print("inside CIFARModel: activation = {}".format(activation))
self.num_channels = 3
self.image_size = 32
self.num_labels = 10
model = Sequential()
model.add(Conv2D(64, (3, 3), input_shape=(32, 32, 3)))
model.add(Activation(activation))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation(activation))
model.add(Conv2D(128, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation(activation))
model.add(Dense(256))
model.add(Activation(activation))
model.add(Dense(10))
if use_softmax:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def build_conv(input_layer):
# with tf.name_scope('DQN'):
# input_layer = Input(tensor=input_ph)
x = Conv2D(32, (8, 8), (4, 4), activation='relu',
name='Conv1')(input_layer)
x = Conv2D(64, (4, 4), (2, 2), activation='relu', name='Conv2')(x)
x = Conv2D(64, (3, 3), (1, 1), activation='relu', name='Conv3')(x)
x = Flatten()(x)
x = Dense(512, activation='elu', name='Dense1')(x)
# model = Model(inputs=input_layer, outputs=x)
return x
def ResNet34V2_model():
inpt = Input(shape=(224, 224, 3))
x = ZeroPadding2D((3, 3))(inpt)
x = _BN_ReLU_Conv2d(x,
nb_filter=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='valid')
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')(x)
# (56,56,64)
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
# (28,28,128)
x = Conv_Block(x,
nb_filter=128,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
# (14,14,256)
x = Conv_Block(x,
nb_filter=256,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
# (7,7,512)
x = Conv_Block(x,
nb_filter=512,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=512, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=512, kernel_size=(3, 3))
x = AveragePooling2D(pool_size=(7, 7))(x)
x = Flatten()(x)
# x = Dense(1000,activation='softmax')(x)
x = [
Dense(n_class, activation='softmax', name='P%d' % (i + 1))(x)
for i in range(7)
]
model = Model(inputs=inpt, outputs=x)
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
return model
def train(self,
x_train,
x_test,
y_train,
y_test,
embedding_matrix,
num_classes,
seq_length=200,
emb_dim=100,
train_emb=True,
windows=(3, 4, 5, 6),
dropouts=(0.2, 0.4),
filter_sz=100,
hid_dim=100,
bch_siz=50,
epoch=8):
#setup and train the nueral net
from tensorflow.contrib.keras.api.keras.models import Model
from tensorflow.contrib.keras.api.keras.layers import Activation, Dense, Dropout, Embedding, Flatten, Input, Concatenate, Conv1D, MaxPool1D
inp = Input(shape=(seq_length, ))
out = Embedding(input_dim=len(embedding_matrix[:, 1]),
output_dim=emb_dim,
input_length=seq_length,
weights=[embedding_matrix],
trainable=train_emb)(inp)
out = Dropout(dropouts[0])(out)
convs = []
for w in windows:
conv = Conv1D(filters=filter_sz,
kernel_size=w,
padding='valid',
activation='relu',
strides=1)(out)
conv = MaxPool1D(pool_size=2)(conv)
conv = Flatten()(conv)
convs.append(conv)
out = Concatenate()(convs)
out = Dense(hid_dim, activation='relu')(out)
out = Dropout(dropouts[1])(out)
out = Activation('relu')(out)
out = Dense(num_classes, activation='softmax')(out)
model = Model(inp, out)
model.compile(loss='categorical_crossentropy',
optimizer='nadam',
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=bch_siz,
epochs=epoch,
verbose=2,
validation_data=(x_test, y_test))
return model
def mlp(self):
"""Build a simple MLP. It uses extracted features as the input
because of the otherwise too-high dimensionality."""
# Model.
model = Sequential()
model.add(Flatten(input_shape=self.input_shape))
model.add(Dense(512))
model.add(Dropout(0.5))
model.add(Dense(512))
model.add(Dropout(0.5))
model.add(Dense(self.nb_classes, activation='softmax'))
return model
def init_model(self):
with tf.variable_scope('xnor'):
x = self.input_img
x = tf.pad(x, [[0, 0], [2, 2], [2, 2], [0, 0]])
x = Conv2D(192,
5,
padding='valid',
name='conv1',
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.05))(x)
x = BatchNormalization(axis=3,
epsilon=1e-4,
momentum=0.9,
center=False,
scale=False,
name='bn1')(x)
x = Activation('relu')(x)
x = binary_conv(x, 1, 160, 0, 1, 'conv2')
x = binary_conv(x, 1, 96, 0, 1, 'conv3')
x = tf.pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]])
x = MaxPooling2D((3, 3), strides=2, padding='valid')(x)
x = binary_conv(x, 5, 192, 2, 1, 'conv4', dropout=0.5)
x = binary_conv(x, 1, 192, 0, 1, 'conv5')
x = binary_conv(x, 1, 192, 0, 1, 'conv6')
x = tf.pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]])
x = AveragePooling2D((3, 3), strides=2, padding='valid')(x)
x = binary_conv(x, 3, 192, 1, 1, 'conv7', dropout=0.5)
x = binary_conv(x, 1, 192, 0, 1, 'conv8')
x = BatchNormalization(axis=3,
epsilon=1e-4,
momentum=0.9,
center=False,
scale=False,
name='bn8')(x)
x = Conv2D(10,
1,
padding='valid',
name='conv9',
kernel_initializer=tf.random_normal_initializer(
mean=0.0, stddev=0.05))(x)
x = Activation('relu')(x)
x = AveragePooling2D((8, 8), strides=1, padding='valid')(x)
x = Flatten()(x)
x = Activation('softmax')(x)
self.output = x
def __init__(self,
restore=None,
session=None,
use_log=False,
use_brelu=False):
def bounded_relu(x):
return K.relu(x, max_value=1)
if use_brelu:
activation = bounded_relu
else:
activation = 'relu'
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Activation(activation))
model.add(Conv2D(32, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.model = model
self.layer_outputs = layer_outputs
def forward(self, x):
# 17 x 17 x 768
x = AveragePooling2D(pool_size=(5, 5), strides=(3, 3))(
x) #x = F.avg_pool2d(x, kernel_size=5, stride=3)
# 5 x 5 x 768
x = self.conv0.forward(x) #x = self.conv0(x)
# 5 x 5 x 128
x = self.conv1.forward(x) #x = self.conv1(x)
# 1 x 1 x 768
x = Flatten()(x) #x = x.view(x.size(0), -1)
# 768
x = self.fc(x)
# 1000
return x
def network(num_classes):
model = Sequential()
model.add(
Conv2D(16,
kernel_size=(3, 3),
activation='relu',
input_shape=(105, 105, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(24, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(36, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(num_classes, activation='softmax'))
return model
def discriminator():
model = Sequential()
model.add(
Conv2D(1,
kernel_size=(5, 5),
strides=(2, 2),
padding='same',
input_shape=(_WIDTH, _HEIGHT, 1)))
model.add(LeakyReLU())
model.add(Conv2D(16, kernel_size=(5, 5), strides=(2, 2), padding='same'))
model.add(LeakyReLU())
model.add(Conv2D(24, kernel_size=(5, 5), strides=(2, 2), padding='same'))
model.add(LeakyReLU())
model.add(Flatten())
model.add(Dense(1))
return model
def get_model():
"""
get model
"""
checkpoint = ModelCheckpoint(MODEL_NAME,
monitor='val_acc',
verbose=1,
save_best_only=True)
model = Sequential()
input_shape = (IMAGE_SIZE, IMAGE_SIZE, 3)
model.add(BatchNormalization(input_shape=input_shape))
model.add(Conv2D(32, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.25))
model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(N_CLASSES, activation='sigmoid'))
return model
