def call(self, inputs, **kwargs): states_encoder = inputs[0] states_decoder = inputs[1] # (0) adjust the size of encoder state to the size of decoder state if isinstance(self.n_state, int): # Key Vector와 Value Vector을 다르게 둚 key_vector = self.key_dense(states_encoder) val_vector = self.val_dense(states_encoder) else: key_vector = states_encoder val_vector = states_encoder # (1) Calculate Score expanded_states_encoder = key_vector[:, None, ...] # >>> (batch size, 1, length of encoder sequence, num hidden) expanded_states_decoder = states_decoder[..., None, :] # >>> (batch size, length of decoder sequence, 1, num hidden) score = K.sum(expanded_states_encoder * expanded_states_decoder, axis=-1) # >>> (batch size, length of decoder input, length of encoder input) # (2) Normalize score attention = Softmax(axis=-1, name='attention')(score) # (3) Calculate Context Vector expanded_val_vector = val_vector[:, None, ...] context = K.sum(expanded_val_vector * attention[..., None], axis=2) # >>> (batch size, length of decoder input, num hidden) return context, attention
def attach_multibox_head(network, source_layer_names, num_priors=4, num_classes=10, activation='softmax'): heads = [] for idx, layer_name in enumerate(source_layer_names): source_layer = network.get_layer(layer_name).output # Classification clf = Conv2D(num_priors * num_classes, (3, 3), padding='same', name=f'clf_head{idx}_logit')(source_layer) clf = Reshape((-1, num_classes), name=f'clf_head{idx}_reshape')(clf) if activation == 'softmax': clf = Softmax(axis=-1, name=f'clf_head{idx}')(clf) elif activation == 'sigmoid': clf = sigmoid(clf) else: raise ValueError('activation은 {softmax,sigmoid}중에서 되어야 합니다.') # Localization loc = Conv2D(num_priors * 4, (3,3), padding='same', name=f'loc_head{idx}')(source_layer) loc = Reshape((-1,4), name=f'loc_head{idx}_reshape')(loc) head = Concatenate(axis=-1, name=f'head{idx}')([clf, loc]) heads.append(head) if len(heads) > 1: predictions = Concatenate(axis=1, name='predictions')(heads) else: predictions = K.identity(heads[0],name='predictions') return predictions
def create_model(input_size, filters, c=10 ** -4): l2 = regularizers.l2(c) input = Input(shape=(FOUR, FOUR, FOUR, input_size)) conv_1 = normalized_relu(line_convolution(input, filters, l2)) conv_2 = normalized_relu(line_convolution(conv_1, filters, l2)) conv_3 = normalized_relu(line_convolution(conv_2, filters, l2)) last_conv = Conv3D(filters, 1, kernel_regularizer=l2)(conv_3) collapse_play = normalized_relu(Conv3D(filters // 2, (1, 1, 4), kernel_regularizer=l2)(last_conv)) squash_play = normalized_relu(Conv3D(3, 1, kernel_regularizer=l2)(collapse_play)) flatten_play = Flatten()(squash_play) dense_play = Dense(16, activation='relu', kernel_regularizer=l2)(flatten_play) sigmoid_play = Dense(16, activation='sigmoid', kernel_regularizer=l2)(dense_play) output_play = Softmax()(sigmoid_play) collapse_win = normalized_relu(Conv3D(3, (1, 1, 4), kernel_regularizer=l2)(last_conv)) flatten_win = Flatten()(collapse_win) dense_win = Dense(16, activation='relu', kernel_regularizer=l2)(flatten_win) output_win = Dense(1, activation='tanh', kernel_regularizer=l2)(dense_win) model = Model(inputs=input, outputs=[output_play, output_win]) optimizer = Adam() metics = {'softmax': 'categorical_accuracy', 'dense_3': 'mae'} model.compile(optimizer, ['categorical_crossentropy', 'mse'], metrics=metics) return model
def pnet(self, input_shape=None): if input_shape is None: input_shape = (None, None, 3) net = Input(input_shape) pnet_layer = Conv2D(10, (3, 3), strides=(1, 1), padding='valid')(net) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_layer = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(pnet_layer) pnet_layer = Conv2D(16, (3, 3), strides=(1, 1), padding='valid')(pnet_layer) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_layer = Conv2D(32, (3, 3), strides=(1, 1), padding='valid')(pnet_layer) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_out1 = Conv2D(2, (1, 1), strides=(1, 1))(pnet_layer) pnet_out1 = Softmax(axis=3)(pnet_out1) pnet_out2 = Conv2D(4, (1, 1), strides=(1, 1))(pnet_layer) p_net = Model(net, [pnet_out2, pnet_out1]) return p_net
def rnet(self, input_shape=None): if input_shape is None: input_shape = (24, 24, 3) net = Input(input_shape) rnet_layer = Conv2D(28, (3, 3), strides=(1, 1), padding='valid')(net) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(rnet_layer) rnet_layer = Conv2D(48, (3, 3), strides=(1, 1), padding='valid')(rnet_layer) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='valid')(rnet_layer) rnet_layer = Conv2D(64, (2, 2), strides=(1, 1), padding='valid')(rnet_layer) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = Flatten()(rnet_layer) rnet_layer = Dense(128)(rnet_layer) rnet_layer = PReLU()(rnet_layer) rnet_out1 = Dense(2)(rnet_layer) rnet_out1 = Softmax(axis=1)(rnet_out1) rnet_out2 = Dense(4)(rnet_layer) rnet = Model(net, [rnet_out2, rnet_out1]) return rnet
def onet(self, input_shape=None): if input_shape is None: input_shape = (48, 48, 3) net = Input(input_shape) onet_layer = Conv2D(32, (3, 3), strides=(1, 1), padding='valid')(net) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(onet_layer) onet_layer = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='valid')(onet_layer) onet_layer = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(onet_layer) onet_layer = Conv2D(128, (2, 2), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = Flatten()(onet_layer) onet_layer = Dense(256)(onet_layer) onet_layer = PReLU()(onet_layer) onet_out1 = Dense(2)(onet_layer) onet_out1 = Softmax(axis=1)(onet_out1) onet_out2 = Dense(4)(onet_layer) onet_out3 = Dense(10)(onet_layer) onet = Model(net, [onet_out2, onet_out3, onet_out1]) return onet
def _build_model(self): sequence_source_id = Input([900], name='source_id', dtype=tf.int32) sequence_target_id = Input([200], name='target_id', dtype=tf.int32) sequence_target_mask = Input([200], name='target_mask', dtype=tf.int32) self.encoder = Encoder(self.vocab_size, self.emb_dim, self.dropout_keep, self.encode_dim, self.n_agents, self.encoder_layers_num, self.batch_size) self.decode = Decoder(self.mode, self.attention_units, self.encode_dim, self.decode_len, self.vocab_size, self.emb_dim, self.batch_size, self.word2id) self.softmax = Softmax(axis=-1) encoder_outputs = self.encoder(sequence_source_id) # encoder_outputs = Concatenate(encoder_outputs, axis=1) decoder_output = self.decode(sequence_target_id, encoder_outputs) print('##########', encoder_outputs) print('##########', decoder_output.shape) # decoder_output = Lambda(lambda x:tf.unstack(x))(decoder_output) vocab_dists = self.softmax(decoder_output) self.loss = Seq2SeqLoss(sequence_target_mask, self.batch_size) model = Model([sequence_source_id, sequence_target_id], vocab_dists) loss = losses(self.decode_len, sequence_target_mask, self.batch_size, vocab_dists, sequence_target_id) model.add_loss(loss) model.compile(Adam(self.learning_rate)) return model
def _predict_masks(self, bert_text: str) -> ([str], float): ''' Predict masked tokens in bert_text :param bert_text: input sequence for bert :return: Top k prediction for input sequence ''' tokenized_text = tokenizer.tokenize('[CLS] ' + bert_text + '. [SEP]') input_ids = tokenizer.convert_tokens_to_ids(tokenized_text) outputs = MODEL(tf.convert_to_tensor([input_ids])) mask_idx = tokenized_text.index(MASK) top_k_output = tf.math.top_k(outputs.logits[0][mask_idx], k=50, sorted=True, name=None) probabilities = Softmax()(top_k_output.values.numpy()).numpy() top_k_pred = [([word], prob) for word, prob in zip( tokenizer.convert_ids_to_tokens(top_k_output.indices), probabilities)] if tokenized_text.count(MASK) > 1: for top_k in top_k_pred.copy(): top_k_pred.remove(top_k) pred = top_k[0] pred_for_last_mask = pred[-1] results_of_next_pred = self._predict_masks( bert_text.replace(MASK, pred_for_last_mask, 1)) for pred_for_next_mask, prob in results_of_next_pred: top_k_pred.append((pred + pred_for_next_mask, prob)) return top_k_pred return top_k_pred
def make_cnn_model( input_shape: Tuple[int, int], conv_blocks: Sequence[Sequence[int]], dense_size: int, output_size: int, dropout: float, ) -> Sequential: model = Sequential() model.add(Conv2D(conv_blocks[0][0], (3, 3), activation="relu", input_shape=(*input_shape, 3))) is_first = True for conv_sizes in conv_blocks: for size in conv_sizes: if is_first: is_first = False continue model.add(Conv2D(size, (3, 3), activation="relu")) model.add(MaxPooling2D()) model.add(Flatten()) model.add(Dense(dense_size)) model.add(Dropout(dropout)) model.add(Dense(output_size)) model.add(Softmax()) return model
def _get_3_classes_model(inputs): """Build Unet architecture that return a 3-classes prediction. Parameters ---------- inputs : tensorflow.keras.Input object Input layer with shape (B, H, W, 1) or (H, W, 1). Returns ------- output : tensorflow.keras.layers object Output layer (softmax) with shape (B, H, W, 3) or (H, W, 3). """ # compute feature map features_core = EncoderDecoder(name="encoder_decoder")( inputs) # (B, H, W, 32) # compute 3-classes output features_3_classes = SameConv(filters=3, kernel_size=(1, 1), activation="linear", name="final_conv")( features_core) # (B, H, W, 3) output = Softmax(axis=-1, name="label_3")(features_3_classes) # (B, H, W, 3) return output
def build_model(self, input_shape: Tuple[int, int, int]) -> Model: x = Input(shape=input_shape, name="input") sub_sampling_out, sub_sampling_stack = self.__build_sub_sampling_stack( x=x) filter_extraction_conv = Conv2D(filters=1024, kernel_size=(3, 3), padding="same", name="filter_extraction_conv", activation="relu")(sub_sampling_out) filter_extraction_conv_bn = BatchNormalization( name=f"filter_extraction_conv_bn")(filter_extraction_conv) up_sampling_input = Conv2D( filters=512, kernel_size=(3, 3), padding="same", name="up_sampling_input", activation="relu")(filter_extraction_conv_bn) up_sampling_output = self.__build_up_sampling_stack( x=up_sampling_input, sub_sampling_stack=sub_sampling_stack) out = Conv2D(filters=self._num_classes, kernel_size=(1, 1), padding="same", name="output")(up_sampling_output) flatten_out = Softmax(name="output_soft_max")(out) return Model(x, flatten_out)
def semantic_prediction(semantic_names, semantic_features, target_level=0, input_target=None, n_filters=64, n_dense=64, ndim=2, n_classes=3, semantic_id=0): """Creates the prediction head from a list of semantic features Args: semantic_names (list): A list of the names of the semantic feature layers semantic_features (list): A list of semantic features NOTE: The semantic_names and semantic features should be in decreasing order e.g. [Q6, Q5, Q4, ...] target_level (int, optional): Defaults to 0. The level we need to reach. Performs 2x upsampling until we're at the target level input_target (tensor, optional): Defaults to None. Tensor with the input image. n_dense (int, optional): Defaults to 256. The number of filters for dense layers. n_classes (int, optional): Defaults to 3. The number of classes to be predicted. semantic_id (int): Defaults to 0. An number to name the final layer. Allows for multiple semantic heads. Returns: tensor: The softmax prediction for the semantic segmentation head Raises: ValueError: ndim is not 2 or 3 """ acceptable_ndims = [2, 3] if ndim not in acceptable_ndims: raise ValueError('Only 2 and 3 dimensional networks are supported') if K.image_data_format() == 'channels_first': channel_axis = 1 else: channel_axis = -1 # Add all the semantic layers semantic_sum = semantic_features[0] for semantic_feature in semantic_features[1:]: semantic_sum = Add()([semantic_sum, semantic_feature]) # Final upsampling min_level = int(re.findall(r'\d+', semantic_names[-1])[0]) n_upsample = min_level - target_level x = semantic_upsample(semantic_sum, n_upsample, target=input_target) # First tensor product x = TensorProduct(n_dense)(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) # Apply tensor product and softmax layer x = TensorProduct(n_classes)(x) x = Softmax(axis=channel_axis, name='semantic_' + str(semantic_id))(x) return x
def caltech_pyramid_ensemble(input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a caltech network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ output_list = [] inputs = create_inputs(input_shape, input_tensor) # Submodel Strong. submodel_strong = caltech_pyramid_ensemble_submodel_strong(input_shape, input_tensor, n_classes, weights_path) outputs_submodel_strong = submodel_strong.output # Submodel Weak 1. submodel_weak1 = caltech_pyramid_ensemble_submodel_weak1(input_shape, input_tensor, n_classes, weights_path) outputs_submodel_weak1 = Dense(61, name='outputs_submodel_weak1')(submodel_weak1.layers[-1]) # Average the predictions for the first half classes. averaged_first_half_classes = Average(name='averaged_first_half_classes')( [ Crop(1, 0, 61)(outputs_submodel_strong), outputs_submodel_weak1 ] ) output_list.append(averaged_first_half_classes) # Submodel Weak 2. # Block1. submodel_weak2 = caltech_pyramid_ensemble_submodel_weak2(input_shape, input_tensor, n_classes, weights_path) outputs_submodel_weak2 = Dense(61, name='outputs_submodel_weak2')(submodel_weak2.layers[-1]) # Average the predictions for the last half classes. averaged_last_half_classes = Average(name='averaged_last_half_classes')( [ Crop(1, 61, 102)(outputs_submodel_strong), outputs_submodel_weak2 ] ) output_list.append(averaged_last_half_classes) # Concatenate all class predictions together. outputs = Concatenate(name='output')(output_list) outputs = Softmax(name='output_softmax')(outputs) # Create model. model = Model(inputs, outputs, name='caltech_pyramid_ensemble') # Load weights, if they exist. load_weights(weights_path, model) return model
def create_classifier_layers(self,add_dropout=True): self.model.add(Flatten()) self.model.add(Dense(units=100)) self.model.add(self.get_activation()) if add_dropout: self.model.add(Dropout(0.3)) self.model.add(Dense(units=CLASS)) self.model.add(Softmax()) return
def attach_multibox_head(network, source_layer_names, num_priors=4, num_classes=11, activation='softmax'): # 10->11 heads = [] batch_size = 64 # OpenCV에서 인식을못해서 하드코딩한다 reshape를 인식못한다 for idx, layer_name in enumerate(source_layer_names): source_layer = network.get_layer(layer_name).output # OpenCV Loading Error # "Can't create layer \"loc_head2_reshape_2/Shape\" of type \"Shape\"" # 조치 : class개수를 10에서 11로 바꿔줌 w = source_layer.get_shape().as_list()[1] h = source_layer.get_shape().as_list()[2] print("w : ", w) print("h : ", h) print("num_priors : ", num_priors) # Classification clf = Conv2D(num_priors * num_classes, (3, 3), padding='same', name=f'clf_head{idx}_logit')(source_layer) print("clf shape입니다 : ", clf.shape) clf = tf.reshape(clf, shape=(batch_size, w * h * num_priors, num_classes), name=f'clf_head{idx}_reshape') # clf = Reshape((w*h*num_priors, num_classes), name=f'clf_head{idx}_reshape')(clf) # (-1, num_classes) # w*h*num_priors print("clf의 reshape 후입니다 : ", clf.shape) if activation == 'softmax': clf = Softmax(axis=-1, name=f'clf_head{idx}')(clf) elif activation == 'sigmoid': clf = sigmoid(clf) else: raise ValueError('activation은 {softmax,sigmoid}중에서 되어야 합니다.') # Localization loc = Conv2D(num_priors * 4, (3, 3), padding='same', name=f'loc_head{idx}')(source_layer) print("loc의 shape입니다 : ", loc.shape) loc = tf.reshape(loc, shape=(batch_size, w * h * num_priors, 4), name='loc_head{}_reshape'.format(idx)) # loc = Reshape((w*h*num_priors, 4), name=f'loc_head{idx}_reshape')(loc) #Reshape((-1, 4), print("loc의 reshape 후입니다 : ", loc.shape) head = Concatenate(axis=-1, name=f'head{idx}')([clf, loc]) heads.append(head) if len(heads) > 1: predictions = Concatenate(axis=1, name='predictions')(heads) else: predictions = K.identity(heads[0], name='predictions') return predictions
def __init__(self, w3, dropout_rate): # w3 are the window sizes of the convolutions, hyperparameters super().__init__() self.logger = logging.getLogger(__name__) self.conv1 = TimeDistributed( Conv1D(1, w3, activation=None, padding='causal', name='atn_weight_conv1')) self.dropout = Dropout(dropout_rate) self.softmax = TimeDistributed(Softmax(name='atn_weight_softmax'))
def omniglot_pyramid_ensemble(input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a omniglot network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ inputs = create_inputs(input_shape, input_tensor) # Generate Submodels. submodel_strong = omniglot_pyramid_ensemble_submodel_strong( input_shape, input_tensor, n_classes, weights_path) submodel_weak1 = omniglot_pyramid_ensemble_submodel_weak1( input_shape, input_tensor, 3, weights_path) submodel_weak2 = omniglot_pyramid_ensemble_submodel_weak2( input_shape, input_tensor, 3, weights_path) # Get their outputs. outputs_submodel_strong = submodel_strong.output outputs_submodel_weak1 = submodel_weak1.output outputs_submodel_weak2 = submodel_weak2.output # Average classes. first_classes = Average(name='averaged_first_classes')([ Crop(1, 0, 812, name='first_classes_submodel_strong')(outputs_submodel_strong), Crop(1, 0, 812, name='first_classes_submodel_weak1')(outputs_submodel_weak1) ]) last_classes = Average(name='averaged_last_classes')([ Crop(1, 812, 1623, name='last_classes_submodel_strong')(outputs_submodel_strong), Crop(1, 0, 811, name='last_classes_submodel_weak2')(outputs_submodel_weak2) ]) # Concatenate all class predictions together. outputs = Concatenate(name='output')([first_classes, last_classes]) outputs = Softmax(name='output_softmax')(outputs) # Create model. model = Model(inputs, outputs, name='omniglot_pyramid_ensemble') # Load weights, if they exist. load_weights(weights_path, model) return model
def heatmap_loss(target_mask, heatmap_3d): X = 2 Y = 3 Z = 4 dims = heatmap_3d.shape # batches, joints, x, y, z batch_size = dims[0] nb_joints = dims[1] heatmap_ = tf.reshape(heatmap_3d, [batch_size, nb_joints, -1]) heatmap_ = Softmax(axis=2)(heatmap_) target_mask = tf.reshape(target_mask, [batch_size, nb_joints, -1]) return binary_crossentropy(target_mask, heatmap_)
def make_transfer_learning_model( input_shape: Tuple[int, int], n_classes: int, model_factory: Callable[..., Model], dropout: float, dense_size: int, ) -> Sequential: input_shape = (*input_shape, 3) base_model: Model = model_factory(weights="imagenet", input_shape=input_shape, include_top=False) return Sequential( [ InputLayer(input_shape), base_model, Flatten(), Dense(dense_size, activation="relu"), Dropout(dropout), Dense(n_classes), Softmax(), ] )
def __init__(self): super(Model, self).__init__() self.gru_1 = GRU(hidden_state, return_sequences=True, input_shape=(testing_samples_per_video, feature_field), dropout=.5) # recurrent layer # self.gru_2 = GRU(hidden_state, return_sequences=True) self.attention_layer = Dense(1) # gets attention weight for time step self.attention_normalizer = Softmax( axis=1 ) # normalizes the 3d tensor to give weight for each time step self.FC_1 = Dense(hidden_state // 2, activation='selu') # recurrent_fusion_model.add(BatchNormalization()) # self.FC_2 = Dense(hidden_state // 4, activation='selu') # self.BN_1 = BatchNormalization() self.classification_layer = Dense(num_actions, activation='softmax')
def __init__(self, n_classes): """ Last layer of the model outputting the probabilities for each class. Performs a SeparableConv2D 1x1, BN, GlobalAveragePooling2D, FC, Dropout, Softmax. Arguments: n_classes: output size. """ super(Classifier, self).__init__(name='classifier') self.conv = SeparableConv2D(filters=1280, kernel_size=(1, 1), kernel_regularizer=l2(WEIGHT_DECAY), activation='relu') self.bn = BatchNormalization() self.avg_pool = GlobalAveragePooling2D() self.fc = Dense(units=n_classes) self.droput = Dropout(0.2) self.softmax = Softmax()
def self_attn_block(inp, n_c, squeeze_factor=8): """ GAN Self Attention Block Code borrows from https://github.com/taki0112/Self-Attention-GAN-Tensorflow """ msg = "Input channels must be >= {}, recieved nc={}".format( squeeze_factor, n_c) assert n_c // squeeze_factor > 0, msg var_x = inp shape_x = var_x.get_shape().as_list() var_f = Conv2D( n_c // squeeze_factor, 1, kernel_regularizer=regularizers.l2(GAN22_REGULARIZER))(var_x) var_g = Conv2D( n_c // squeeze_factor, 1, kernel_regularizer=regularizers.l2(GAN22_REGULARIZER))(var_x) var_h = Conv2D( n_c, 1, kernel_regularizer=regularizers.l2(GAN22_REGULARIZER))(var_x) shape_f = var_f.get_shape().as_list() shape_g = var_g.get_shape().as_list() shape_h = var_h.get_shape().as_list() flat_f = Reshape((-1, shape_f[-1]))(var_f) flat_g = Reshape((-1, shape_g[-1]))(var_g) flat_h = Reshape((-1, shape_h[-1]))(var_h) var_s = Lambda(lambda var_x: K.batch_dot(var_x[0], Permute((2, 1))(var_x[1])))( [flat_g, flat_f]) beta = Softmax(axis=-1)(var_s) var_o = Lambda(lambda var_x: K.batch_dot(var_x[0], var_x[1]))( [beta, flat_h]) var_o = Reshape(shape_x[1:])(var_o) var_o = Scale()(var_o) out = add([var_o, inp]) return out
def __init__(self, hyperparameters: Dict[str, any]): super().__init__() self.logger = logging.getLogger(__name__) vocabulary_size = hyperparameters['vocabulary_size'] embedding_dim = hyperparameters['embedding_dim'] max_chunk_length = hyperparameters['max_chunk_length'] dropout_rate = hyperparameters['dropout_rate'] w1 = hyperparameters['w1'] w2 = hyperparameters['w2'] w3 = hyperparameters['w3'] k1 = hyperparameters['k1'] k2 = hyperparameters['k2'] self.embedding_layer = TimeDistributed( Embedding(vocabulary_size, embedding_dim, mask_zero=True, input_length=max_chunk_length, name='cnn_att_embedding')) self.gru_layer = TimeDistributed( GRU( k2, return_state=True, return_sequences=True, # recurrent_dropout=dropout_rate, name='cnn_att_gru')) self.attention_feature_layer = AttentionFeatures( k1, w1, k2, w2, dropout_rate) self.attention_weights_alpha_layer = AttentionWeights(w3, dropout_rate) self.attention_weights_kappa_layer = AttentionWeights(w3, dropout_rate) self.lambda_conv_layer = TimeDistributed( Conv1D(1, w3, activation='sigmoid')) self.max_layer = TimeDistributed(MaxPooling1D(pool_size=1, strides=50)) # dense layer: E * n_t + bias, mapped to probability of words embedding self.bias = self.add_weight(name='bias', shape=[ vocabulary_size, ], initializer='zeros', trainable=True) self.softmax_layer = TimeDistributed(Softmax())
def prediction_from_heatmap(self, heatmaps): X = 2 Y = 3 Z = 4 dims = heatmaps.shape # batches, joints, x, y, z batch_size = dims[0] nb_joints = dims[1] max_x = tf.cast(dims[X], dtype=tf.float32) max_y = tf.cast(dims[Y], dtype=tf.float32) max_z = tf.cast(dims[Z], dtype=tf.float32) # reshape into batches, joints, location heatmaps = tf.reshape( heatmaps, [batch_size, nb_joints, dims[X] * dims[Y] * dims[Z]]) # apply softmax on locations heatmaps = Softmax(axis=2)(heatmaps) # reshape back to batches, joints,x,y,z heatmaps = tf.reshape(heatmaps, dims) # reduce probability on each axis prob_x = tf.reduce_sum(heatmaps, axis=(Y, Z)) prob_y = tf.reduce_sum(heatmaps, axis=(X, Z)) prob_z = tf.reduce_sum(heatmaps, axis=(X, Y)) estimate_x = prob_x * tf.range(0, max_x) estimate_y = prob_y * tf.range(0, max_y) estimate_z = prob_z * tf.range(0, max_z) estimate_x = tf.reduce_sum(estimate_x, axis=2, keepdims=True) estimate_y = tf.reduce_sum(estimate_y, axis=2, keepdims=True) estimate_z = tf.reduce_sum(estimate_z, axis=2, keepdims=True) # normalize to -0.5;+0.5 estimate_x = estimate_x / max_x - 0.5 estimate_y = estimate_y / max_y - 0.5 estimate_z = estimate_z / max_z - 0.5 prediction = tf.concat([estimate_x, estimate_y, estimate_z], axis=2) # reshape into batches, joints, [x,y,z] prediction = tf.reshape(prediction, [batch_size, nb_joints * 3]) return prediction
def build_model(self, input_shape: Tuple[int, int, int]) -> Model: x = Input(shape=input_shape, name="input") big_branch_out = self.__build_big_output_head(x=x) sub_sampled_branches_out = self.__build_sub_sampled_branches_out(x=x) medium_branch_up = UpSampling2D( size=(2, 2), name="medium_branch_up")(sub_sampled_branches_out) medium_branch_up_refine = Conv2D( filters=32, kernel_size=(3, 3), padding="same", dilation_rate=(2, 2), activation="relu", name="medium_branch_up_refine")(medium_branch_up) fuse_add = Add(name="big_medium_fuse_add")( [big_branch_out, medium_branch_up_refine]) fuse_add_bn = BatchNormalization( name=f"big_medium_fuse_add_bn")(fuse_add) cls_conv = Conv2D(filters=self._num_classes, kernel_size=(1, 1), padding="same", name="output")(fuse_add_bn) flatten_out = Softmax(name="output_soft_max")(cls_conv) return Model(x, flatten_out)
def __create_semantic_head(pyramid_dict, n_classes=3, n_filters=64, n_dense=128, semantic_id=0, ndim=2, include_top=False, target_level=2, **kwargs): """Creates a semantic head from a feature pyramid network. Args: pyramid_dict: dict of pyramid names and features n_classes (int): Defaults to 3. The number of classes to be predicted n_filters (int): Defaults to 64. The number of convolutional filters. n_dense (int): Defaults to 128. Number of dense filters. semantic_id (int): Defaults to 0. ndim (int): Defaults to 2, 3d supported. include_top (bool): Defaults to False. target_level (int, optional): Defaults to 2. The level we need to reach. Performs 2x upsampling until we're at the target level Returns: keras.layers.Layer: The semantic segmentation head """ if K.image_data_format() == 'channels_first': channel_axis = 1 else: channel_axis = -1 if n_classes == 1: include_top = False # Get pyramid names and features into list form pyramid_names = get_sorted_keys(pyramid_dict) pyramid_features = [pyramid_dict[name] for name in pyramid_names] # Reverse pyramid names and features pyramid_names.reverse() pyramid_features.reverse() semantic_sum = pyramid_features[-1] semantic_names = pyramid_names[-1] # Final upsampling min_level = int(re.findall(r'\d+', semantic_names[-1])[0]) n_upsample = min_level x = semantic_upsample(semantic_sum, n_upsample, ndim=ndim) # First tensor product x = TensorProduct(n_dense)(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) # Apply tensor product and softmax layer x = TensorProduct(n_classes)(x) if include_top: x = Softmax(axis=channel_axis, name='semantic_{}'.format(semantic_id))(x) else: x = Activation('relu', name='semantic_{}'.format(semantic_id))(x) return x
def bn_feature_net_2D(receptive_field=61, input_shape=(256, 256, 1), inputs=None, n_features=3, n_channels=1, reg=1e-5, n_conv_filters=64, n_dense_filters=200, VGG_mode=False, init='he_normal', norm_method='std', location=False, dilated=False, padding=False, padding_mode='reflect', multires=False, include_top=True): """Creates a 2D featurenet. Args: receptive_field (int): the receptive field of the neural network. input_shape (tuple): If no input tensor, create one with this shape. inputs (tensor): optional input tensor n_features (int): Number of output features n_channels (int): number of input channels reg (int): regularization value n_conv_filters (int): number of convolutional filters n_dense_filters (int): number of dense filters VGG_mode (bool): If multires, uses VGG_mode for multiresolution init (str): Method for initalizing weights. norm_method (str): ImageNormalization mode to use location (bool): Whether to include location data dilated (bool): Whether to use dilated pooling. padding (bool): Whether to use padding. padding_mode (str): Type of padding, one of 'reflect' or 'zero' multires (bool): Enables multi-resolution mode include_top (bool): Whether to include the final layer of the model Returns: tensorflow.keras.Model: 2D FeatureNet """ # Create layers list (x) to store all of the layers. # We need to use the functional API to enable the multiresolution mode x = [] win = (receptive_field - 1) // 2 if dilated: padding = True if K.image_data_format() == 'channels_first': channel_axis = 1 row_axis = 2 col_axis = 3 if not dilated: input_shape = (n_channels, receptive_field, receptive_field) else: row_axis = 1 col_axis = 2 channel_axis = -1 if not dilated: input_shape = (receptive_field, receptive_field, n_channels) if inputs is not None: if not K.is_keras_tensor(inputs): img_input = Input(tensor=inputs, shape=input_shape) else: img_input = inputs x.append(img_input) else: x.append(Input(shape=input_shape)) x.append( ImageNormalization2D(norm_method=norm_method, filter_size=receptive_field)(x[-1])) if padding: if padding_mode == 'reflect': x.append(ReflectionPadding2D(padding=(win, win))(x[-1])) elif padding_mode == 'zero': x.append(ZeroPadding2D(padding=(win, win))(x[-1])) if location: x.append(Location2D(in_shape=tuple(x[-1].shape.as_list()[1:]))(x[-1])) x.append(Concatenate(axis=channel_axis)([x[-2], x[-1]])) layers_to_concat = [] rf_counter = receptive_field block_counter = 0 d = 1 while rf_counter > 4: filter_size = 3 if rf_counter % 2 == 0 else 4 x.append( Conv2D(n_conv_filters, filter_size, dilation_rate=d, kernel_initializer=init, padding='valid', kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) block_counter += 1 rf_counter -= filter_size - 1 if block_counter % 2 == 0: if dilated: x.append( DilatedMaxPool2D(dilation_rate=d, pool_size=(2, 2))(x[-1])) d *= 2 else: x.append(MaxPool2D(pool_size=(2, 2))(x[-1])) if VGG_mode: n_conv_filters *= 2 rf_counter = rf_counter // 2 if multires: layers_to_concat.append(len(x) - 1) if multires: c = [] for l in layers_to_concat: output_shape = x[l].get_shape().as_list() target_shape = x[-1].get_shape().as_list() row_crop = int(output_shape[row_axis] - target_shape[row_axis]) if row_crop % 2 == 0: row_crop = (row_crop // 2, row_crop // 2) else: row_crop = (row_crop // 2, row_crop // 2 + 1) col_crop = int(output_shape[col_axis] - target_shape[col_axis]) if col_crop % 2 == 0: col_crop = (col_crop // 2, col_crop // 2) else: col_crop = (col_crop // 2, col_crop // 2 + 1) cropping = (row_crop, col_crop) c.append(Cropping2D(cropping=cropping)(x[l])) if multires: x.append(Concatenate(axis=channel_axis)(c)) x.append( Conv2D(n_dense_filters, (rf_counter, rf_counter), dilation_rate=d, kernel_initializer=init, padding='valid', kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) if include_top: x.append( TensorProduct(n_dense_filters, kernel_initializer=init, kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) x.append( TensorProduct(n_features, kernel_initializer=init, kernel_regularizer=l2(reg))(x[-1])) if not dilated: x.append(Flatten()(x[-1])) x.append(Softmax(axis=channel_axis)(x[-1])) if inputs is not None: real_inputs = keras_utils.get_source_inputs(x[0]) else: real_inputs = x[0] model = Model(inputs=real_inputs, outputs=x[-1]) return model
def TD(input_shape, optimizer, weight_decay, class_weights, method='tf'): input_1 = Input(shape=input_shape) interpolation = 'nearest' sigma = 1 if method == 'gaussian': input_2 = Lambda(downscale_gaussian, arguments={'sigma': sigma})(input_1) input_4 = Lambda(downscale_gaussian, arguments={ 'sigma': 2 * sigma, 'down_factor': 4 })(input_1) elif method == 'noblur': input_2 = Lambda(downscale_noblur)(input_1) input_4 = Lambda(downscale_noblur)(input_2) elif method == 'antialias': input_2 = Lambda(downscale_antialias)(input_1) input_4 = Lambda(downscale_antialias)(input_2) elif method == 'tf': input_2 = Lambda(downscale_tf)(input_1) input_4 = Lambda(downscale_tf, arguments={'down_factor': 4})(input_1) else: input_2 = Lambda(downscale_pool)(input_1) input_4 = Lambda(downscale_pool)(input_2) regularizer = regularizers.l2(weight_decay) conv_1 = conv_block(input_1, 2, num_filters=64, k_size=3, regularizer=regularizer) conv_2 = conv_block(input_2, 2, num_filters=128, k_size=3, regularizer=regularizer) x = conv_block(input_4, 2, num_filters=256, k_size=3, regularizer=regularizer) # 14x14 x = Conv2D(filters=128, kernel_size=1, padding='same', kernel_regularizer=regularizer)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Lambda(upscale, arguments={'method': interpolation})(x) x = add([x, conv_2]) x = Concatenate(axis=-1)([x, conv_2]) x = conv_block(x, 3, num_filters=128, k_size=3, regularizer=regularizer) x = Conv2D(filters=64, kernel_size=1, padding='same', kernel_regularizer=regularizer)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Lambda(upscale, arguments={'method': interpolation})(x) x = add([x, conv_1]) x = Concatenate(axis=-1)([x, conv_1]) x = conv_block(x, 3, num_filters=64, k_size=3, regularizer=regularizer) x = Conv2D(filters=12, kernel_size=1, padding='same', kernel_regularizer=regularizer)(x) x = BatchNormalization()(x) out = Softmax()(x) model = Model(inputs=input_1, outputs=out) w_loss = weighted_centropy(class_weights) model.compile(optimizer=optimizer, loss=w_loss, metrics=['accuracy', mIoU]) return model
def cifar100_complicated_ensemble( input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar100 network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ output_list = [] inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 1e-4 # Submodel 1. # Block1. x1 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel1_block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x1 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel1_block1_conv2', kernel_regularizer=l2(weight_decay))(x1) x1 = BatchNormalization(name='submodel1_block1_batch-norm')(x1) x1 = MaxPooling2D(pool_size=(2, 2), name='submodel1_block1_pool')(x1) # Block2 x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel1_block2_conv1', kernel_regularizer=l2(weight_decay))(x1) x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel1_block2_conv2', kernel_regularizer=l2(weight_decay))(x1) x1 = BatchNormalization(name='submodel1_block2_batch-norm')(x1) x1 = MaxPooling2D(pool_size=(2, 2), name='submodel1_block2_pool')(x1) # Block3 x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel1_block3_conv1', kernel_regularizer=l2(weight_decay))(x1) x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel1_block3_conv2', kernel_regularizer=l2(weight_decay))(x1) x1 = BatchNormalization(name='submodel1_block3_batch-norm')(x1) x1 = MaxPooling2D(pool_size=(2, 2), name='submodel1_block3_pool')(x1) # Add Submodel 1 top layers. x1 = Flatten(name='submodel1_flatten')(x1) outputs1 = Dense(20, name='submodel1_output')(x1) # Crop outputs1 in order to create the first submodel's output. outputs_first_submodel = Crop(1, 0, 10, name='first_ten_classes_submodel')(outputs1) output_list.append(outputs_first_submodel) # Submodel 2. # Block1. x2 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel2_block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x2 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel2_block1_conv2', kernel_regularizer=l2(weight_decay))(x2) x2 = BatchNormalization(name='submodel2_block1_batch-norm')(x2) x2 = MaxPooling2D(pool_size=(2, 2), name='submodel2_block1_pool')(x2) # Block2 x2 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel2_block2_conv1', kernel_regularizer=l2(weight_decay))(x2) x2 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel2_block2_conv2', kernel_regularizer=l2(weight_decay))(x2) x2 = BatchNormalization(name='submodel2_block2_batch-norm')(x2) x2 = MaxPooling2D(pool_size=(2, 2), name='submodel2_block2_pool')(x2) # Add Submodel 2 top layers. x2 = Flatten(name='submodel2_flatten')(x2) outputs2 = Dense(30, name='submodel2_output')(x2) # Average the predictions for the second class of the first two submodels. averaged_classes_20_30 = Average(name='averaged_second_ten_classes')( [Crop(1, 10, 20)(outputs1), Crop(1, 0, 10)(outputs2)]) # Crop outputs2 in order to create the third ten classes output. outputs_classes_30_40 = Crop(1, 10, 20, name='third_ten_classes')(outputs2) # Concatenate classes outputs in order to create the second submodel's output. outputs_second_submodel = Concatenate(name='second_submodel')( [averaged_classes_20_30, outputs_classes_30_40]) output_list.append(outputs_second_submodel) # Submodel 3. # Block1. x3 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel3_block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x3 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel3_block1_conv2', kernel_regularizer=l2(weight_decay))(x3) x3 = BatchNormalization(name='submodel3_block1_batch-norm')(x3) x3 = MaxPooling2D(pool_size=(2, 2), name='submodel3_block1_pool')(x3) # Block2 x3 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel3_block2_conv1', kernel_regularizer=l2(weight_decay))(x3) x3 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel3_block2_conv2', kernel_regularizer=l2(weight_decay))(x3) x3 = BatchNormalization(name='submodel3_block2_batch-norm')(x3) x3 = MaxPooling2D(pool_size=(2, 2), name='submodel3_block2_pool')(x3) # Add Submodel 3 top layers. x3 = Flatten(name='submodel3_flatten')(x3) outputs3 = Dense(30, name='submodel3_output')(x3) # Average the predictions for the fourth class of the last two submodels. averaged_classes_30_40 = Average(name='averaged_fourth_ten_class')( [Crop(1, 20, 30)(outputs2), Crop(1, 0, 10)(outputs3)]) # Crop outputs3 in order to create the fifth abd sixth class outputs. outputs_classes_40_50 = Crop(1, 10, 20, name='fifth_ten_class')(outputs3) outputs_classes_50_60 = Crop(1, 20, 30, name='sixth_ten_class')(outputs3) # Concatenate classes outputs in order to create the third submodel's output. outputs_third_submodel = Concatenate(name='third_submodel')( [averaged_classes_30_40, outputs_classes_40_50, outputs_classes_50_60]) output_list.append(outputs_third_submodel) # Submodel 4. # Block1. x4 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel4_block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x4 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel4_block1_conv2', kernel_regularizer=l2(weight_decay))(x4) x4 = BatchNormalization(name='submodel4_block1_batch-norm')(x4) x4 = MaxPooling2D(pool_size=(2, 2), name='submodel4_block1_pool')(x4) # Block2 x4 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel4_block2_conv1', kernel_regularizer=l2(weight_decay))(x4) x4 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel4_block2_conv2', kernel_regularizer=l2(weight_decay))(x4) x4 = BatchNormalization(name='submodel4_block2_batch-norm')(x4) x4 = MaxPooling2D(pool_size=(2, 2), name='submodel4_block2_pool')(x4) # Block3 x4 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel4_block3_conv1', kernel_regularizer=l2(weight_decay))(x4) x4 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel4_block3_conv2', kernel_regularizer=l2(weight_decay))(x4) x4 = BatchNormalization(name='submodel4_block3_batch-norm')(x4) x4 = MaxPooling2D(pool_size=(2, 2), name='submodel4_block3_pool')(x4) # Add Submodel 4 top layers. x4 = Flatten(name='submodel4_flatten')(x4) outputs4 = Dense(20, name='60-80_classes_submodel4')(x4) output_list.append(outputs4) # Submodel 5. # Block1. x5 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel5_block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x5 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel5_block1_conv2', kernel_regularizer=l2(weight_decay))(x5) x5 = BatchNormalization(name='submodel5_block1_batch-norm')(x5) x5 = MaxPooling2D(pool_size=(2, 2), name='submodel5_block1_pool')(x5) # Block2 x5 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel5_block2_conv1', kernel_regularizer=l2(weight_decay))(x5) x5 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel5_block2_conv2', kernel_regularizer=l2(weight_decay))(x5) x5 = BatchNormalization(name='submodel5_block2_batch-norm')(x5) x5 = MaxPooling2D(pool_size=(2, 2), name='submodel5_block2_pool')(x5) # Block3 x5 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel5_block3_conv1', kernel_regularizer=l2(weight_decay))(x5) x5 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel5_block3_conv2', kernel_regularizer=l2(weight_decay))(x5) x5 = BatchNormalization(name='submodel5_block3_batch-norm')(x5) x5 = MaxPooling2D(pool_size=(2, 2), name='submodel5_block3_pool')(x5) # Add Submodel 5 top layers. x5 = Flatten(name='submodel5_flatten')(x5) outputs5 = Dense(20, name='80-100_classes_submodel4')(x5) output_list.append(outputs5) # Concatenate all class predictions together. outputs = Concatenate(name='output')(output_list) outputs = Softmax(name='output_softmax')(outputs) # Create model. model = Model(inputs, outputs, name='cifar100_complicated_ensemble') # Load weights, if they exist. load_weights(weights_path, model) return model
def cifar100_pyramid_ensemble(input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar100 network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ output_list = [] inputs = create_inputs(input_shape, input_tensor) # Submodel Strong. # Block1. x1 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel_strong_block1_conv1')(inputs) x1 = Conv2D(64, (3, 3), padding='same', activation='elu', name='submodel_strong_block1_conv2')(x1) x1 = MaxPooling2D(pool_size=(2, 2), name='submodel_strong_block1_pool')(x1) # Block2 x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_strong_block2_conv1')(x1) x1 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_strong_block2_conv2')(x1) x1 = MaxPooling2D(pool_size=(2, 2), name='submodel_strong_block2_pool')(x1) # Block3 x1 = BatchNormalization(name='submodel_strong_block3_batch-norm')(x1) x1 = Conv2D(256, (3, 3), padding='same', activation='elu', name='submodel_strong_block3_conv')(x1) x1 = Dropout(0.5, name='submodel_strong_block3_dropout', seed=0)(x1) # Add Submodel Strong top layers. x1 = Flatten(name='submodel_strong_flatten')(x1) outputs_submodel_strong = Dense(100, name='submodel_strong_output')(x1) # Submodel Weak 1. # Block1. x2 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_weak_1_block1_conv1')(inputs) x2 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_weak_1_block1_conv2')(x2) x2 = MaxPooling2D(pool_size=(2, 2), name='submodel_weak_1_block1_pool')(x2) # Add Submodel Weak 1 top layers. x2 = Flatten(name='submodel_weak_1_flatten')(x2) outputs2 = Dense(50, name='submodel_weak_1_output')(x2) # Average the predictions for the first five classes. averaged_first_half_classes = Average(name='averaged_first_half_classes')( [Crop(1, 0, 50)(outputs_submodel_strong), outputs2]) output_list.append(averaged_first_half_classes) # Submodel Weak 2. # Block1. x3 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_weak_2_block1_conv1')(inputs) x3 = Conv2D(128, (3, 3), padding='same', activation='elu', name='submodel_weak_2_block1_conv2')(x3) x3 = MaxPooling2D(pool_size=(2, 2), name='submodel_weak_2_block1_pool')(x3) # Add Submodel Weak 2 top layers. x3 = Flatten(name='submodel_weak_2_flatten')(x3) outputs3 = Dense(50, name='submodel_weak_2_output')(x3) # Average the predictions for the last five classes. averaged_last_half_classes = Average(name='averaged_last_half_classes')( [Crop(1, 50, 100)(outputs_submodel_strong), outputs3]) output_list.append(averaged_last_half_classes) # Concatenate all class predictions together. outputs = Concatenate(name='output')(output_list) outputs = Softmax(name='output_softmax')(outputs) # Create model. model = Model(inputs, outputs, name='cifar100_pyramid_ensemble') # Load weights, if they exist. load_weights(weights_path, model) return model