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