def build(self):
d_input = Input(shape=(2, ))
x = Dense(64, activation='relu')(d_input)
x = Dropout(0.5)(x)
x = Dense(64, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(64, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(64, activation='relu')(x)
x = Dropout(0.5)(x)
d_output = Dense(3, activation="relu")(x)
model = Model(inputs=[d_input], outputs=[d_output])
optimizer = Adam(lr=0.00005)
model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["accuracy"])
return model
def run(model):
# Download kitti dataset
helper.maybe_download_training_img(DATA_DIRECTORY)
x, y = helper.get_data(TRAINING_DATA_DIRECTORY, IMAGE_SHAPE)
if model is None:
inputs = Input(shape=(IMAGE_SHAPE[0], IMAGE_SHAPE[1], 3))
# Block 1
block1_conv1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(inputs)
block1_conv2 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(block1_conv1)
block1_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block1_pool')(block1_conv2)
# Block 2
block2_conv1 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(block1_pool)
block2_conv2 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(block2_conv1)
block2_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block2_pool')(block2_conv2)
# Block 3
block3_conv1 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(block2_pool)
block3_conv2 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(block3_conv1)
block3_conv3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(block3_conv2)
block3_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block3_pool')(block3_conv3)
# Block 4
block4_conv1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv1')(block3_pool)
block4_conv2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv2')(block4_conv1)
block4_conv3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv3')(block4_conv2)
block4_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block4_pool')(block4_conv3)
# Block 5
block5_conv1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv1')(block4_pool)
block5_conv2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv2')(block5_conv1)
block5_conv3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv3')(block5_conv2)
block5_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block5_pool')(block5_conv3)
pool5_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block5_pool)
upsample_1 = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
padding="same")(pool5_conv1x1)
pool4_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block4_pool)
add_1 = Add()([upsample_1, pool4_conv1x1])
upsample_2 = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
padding="same")(add_1)
pool3_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block3_pool)
add_2 = Add()([upsample_2, pool3_conv1x1])
upsample_3 = Conv2DTranspose(2,
kernel_size=(16, 16),
strides=(8, 8),
padding="same")(add_2)
output = Dense(2, activation='softmax')(upsample_3)
model = Model(inputs, output, name='multinet_seg')
adam = Adam(lr=LEARNING_RATE)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
model.fit(x, y, batch_size=BATCH_SIZE, epochs=EPOCHS)
model.save('trained_model' + str(time.time()) + '.h5')
class Sequential(Model):
"""Linear stack of layers.
Arguments:
layers: list of layers to add to the model.
# Note
The first layer passed to a Sequential model
should have a defined input shape. What that
means is that it should have received an `input_shape`
or `batch_input_shape` argument,
or for some type of layers (recurrent, Dense...)
an `input_dim` argument.
Example:
```python
model = Sequential()
# first layer must have a defined input shape
model.add(Dense(32, input_dim=500))
# afterwards, Keras does automatic shape inference
model.add(Dense(32))
# also possible (equivalent to the above):
model = Sequential()
model.add(Dense(32, input_shape=(500,)))
model.add(Dense(32))
# also possible (equivalent to the above):
model = Sequential()
# here the batch dimension is None,
# which means any batch size will be accepted by the model.
model.add(Dense(32, batch_input_shape=(None, 500)))
model.add(Dense(32))
```
"""
def __init__(self, layers=None, name=None):
self.layers = [] # Stack of layers.
self.model = None # Internal Model instance.
self.inputs = [] # List of input tensors
self.outputs = [] # List of length 1: the output tensor (unique).
self._trainable = True
self._initial_weights = None
# Model attributes.
self.inbound_nodes = []
self.outbound_nodes = []
self.built = False
# Set model name.
if not name:
prefix = 'sequential_'
name = prefix + str(K.get_uid(prefix))
self.name = name
# Add to the model any layers passed to the constructor.
if layers:
for layer in layers:
self.add(layer)
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Arguments:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
if not isinstance(layer, Layer):
raise TypeError('The added layer must be '
'an instance of class Layer. '
'Found: ' + str(layer))
if not self.outputs:
# first layer in model: check that it is an input layer
if not layer.inbound_nodes:
# create an input layer
if not hasattr(layer, 'batch_input_shape'):
raise ValueError('The first layer in a '
'Sequential model must '
'get an `input_shape` or '
'`batch_input_shape` argument.')
# Instantiate the input layer.
x = Input(batch_shape=layer.batch_input_shape,
dtype=layer.dtype,
name=layer.name + '_input')
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
if len(layer.inbound_nodes) != 1:
raise ValueError('A layer added to a Sequential model must '
'not already be connected somewhere else. '
'Model received layer ' + layer.name +
' which has ' +
str(len(layer.inbound_nodes)) +
' pre-existing inbound connections.')
if len(layer.inbound_nodes[0].output_tensors) != 1:
raise ValueError('All layers in a Sequential model '
'should have a single output tensor. '
'For multi-output layers, '
'use the functional API.')
self.outputs = [layer.inbound_nodes[0].output_tensors[0]]
self.inputs = topology.get_source_inputs(self.outputs[0])
# We create an input node, which we will keep updated
# as we add more layers
topology.Node(
outbound_layer=self,
inbound_layers=[],
node_indices=[],
tensor_indices=[],
input_tensors=self.inputs,
output_tensors=self.outputs,
# no model-level masking for now
input_masks=[None for _ in self.inputs],
output_masks=[None])
else:
output_tensor = layer(self.outputs[0])
if isinstance(output_tensor, list):
raise TypeError('All layers in a Sequential model '
'should have a single output tensor. '
'For multi-output layers, '
'use the functional API.')
self.outputs = [output_tensor]
# update self.inbound_nodes
self.inbound_nodes[0].output_tensors = self.outputs
self.inbound_nodes[0].output_shapes = [
K.int_shape(self.outputs[0])
]
self.layers.append(layer)
self.built = False
def pop(self):
"""Removes the last layer in the model.
Raises:
TypeError: if there are no layers in the model.
"""
if not self.layers:
raise TypeError('There are no layers in the model.')
self.layers.pop()
if not self.layers:
self.outputs = []
self.inbound_nodes = []
self.outbound_nodes = []
else:
self.layers[-1].outbound_nodes = []
self.outputs = [self.layers[-1].output]
# update self.inbound_nodes
self.inbound_nodes[0].output_tensors = self.outputs
self.inbound_nodes[0].output_shapes = [
K.int_shape(self.outputs[0])
]
self.built = False
def get_layer(self, name=None, index=None):
"""Retrieve a layer that is part of the model.
Returns a layer based on either its name (unique)
or its index in the graph. Indices are based on
order of horizontal graph traversal (bottom-up).
Arguments:
name: string, name of layer.
index: integer, index of layer.
Returns:
A layer instance.
"""
if self.model is None:
self.build()
return self.model.get_layer(name, index)
def call(self, inputs, mask=None):
if self.model is None:
self.build()
return self.model.call(inputs, mask)
def build(self, input_shape=None):
if not self.inputs or not self.outputs:
raise TypeError('Sequential model cannot be built: model is empty.'
' Add some layers first.')
# actually create the model
self.model = Model(self.inputs,
self.outputs[0],
name=self.name + '_model')
self.model.trainable = self.trainable
# mirror model attributes
self.supports_masking = self.model.supports_masking
self._output_mask_cache = self.model._output_mask_cache
self._output_tensor_cache = self.model._output_tensor_cache
self._output_shape_cache = self.model._output_shape_cache
self.input_layers = self.model.input_layers
self.input_layers_node_indices = self.model.input_layers_node_indices
self.input_layers_tensor_indices = self.model.input_layers_tensor_indices
self.output_layers = self.model.output_layers
self.output_layers_node_indices = self.model.output_layers_node_indices
self.output_layers_tensor_indices = self.model.output_layers_tensor_indices
self.nodes_by_depth = self.model.nodes_by_depth
self.container_nodes = self.model.container_nodes
self.output_names = self.model.output_names
self.input_names = self.model.input_names
self._feed_input_names = self.model._feed_input_names
self._feed_inputs = self.model._feed_inputs
# Make sure child model callbacks
# will call the parent Sequential model.
self.model.callback_model = self
self.built = True
@property
def uses_learning_phase(self):
if self.model is None:
self.build()
return self.model.uses_learning_phase
def _gather_list_attr(self, attr):
all_attrs = []
for layer in self.layers:
all_attrs += getattr(layer, attr, [])
return all_attrs
@property
def trainable(self):
return self._trainable
@trainable.setter
def trainable(self, value):
if self.model:
self.model.trainable = value
self._trainable = value
@property
def trainable_weights(self):
if not self.trainable:
return []
return self._gather_list_attr('trainable_weights')
@property
def non_trainable_weights(self):
weights = self._gather_list_attr('non_trainable_weights')
if not self.trainable:
trainable_weights = self._gather_list_attr('trainable_weights')
return trainable_weights + weights
return weights
@property
def updates(self):
if self.model is None:
self.build()
return self.model.updates
@property
def state_updates(self):
if self.model is None:
self.build()
return self.model.state_updates
def get_updates_for(self, inputs):
if self.model is None:
self.build()
return self.model.get_updates_for(inputs)
@property
def losses(self):
if self.model is None:
self.build()
return self.model.losses
def get_losses_for(self, inputs):
if self.model is None:
self.build()
return self.model.get_losses_for(inputs)
@property
def regularizers(self):
if self.model is None:
self.build()
return self.model.regularizers
@property
def constraints(self):
if self.model is None:
self.build()
return self.model.constraints
def get_weights(self):
"""Retrieves the weights of the model.
Returns:
A flat list of Numpy arrays
(one array per model weight).
"""
if self.model is None:
self.build()
return self.model.get_weights()
def set_weights(self, weights):
"""Sets the weights of the model.
Arguments:
weights: Should be a list
of Numpy arrays with shapes and types matching
the output of `model.get_weights()`.
"""
if self.model is None:
self.build()
self.model.set_weights(weights)
def load_weights(self, filepath, by_name=False):
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(filepath, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
layers = self.layers
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
def save_weights(self, filepath, overwrite=True):
if h5py is None:
raise ImportError('`save_weights` requires h5py.')
# If file exists and should not be overwritten:
if not overwrite and os.path.isfile(filepath):
proceed = ask_to_proceed_with_overwrite(filepath)
if not proceed:
return
layers = self.layers
f = h5py.File(filepath, 'w')
topology.save_weights_to_hdf5_group(f, layers)
f.flush()
f.close()
def compile(self,
optimizer,
loss,
metrics=None,
sample_weight_mode=None,
**kwargs):
"""Configures the learning process.
Arguments:
optimizer: str (name of optimizer) or optimizer object.
See [optimizers](/optimizers).
loss: str (name of objective function) or objective function.
See [objectives](/objectives).
metrics: list of metrics to be evaluated by the model
during training and testing.
Typically you will use `metrics=['accuracy']`.
See [metrics](/metrics).
sample_weight_mode: if you need to do timestep-wise
sample weighting (2D weights), set this to "temporal".
"None" defaults to sample-wise weights (1D).
**kwargs: for Theano backend, these are passed into K.function.
Ignored for Tensorflow backend.
Example:
```python
model = Sequential()
model.add(Dense(32, input_shape=(500,)))
model.add(Dense(10, activation='softmax'))
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
```
"""
# create the underlying model
self.build()
# call compile method of Model class
self.model.compile(optimizer,
loss,
metrics=metrics,
sample_weight_mode=sample_weight_mode,
**kwargs)
self.optimizer = self.model.optimizer
self.loss = self.model.loss
self.loss_weights = self.model.loss_weights
self.metrics = self.model.metrics
self.metrics_tensors = self.model.metrics_tensors
self.metrics_names = self.model.metrics_names
self.sample_weight_mode = self.model.sample_weight_mode
def fit(self,
x,
y,
batch_size=32,
epochs=10,
verbose=1,
callbacks=None,
validation_split=0.,
validation_data=None,
shuffle=True,
class_weight=None,
sample_weight=None,
initial_epoch=0):
"""Trains the model for a fixed number of epochs.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
batch_size: integer. Number of samples per gradient update.
epochs: integer, the number of epochs to train the model.
verbose: 0 for no logging to stdout,
1 for progress bar logging, 2 for one log line per epoch.
callbacks: list of `keras.callbacks.Callback` instances.
List of callbacks to apply during training.
See [callbacks](/callbacks).
validation_split: float (0. < x < 1).
Fraction of the data to use as held-out validation data.
validation_data: tuple (x_val, y_val) or tuple
(x_val, y_val, val_sample_weights) to be used as held-out
validation data. Will override validation_split.
shuffle: boolean or str (for 'batch').
Whether to shuffle the samples at each epoch.
'batch' is a special option for dealing with the
limitations of HDF5 data; it shuffles in batch-sized chunks.
class_weight: dictionary mapping classes to a weight value,
used for scaling the loss function (during training only).
sample_weight: Numpy array of weights for
the training samples, used for scaling the loss function
(during training only). You can either pass a flat (1D)
Numpy array with the same length as the input samples
(1:1 mapping between weights and samples),
or in the case of temporal data,
you can pass a 2D array with shape (samples, sequence_length),
to apply a different weight to every timestep of every sample.
In this case you should make sure to specify
sample_weight_mode="temporal" in compile().
initial_epoch: epoch at which to start training
(useful for resuming a previous training run)
Returns:
A `History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.fit(x,
y,
batch_size=batch_size,
epochs=epochs,
verbose=verbose,
callbacks=callbacks,
validation_split=validation_split,
validation_data=validation_data,
shuffle=shuffle,
class_weight=class_weight,
sample_weight=sample_weight,
initial_epoch=initial_epoch)
def evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None):
"""Computes the loss on some input data, batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
batch_size: integer. Number of samples per gradient update.
verbose: verbosity mode, 0 or 1.
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.evaluate(x,
y,
batch_size=batch_size,
verbose=verbose,
sample_weight=sample_weight)
def predict(self, x, batch_size=32, verbose=0):
"""Generates output predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: the input data, as a Numpy array.
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict(x, batch_size=batch_size, verbose=verbose)
def predict_on_batch(self, x):
"""Returns predictions for a single batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict_on_batch(x)
def train_on_batch(self, x, y, class_weight=None, sample_weight=None):
"""Single gradient update over one batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
class_weight: dictionary mapping classes to a weight value,
used for scaling the loss function (during training only).
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar training loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.train_on_batch(x,
y,
sample_weight=sample_weight,
class_weight=class_weight)
def test_on_batch(self, x, y, sample_weight=None):
"""Evaluates the model over a single batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.test_on_batch(x, y, sample_weight=sample_weight)
def predict_proba(self, x, batch_size=32, verbose=1):
"""Generates class probability predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A Numpy array of probability predictions.
"""
preds = self.predict(x, batch_size, verbose)
if preds.min() < 0. or preds.max() > 1.:
warnings.warn('Network returning invalid probability values. '
'The last layer might not normalize predictions '
'into probabilities '
'(like softmax or sigmoid would).')
return preds
def predict_classes(self, x, batch_size=32, verbose=1):
"""Generate class predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A numpy array of class predictions.
"""
proba = self.predict(x, batch_size=batch_size, verbose=verbose)
if proba.shape[-1] > 1:
return proba.argmax(axis=-1)
else:
return (proba > 0.5).astype('int32')
def fit_generator(self,
generator,
steps_per_epoch,
epochs=1,
verbose=1,
callbacks=None,
validation_data=None,
validation_steps=None,
class_weight=None,
max_q_size=10,
workers=1,
pickle_safe=False,
initial_epoch=0):
"""Fits the model on data generated batch-by-batch by a Python generator.
The generator is run in parallel to the model, for efficiency.
For instance, this allows you to do real-time data augmentation
on images on CPU in parallel to training your model on GPU.
Arguments:
generator: A generator.
The output of the generator must be either
- a tuple (inputs, targets)
- a tuple (inputs, targets, sample_weights).
All arrays should contain the same number of samples.
The generator is expected to loop over its data
indefinitely. An epoch finishes when `samples_per_epoch`
samples have been seen by the model.
steps_per_epoch: Total number of steps (batches of samples)
to yield from `generator` before declaring one epoch
finished and starting the next epoch. It should typically
be equal to the number of unique samples if your dataset
divided by the batch size.
epochs: Integer, total number of iterations on the data.
verbose: Verbosity mode, 0, 1, or 2.
callbacks: List of callbacks to be called during training.
validation_data: This can be either
- A generator for the validation data
- A tuple (inputs, targets)
- A tuple (inputs, targets, sample_weights).
validation_steps: Only relevant if `validation_data`
is a generator.
Number of samples to use from validation generator
at the end of every epoch.
class_weight: Dictionary mapping class indices to a weight
for the class.
max_q_size: Maximum size for the generator queue
workers: Maximum number of processes to spin up
pickle_safe: Ff True, use process based threading.
Note that because
this implementation relies on multiprocessing,
you should not pass
non picklable arguments to the generator
as they can't be passed
easily to children processes.
initial_epoch: Epoch at which to start training
(useful for resuming a previous training run)
Returns:
A `History` object.
Raises:
RuntimeError: if the model was never compiled.
Example:
```python
def generate_arrays_from_file(path):
while 1:
f = open(path)
for line in f:
# create Numpy arrays of input data
# and labels, from each line in the file
x, y = process_line(line)
yield (x, y)
f.close()
model.fit_generator(generate_arrays_from_file('/my_file.txt'),
samples_per_epoch=10000, epochs=10)
```
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.fit_generator(generator,
steps_per_epoch,
epochs,
verbose=verbose,
callbacks=callbacks,
validation_data=validation_data,
validation_steps=validation_steps,
class_weight=class_weight,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe,
initial_epoch=initial_epoch)
def evaluate_generator(self,
generator,
steps,
max_q_size=10,
workers=1,
pickle_safe=False):
"""Evaluates the model on a data generator.
The generator should return the same kind of data
as accepted by `test_on_batch`.
Arguments:
generator: Generator yielding tuples (inputs, targets)
or (inputs, targets, sample_weights)
steps: Total number of steps (batches of samples)
to yield from `generator` before stopping.
max_q_size: maximum size for the generator queue
workers: maximum number of processes to spin up
pickle_safe: if True, use process based threading.
Note that because this implementation
relies on multiprocessing, you should not pass
non picklable arguments to the generator
as they can't be passed easily to children processes.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled '
'before being used.')
return self.model.evaluate_generator(generator,
steps,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe)
def predict_generator(self,
generator,
steps,
max_q_size=10,
workers=1,
pickle_safe=False):
"""Generates predictions for the input samples from a data generator.
The generator should return the same kind of data as accepted by
`predict_on_batch`.
Arguments:
generator: generator yielding batches of input samples.
steps: Total number of steps (batches of samples)
to yield from `generator` before stopping.
max_q_size: maximum size for the generator queue
workers: maximum number of processes to spin up
pickle_safe: if True, use process based threading.
Note that because this implementation
relies on multiprocessing, you should not pass
non picklable arguments to the generator
as they can't be passed easily to children processes.
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict_generator(generator,
steps,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe)
def get_config(self):
config = []
for layer in self.layers:
config.append({
'class_name': layer.__class__.__name__,
'config': layer.get_config()
})
return copy.deepcopy(config)
@classmethod
def from_config(cls, config):
model = cls()
for conf in config:
layer = layer_module.deserialize(conf)
model.add(layer)
return model
class Sequential(Model):
"""Linear stack of layers.
Arguments:
layers: list of layers to add to the model.
# Note
The first layer passed to a Sequential model
should have a defined input shape. What that
means is that it should have received an `input_shape`
or `batch_input_shape` argument,
or for some type of layers (recurrent, Dense...)
an `input_dim` argument.
Example:
```python
model = Sequential()
# first layer must have a defined input shape
model.add(Dense(32, input_dim=500))
# afterwards, Keras does automatic shape inference
model.add(Dense(32))
# also possible (equivalent to the above):
model = Sequential()
model.add(Dense(32, input_shape=(500,)))
model.add(Dense(32))
# also possible (equivalent to the above):
model = Sequential()
# here the batch dimension is None,
# which means any batch size will be accepted by the model.
model.add(Dense(32, batch_input_shape=(None, 500)))
model.add(Dense(32))
```
"""
def __init__(self, layers=None, name=None):
self.layers = [] # Stack of layers.
self.model = None # Internal Model instance.
self.inputs = [] # List of input tensors
self.outputs = [] # List of length 1: the output tensor (unique).
self._trainable = True
self._initial_weights = None
# Model attributes.
self.inbound_nodes = []
self.outbound_nodes = []
self.built = False
# Set model name.
if not name:
prefix = 'sequential_'
name = prefix + str(K.get_uid(prefix))
self.name = name
# The following properties are not actually used by Keras;
# they exist for compatibility with TF's variable scoping mechanism.
self._updates = []
self._losses = []
self._scope = None
self._reuse = None
self._base_name = name
self._graph = ops.get_default_graph()
# Add to the model any layers passed to the constructor.
if layers:
for layer in layers:
self.add(layer)
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Arguments:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
if not isinstance(layer, Layer):
raise TypeError('The added layer must be '
'an instance of class Layer. '
'Found: ' + str(layer))
if not self.outputs:
# first layer in model: check that it is an input layer
if not layer.inbound_nodes:
# create an input layer
if not hasattr(layer, 'batch_input_shape'):
raise ValueError('The first layer in a '
'Sequential model must '
'get an `input_shape` or '
'`batch_input_shape` argument.')
# Instantiate the input layer.
x = Input(
batch_shape=layer.batch_input_shape,
dtype=layer.dtype,
name=layer.name + '_input')
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
if len(layer.inbound_nodes) != 1:
raise ValueError('A layer added to a Sequential model must '
'not already be connected somewhere else. '
'Model received layer ' + layer.name + ' which has ' +
str(len(layer.inbound_nodes)) +
' pre-existing inbound connections.')
if len(layer.inbound_nodes[0].output_tensors) != 1:
raise ValueError('All layers in a Sequential model '
'should have a single output tensor. '
'For multi-output layers, '
'use the functional API.')
self.outputs = [layer.inbound_nodes[0].output_tensors[0]]
self.inputs = topology.get_source_inputs(self.outputs[0])
# We create an input node, which we will keep updated
# as we add more layers
topology.Node(
outbound_layer=self,
inbound_layers=[],
node_indices=[],
tensor_indices=[],
input_tensors=self.inputs,
output_tensors=self.outputs,
# no model-level masking for now
input_masks=[None for _ in self.inputs],
output_masks=[None])
else:
output_tensor = layer(self.outputs[0])
if isinstance(output_tensor, list):
raise TypeError('All layers in a Sequential model '
'should have a single output tensor. '
'For multi-output layers, '
'use the functional API.')
self.outputs = [output_tensor]
# update self.inbound_nodes
self.inbound_nodes[0].output_tensors = self.outputs
self.inbound_nodes[0].output_shapes = [K.int_shape(self.outputs[0])]
self.layers.append(layer)
self.built = False
def pop(self):
"""Removes the last layer in the model.
Raises:
TypeError: if there are no layers in the model.
"""
if not self.layers:
raise TypeError('There are no layers in the model.')
self.layers.pop()
if not self.layers:
self.outputs = []
self.inbound_nodes = []
self.outbound_nodes = []
else:
self.layers[-1].outbound_nodes = []
self.outputs = [self.layers[-1].output]
# update self.inbound_nodes
self.inbound_nodes[0].output_tensors = self.outputs
self.inbound_nodes[0].output_shapes = [K.int_shape(self.outputs[0])]
self.built = False
def get_layer(self, name=None, index=None):
"""Retrieve a layer that is part of the model.
Returns a layer based on either its name (unique)
or its index in the graph. Indices are based on
order of horizontal graph traversal (bottom-up).
Arguments:
name: string, name of layer.
index: integer, index of layer.
Returns:
A layer instance.
"""
if self.model is None:
self.build()
return self.model.get_layer(name, index)
def call(self, inputs, mask=None):
if self.model is None:
self.build()
return self.model.call(inputs, mask)
def build(self, input_shape=None):
if not self.inputs or not self.outputs:
raise TypeError('Sequential model cannot be built: model is empty.'
' Add some layers first.')
# actually create the model
self.model = Model(self.inputs, self.outputs[0], name=self.name + '_model')
self.model.trainable = self.trainable
# mirror model attributes
self.supports_masking = self.model.supports_masking
self._output_mask_cache = self.model._output_mask_cache
self._output_tensor_cache = self.model._output_tensor_cache
self._output_shape_cache = self.model._output_shape_cache
self.input_layers = self.model.input_layers
self.input_layers_node_indices = self.model.input_layers_node_indices
self.input_layers_tensor_indices = self.model.input_layers_tensor_indices
self.output_layers = self.model.output_layers
self.output_layers_node_indices = self.model.output_layers_node_indices
self.output_layers_tensor_indices = self.model.output_layers_tensor_indices
self.nodes_by_depth = self.model.nodes_by_depth
self.container_nodes = self.model.container_nodes
self.output_names = self.model.output_names
self.input_names = self.model.input_names
self._feed_input_names = self.model._feed_input_names
self._feed_inputs = self.model._feed_inputs
# Make sure child model callbacks
# will call the parent Sequential model.
self.model.callback_model = self
self.built = True
@property
def uses_learning_phase(self):
if self.model is None:
self.build()
return self.model.uses_learning_phase
def _gather_list_attr(self, attr):
all_attrs = []
for layer in self.layers:
all_attrs += getattr(layer, attr, [])
return all_attrs
@property
def trainable(self):
return self._trainable
@trainable.setter
def trainable(self, value):
if self.model:
self.model.trainable = value
self._trainable = value
@property
def trainable_weights(self):
if not self.trainable:
return []
return self._gather_list_attr('trainable_weights')
@property
def non_trainable_weights(self):
weights = self._gather_list_attr('non_trainable_weights')
if not self.trainable:
trainable_weights = self._gather_list_attr('trainable_weights')
return trainable_weights + weights
return weights
@property
def updates(self):
if self.model is None:
self.build()
return self.model.updates
@property
def state_updates(self):
if self.model is None:
self.build()
return self.model.state_updates
def get_updates_for(self, inputs):
if self.model is None:
self.build()
return self.model.get_updates_for(inputs)
@property
def losses(self):
if self.model is None:
self.build()
return self.model.losses
def get_losses_for(self, inputs):
if self.model is None:
self.build()
return self.model.get_losses_for(inputs)
@property
def regularizers(self):
if self.model is None:
self.build()
return self.model.regularizers
@property
def constraints(self):
if self.model is None:
self.build()
return self.model.constraints
def get_weights(self):
"""Retrieves the weights of the model.
Returns:
A flat list of Numpy arrays
(one array per model weight).
"""
if self.model is None:
self.build()
return self.model.get_weights()
def set_weights(self, weights):
"""Sets the weights of the model.
Arguments:
weights: Should be a list
of Numpy arrays with shapes and types matching
the output of `model.get_weights()`.
"""
if self.model is None:
self.build()
self.model.set_weights(weights)
def load_weights(self, filepath, by_name=False):
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(filepath, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
layers = self.layers
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
def save_weights(self, filepath, overwrite=True):
if h5py is None:
raise ImportError('`save_weights` requires h5py.')
# If file exists and should not be overwritten:
if not overwrite and os.path.isfile(filepath):
proceed = ask_to_proceed_with_overwrite(filepath)
if not proceed:
return
layers = self.layers
f = h5py.File(filepath, 'w')
topology.save_weights_to_hdf5_group(f, layers)
f.flush()
f.close()
def compile(self,
optimizer,
loss,
metrics=None,
sample_weight_mode=None,
**kwargs):
"""Configures the learning process.
Arguments:
optimizer: str (name of optimizer) or optimizer object.
See [optimizers](/optimizers).
loss: str (name of objective function) or objective function.
See [losses](/losses).
metrics: list of metrics to be evaluated by the model
during training and testing.
Typically you will use `metrics=['accuracy']`.
See [metrics](/metrics).
sample_weight_mode: if you need to do timestep-wise
sample weighting (2D weights), set this to "temporal".
"None" defaults to sample-wise weights (1D).
**kwargs: for Theano backend, these are passed into K.function.
When using the Tensorflow backend, these are passed into
`tf.Session.run`.
Example:
```python
model = Sequential()
model.add(Dense(32, input_shape=(500,)))
model.add(Dense(10, activation='softmax'))
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
```
"""
# create the underlying model
self.build()
# call compile method of Model class
self.model.compile(
optimizer,
loss,
metrics=metrics,
sample_weight_mode=sample_weight_mode,
**kwargs)
self.optimizer = self.model.optimizer
self.loss = self.model.loss
self.total_loss = self.model.total_loss
self.loss_weights = self.model.loss_weights
self.metrics = self.model.metrics
self.metrics_tensors = self.model.metrics_tensors
self.metrics_names = self.model.metrics_names
self.sample_weight_mode = self.model.sample_weight_mode
self.sample_weights = self.model.sample_weights
self.targets = self.model.targets
def fit(self,
x,
y,
batch_size=32,
epochs=10,
verbose=1,
callbacks=None,
validation_split=0.,
validation_data=None,
shuffle=True,
class_weight=None,
sample_weight=None,
initial_epoch=0):
"""Trains the model for a fixed number of epochs.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
batch_size: integer. Number of samples per gradient update.
epochs: integer, the number of epochs to train the model.
verbose: 0 for no logging to stdout,
1 for progress bar logging, 2 for one log line per epoch.
callbacks: list of `keras.callbacks.Callback` instances.
List of callbacks to apply during training.
See [callbacks](/callbacks).
validation_split: float (0. < x < 1).
Fraction of the data to use as held-out validation data.
validation_data: tuple (x_val, y_val) or tuple
(x_val, y_val, val_sample_weights) to be used as held-out
validation data. Will override validation_split.
shuffle: boolean or str (for 'batch').
Whether to shuffle the samples at each epoch.
'batch' is a special option for dealing with the
limitations of HDF5 data; it shuffles in batch-sized chunks.
class_weight: dictionary mapping classes to a weight value,
used for scaling the loss function (during training only).
sample_weight: Numpy array of weights for
the training samples, used for scaling the loss function
(during training only). You can either pass a flat (1D)
Numpy array with the same length as the input samples
(1:1 mapping between weights and samples),
or in the case of temporal data,
you can pass a 2D array with shape (samples, sequence_length),
to apply a different weight to every timestep of every sample.
In this case you should make sure to specify
sample_weight_mode="temporal" in compile().
initial_epoch: epoch at which to start training
(useful for resuming a previous training run)
Returns:
A `History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.fit(
x,
y,
batch_size=batch_size,
epochs=epochs,
verbose=verbose,
callbacks=callbacks,
validation_split=validation_split,
validation_data=validation_data,
shuffle=shuffle,
class_weight=class_weight,
sample_weight=sample_weight,
initial_epoch=initial_epoch)
def evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None):
"""Computes the loss on some input data, batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
batch_size: integer. Number of samples per gradient update.
verbose: verbosity mode, 0 or 1.
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.evaluate(
x,
y,
batch_size=batch_size,
verbose=verbose,
sample_weight=sample_weight)
def predict(self, x, batch_size=32, verbose=0):
"""Generates output predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: the input data, as a Numpy array.
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict(x, batch_size=batch_size, verbose=verbose)
def predict_on_batch(self, x):
"""Returns predictions for a single batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict_on_batch(x)
def train_on_batch(self, x, y, class_weight=None, sample_weight=None):
"""Single gradient update over one batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
class_weight: dictionary mapping classes to a weight value,
used for scaling the loss function (during training only).
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar training loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.train_on_batch(
x, y, sample_weight=sample_weight, class_weight=class_weight)
def test_on_batch(self, x, y, sample_weight=None):
"""Evaluates the model over a single batch of samples.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
y: labels, as a Numpy array.
sample_weight: sample weights, as a Numpy array.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.test_on_batch(x, y, sample_weight=sample_weight)
def predict_proba(self, x, batch_size=32, verbose=1):
"""Generates class probability predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A Numpy array of probability predictions.
"""
preds = self.predict(x, batch_size, verbose)
if preds.min() < 0. or preds.max() > 1.:
logging.warning('Network returning invalid probability values. '
'The last layer might not normalize predictions '
'into probabilities '
'(like softmax or sigmoid would).')
return preds
def predict_classes(self, x, batch_size=32, verbose=1):
"""Generate class predictions for the input samples.
The input samples are processed batch by batch.
Arguments:
x: input data, as a Numpy array or list of Numpy arrays
(if the model has multiple inputs).
batch_size: integer.
verbose: verbosity mode, 0 or 1.
Returns:
A numpy array of class predictions.
"""
proba = self.predict(x, batch_size=batch_size, verbose=verbose)
if proba.shape[-1] > 1:
return proba.argmax(axis=-1)
else:
return (proba > 0.5).astype('int32')
def fit_generator(self,
generator,
steps_per_epoch,
epochs=1,
verbose=1,
callbacks=None,
validation_data=None,
validation_steps=None,
class_weight=None,
max_q_size=10,
workers=1,
pickle_safe=False,
initial_epoch=0):
"""Fits the model on data generated batch-by-batch by a Python generator.
The generator is run in parallel to the model, for efficiency.
For instance, this allows you to do real-time data augmentation
on images on CPU in parallel to training your model on GPU.
Arguments:
generator: A generator.
The output of the generator must be either
- a tuple (inputs, targets)
- a tuple (inputs, targets, sample_weights).
All arrays should contain the same number of samples.
The generator is expected to loop over its data
indefinitely. An epoch finishes when `steps_per_epoch`
batches have been seen by the model.
steps_per_epoch: Total number of steps (batches of samples)
to yield from `generator` before declaring one epoch
finished and starting the next epoch. It should typically
be equal to the number of unique samples of your dataset
divided by the batch size.
epochs: Integer, total number of iterations on the data.
verbose: Verbosity mode, 0, 1, or 2.
callbacks: List of callbacks to be called during training.
validation_data: This can be either
- A generator for the validation data
- A tuple (inputs, targets)
- A tuple (inputs, targets, sample_weights).
validation_steps: Only relevant if `validation_data`
is a generator.
Number of steps to yield from validation generator
at the end of every epoch. It should typically
be equal to the number of unique samples of your
validation dataset divided by the batch size.
class_weight: Dictionary mapping class indices to a weight
for the class.
max_q_size: Maximum size for the generator queue
workers: Maximum number of processes to spin up
pickle_safe: Ff True, use process based threading.
Note that because
this implementation relies on multiprocessing,
you should not pass
non picklable arguments to the generator
as they can't be passed
easily to children processes.
initial_epoch: Epoch at which to start training
(useful for resuming a previous training run)
Returns:
A `History` object.
Raises:
RuntimeError: if the model was never compiled.
Example:
```python
def generate_arrays_from_file(path):
while 1:
f = open(path)
for line in f:
# create Numpy arrays of input data
# and labels, from each line in the file
x, y = process_line(line)
yield (x, y)
f.close()
model.fit_generator(generate_arrays_from_file('/my_file.txt'),
steps_per_epoch=1000, epochs=10)
```
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.fit_generator(
generator,
steps_per_epoch,
epochs,
verbose=verbose,
callbacks=callbacks,
validation_data=validation_data,
validation_steps=validation_steps,
class_weight=class_weight,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe,
initial_epoch=initial_epoch)
def evaluate_generator(self,
generator,
steps,
max_q_size=10,
workers=1,
pickle_safe=False):
"""Evaluates the model on a data generator.
The generator should return the same kind of data
as accepted by `test_on_batch`.
Arguments:
generator: Generator yielding tuples (inputs, targets)
or (inputs, targets, sample_weights)
steps: Total number of steps (batches of samples)
to yield from `generator` before stopping.
max_q_size: maximum size for the generator queue
workers: maximum number of processes to spin up
pickle_safe: if True, use process based threading.
Note that because this implementation
relies on multiprocessing, you should not pass
non picklable arguments to the generator
as they can't be passed easily to children processes.
Returns:
Scalar test loss (if the model has no metrics)
or list of scalars (if the model computes other metrics).
The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: if the model was never compiled.
"""
if self.model is None:
raise RuntimeError('The model needs to be compiled ' 'before being used.')
return self.model.evaluate_generator(
generator,
steps,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe)
def predict_generator(self,
generator,
steps,
max_q_size=10,
workers=1,
pickle_safe=False,
verbose=0):
"""Generates predictions for the input samples from a data generator.
The generator should return the same kind of data as accepted by
`predict_on_batch`.
Arguments:
generator: generator yielding batches of input samples.
steps: Total number of steps (batches of samples)
to yield from `generator` before stopping.
max_q_size: maximum size for the generator queue
workers: maximum number of processes to spin up
pickle_safe: if True, use process based threading.
Note that because this implementation
relies on multiprocessing, you should not pass
non picklable arguments to the generator
as they can't be passed easily to children processes.
verbose: verbosity mode, 0 or 1.
Returns:
A Numpy array of predictions.
"""
if self.model is None:
self.build()
return self.model.predict_generator(
generator,
steps,
max_q_size=max_q_size,
workers=workers,
pickle_safe=pickle_safe,
verbose=verbose)
def get_config(self):
config = []
for layer in self.layers:
config.append({
'class_name': layer.__class__.__name__,
'config': layer.get_config()
})
return copy.deepcopy(config)
@classmethod
def from_config(cls, config, custom_objects=None):
model = cls()
for conf in config:
layer = layer_module.deserialize(conf, custom_objects=custom_objects)
model.add(layer)
return model