def build_subnetwork(self, features, logits_dimension, training,
iteration_step, summary, previous_ensemble):
"""See `adanet.subnetwork.Builder`."""
# Required for scoping weight decay.
self._name_scope = tf.get_default_graph().get_name_scope()
if len(features) != 1:
raise ValueError(
"Features dict must only contain a single image tensor; got {}"
.format(features))
if logits_dimension == 1:
raise ValueError("Only multi-class classification is supported")
images = tf.to_float(list(features.values())[0])
nasnet_fn = nets_factory.get_network_fn(
self._model_name,
num_classes=logits_dimension,
weight_decay=self._weight_decay,
is_training=training)
logits, end_points = nasnet_fn(images,
config=self._config,
current_step=iteration_step)
persisted_tensors = {}
if "AuxLogits" in end_points:
persisted_tensors["aux_logits"] = end_points["AuxLogits"]
return adanet.Subnetwork(last_layer=logits,
logits=logits,
complexity=1,
persisted_tensors=persisted_tensors)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
images = list(features.values())[0]
x = images
for i in range(self._n_convs):
x = Conv2D(32, kernel_size=7, activation='relu')(x)
x = MaxPooling2D(strides=2)(x)
x = Flatten()(x)
x = Dense(120, activation='relu')(x)
logits = Dense(120)(x)
complexity = tf.constant(1)
persisted_tensors = {'n_convs': tf.constant(self._n_convs)}
return adanet.Subnetwork(last_layer=x,
logits=logits,
complexity=complexity,
persisted_tensors=persisted_tensors)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
input_layer = tf.to_float(features[FEATURES_KEY])
kernel_initializer = tf.glorot_uniform_initializer(seed=self._seed)
last_layer = input_layer
# hidden layesr
for _ in range(self._num_layers):
last_layer = tf.layers.dense(last_layer,
units=self._layer_size,
activation=tf.nn.relu,
kernel_initializer=kernel_initializer)
# logits are input to activation function
logits = tf.layers.dense(last_layer,
units=logits_dimension,
kernel_initializer=kernel_initializer)
# At the end of iteration,the tf.Tensor instances (hidden layers) will be available to subnetworks in the next iterations
persisted_tensors = {_NUM_LAYERS_KEY: tf.constant(self._num_layers)}
return adanet.Subnetwork(last_layer=last_layer,
logits=logits,
complexity=self._measure_complexity(),
persisted_tensors=persisted_tensors)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
images = list(features.values())[0]
kernel_initializer = tf.glorot_uniform_initializer(seed=self._seed)
x = tf.keras.layers.Flatten()(images)
last_layer = x
for _ in range(self._num_layers):
x = tf.layers.dense(x,
units=self._layer_size,
activation=tf.nn.relu,
kernel_initializer=kernel_initializer)
logits = tf.layers.dense(last_layer,
units=10,
kernel_initializer=kernel_initializer)
persisted_tensors = {_NUM_LAYERS_KEY: tf.constant(self._num_layers)}
return adanet.Subnetwork(last_layer=last_layer,
logits=logits,
complexity=self._measure_complexity(),
persisted_tensors=persisted_tensors)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
input_layer = tf.to_float(features[utils.FEATURES_KEY])
kernel_initializer = tf.glorot_uniform_initializer(seed=self._seed)
last_layer = input_layer
for _ in range(self._num_layers):
last_layer = tf.layers.dense(last_layer,
units=self._layer_size,
activation=tf.nn.relu,
kernel_initializer=kernel_initializer)
logits = tf.layers.dense(last_layer,
units=logits_dimension,
kernel_initializer=kernel_initializer)
persisted_tensors = {_NUM_LAYERS_KEY: tf.constant(self._num_layers)}
return adanet.Subnetwork(last_layer=last_layer,
logits=logits,
complexity=self._measure_complexity(),
persisted_tensors=persisted_tensors)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
print(features['images'])
images = features['images']
kernel_initializer = tf.keras.initializers.he_normal(seed=self._seed)
x = tf.layers.conv1d(
images,
filters=16,
kernel_size=32,
padding="same",
activation="relu",
kernel_initializer=kernel_initializer)
x = tf.layers.max_pooling1d(x, pool_size=1, strides=1)
x = tf.layers.conv1d(
images,
filters=32,
kernel_size=32,
padding="same",
activation="relu",
kernel_initializer=kernel_initializer)
x = tf.layers.max_pooling1d(x, pool_size=1, strides=1)
x = tf.layers.conv1d(
images,
filters=64,
kernel_size=32,
padding="same",
activation="relu",
kernel_initializer=kernel_initializer)
x = tf.layers.max_pooling1d(x, pool_size=1, strides=1)
x = tf.layers.flatten(x)
x = tf.layers.dense(
x, units=512, activation="relu", kernel_initializer=kernel_initializer)
# The `Head` passed to adanet.Estimator will apply the softmax activation.
logits = tf.layers.dense(
x, units=3, activation=None, kernel_initializer=kernel_initializer)
# Use a constant complexity measure, since all subnetworks have the same
# architecture and hyperparameters.
complexity = tf.constant(1)
return adanet.Subnetwork(
last_layer=x,
logits=logits,
complexity=complexity,
persisted_tensors={})
def __init__(self, num_layers):
shared_tensors = {"num_layers": tf.constant(num_layers)}
self._weighted_subnetworks = [
adanet.WeightedSubnetwork(name=None,
iteration_number=None,
weight=None,
logits=None,
subnetwork=adanet.Subnetwork(
last_layer=[1],
logits=[1],
complexity=1,
shared=shared_tensors))
]
def __init__(self, num_layers):
persisted_tensors = {"num_layers": tf.constant(num_layers)}
self._weighted_subnetworks = [
adanet.WeightedSubnetwork(
name=None,
weight=None,
logits=None,
subnetwork=adanet.Subnetwork(
last_layer=[1],
logits=[1],
complexity=1,
persisted_tensors=persisted_tensors))
]
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
# Prepare the input.
assert len(
self._feature_columns) == 1, "Got feature columns: {}".format(
self._feature_columns)
images = tf.to_float(features[self._feature_columns[0].name])
self._name_scope = tf.get_default_graph().get_name_scope()
seed = self._seed
if seed is not None and previous_ensemble:
# Deterministically change the seed for different iterations so that
# subnetworks are not correlated.
seed += len(previous_ensemble.weighted_subnetworks)
arg_scope = nasnet.nasnet_cifar_arg_scope(
weight_decay=self._weight_decay)
with tf.contrib.slim.arg_scope(arg_scope):
build_fn = nasnet.build_nasnet_cifar
logits, end_points = build_fn(images,
num_classes=logits_dimension,
is_training=training,
config=self._hparams)
last_layer = end_points["global_pool"]
subnetwork_shared_data = {
_PREVIOUS_NUM_CELLS: tf.constant(self._num_cells),
_PREVIOUS_CONV_FILTERS: tf.constant(self._num_conv_filters)
}
return adanet.Subnetwork(last_layer=last_layer,
logits=logits,
complexity=1,
shared=subnetwork_shared_data)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
input_layer = tf.compat.v1.feature_column.input_layer(
features=features, feature_columns=self._feature_columns)
last_layer = input_layer
for _ in range(self._num_layers):
last_layer = tf.compat.v1.layers.dense(
last_layer,
units=self._layer_size,
activation=tf.nn.relu,
kernel_initializer=tf.compat.v1.glorot_uniform_initializer(
seed=self._seed))
last_layer = tf.compat.v1.layers.dropout(last_layer,
rate=self._dropout,
seed=self._seed,
training=training)
logits = tf.compat.v1.layers.dense(
last_layer,
units=logits_dimension,
kernel_initializer=tf.compat.v1.glorot_uniform_initializer(
seed=self._seed))
# Approximate the Rademacher complexity of this subnetwork as the square-
# root of its depth.
complexity = tf.sqrt(tf.cast(self._num_layers, dtype=tf.float32))
with tf.name_scope(""):
summary.scalar("complexity", complexity)
summary.scalar("num_layers", self._num_layers)
shared = {_NUM_LAYERS_KEY: self._num_layers}
return adanet.Subnetwork(last_layer=last_layer,
logits=logits,
complexity=complexity,
shared=shared)
def build_subnetwork(self,
features,
logits_dimension,
training,
iteration_step,
summary,
previous_ensemble=None):
"""See `adanet.subnetwork.Builder`."""
images = list(features.values())[0]
# Visualize some of the input images in TensorBoard.
summary.image("images", images)
kernel_initializer = tf.keras.initializers.he_normal(seed=self._seed)
x = tf.keras.layers.Conv2D(
filters=16,
kernel_size=3,
padding="same",
activation="relu",
kernel_initializer=kernel_initializer)(images)
x = tf.keras.layers.MaxPool2D(pool_size=2, strides=2)(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(units=64,
activation="relu",
kernel_initializer=kernel_initializer)(x)
# The `Head` passed to adanet.Estimator will apply the softmax activation.
logits = tf.keras.layers.Dense(
units=10, activation=None,
kernel_initializer=kernel_initializer)(x)
# Use a constant complexity measure, since all subnetworks have the same
# architecture and hyperparameters.
complexity = tf.constant(1)
return adanet.Subnetwork(last_layer=x,
logits=logits,
complexity=complexity,
persisted_tensors={})