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 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 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 simple_lstm(input_shape, classes, leaky_relu_alpha=0.04): """ Generate network of architecture: LSTM units = M * N / 10 activation = leaky relu Dense units = classes activation = softmax :param input_shape: tuple of int with length input_shape_rank=2 specifying the model input shape (MxN) :param classes: number of output units :param leaky_relu_alpha: slope of the leaky relu activation function :return: network with an lstm layer and a dense layer (see network architecture) """ from tensorflow.contrib.keras.api.keras.layers import LSTM, Dense, LeakyReLU model = tf.keras.models.Sequential() input_units = round_even(input_shape[0] * input_shape[1] / 10.0) model.add(LSTM(input_units, input_shape=input_shape)) model.add(LeakyReLU(alpha=leaky_relu_alpha)) model.add(Dense(classes, activation="softmax")) return model
def lstm_2_dense_2(input_shape, classes, input_unit_multiplier=0.10, input_layer_dropout=0.16, dropout_decay=0.5, lstm_1_leaky_relu_alpha=0.04, lstm_2_leaky_relu_alpha=0.02, lstm_2_unit_input_multiplier=0.5, dense_1_unit_input_multiplier=0.25, presoftmax_dense_activation="tanh"): """ Generate network of architecture: LSTM units = M * N * input_unit_multiplier activation = leaky relu dropout = input_layer_dropout LSTM units = M * N * input_unit_multiplier * lstm_2_unit_input_multiplier activation = leaky relu dropout = input_layer_dropout * dropout_decay Dense units = M * N * input_unit_multiplier * dense_1_unit_input_multiplier activation = presoftmax_dense_activation dropout = input_layer_dropout * (dropout_decay ** 2) Dense units = classes activation = softmax :param input_shape: tuple of int with length input_shape_rank=2 specifying the model input shape (MxN) :param classes: number of output units :param input_unit_multiplier: multiplier for generating number of input units (see model architecture) :param input_layer_dropout: dropout rate for the first LSTM. If 0, no dropout :param dropout_decay: dropout decay rate by which the initial dropout rate decays for lower layers. If 0, constant dropout rate :param lstm_1_leaky_relu_alpha: slope of the leaky relu activation function for the first lstm :param lstm_2_leaky_relu_alpha: slope of the leaky relu activation function for the second lstm :param lstm_2_unit_input_multiplier: multiplier for generating the number of units for the second lstm (see model architecture) :param dense_1_unit_input_multiplier: multiplier for generating the number of units for the first dense layer (see model architecture) :param presoftmax_dense_activation: activation function for the first dense layer :return: network with two lstm layers and two dense layers (see network architecture) """ from tensorflow.contrib.keras.api.keras.layers import LSTM, Dense, LeakyReLU, Dropout model = tf.keras.models.Sequential() input_units = round_even(input_shape[0] * input_shape[1] * input_unit_multiplier) model.add( LSTM(input_units, input_shape=input_shape, return_sequences=True)) model.add(LeakyReLU(alpha=lstm_1_leaky_relu_alpha)) if input_layer_dropout > 0: model.add(Dropout(input_layer_dropout)) model.add(LSTM(round_even(input_units * lstm_2_unit_input_multiplier))) model.add(LeakyReLU(alpha=lstm_2_leaky_relu_alpha)) if input_layer_dropout > 0: model.add(Dropout(input_layer_dropout * dropout_decay)) model.add( Dense(round_even(input_units * dense_1_unit_input_multiplier), activation=presoftmax_dense_activation)) if input_layer_dropout > 0: model.add(Dropout(input_layer_dropout * (dropout_decay**2))) model.add(Dense(classes, activation="softmax")) return model
def convlstm_2_dense_2(input_shape, output_units, channels_first=True, units=None, filter_sizes=(5, 3), dropouts=(0.20, 0.24, 0.32), leaky_relu_alphas=(0.04, 0.04), pool_size=2, pool_method="avg", dense_1_activation="tanh", dense_2_activation="tanh", print_model_architecture=True): """ :param input_shape: 5 dimensional (batch, timesteps, channels, rows, columns) :param output_units: total number of output neurons :param channels_first: if False, input_shape is: (batch, timesteps, rows, columns, channels) :param units: list of int specifying the number of filters and units per layer (excluding final layer) :param filter_sizes: list of int specifying the dimensions of the convolutional filters of ConvLSTM2D :param dropouts: list of float specifying the dropout rates per layer (excluding final layer) :param leaky_relu_alphas: list of float specifying leak relu slope in the negative domain for the ConvLSTM2D activation functions :param pool_size: int specifying the size of the square used for pooling between the second ConvLSTM and first Dense layers :param pool_method: if "avg", 2D average pooling is used, otherwise max pooling is used :param dense_1_activation: activation function for the first dense layer :param dense_2_activation: activation function for the output layer :param print_model_architecture: if True, the model architecture is printed before trying to build it :return: """ from tensorflow.contrib.keras.api.keras.layers import ConvLSTM2D, LeakyReLU, Dense, AveragePooling2D, MaxPooling2D, Dropout, Flatten model = tf.keras.models.Sequential() data_format = "channels_first" if channels_first else "channels_last" if not units: units = [] units.append(round_even(input_shape[2] * input_shape[3] / 2)) units.append(round_even(units[0] * 1.5)) units.append(round_even((units[1] + output_units) / 2)) if print_model_architecture: print("building network with architecture:") print("\tCONV LSTM 2D") print("\t\tfilters: {}".format(units[0])) print("\t\tleaky relu alpha: {}".format(leaky_relu_alphas[0])) print("\t\tdata format: {}".format(data_format)) if dropouts[0] > 0: print("\t\tdropout: {}".format(dropouts[0])) print("\tCONV LSTM 2D") print("\t\tfilters: {}".format(units[1])) print("\t\tleaky relu alpha: {}".format(leaky_relu_alphas[1])) print("\t\tdata format: {}".format(data_format)) if dropouts[1] > 0: print("\t\tdropout: {}".format(dropouts[1])) if pool_size > 0: print("\tPOOL") print("\t\tsize: {}".format(pool_size)) print("\t\tmethod: {}".format(pool_method)) print("\tFLATTEN") print("\t\tdata format: {}".format(data_format)) print("\tDENSE") print("\t\tunits: {}".format(units[2])) print("\t\tactivation: {}".format(dense_1_activation)) print("\tDENSE") print("\t\tunits: {}".format(output_units)) print("\t\tactivation: {}".format(dense_2_activation)) if len(units) != 3 or not all([x > 0 for x in units]): raise ValueError("inputs to each layer must be a positive int") model.add( ConvLSTM2D(units[0], (filter_sizes[0], filter_sizes[0]), input_shape=input_shape, data_format=data_format, return_sequences=True)) model.add(LeakyReLU(alpha=leaky_relu_alphas[0])) if dropouts[0] > 0: model.add(Dropout(dropouts[0])) model.add( ConvLSTM2D(units[1], (filter_sizes[1], filter_sizes[1]), data_format=data_format)) model.add(LeakyReLU(alpha=leaky_relu_alphas[1])) if dropouts[1] > 0: model.add(Dropout(dropouts[1])) if pool_size > 0: model.add( AveragePooling2D((pool_size, pool_size)) if pool_method == "avg" else MaxPooling2D(pool_size, pool_size)) model.add(Flatten(data_format=data_format)) model.add(Dense(units[2], activation=dense_1_activation)) model.add(Dense(output_units, activation=dense_2_activation)) return model