def dueling_dqn(input_shape: Tuple[int], action_size: int, learning_rate: float, noisy: bool) -> Model: # Build the convolutional network section and flatten the output state_input, x = build_base_cnn(input_shape, noisy) # Determine the type of the fully collected layer dense_layer = NoisyDense if noisy else Dense # State value tower - V state_value = dense_layer(256, activation='relu', kernel_initializer=he_uniform())(x) state_value = dense_layer(1, kernel_initializer=he_uniform())(state_value) state_value = Lambda(lambda s: K.expand_dims(s[:, 0], axis=-1), output_shape=(action_size, ))(state_value) # Action advantage tower - A action_advantage = dense_layer(256, activation='relu', kernel_initializer=he_uniform())(x) action_advantage = dense_layer( action_size, kernel_initializer=he_uniform())(action_advantage) action_advantage = Lambda( lambda a: a[:, :] - K.mean(a[:, :], keepdims=True), output_shape=(action_size, ))(action_advantage) # Merge to state-action value function Q state_action_value = add([state_value, action_advantage]) model = Model(inputs=state_input, outputs=state_action_value) model.compile(loss=Huber(), optimizer=Adam(lr=learning_rate)) return model
def blstm(): model = Sequential() # model.add(TimeDistributed(Flatten(input_shape=(x.shape[1:])))) # samples, time steps, features中的后两者 model.add( Bidirectional( LSTM(250, input_shape=(30, 513), kernel_initializer=he_uniform(seed=50), return_sequences=True))) # return_sequences=true: 返回形如(samples,timesteps,output_dim)的3D张量 # 通过LSTM,把词的维度由513转变成了250 # BLSTM layer: 250 forward and 250 backward LSTM cells whose output is concatenated to form the overall output of the layer to form the overall output of the layer. model.add( Bidirectional( LSTM(250, kernel_initializer=he_uniform(seed=50), return_sequences=True))) model.add( Bidirectional( LSTM(250, kernel_initializer=he_uniform(seed=50), return_sequences=True))) model.add( TimeDistributed( Dense(513, activation='relu', kernel_initializer=he_uniform(seed=50)))) # 每个time step都输出x.shape[2]长的向量 # model.add(TimeDistributed(Reshape(x.shape[0:]))) return model
def __init__(self, obs_dim, act_dim, lr): super(ActorCritic, self).__init__() self.obs_dim = obs_dim self.act_dim = act_dim self.std = 0.5 self.action_var = tf.constant( [self.std * self.std for i in range(act_dim)]) self.cov_mat = tf.linalg.tensor_diag(self.action_var) actor_input = keras.Input(shape=(obs_dim, )) actor_layer = layers.Dense( 64, activation="tanh", kernel_initializer=initializers.he_uniform())(actor_input) actor_layer = layers.Dense( 64, activation="tanh", kernel_initializer=initializers.he_uniform())(actor_layer) actor_output = layers.Dense(act_dim, activation="tanh")(actor_layer) self.actor = keras.Model(inputs=actor_input, outputs=actor_output) critic_input = keras.Input(shape=(obs_dim, )) critic_layer = layers.Dense( 64, activation="tanh", kernel_initializer=initializers.he_uniform())(critic_input) critic_layer = layers.Dense( 64, activation="tanh", kernel_initializer=initializers.he_uniform())(critic_layer) critic_output = layers.Dense(1)(critic_layer) self.critic = keras.Model(inputs=critic_input, outputs=critic_output) self.optimizer = optimizers.Adam(learning_rate=lr)
def __init__(self, obs_dim, act_dim): super().__init__() self.net = keras.Sequential([ layers.Dense(obs_dim + act_dim), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(1) ])
def get_mlp_model(): model = Sequential([ Flatten(input_shape=X_train_grayscale[0].shape, name='flatten'), Dense(units=128, activation=relu, kernel_initializer=he_uniform(), bias_initializer=he_uniform(), name='dense_1'), Dense(units=64, activation=relu, kernel_initializer=he_uniform(), bias_initializer=he_uniform(), name='dense_2'), Dense(units=32, activation=relu, kernel_initializer=he_uniform(), bias_initializer=he_uniform(), name='dense_3'), Dense(units=10, activation=softmax, kernel_initializer=he_uniform(), bias_initializer=he_uniform(), name='dense_output') ]) model.compile( optimizer=Adam(), loss=SparseCategoricalCrossentropy(), metrics=['accuracy']) return model
def build(self, hp): ###### Setup hyperparamaters dropout = hp.Float('dropout', 0.1, 0.6) bias_constant = hp.Float('bias', 0.01, 0.03) optimizer = hp.Choice('optimizer', values=['adam', 'sgd', 'rmsprop']) ###### Construct model # Initially, the network model is defined model = Sequential() # Add layers model.add( LSTM(units=self.lstm_units, input_shape=self.input_shape, return_sequences=True)) model.add(Dropout(dropout)) model.add( LSTM(units=int(self.lstm_units * 0.5), return_sequences=False)) model.add(Dropout(dropout)) model.add( Dense(features, activation='sigmoid', kernel_initializer=initializers.he_uniform(seed=0), bias_initializer=initializers.Constant(bias_constant))) # Compile model model.compile( optimizer=self.get_optimizer(hp, optimizer), loss='mse', ) return model
def __init__(self, training_config, architecture=None, name="StepCOVNetAudioModel"): model_input = Input(shape=training_config.audio_input_shape, name="audio_input", dtype=tf.float64) if architecture is None: # Channel reduction if training_config.dataset_config["NUM_CHANNELS"] > 1: vggish_input = TimeDistributed(Conv2D(1, (1, 1), strides=(1, 1), activation='linear', padding='same', kernel_initializer=he_uniform(42), bias_initializer=he_uniform(42), image_shape=model_input.shape[1:], data_format='channels_last', name='channel_reduction') )(model_input) else: vggish_input = model_input vggish_input = BatchNormalization()(vggish_input) vggish_model = PretrainedModels.vggish_model(input_shape=training_config.audio_input_shape, input_tensor=vggish_input, lookback=training_config.lookback) model_output = vggish_model(vggish_input) # VGGish model returns feature maps for avg/max pooling. Using LSTM for additional feature extraction. # Might be able to replace this with another method in the future model_output = Bidirectional( LSTM(128, return_sequences=False, kernel_initializer=glorot_uniform(42)) )(model_output) else: # TODO: Add support for existing audio models raise NotImplementedError("No support yet for existing architectures") super(AudioModel, self).__init__(model_input=model_input, model_output=model_output, name=name)
def apply_blstm(d_model=(2, 240, 2049), name='blstm', lstm_units=250): """ Apply BLSTM to the given input_tensor. :param input_tensor: Input of the model. :param output_name: (Optional) name of the output, default to 'output'. :param params: (Optional) dict of BLSTM parameters. :returns: Output tensor. """ inputm = tf.keras.Input(shape=d_model, name="input") inputt = tf.transpose(inputm, perm=[0, 2, 1, 3]) #slices = np.transpose(slices, (0, 2, 1, 3)) # 想要[batch, time, channel, freaquency] units = lstm_units kernel_initializer = he_uniform(seed=50) flatten_input = TimeDistributed(Flatten())((inputt)) def create_bidirectional(): return Bidirectional( CuDNNLSTM(units, kernel_initializer=kernel_initializer, return_sequences=True)) l1 = create_bidirectional()((flatten_input)) l2 = create_bidirectional()((l1)) l3 = create_bidirectional()((l2)) dense = TimeDistributed( Dense(int(flatten_input.shape[2]), activation='relu', kernel_initializer=kernel_initializer))((l3)) outputt = TimeDistributed(Reshape(inputt.shape[2:]), name='output')(dense) outputm = tf.transpose(outputt, perm=[0, 2, 1, 3]) return tf.keras.Model(inputs=inputm, outputs=outputm, name=name)
def _build_TCN_model(self) -> Model: """ build the TCN model # Returns: a keras Model object """ previous_layer = Input(self._input_shape, name='input_layer') input_layer = previous_layer for i in range(self._length): if i == self._length - 1: filters = self._input_shape[-1] kernel_initializer = 'zeros' activation = 'softmax' else: filters = self._filters kernel_initializer = he_uniform() activation = 'relu' previous_layer = Conv1D( filters=filters, kernel_size=self._kernel_size, padding='causal', # dilation_rate=2 ** i, use_bias=self._use_bias, kernel_initializer=kernel_initializer, name=f'conv1d_{i+1}')(previous_layer) previous_layer = Activation( activation, name=f'activation_{i+1}')(previous_layer) model = Model(inputs=input_layer, outputs=previous_layer) return model
def _set_default_initializer(self, kwargs): """ Sets the default initializer for convolution 2D and Seperable convolution 2D layers to Convolutional Aware or he_uniform. if a specific initializer has been passed in from the model plugin, then the specified initializer will be used rather than the default. Parameters ---------- kwargs: dict The keyword arguments for the current layer Returns ------- dict The keyword arguments for the current layer with the initializer updated to the select default value """ if "kernel_initializer" in kwargs: logger.debug("Using model specified initializer: %s", kwargs["kernel_initializer"]) return kwargs if self.use_convaware_init: default = ConvolutionAware() if self.first_run: # Indicate the Convolutional Aware should be calculated on first run default._init = True # pylint:disable=protected-access else: default = he_uniform() if kwargs.get("kernel_initializer", None) != default: kwargs["kernel_initializer"] = default logger.debug("Set default kernel_initializer to: %s", kwargs["kernel_initializer"]) return kwargs
def create_mlp_regression_model(num_units, num_layers, dropout, l2_penalty): """Creates a multilayer perceptron model of num_units per layer, with num_layers. Args: num_units (int): The number of units in each Dense layer (or the "width"). num_layers (int): The number of densely connected layers in the model (the "depth"). dropout (float): Rate of dropout between 0.0 and 1.0 for a dropout layer placed after every dense layer. If set to 0.0, the layer isn't added. l2_penalty (float): The l2 regularization factor for each dense layer. Smaller adds less to the loss function and affects the model less. More slows learning but can prevent overfitting. Returns: model (tensorflow.keras.Sequential): The Sequential keras model. """ model = Sequential() for i in range(num_layers): model.add( Dense( num_units, activation="relu", kernel_initializer=he_uniform(), kernel_regularizer=tf.keras.regularizers.l2(l2_penalty), )) if dropout > 0.0: model.add(Dropout(dropout)) model.add(Dense(1)) return model
def __init__(self): super(ConvBNReLU, self).__init__() self.conv = Conv2D(64, 3, padding='same', kernel_initializer=he_uniform()) self.bn = BatchNormalization() self.relu = ReLU()
def build_base_cnn(input_shape: Tuple[int], noisy: bool) -> Tuple: conv_layer = NoisyConv2D if noisy else Conv2D input_layer = Input(shape=input_shape) x = conv_layer(32, (8, 8), strides=(4, 4), activation='relu', kernel_initializer=he_uniform())(input_layer) x = conv_layer(64, (4, 4), strides=(2, 2), activation='relu', kernel_initializer=he_uniform())(x) x = conv_layer(64, (3, 3), strides=(1, 1), activation='relu', kernel_initializer=he_uniform())(x) x = Flatten()(x) return input_layer, x
def deep_neural_network(): n_in = layers.Input(shape=(13, )) n = layers.Dense(64, activation='elu', kernel_initializer=initializers.he_uniform())(n_in) n = layers.Dense(128, activation='elu', kernel_initializer=initializers.he_uniform())(n) n = layers.Dense(128, activation='elu', kernel_initializer=initializers.he_uniform())(n) n = layers.Dense(256, activation='elu', kernel_initializer=initializers.he_uniform())(n) n = layers.Dense(128, activation='elu', kernel_initializer=initializers.he_uniform())(n) n = layers.Dense(128, activation='elu', kernel_initializer=initializers.he_uniform())(n) n = layers.Dense(64, activation='elu', kernel_initializer=initializers.he_uniform())(n) n_out = layers.Dense(1, activation='linear')(n) model = Model(inputs=n_in, outputs=n_out) utils.plot_model(model, 'deep_neural_network.png', show_shapes=True) model = _fit_model(model, x_train, y_train, x_validation, y_validation) return model
def __init__(self, depth=8): super(DnCNNRN, self).__init__() # Initial conv + relu (same as in DnCNN) self.conv = Conv2D(64, 3, padding='same', kernel_initializer=he_uniform()) self.relu = ReLU() # Use 8 ResNet-inspired blocks (16 layers) self.rn_layers = [BasicBlock() for i in range(depth)] # Final conv self.conv_final = Conv2D(1, 3, padding='same', kernel_initializer=he_uniform())
def __init__(self, depth=17): super(DnCNN, self).__init__() # Initial conv + relu self.conv1 = Conv2D(64, 3, padding='same', activation='relu', kernel_initializer=he_uniform()) # Depth - 2 cnv+bn+relu layers self.conv_bn_relu = [ConvBNReLU() for i in range(depth - 2)] # final conv self.conv_final = Conv2D(1, 3, padding='same', kernel_initializer=he_uniform())
def conv_block(X_in, nf, k, dr): X = Conv2D(filters=nf, kernel_size=(k, k), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X_in) X = Activation('relu')(X) X = Dropout(dr)(X) X = Conv2D(filters=nf, kernel_size=(k, k), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = Activation('relu')(X) X = Dropout(dr)(X) return X
def get_kernel_initializer(self, initializer): if initializer == 'xavier': kernel = GlorotNormal(seed=42) print('[INFO] -- Inizializzazione pesi: xavier\n') elif initializer == 'he_uniform': kernel = he_uniform(seed=42) print('[INFO] -- Inizializzazione pesi: he_uniform\n') else: kernel = RandomNormal(mean=0., stddev=0.02, seed=42) print('[INFO] -- Inizializzazione pesi: random\n') return kernel
def __init__(self): # One ResNet block is: # conv1 - bn1 - relu # conv2 - bn2 # residual connection # relu super(BasicBlock, self).__init__() self.conv1 = Conv2D(64, 3, padding='same', kernel_initializer=he_uniform()) self.bn1 = BatchNormalization() self.relu = ReLU() self.conv2 = Conv2D(64, 3, padding='same', kernel_initializer=he_uniform()) self.bn2 = BatchNormalization()
def __init__(self, obs_dim, act_dim, lr): super(ActorCritic, self).__init__() self.obs_dim = obs_dim self.act_dim = act_dim self.actor = keras.Sequential( [ layers.Dense(obs_dim), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(act_dim, activation="softmax") ] ) self.critic = keras.Sequential( [ layers.Dense(obs_dim), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()), layers.Dense(1) ] ) self.optimizer = optimizers.Adam(learning_rate=lr)
def create_mode(model_type,window_size): input_signals = Input(shape=(window_size,5)) if(model_type == "LINEAR"): x = Dense(1,activation = sigmoid)(input_signals) elif (model_type == "PLOY"): x = Dense(30,activation = sigmoid)(input_signals) x = Dense(5,activation = sigmoid)(x) x = Dense(1,activation = sigmoid)(x) elif (model_type == "LSTM"): x = LSTM(window_size,recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform())(input_signals) elif (model_type == "BiLSTM"): x = Bidirectional(LSTM(int(window_size/2),recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform()))(input_signals) elif (model_type == "CNNLSTM"): x = Conv1D(4, 256, activation='relu',input_shape=(window_size,5),padding = "same")(input_signals) x = Conv1D(8, 128, activation='relu',padding = "same")(x) x = Conv1D(16, 64, activation='relu',padding = "same")(x) x = Conv1D(64, 32, activation='relu',padding = "same")(x) x = Conv1D(128, 16, activation='relu',padding = "same")(x) x = LSTM(window_size,recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform())(x) else: print("Not a supported model") exit(0) model = Model(input_signals, x) return model
def create_str_to_initialiser_converter(self): """Creates a dictionary which converts strings to initialiser""" str_to_initialiser_converter = { "glorot_normal": initializers.glorot_normal, "glorot_uniform": initializers.glorot_uniform, "xavier_normal": initializers.glorot_normal, "xavier_uniform": initializers.glorot_uniform, "xavier": initializers.glorot_uniform, "he_normal": initializers.he_normal(), "he_uniform": initializers.he_uniform(), "lecun_normal": initializers.lecun_normal(), "lecun_uniform": initializers.lecun_uniform(), "truncated_normal": initializers.TruncatedNormal, "variance_scaling": initializers.VarianceScaling, "default": initializers.glorot_uniform } return str_to_initialiser_converter
def baseline_model(self): initializer = initializers.he_uniform() self.clf = Sequential() self.clf.add(Dense(128, input_dim=32, kernel_initializer=initializer)) self.clf.add(LeakyReLU()) self.clf.add(Dense(512, kernel_initializer=initializer)) self.clf.add(LeakyReLU()) self.clf.add(Dropout(0.1)) self.clf.add(Dense(256, kernel_initializer=initializer)) self.clf.add(LeakyReLU()) self.clf.add(Dropout(0.1)) self.clf.add(Dense(6, activation='softmax')) # Final Layer using Softmax optimizer = optimizers.Adamax(0.0008) self.clf.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) return self.clf
def get_model(input_shape): model = Sequential([ Dense(units=64, input_shape=input_shape, kernel_initializer=he_uniform(), bias_initializer=ones(), activation=relu), Dense(units=128, activation=relu), Dense(units=128, activation=relu), Dense(units=128, activation=relu), Dense(units=128, activation=relu), Dense(units=64, activation=relu), Dense(units=64, activation=relu), Dense(units=64, activation=relu), Dense(units=64, activation=relu), Dense(units=3, activation=softmax) ]) return model
def __init__(self, learning_rate, product_features): """ Args: learning_rate: product_features: """ self.lr = learning_rate self.prod_feat = product_features self.ae_metrics = ['mse', 'cosine_similarity'] self.r_metrics = ['mse'] self.loss = 'mae' self.EPOCHS = 500 self.BATCH_SIZE = 64 self.act_func_dict = [relu, tanh, selu, linear, LeakyReLU] self.optimizer_dict = ['adam', 'nadam', 'rmsprop'] self.init_dict = [he_normal(1), he_uniform(1)] self.rnn_kind_dict = ['SimpleRNN', 'LSTM', 'GRU'] self.enc_dim = None
def convolution_block(self, x, name, kernel, channels_out, is_training, stride=1, max_pool=False, activate_with_relu=True, padding='VALID'): with tf.variable_scope(name): weights = tf.get_variable( name='W', shape=[kernel, kernel, x.shape[-1], channels_out], dtype=tf.float32, initializer=he_normal()) b = tf.get_variable(name='b', shape=[channels_out], dtype=tf.float32, initializer=he_uniform()) x = tf.nn.conv2d(input=x, filter=weights, strides=[1, stride, stride, 1], padding=padding) x = tf.layers.batch_normalization(inputs=x, axis=-1, momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True, scale=True, training=is_training, fused=True) x += b if activate_with_relu: x = tf.nn.relu(x + b) if max_pool: x = tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=padding) self.layer_print(name=name, w=weights, b=b, output=x) return x
def get_initializer(init_name='truncate_norm', init_stddev=0.05, seed=1024): if init_name in ('truncate_norm', 'truncate_normal'): return TruncatedNormal(stddev=init_stddev, seed=seed) elif init_name in ('glorot_norm', 'glorot_normal', 'xavier_norm', 'xavier_normal'): return glorot_normal(seed=seed) elif init_name in ('he_norm', 'he_normal'): return he_normal(seed) elif init_name in ('trucate_uniform'): return TruncatedNormal(stddev=init_stddev) elif init_name in ('glorot_uniform'): return glorot_uniform() elif init_name in ('he_uniform'): return he_uniform() elif init_name in ('zero', 'zeros'): return Zeros() elif init_name in ('ones', 'one'): return Ones() else: raise ValueError('not support {} initializer'.format(init_name))
def get_regularized_model(input_shape, dropout_rate, weight_decay): model = Sequential([ Dense(units=64, input_shape=input_shape, kernel_initializer=he_uniform(), bias_initializer=ones(), activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)), Dropout(rate=dropout_rate), Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)), BatchNormalization(), Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)), Dropout(rate=dropout_rate), Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)), Dense(units=3, activation=softmax) ]) return model
def embed_functions(path_to_output, path_to_models, path_to_histories=None, autoencoder=False, dimension=256, epochs=150, batch_size=2048): """Function projecting functional signatures of premises into a lower dimensional space. Arguments: path_to_output - path to premise count functional signatures autoencoder - if True, then autoencoder embedding will be the method of projection, dimension - dimension of projection, epochs - number of training epochs for the embedding model, batch_size - batch size for the training of the embedding model, save_model - if True, then model is saved to path_to_current_working_directory/models/embedding_model.h5, save_histories - if True then training history is saved to path_to_current_working_directory/histories/embedding_model.pickle, """ # Get functional signatures output_tensor = np.load(path_to_output, mmap_mode='r') # Number of unique functions num_fun = output_tensor.shape[-1] # Define model parameters if autoencoder: output_tensor = output_tensor / np.max(output_tensor, axis=-1) input_tensor = output_tensor activation = 'sigmoid' loss = 'mse' else: input_tensor = np.identity(num_fun) activation = 'softmax' loss = 'categorical_crossentropy' # Embedding model model_input = Input(shape=(num_fun, ), name='input') embedding = Dense(dimension, kernel_initializer=he_uniform(), activation='tanh', name='embedding')(model_input) model_output = Dense(num_fun, kernel_initializer=he_uniform(), activation=activation, name='output')(embedding) model = Model(model_input, model_output, name='encoder_decoder') model.summary() # Compile model model.compile(optimizer=RMSprop(decay=1e-8), loss=loss, metrics=['accuracy']) # Train model history = model.fit(input_tensor, output_tensor, epochs=epochs, batch_size=batch_size, shuffle=True) # Save history if path_to_histories is not None: with open( os.path.join(path_to_histories, 'embedding_model_history.pickle'), 'wb') as dictionary: pickle.dump(history.history, dictionary, protocol=pickle.HIGHEST_PROTOCOL) # Save trained model model.save(os.path.join(path_to_models, 'embedding_model.h5'))
def ResUNet53D(input_shape=(96, 96, 125), do_rate=0.5, filt0_k12=3, filt0_k3=8): """ Implementation of a 5-layer U-Net model with residual blocks for the reconstruction of power Doppler images from sparse compound data. This model includes an initial Conv3D block that extracts spatiotemporal features. Residual blocks are made of Conv2D + ReLU activations. Downsampling is implemented with MaxPooling2D. Upsampling is implemented with Conv2DTranspose. Dropout used on all residual blocks. Arguments: input_shape -- dimensions of compound dataset do_rate -- dropout factor filt0_k12 -- first and second kernel dimensions for first Conv3D layer filt0_k3 -- third kernel dimension of first Conv3D layer Returns: model -- a Model() instance in Keras """ def res_block(X_in, nf, k, dr): X = Conv2D(filters=nf, kernel_size=(k, k), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X_in) X = Activation('relu')(X) X = Dropout(dr)(X) X = Conv2D(filters=nf, kernel_size=(k, k), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = Activation('relu')(X) X = Dropout(dr)(X) X_out = Add()([X, X_in]) return X_out # Filter kernel size used for convolutional layers filt_k = 3 # Number of filters for respective layers F0 = 4 F1 = 32 F2 = 64 F3 = 128 F4 = 256 F5 = 512 # Input layer X_input = Input(input_shape, dtype=tf.float32, name="input") # Reshape input to 4-D X = Reshape((input_shape[0], input_shape[1], input_shape[2], 1))(X_input) # Conv3D layer X = Conv3D(filters=F0, kernel_size=(filt0_k12, filt0_k12, filt0_k3), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = Activation('relu')(X) # Reshape input to 3-D X = Reshape((input_shape[0], input_shape[1], input_shape[2] * F0))(X) # Encoder L1 X = Conv2D(filters=F1, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F1, filt_k, do_rate) X_skip1 = X X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X) # Encoder L2 X = Conv2D(filters=F2, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F2, filt_k, do_rate) X_skip2 = X X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X) # Encoder L3 X = Conv2D(filters=F3, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F3, filt_k, do_rate) X_skip3 = X X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X) # Encoder L4 X = Conv2D(filters=F4, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F4, filt_k, do_rate) X_skip4 = X X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X) # Encoder L5 X = Conv2D(filters=F5, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F5, filt_k, do_rate) X = Conv2DTranspose(filters=F4, kernel_size=(filt_k, filt_k), strides=(2, 2), padding='same')(X) X = Activation('relu')(X) # Decoder L4 X = Concatenate(axis=3)([X, X_skip4]) X = Conv2D(filters=F4, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F4, filt_k, do_rate) X = Conv2DTranspose(filters=F3, kernel_size=(filt_k, filt_k), strides=(2, 2), padding='same')(X) X = Activation('relu')(X) # Decoder L3 X = Concatenate(axis=3)([X, X_skip3]) X = Conv2D(filters=F3, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F3, filt_k, do_rate) X = Conv2DTranspose(filters=F2, kernel_size=(filt_k, filt_k), strides=(2, 2), padding='same')(X) X = Activation('relu')(X) # Decoder L2 X = Concatenate(axis=3)([X, X_skip2]) X = Conv2D(filters=F2, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F2, filt_k, do_rate) X = Conv2DTranspose(filters=F1, kernel_size=(filt_k, filt_k), strides=(2, 2), padding='same')(X) X = Activation('relu')(X) # Decoder L1 X = Concatenate(axis=3)([X, X_skip1]) X = Conv2D(filters=F1, kernel_size=(1, 1), strides=1, padding='same', kernel_initializer=he_uniform(seed=0))(X) X = res_block(X, F1, filt_k, do_rate) # Output layer X = Conv2D(filters=1, kernel_size=(1, 1), strides=1, padding='same')(X) # Reshape output X = Reshape((input_shape[0], input_shape[1]))(X) # Create model model = Model(inputs=X_input, outputs=X, name='ResUNet53D') return model