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 = 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 build_generator_dense(): model = Sequential() # Add arbitrary layers first = True for size in generator_layers.split(":"): size = int(size) if first: model.add(Dense(size, input_shape=noise_shape, activation=generator_activation)) else: model.add(Dense(size, activation=generator_activation)) model.add(Dropout(dropout_value)) first = False # Add the final layer model.add(Dense( np.prod(url_shape) , activation="tanh")) model.add(Dropout(dropout_value)) model.add(Reshape(url_shape)) model.summary() # Build the model noise = Input(shape=noise_shape) gen = model(noise) return Model(noise, gen)
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 add_conv_layer(self, img_size=(32, 32), img_channels=3): self.classifier.add( BatchNormalization(input_shape=(img_size[0], img_size[1], img_channels))) self.classifier.add( Conv2D(32, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(32, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(64, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(64, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(128, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(128, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(256, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(256, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25))
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] model = Sequential() model.add( Dense(512, activation='relu', input_shape=(28 * 28, ), name='dense_1')) model.add(Dropout(0.2, name='d1')) model.add(Dense(512, activation='relu', name='dense_2')) model.add(Dropout(0.2, name='d2')) model.add(Dense(10, activation='softmax', name='dense_3')) if restore: model.load_weights(restore, by_name=True) 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 __init__(self, nn_type="resnet50", restore = None, session=None, use_imagenet_pretrain=False, use_softmax=True): self.image_size = 224 self.num_channels = 3 self.num_labels = 8 input_layer = Input(shape=(self.image_size, self.image_size, self.num_channels)) weights = "imagenet" if use_imagenet_pretrain else None if nn_type == "resnet50": base_model = ResNet50(weights=weights, input_tensor=input_layer) elif nn_type == "vgg16": base_model = VGG16(weights=weights, input_tensor=input_layer) # base_model = VGG16(weights=None, input_tensor=input_layer) x = base_model.output x = LeakyReLU()(x) x = Dense(1024)(x) x = Dropout(0.2)(x) x = LeakyReLU()(x) x = Dropout(0.3)(x) x = Dense(8)(x) if use_softmax: x = Activation("softmax")(x) model = Model(inputs=base_model.input, outputs=x) # for layer in base_model.layers: # layer.trainable = False if restore: print("Load: {}".format(restore)) model.load_weights(restore) self.model = model
def classifier(self, x): x = Dropout(0.5)(x) # nn.Dropout(), x = Dense(4096)(x) #nn.Linear(256 * 6 * 6, 4096), x = Activation('relu')(x) #nn.ReLU(inplace=True), x = Dropout(0.5)(x) #nn.Dropout(), x = Dense(4096)(x) #nn.Linear(4096, 4096), x = Activation('relu')(x) #nn.ReLU(inplace=True), x = Dense(self.num_classes)(x) #nn.Linear(4096, num_classes), return x
def add_conv_layer(self, img_size=(32, 32), img_channels=3): self.classifier.add(BatchNormalization(input_shape=(*img_size, img_channels))) self.classifier.add(Conv2D(32, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25)) self.classifier.add(Conv2D(64, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25)) self.classifier.add(Conv2D(16, (2, 2), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25))
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 decoder_block(x, y, scope, size=None, upconv=True, ksize=(3, 3), upsize=(2, 2), upstirdes=(2, 2), act_fn='relu', ep_collection='end_points', reuse=None, batch_norm=True, dropout=0.0): if size is None: base_size = x.get_shape().as_list()[-1] size = int(base_size / 2) with tf.variable_scope(scope, scope, [x], reuse=reuse) as sc: x = ThresholdedReLU(theta=0.0)(x) uped = Conv2DTranspose(size, upsize, strides=upstirdes, padding='same')(x) if upconv else x uped, y = reconcile_feature_size(uped, y) up = concatenate([uped, y], axis=3) tf.add_to_collection(ep_collection, up) conv = Conv2D(size, ksize, activation=act_fn, padding='same')(up) tf.add_to_collection(ep_collection, conv) conv = Conv2D(size, ksize, activation=act_fn, padding='same')(conv) tf.add_to_collection(ep_collection, conv) if batch_norm: conv = BatchNormalization()(conv, training=True) tf.add_to_collection(ep_collection, conv) if dropout > 0.0: conv = Dropout(dropout)(conv) tf.add_to_collection(ep_collection, conv) return conv
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 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_classifier(optimizer): classifier = Sequential() classifier.add( Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11)) classifier.add(Dropout(0.1)) classifier.add( Dense(units=6, kernel_initializer='uniform', activation='relu')) classifier.add(Dropout(0.1)) classifier.add( Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) return classifier
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 build_classifier(optimizer): classifier = Sequential() classifier.add(Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11)) # Improving the ANN # Dropout Regularization to reduce overfitting if needed classifier.add(Dropout(0.1)) classifier.add(Dense(units=6, kernel_initializer='uniform', activation='relu')) classifier.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) return classifier
def build_regressor(optimizer): regressor = Sequential() regressor.add(Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11)) # Improving the ANN # Dropout Regularization to reduce overfitting if needed regressor.add(Dropout(0.1)) regressor.add(Dense(units=6, kernel_initializer='uniform', activation='relu')) regressor.add(Dense(units=1, kernel_initializer='uniform', activation='linear')) regressor.compile(optimizer=optimizer, loss='mean_squared_error') return regressor
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
def default_model(input_shape, classes): from tensorflow.contrib.keras.api.keras.layers import LSTM, Dense, LeakyReLU, Dropout model = tf.keras.models.Sequential() model.add(LSTM(256, input_shape=input_shape, return_sequences=True)) model.add(LeakyReLU(alpha=0.05)) model.add(Dropout(0.2)) model.add(LSTM(128)) model.add(LeakyReLU(alpha=0.02)) model.add(Dropout(0.1)) model.add(Dense(32, activation="tanh")) model.add(Dropout(0.1)) model.add(Dense(classes, activation="softmax")) return model
def init_model(self): with tf.variable_scope('cnn', reuse=(self.gpu_id != 0)): x = self.input_img x = tf.reshape(x, (-1, 28, 28, 1)) x = Conv2D(20, (5, 5), padding='same', activation='relu', name='conv1')(x) x = MaxPooling2D()(x) x = Conv2D(50, (5, 5), padding='same', activation='relu', name='conv2')(x) x = MaxPooling2D()(x) x = Dropout(self.input_droprate)(x) x = Flatten()(x) x = Dense(500, activation='relu', name='fc1')(x) x = Dropout(self.input_droprate)(x) x = Dense(args.classes, activation='softmax', name='fc2')(x) self.output = x
def forward(self, x): if K.image_data_format() == 'channels_first': channel_axis = 1 else: channel_axis = -1 x = self.BN1(x) x = self.relu(x) x = self.conv(x) x = self.BN2(x) x = self.relu2(x) new_features = self.conv2(x) #new_features = super(_DenseLayer, self).forward(x) if self.drop_rate > 0: new_features = Dropout(self.drop_rate)(new_features) #new_features = F.dropout(new_features, p=self.drop_rate, training=self.training) return concatenate([x, new_features], axis=channel_axis) #torch.cat([x, new_features], 1)
def lstm(self): """Build a simple LSTM network. We pass the extracted features from our CNN to this model predomenently.""" # Model. model = Sequential() model.add( LSTM(2048, return_sequences=False, input_shape=self.input_shape, dropout=0.5)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(self.nb_classes, activation='softmax')) return model
def build_classifier( optimizer ): # we explicitly use optimizer parameter here, and other parameters are in fit method Classifier = Sequential() Classifier.add( Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11)) Classifier.add(Dropout(0.1)) Classifier.add( Dense(units=6, kernel_initializer='uniform', activation='relu')) Classifier.add( Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) Classifier.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) return Classifier
def build_discriminator_dense(): model = Sequential() model.add(Flatten(input_shape=url_shape)) # Add arbitrary layers for size in discriminator_layers.split(":"): size = int(size) model.add(Dense(size, activation=discriminator_activation)) model.add(Dropout(dropout_value)) # Add the final layer, with a single output model.add(Dense(1, activation='sigmoid')) model.summary() # Build the model gen = Input(shape=url_shape) validity = model(gen) return Model(gen, validity)
def __init__(self): self.model = Sequential() self.model.add( Conv2D(32, (3, 3), input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3))) self.model.add(Activation('relu')) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Conv2D(32, (3, 3))) self.model.add(Activation('relu')) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Conv2D(64, (3, 3))) self.model.add(Activation('relu')) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Flatten()) self.model.add(Dense(64)) self.model.add(Activation('relu')) self.model.add(Dropout(0.5)) self.model.add(Dense(1)) self.model.add(Activation('sigmoid'))
def binary_conv(input, ksize, o_ch, padding, strides, name, dropout=0): with tf.variable_scope(name): x = input x = BatchNormalization(axis=3, epsilon=1e-4, momentum=0.9, name='bn', gamma_initializer=tf.random_uniform_initializer( 0, 1))(x) xb = binary(x) if dropout > 0: xb = Dropout(dropout)(xb) i_ch = xb.shape.as_list()[-1] w = tf.get_variable('conv/kernel', shape=[ksize, ksize, i_ch, o_ch], initializer=tf.random_normal_initializer( mean=0.0, stddev=0.05)) b = tf.get_variable('conv/bias', shape=[o_ch], initializer=tf.constant_initializer(0)) wb = binary2(w) if padding > 0: xb = tf.pad( xb, [[0, 0], [padding, padding], [padding, padding], [0, 0]]) s = tf.nn.conv2d(xb, wb, strides=[1, strides, strides, 1], padding='VALID') x = s + b x = myrelu(x, 'prelu') norm_op = tf.assign(w, w - tf.reduce_mean(w, axis=2, keep_dims=True)) tf.add_to_collection('norm_op', norm_op) clip_op = tf.assign(w, tf.clip_by_value(w, -1, 1)) tf.add_to_collection('clip_op', clip_op) return x
def classifier(self, x): scope = Scoping.get_global_scope() with scope.name_scope('classifier'): if self.data_set == 'NTURGBD': blocks = [{'size': 128, 'bneck': 32, 'groups': 16, 'strides': 1}, {'size': 256, 'bneck': 64, 'groups': 16, 'strides': 2}, {'size': 512, 'bneck': 128, 'groups': 16, 'strides': 2}] n_reps = 3 else: blocks = [{'size': 64, 'bneck': 32, 'groups': 8, 'strides': 3}, {'size': 128, 'bneck': 64, 'groups': 8, 'strides': 3}] n_reps = 3 def _data_augmentation(x): return K.in_train_phase(_sim_occlusions(_jitter_height(x)), x) x = Lambda(_data_augmentation, name=scope+"data_augmentation")(x) x = CombMatrix(self.njoints, name=scope+'comb_matrix')(x) x = EDM(name=scope+'edms')(x) x = Reshape((self.njoints * self.njoints, self.seq_len, 1), name=scope+'resh_in')(x) x = BatchNormalization(axis=-1, name=scope+'bn_in')(x) x = Conv2D(blocks[0]['bneck'], 1, 1, name=scope+'conv_in', **CONV2D_ARGS)(x) for i in range(len(blocks)): for j in range(n_reps): with scope.name_scope('block_%d_%d' % (i, j)): x = _conv_block(x, blocks[i]['size'], blocks[i]['bneck'], blocks[i]['groups'], 3, blocks[i]['strides'] if j == 0 else 1) x = Lambda(lambda args: K.mean(args, axis=(1, 2)), name=scope+'mean_pool')(x) x = BatchNormalization(axis=-1, name=scope + 'bn_out')(x) x = Activation('relu', name=scope + 'relu_out')(x) x = Dropout(self.dropout, name=scope+'dropout')(x) x = Dense(self.num_actions, activation='softmax', name=scope+'label')(x) return x
def __init__(self, img_size, img_channels=3, output_size=17): self.losses = [] self.model = Sequential() self.model.add( BatchNormalization(input_shape=(img_size[0], img_size[1], img_channels))) self.model.add(Conv2D(32, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(32, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(64, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(128, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(128, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(256, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(512, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Flatten()) self.model.add(Dense(512, activation='relu')) self.model.add(BatchNormalization()) self.model.add(Dropout(0.5)) self.model.add(Dense(output_size, activation='sigmoid'))