def __call__(self, inputs): self.inputs = layer_utils.format_inputs(inputs, self.name) for input_node in self.inputs: input_node.add_out_hypermodel(self) self.outputs = [] for _ in range(self._num_output_node): output_node = hyper_node.Node() output_node.add_in_hypermodel(self) self.outputs.append(output_node) return self.outputs
def build(self, hp, inputs=None): # TODO: make it more advanced, selecting from multiple models, e.g., # ResNet. input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node for i in range(hp.Choice('num_layers', [1, 2, 3], default=2)): output_node = tf.keras.layers.Conv2D( hp.Choice('units_{i}'.format(i=i), [16, 32, 64], default=32), hp.Choice('kernel_size_{i}'.format(i=i), [3, 5, 7], default=3))(output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node if len(self.output_shape) == 1: output_node = hyper_block.Flatten().build(hp, output_node) output_node = tf.keras.layers.Dense( self.output_shape[0])(output_node) output_node = tf.keras.layers.Softmax()(output_node) return output_node # TODO: Add hp.Choice to use sigmoid return hyper_block.Reshape(self.output_shape).build(hp, output_node)
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node block_type = hp.Choice('block_type', ['resnet', 'xception', 'vanilla'], default='resnet') if block_type == 'resnet': output_node = ResNetBlock().build(hp, output_node) elif block_type == 'xception': output_node = XceptionBlock().build(hp, output_node) elif block_type == 'vanilla': output_node = ConvBlock().build(hp, output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node if len(output_node.shape) > 5: raise ValueError( 'Expect the input tensor to have less or equal to 5 ' 'dimensions, but got {shape}'.format(shape=output_node.shape)) # Flatten the input tensor # TODO: Add hp.Choice to use Flatten() if len(output_node.shape) > 2: global_average_pooling = \ layer_utils.get_global_average_pooling_layer_class( output_node.shape) output_node = global_average_pooling()(output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] shape = input_node.shape.as_list() if len(shape) < 3: raise ValueError("Expect the input tensor to have " "at least 3 dimensions for rnn models, " "but got {shape}".format(shape=input_node.shape)) # Flatten feature_list to a single dimension. # Final shape 3-D (num_sample , time_steps , features) feature_size = np.prod(shape[2:]) input_node = tf.reshape(input_node, [-1, shape[1], feature_size]) output_node = input_node in_layer = const.Constant.RNN_LAYERS[hp.Choice('rnn_type', ['gru', 'lstm'], default='lstm')] choice_of_layers = hp.Choice('num_layers', [1, 2, 3], default=2) bidirectional = self.bidirectional if bidirectional is None: bidirectional = hp.Choice('bidirectional', [True, False], default=True) return_sequences = self.return_sequences if return_sequences is None: return_sequences = hp.Choice('return_sequences', [True, False], default=True) for i in range(choice_of_layers): temp_return_sequences = True if i == choice_of_layers - 1: temp_return_sequences = return_sequences if bidirectional: output_node = tf.keras.layers.Bidirectional( in_layer( feature_size, return_sequences=temp_return_sequences))(output_node) else: output_node = in_layer(feature_size, return_sequences=return_sequences) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node # No need to reduce. if len(output_node.shape) <= 2: return output_node reduction_type = hp.Choice('reduction_type', ['flatten', 'global_max', 'global_ave'], default='global_ave') if reduction_type == 'flatten': output_node = Flatten().build(hp, output_node) elif reduction_type == 'global_max': output_node = layer_utils.get_global_max_pooling_layer( output_node.shape)()(output_node) elif reduction_type == 'global_ave': output_node = layer_utils.get_global_average_pooling_layer( output_node.shape)()(output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node output_node = Flatten().build(hp, output_node) active_category = hp.Choice('activate_category', ['softmax', 'relu', 'tanh', 'sigmoid'], default='relu') layer_stack = hp.Choice('layer_stack', ['dense-bn-act', 'dense-act', 'act-bn-dense'], default='act-bn-dense') for i in range(hp.Choice('num_layers', [1, 2, 3], default=2)): if layer_stack == 'dense-bn-act': output_node = tf.keras.layers.Dense( hp.Choice('units_{i}'.format(i=i), [16, 32, 64, 128, 256, 512, 1024], default=32))(output_node) output_node = tf.keras.layers.BatchNormalization()(output_node) output_node = tf.keras.layers.Activation(active_category)( output_node) output_node = tf.keras.layers.Dropout(rate=hp.Choice( 'dropout_rate', [0, 0.25, 0.5], default=0.5))(output_node) elif layer_stack == 'dense-act': output_node = tf.keras.layers.Dense( hp.Choice('units_{i}'.format(i=i), [16, 32, 64, 128, 256, 512, 1024], default=32))(output_node) output_node = tf.keras.layers.Activation(active_category)( output_node) output_node = tf.keras.layers.Dropout(rate=hp.Choice( 'dropout_rate', [0, 0.25, 0.5], default=0.5))(output_node) else: output_node = tf.keras.layers.Activation(active_category)( output_node) output_node = tf.keras.layers.BatchNormalization()(output_node) output_node = tf.keras.layers.Dense( hp.Choice('units_{i}'.format(i=i), [16, 32, 64, 128, 256, 512, 1024], default=32))(output_node) output_node = tf.keras.layers.Dropout(rate=hp.Choice( 'dropout_rate', [0, 0.25, 0.5], default=0.5))(output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node channel_axis = 1 \ if tf.keras.backend.image_data_format() == 'channels_first' else -1 # Parameters # [general] kernel_size = hp.Range("kernel_size", 3, 5) initial_strides = (2, 2) activation = hp.Choice("activation", ["relu", "selu"]) # [Entry Flow] conv2d_filters = hp.Choice("conv2d_num_filters", [32, 64, 128]) sep_filters = hp.Range("sep_num_filters", 128, 768) # [Middle Flow] residual_blocks = hp.Range("num_residual_blocks", 2, 8) # [Exit Flow] # Model # Initial conv2d dims = conv2d_filters output_node = self._conv(dims, kernel_size=(kernel_size, kernel_size), activation=activation, strides=initial_strides)(output_node) # Separable convs dims = sep_filters for _ in range(residual_blocks): output_node = self._residual( dims, activation=activation, max_pooling=False, channel_axis=channel_axis)(output_node) # Exit dims *= 2 output_node = self._residual(dims, activation=activation, max_pooling=True, channel_axis=channel_axis)(output_node) return output_node
def build(self, hp, inputs=None): inputs = layer_utils.format_inputs(inputs, self.name) if len(inputs) == 1: return inputs if not all([ shape_compatible(input_node.shape, inputs[0].shape) for input_node in inputs ]): new_inputs = [] for input_node in inputs: new_inputs.append(Flatten().build(hp, input_node)) inputs = new_inputs # TODO: Even inputs have different shape[-1], they can still be Add( # ) after another layer. Check if the inputs are all of the same # shape if all([input_node.shape == inputs[0].shape for input_node in inputs]): if hp.Choice("merge_type", ['Add', 'Concatenate'], default='Add'): return tf.keras.layers.Add(inputs) return tf.keras.layers.Add()(inputs)
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node # No need to reduce. if len(output_node.shape) <= 2: return output_node reduction_type = hp.Choice('reduction_type', ['flatten', 'max', 'ave', 'min'], default='global_ave') if reduction_type == 'flatten': output_node = Flatten().build(hp, output_node) elif reduction_type == 'max': output_node = tf.math.reduce_max(output_node, axis=-2) elif reduction_type == 'ave': output_node = tf.math.reduce_mean(output_node, axis=-2) elif reduction_type == 'min': output_node = tf.math.reduce_min(output_node, axis=-2) return output_node
def build(self, hp): real_nodes = {} for input_node in self._model_inputs: node_id = self._node_to_id[input_node] real_nodes[node_id] = input_node.build() for hypermodel in self._hypermodels: if isinstance(hypermodel, processor.HyperPreprocessor): continue temp_inputs = [real_nodes[self._node_to_id[input_node]] for input_node in hypermodel.inputs] outputs = hypermodel.build(hp, inputs=temp_inputs) outputs = layer_utils.format_inputs(outputs, hypermodel.name) for output_node, real_output_node in zip(hypermodel.outputs, outputs): real_nodes[self._node_to_id[output_node]] = real_output_node model = tf.keras.Model( [real_nodes[self._node_to_id[input_node]] for input_node in self._model_inputs], [real_nodes[self._node_to_id[output_node]] for output_node in self.outputs]) return self._compiled(hp, model)
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] output_node = input_node output_node = Flatten().build(hp, output_node) layer_stack = hp.Choice('layer_stack', ['dense-bn-act', 'dense-act'], default='dense-bn-act') dropout_rate = hp.Choice('dropout_rate', [0, 0.25, 0.5], default=0.5) for i in range(hp.Choice('num_layers', [1, 2, 3], default=2)): units = hp.Choice('units_{i}'.format(i=i), [16, 32, 64, 128, 256, 512, 1024], default=32) if layer_stack == 'dense-bn-act': output_node = tf.keras.layers.Dense(units)(output_node) output_node = tf.keras.layers.BatchNormalization()(output_node) output_node = tf.keras.layers.ReLU()(output_node) output_node = tf.keras.layers.Dropout(dropout_rate)( output_node) elif layer_stack == 'dense-act': output_node = tf.keras.layers.Dense(units)(output_node) output_node = tf.keras.layers.ReLU()(output_node) output_node = tf.keras.layers.Dropout(dropout_rate)( output_node) return output_node
def build(self, hp, inputs=None): input_node = layer_utils.format_inputs(inputs, self.name, num=1)[0] if len(input_node.shape) > 2: return tf.keras.layers.Flatten()(input_node) return input_node