Python tensorflow.keras.layers.Activation() Examples
The following are 30
code examples of tensorflow.keras.layers.Activation().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow.keras.layers
, or try the search function
.
Example #1
Source File: lstm_experiment_keras.py From blood-glucose-prediction with GNU General Public License v3.0 | 7 votes |
def load(input_shape, output_shape, cfg): nb_lstm_states = int(cfg['nb_lstm_states']) inputs = KL.Input(shape=input_shape) x = KL.CuDNNLSTM(units=nb_lstm_states, unit_forget_bias=True)(inputs) x = KL.Dense(512)(x) x = KL.Activation('relu')(x) x = KL.Dropout(0.2)(x) x = KL.Dense(256)(x) x = KL.Activation('relu')(x) x = KL.Dropout(0.3)(x) mu = KL.Dense(1)(x) std = KL.Dense(1)(x) activation_fn = get_activation_function_by_name(cfg['activation_function']) std = KL.Activation(activation_fn, name="exponential_activation")(std) output = KL.Concatenate(axis=-1)([std, mu]) model = KM.Model(inputs=[inputs], outputs=[output]) return model
Example #2
Source File: test_continuous.py From keras-rl2 with MIT License | 6 votes |
def test_ddpg(): # TODO: replace this with a simpler environment where we can actually test if it finds a solution env = gym.make('Pendulum-v0') np.random.seed(123) env.seed(123) random.seed(123) nb_actions = env.action_space.shape[0] actor = Sequential() actor.add(Flatten(input_shape=(1,) + env.observation_space.shape)) actor.add(Dense(16)) actor.add(Activation('relu')) actor.add(Dense(nb_actions)) actor.add(Activation('linear')) action_input = Input(shape=(nb_actions,), name='action_input') observation_input = Input(shape=(1,) + env.observation_space.shape, name='observation_input') flattened_observation = Flatten()(observation_input) x = Concatenate()([action_input, flattened_observation]) x = Dense(16)(x) x = Activation('relu')(x) x = Dense(1)(x) x = Activation('linear')(x) critic = Model(inputs=[action_input, observation_input], outputs=x) memory = SequentialMemory(limit=1000, window_length=1) random_process = OrnsteinUhlenbeckProcess(theta=.15, mu=0., sigma=.3) agent = DDPGAgent(nb_actions=nb_actions, actor=actor, critic=critic, critic_action_input=action_input, memory=memory, nb_steps_warmup_critic=50, nb_steps_warmup_actor=50, random_process=random_process, gamma=.99, target_model_update=1e-3) agent.compile([Adam(lr=1e-3), Adam(lr=1e-3)]) agent.fit(env, nb_steps=400, visualize=False, verbose=0, nb_max_episode_steps=100) h = agent.test(env, nb_episodes=2, visualize=False, nb_max_episode_steps=100) # TODO: evaluate history
Example #3
Source File: attention.py From keras-attention-mechanism with Apache License 2.0 | 6 votes |
def attention_3d_block(hidden_states): """ Many-to-one attention mechanism for Keras. @param hidden_states: 3D tensor with shape (batch_size, time_steps, input_dim). @return: 2D tensor with shape (batch_size, 128) @author: felixhao28. """ hidden_size = int(hidden_states.shape[2]) # Inside dense layer # hidden_states dot W => score_first_part # (batch_size, time_steps, hidden_size) dot (hidden_size, hidden_size) => (batch_size, time_steps, hidden_size) # W is the trainable weight matrix of attention Luong's multiplicative style score score_first_part = Dense(hidden_size, use_bias=False, name='attention_score_vec')(hidden_states) # score_first_part dot last_hidden_state => attention_weights # (batch_size, time_steps, hidden_size) dot (batch_size, hidden_size) => (batch_size, time_steps) h_t = Lambda(lambda x: x[:, -1, :], output_shape=(hidden_size,), name='last_hidden_state')(hidden_states) score = dot([score_first_part, h_t], [2, 1], name='attention_score') attention_weights = Activation('softmax', name='attention_weight')(score) # (batch_size, time_steps, hidden_size) dot (batch_size, time_steps) => (batch_size, hidden_size) context_vector = dot([hidden_states, attention_weights], [1, 1], name='context_vector') pre_activation = concatenate([context_vector, h_t], name='attention_output') attention_vector = Dense(128, use_bias=False, activation='tanh', name='attention_vector')(pre_activation) return attention_vector
Example #4
Source File: inception_resnet_v1.py From TripletLossFace with MIT License | 6 votes |
def conv2d_bn(x, filters, kernel_size, strides=1, padding='same', activation='relu', use_bias=False, name=None): x = Conv2D(filters, kernel_size, strides=strides, padding=padding, use_bias=use_bias, name=name)(x) if not use_bias: bn_axis = 1 if K.image_data_format() == 'channels_first' else 3 bn_name = _generate_layer_name('BatchNorm', prefix=name) x = BatchNormalization(axis=bn_axis, momentum=0.995, epsilon=0.001, scale=False, name=bn_name)(x) if activation is not None: ac_name = _generate_layer_name('Activation', prefix=name) x = Activation(activation, name=ac_name)(x) return x
Example #5
Source File: common_utils.py From interpret-text with MIT License | 6 votes |
def create_keras_multiclass_classifier(X, y): batch_size = 128 epochs = 12 num_classes = len(np.unique(y)) model = _common_model_generator(X.shape[1], num_classes) model.add(Dense(units=num_classes, activation=Activation("softmax"))) model.compile( loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=["accuracy"], ) y_train = keras.utils.to_categorical(y, num_classes) model.fit( X, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(X, y_train), ) return model
Example #6
Source File: test_discrete.py From keras-rl2 with MIT License | 6 votes |
def test_dqn(): env = TwoRoundDeterministicRewardEnv() np.random.seed(123) env.seed(123) random.seed(123) nb_actions = env.action_space.n # Next, we build a very simple model. model = Sequential() model.add(Dense(16, input_shape=(1,))) model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) memory = SequentialMemory(limit=1000, window_length=1) policy = EpsGreedyQPolicy(eps=.1) dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=50, target_model_update=1e-1, policy=policy, enable_double_dqn=False) dqn.compile(Adam(lr=1e-3)) dqn.fit(env, nb_steps=2000, visualize=False, verbose=0) policy.eps = 0. h = dqn.test(env, nb_episodes=20, visualize=False) assert_allclose(np.mean(h.history['episode_reward']), 3.)
Example #7
Source File: efficientnet.py From keras_imagenet with MIT License | 6 votes |
def get_swish(**kwargs): def swish(x): """Swish activation function: x * sigmoid(x). Reference: [Searching for Activation Functions](https://arxiv.org/abs/1710.05941) """ if backend.backend() == 'tensorflow': try: # The native TF implementation has a more # memory-efficient gradient implementation return backend.tf.nn.swish(x) except AttributeError: pass return x * backend.sigmoid(x) return swish
Example #8
Source File: test_discrete.py From keras-rl2 with MIT License | 6 votes |
def test_double_dqn(): env = TwoRoundDeterministicRewardEnv() np.random.seed(123) env.seed(123) random.seed(123) nb_actions = env.action_space.n # Next, we build a very simple model. model = Sequential() model.add(Dense(16, input_shape=(1,))) model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) memory = SequentialMemory(limit=1000, window_length=1) policy = EpsGreedyQPolicy(eps=.1) dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=50, target_model_update=1e-1, policy=policy, enable_double_dqn=True) dqn.compile(Adam(lr=1e-3)) dqn.fit(env, nb_steps=2000, visualize=False, verbose=0) policy.eps = 0. h = dqn.test(env, nb_episodes=20, visualize=False) assert_allclose(np.mean(h.history['episode_reward']), 3.)
Example #9
Source File: test_discrete.py From keras-rl2 with MIT License | 6 votes |
def test_cem(): env = TwoRoundDeterministicRewardEnv() np.random.seed(123) env.seed(123) random.seed(123) nb_actions = env.action_space.n # Next, we build a very simple model. model = Sequential() model.add(Dense(16, input_shape=(1,))) model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) memory = EpisodeParameterMemory(limit=1000, window_length=1) dqn = CEMAgent(model=model, nb_actions=nb_actions, memory=memory) dqn.compile() dqn.fit(env, nb_steps=2000, visualize=False, verbose=1) h = dqn.test(env, nb_episodes=20, visualize=False) assert_allclose(np.mean(h.history['episode_reward']), 3.)
Example #10
Source File: test_discrete.py From keras-rl2 with MIT License | 6 votes |
def test_sarsa(): env = TwoRoundDeterministicRewardEnv() np.random.seed(123) env.seed(123) random.seed(123) nb_actions = env.action_space.n # Next, we build a very simple model. model = Sequential() model.add(Dense(16, input_shape=(1,))) model.add(Activation('relu')) model.add(Dense(nb_actions, activation='linear')) policy = EpsGreedyQPolicy(eps=.1) sarsa = SARSAAgent(model=model, nb_actions=nb_actions, nb_steps_warmup=50, policy=policy) sarsa.compile(Adam(lr=1e-3)) sarsa.fit(env, nb_steps=20000, visualize=False, verbose=0) policy.eps = 0. h = sarsa.test(env, nb_episodes=20, visualize=False) assert_allclose(np.mean(h.history['episode_reward']), 3.)
Example #11
Source File: ml_agent.py From Grid2Op with Mozilla Public License 2.0 | 6 votes |
def _build_q_NN(self): input_states = Input(shape=(self.observation_size,)) input_action = Input(shape=(self.action_size,)) input_layer = Concatenate()([input_states, input_action]) lay1 = Dense(self.observation_size)(input_layer) lay1 = Activation('relu')(lay1) lay2 = Dense(self.observation_size)(lay1) lay2 = Activation('relu')(lay2) lay3 = Dense(2*self.action_size)(lay2) lay3 = Activation('relu')(lay3) advantage = Dense(1, activation = 'linear')(lay3) model = Model(inputs=[input_states, input_action], outputs=[advantage]) model.compile(loss='mse', optimizer=Adam(lr=self.lr_)) return model
Example #12
Source File: cyclegan-7.1.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def encoder_layer(inputs, filters=16, kernel_size=3, strides=2, activation='relu', instance_norm=True): """Builds a generic encoder layer made of Conv2D-IN-LeakyReLU IN is optional, LeakyReLU may be replaced by ReLU """ conv = Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding='same') x = inputs if instance_norm: x = InstanceNormalization()(x) if activation == 'relu': x = Activation('relu')(x) else: x = LeakyReLU(alpha=0.2)(x) x = conv(x) return x
Example #13
Source File: ml_agent.py From Grid2Op with Mozilla Public License 2.0 | 6 votes |
def construct_q_network(self): # construct double Q networks self.model_Q = self._build_q_NN() self.model_Q2 = self._build_q_NN() # state value function approximation self.model_value = self._build_model_value() self.model_value_target = self._build_model_value() self.model_value_target.set_weights(self.model_value.get_weights()) # policy function approximation self.model_policy = Sequential() # proba of choosing action a depending on policy pi input_states = Input(shape = (self.observation_size,)) lay1 = Dense(self.observation_size)(input_states) lay1 = Activation('relu')(lay1) lay2 = Dense(self.observation_size)(lay1) lay2 = Activation('relu')(lay2) lay3 = Dense(2*self.action_size)(lay2) lay3 = Activation('relu')(lay3) soft_proba = Dense(self.action_size, activation="softmax", kernel_initializer='uniform')(lay3) self.model_policy = Model(inputs=[input_states], outputs=[soft_proba]) self.model_policy.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.lr_)) print("Successfully constructed networks.")
Example #14
Source File: ml_agent.py From Grid2Op with Mozilla Public License 2.0 | 6 votes |
def construct_q_network(self): # replacement of the Convolution layers by Dense layers, and change the size of the input space and output space # Uses the network architecture found in DeepMind paper self.model = Sequential() input_layer = Input(shape=(self.observation_size * self.training_param.NUM_FRAMES,)) layer1 = Dense(self.observation_size * self.training_param.NUM_FRAMES)(input_layer) layer1 = Activation('relu')(layer1) layer2 = Dense(self.observation_size)(layer1) layer2 = Activation('relu')(layer2) layer3 = Dense(self.observation_size)(layer2) layer3 = Activation('relu')(layer3) layer4 = Dense(2 * self.action_size)(layer3) layer4 = Activation('relu')(layer4) output = Dense(self.action_size)(layer4) self.model = Model(inputs=[input_layer], outputs=[output]) self.model.compile(loss='mse', optimizer=Adam(lr=self.lr_)) self.target_model = Model(inputs=[input_layer], outputs=[output]) self.target_model.compile(loss='mse', optimizer=Adam(lr=self.lr_)) self.target_model.set_weights(self.model.get_weights())
Example #15
Source File: mine-13.8.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def build_model(self, input_dim, hidden_units, output_dim): """Build a simple MINE model Arguments: See class arguments. """ inputs1 = Input(shape=(input_dim), name="x") inputs2 = Input(shape=(input_dim), name="y") x1 = Dense(hidden_units)(inputs1) x2 = Dense(hidden_units)(inputs2) x = Add()([x1, x2]) x = Activation('relu', name="ReLU")(x) outputs = Dense(output_dim, name="MI")(x) inputs = [inputs1, inputs2] self._model = Model(inputs, outputs, name='MINE') self._model.summary()
Example #16
Source File: model.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def tconv_layer(inputs, filters=32, kernel_size=3, strides=2, postfix=None): """Helper function to build Conv2DTranspose-BN-ReLU layer """ x = Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides, padding='same', kernel_initializer='he_normal', name='tconv_'+postfix)(inputs) x = BatchNormalization(name="bn_"+postfix)(x) x = Activation('relu', name='relu_'+postfix)(x) return x
Example #17
Source File: layers.py From attention-mechanisms with MIT License | 6 votes |
def call(self, inputs): # (B, S, H) # Expand weights to include batch size through implicit broadcasting W1, W2 = self.W1[None, :, :], self.W2[None, :, :] hidden_states_transposed = Permute(dims=(2, 1))(inputs) # (B, H, S) attention_score = tf.matmul(W1, hidden_states_transposed) # (B, size, S) attention_score = Activation('tanh')(attention_score) # (B, size, S) attention_weights = tf.matmul(W2, attention_score) # (B, num_hops, S) attention_weights = Activation('softmax')(attention_weights) # (B, num_hops, S) embedding_matrix = tf.matmul(attention_weights, inputs) # (B, num_hops, H) embedding_matrix_flattened = Flatten()(embedding_matrix) # (B, num_hops*H) if self.use_penalization: attention_weights_transposed = Permute(dims=(2, 1))(attention_weights) # (B, S, num_hops) product = tf.matmul(attention_weights, attention_weights_transposed) # (B, num_hops, num_hops) identity = tf.eye(self.num_hops, batch_shape=(inputs.shape[0],)) # (B, num_hops, num_hops) frobenius_norm = tf.sqrt(tf.reduce_sum(tf.square(product - identity))) # distance self.add_loss(self.penalty_coefficient * frobenius_norm) # loss if self.model_api == 'functional': return embedding_matrix_flattened, attention_weights elif self.model_api == 'sequential': return embedding_matrix_flattened
Example #18
Source File: train.py From object-localization with MIT License | 6 votes |
def create_model(trainable=False): model = MobileNetV2(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), include_top=False, alpha=ALPHA, weights="imagenet") for layer in model.layers: layer.trainable = trainable block = model.get_layer("block_16_project_BN").output x = Conv2D(112, padding="same", kernel_size=3, strides=1, activation="relu")(block) x = Conv2D(112, padding="same", kernel_size=3, strides=1, use_bias=False)(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = Conv2D(5, padding="same", kernel_size=1, activation="sigmoid")(x) model = Model(inputs=model.input, outputs=x) # divide by 2 since d/dweight learning_rate * weight^2 = 2 * learning_rate * weight # see https://arxiv.org/pdf/1711.05101.pdf regularizer = l2(WEIGHT_DECAY / 2) for weight in model.trainable_weights: with tf.keras.backend.name_scope("weight_regularizer"): model.add_loss(regularizer(weight)) # in tf2.0: lambda: regularizer(weight) return model
Example #19
Source File: model.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def conv_layer(inputs, filters=32, kernel_size=3, strides=1, use_maxpool=True, postfix=None, activation=None): """Helper function to build Conv2D-BN-ReLU layer with optional MaxPooling2D. """ x = Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, kernel_initializer='he_normal', name="conv_"+postfix, padding='same')(inputs) x = BatchNormalization(name="bn_"+postfix)(x) x = Activation('relu', name='relu_'+postfix)(x) if use_maxpool: x = MaxPooling2D(name='pool'+postfix)(x) return x
Example #20
Source File: example_qdense.py From qkeras with Apache License 2.0 | 5 votes |
def QDenseModel(weights_f, load_weights=False): """Construct QDenseModel.""" x = x_in = Input((RESHAPED,), name="input") x = QActivation("quantized_relu(4)", name="act_i")(x) x = QDense(N_HIDDEN, kernel_quantizer=ternary(), bias_quantizer=quantized_bits(4, 0, 1), name="dense0")(x) x = QActivation("quantized_relu(2)", name="act0")(x) x = QDense( NB_CLASSES, kernel_quantizer=quantized_bits(4, 0, 1), bias_quantizer=quantized_bits(4, 0, 1), name="dense2")( x) x = Activation("softmax", name="softmax")(x) model = Model(inputs=[x_in], outputs=[x]) model.summary() model.compile(loss="categorical_crossentropy", optimizer=OPTIMIZER, metrics=["accuracy"]) if load_weights and weights_f: model.load_weights(weights_f) print_qstats(model) return model
Example #21
Source File: multiRes.py From MIScnn with GNU General Public License v3.0 | 5 votes |
def ResPath_3D(filters, length, inp): ''' ResPath Arguments: filters {int} -- [description] length {int} -- length of ResPath inp {keras layer} -- input layer Returns: [keras layer] -- [output layer] ''' shortcut = inp shortcut = conv3d_bn(shortcut, filters , 1, 1, 1, activation=None, padding='same') out = conv3d_bn(inp, filters, 3, 3, 3, activation='relu', padding='same') out = add([shortcut, out]) out = Activation('relu')(out) out = BatchNormalization(axis=4)(out) for i in range(length-1): shortcut = out shortcut = conv3d_bn(shortcut, filters , 1, 1, 1, activation=None, padding='same') out = conv3d_bn(out, filters, 3, 3, 3, activation='relu', padding='same') out = add([shortcut, out]) out = Activation('relu')(out) out = BatchNormalization(axis=4)(out) return out #-----------------------------------------------------# # Subroutines for 2D version # #-----------------------------------------------------#
Example #22
Source File: mnist_cifar_models.py From CROWN-IBP with BSD 2-Clause "Simplified" License | 5 votes |
def get_model_meta(filename): print("Loading model " + filename) global use_tf_keras global Sequential, Dense, Dropout, Activation, Flatten, Lambda, Conv2D, MaxPooling2D, LeakyReLU, regularizers, K try: from keras.models import load_model as load_model_keras ret = get_model_meta_real(filename, load_model_keras) # model is successfully loaded. Import layers from keras from keras.models import Sequential from keras.layers import Input, Dense, Dropout, Activation, Flatten, Lambda from keras.layers import Conv2D, MaxPooling2D from keras.layers import LeakyReLU from keras import regularizers from keras import backend as K print("Model imported using keras") except (KeyboardInterrupt, SystemExit, SyntaxError, NameError, IndentationError): raise except: print("Failed to load model with keras. Trying tf.keras...") use_tf_keras = True from tensorflow.keras.models import load_model as load_model_tf ret = get_model_meta_real(filename, load_model_tf) # model is successfully loaded. Import layers from tensorflow.keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Input, Dense, Dropout, Activation, Flatten, Lambda from tensorflow.keras.layers import Conv2D, MaxPooling2D from tensorflow.keras.layers import LeakyReLU from tensorflow.keras import regularizers from tensorflow.keras import backend as K print("Model imported using tensorflow.keras") # put imported functions in global Sequential, Dense, Dropout, Activation, Flatten, Lambda, Conv2D, MaxPooling2D, LeakyReLU, regularizers, K = \ Sequential, Dense, Dropout, Activation, Flatten, Lambda, Conv2D, MaxPooling2D, LeakyReLU, regularizers, K return ret
Example #23
Source File: train_keras_model.py From gym-2048 with MIT License | 5 votes |
def build_model(board_size=4, board_layers=16, outputs=4, filters=64, residual_blocks=4): # Functional API model inputs = layers.Input(shape=(board_size * board_size * board_layers,)) x = layers.Reshape((board_size, board_size, board_layers))(inputs) # Initial convolutional block x = layers.Conv2D(filters=filters, kernel_size=(3, 3), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) # residual blocks for i in range(residual_blocks): # x at the start of a block temp_x = layers.Conv2D(filters=filters, kernel_size=(3, 3), padding='same')(x) temp_x = layers.BatchNormalization()(temp_x) temp_x = layers.Activation('relu')(temp_x) temp_x = layers.Conv2D(filters=filters, kernel_size=(3, 3), padding='same')(temp_x) temp_x = layers.BatchNormalization()(temp_x) x = layers.add([x, temp_x]) x = layers.Activation('relu')(x) # policy head x = layers.Conv2D(filters=2, kernel_size=(1, 1), padding='same')(x) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Flatten()(x) predictions = layers.Dense(outputs, activation='softmax')(x) # Create model return models.Model(inputs=inputs, outputs=predictions)
Example #24
Source File: basic_lstm_independent_keras.py From blood-glucose-prediction with GNU General Public License v3.0 | 5 votes |
def load(input_shape, output_shape, cfg): nb_lstm_states = int(cfg['nb_lstm_states']) inputs = KL.Input(shape=input_shape) x = KL.LSTM(units=nb_lstm_states, unit_forget_bias=True)(inputs) mu = KL.Dense(1)(x) std = KL.Dense(1)(x) std = KL.Activation(tf.exp, name="exponential_activation")(std) output = KL.Concatenate(axis=-1)([std, mu]) model = KM.Model(inputs=[inputs], outputs=[output]) return model
Example #25
Source File: multiRes.py From MIScnn with GNU General Public License v3.0 | 5 votes |
def MultiResBlock_2D(U, inp, alpha = 1.67): ''' MultiRes Block Arguments: U {int} -- Number of filters in a corrsponding UNet stage inp {keras layer} -- input layer Returns: [keras layer] -- [output layer] ''' W = alpha * U shortcut = inp shortcut = conv2d_bn(shortcut, int(W*0.167) + int(W*0.333) + int(W*0.5), 1, 1, activation=None, padding='same') conv3x3 = conv2d_bn(inp, int(W*0.167), 3, 3, activation='relu', padding='same') conv5x5 = conv2d_bn(conv3x3, int(W*0.333), 3, 3, activation='relu', padding='same') conv7x7 = conv2d_bn(conv5x5, int(W*0.5), 3, 3, activation='relu', padding='same') out = concatenate([conv3x3, conv5x5, conv7x7], axis=3) out = BatchNormalization(axis=3)(out) out = add([shortcut, out]) out = Activation('relu')(out) out = BatchNormalization(axis=3)(out) return out
Example #26
Source File: dcgan-mnist-4.2.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 5 votes |
def build_discriminator(inputs): """Build a Discriminator Model Stack of LeakyReLU-Conv2D to discriminate real from fake. The network does not converge with BN so it is not used here unlike in [1] or original paper. Arguments: inputs (Layer): Input layer of the discriminator (the image) Returns: discriminator (Model): Discriminator Model """ kernel_size = 5 layer_filters = [32, 64, 128, 256] x = inputs for filters in layer_filters: # first 3 convolution layers use strides = 2 # last one uses strides = 1 if filters == layer_filters[-1]: strides = 1 else: strides = 2 x = LeakyReLU(alpha=0.2)(x) x = Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding='same')(x) x = Flatten()(x) x = Dense(1)(x) x = Activation('sigmoid')(x) discriminator = Model(inputs, x, name='discriminator') return discriminator
Example #27
Source File: model.py From DeepMusicClassification with MIT License | 5 votes |
def create_model(input_shape): model = Sequential() model.add(Conv2D(64, (3,3), input_shape=input_shape)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(128, (3,3), kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01))) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(256, (3,3), kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01))) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(512, (3,3), kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01))) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Flatten()) model.add(Dense(1024)) model.add(Activation('elu')) model.add(Dropout(0.5)) model.add(Dense(10)) model.add(Activation('softmax')) # compile model model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics = ['accuracy']) return model
Example #28
Source File: stackedgan-mnist-6.2.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 5 votes |
def build_discriminator(inputs, z_dim=50): """Build Discriminator 1 Model Classifies feature1 (features) as real/fake image and recovers the input noise or latent code (by minimizing entropy loss) # Arguments inputs (Layer): feature1 z_dim (int): noise dimensionality # Returns dis1 (Model): feature1 as real/fake and recovered latent code """ # input is 256-dim feature1 x = Dense(256, activation='relu')(inputs) x = Dense(256, activation='relu')(x) # first output is probability that feature1 is real f1_source = Dense(1)(x) f1_source = Activation('sigmoid', name='feature1_source')(f1_source) # z1 reonstruction (Q1 network) z1_recon = Dense(z_dim)(x) z1_recon = Activation('tanh', name='z1')(z1_recon) discriminator_outputs = [f1_source, z1_recon] dis1 = Model(inputs, discriminator_outputs, name='dis1') return dis1
Example #29
Source File: models.py From medaka with Mozilla Public License 2.0 | 5 votes |
def build_majority(feature_len, num_classes, gru_size=128, classify_activation='softmax', time_steps=None, allow_cudnn=True): """Build a mock model that simply sums counts. :param feature_len: int, number of features for each pileup column. :param num_classes: int, number of output class labels. :param gru_size: int, size of each GRU layer. :param classify_activation: str, activation to use in classification layer. :param time_steps: int, number of pileup columns in a sample. :param allow_cudnn: bool, opt-in to cudnn when using a GPU. :returns: `keras.models.Sequential` object. """ import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Lambda, Activation def sum_counts(f): """Sum forward and reverse counts.""" # TODO write to handle multiple dtypes # acgtACGTdD # sum base counts b = f[:, :, 0:4] + f[:, :, 4:8] # sum deletion counts (indexing in this way retains correct shape) d = f[:, :, 8:9] + f[:, :, 9:10] return tf.concat([d, b], axis=-1) model = Sequential() model.add(Lambda(sum_counts, output_shape=(time_steps, num_classes))) model.add(Activation('softmax')) return model
Example #30
Source File: autoqkeras_test.py From qkeras with Apache License 2.0 | 5 votes |
def dense_model(): """Creates test dense model.""" x = x_in = Input((4,), name="input") x = Dense(20, name="dense_0")(x) x = BatchNormalization(name="bn0")(x) x = Dropout(0.1, name="dp0")(x) x = Activation("relu", name="relu_0")(x) x = Dense(3, name="dense")(x) x = Activation("softmax", name="softmax")(x) model = Model(inputs=x_in, outputs=x) return model