Apply an activation function to an output. # Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, do

Convolution operator for filtering windows of two-dimensional inputs. When using this layer as the first layer in a model, provide the keyword

Apply Dropout to the input. Dropout consists in randomly setting a fraction `p` of input units to 0 at each update during training time, which

Just your regular fully connected NN layer. # Input shape 2D tensor with shape: `(nb_samples, input_dim)`. # Output shape 2D

Max pooling operation for spatial data. # Input shape 4D tensor with shape: `(samples, channels, rows, cols)` if dim_ordering='th

Linear stack of layers. Inherits from containers.Sequential.

Flatten the input. Does not affect the batch size. # Input shape Arbitrary, although all dimensions in the input shape must be fixed.

Zero-padding layer for 2D input (e.g. picture). # Input shape 4D tensor with shape: (samples, depth, first_axis_to_pad, second_ax

Stochastic gradient descent, with support for momentum, decay, and Nesterov momentum. # Arguments lr: float >= 0. Learning rate.

Merge the output of a list of layers or containers into a single tensor. # Arguments mode: one of {sum, mul, concat, ave, dot}.

Arbitrary connection graph. It can have any number of inputs and outputs, with each output trained with its own loss function. The quantit

Turn positive integers (indexes) into dense vectors of fixed size. eg. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]] This layer can only be used

Long-Short Term Memory unit - Hochreiter 1997. For a step-by-step description of the algorithm, see [this tutorial](http://deeplearning.net/t

# Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, does not include the samples axis) wh

RMSProp optimizer. It is recommended to leave the parameters of this optimizer at their default values. This optimizer is usually a good

Reshape an output to a certain shape. # Input shape Arbitrary, although all dimensions in the input shaped must be fixed. Use the

Share a layer accross multiple inputs. For instance, this allows you to applied e.g. a same `Dense` layer to the output of two different

Apply a same Dense layer for each dimension[1] (time_dimension) input. Especially useful after a recurrent network with 'return_sequence=True'.

Normalize the activations of the previous layer at each batch, i.e. applies a transformation that maintains the mean activation close to 0 and

Convolution operator for filtering neighborhoods of one-dimensional inputs. When using this layer as the first layer in a model, either provid

Max pooling operation for temporal data. # Input shape 3D tensor with shape: `(samples, steps, features)`. # Output shape 3D

This layer should be added only on top of a Siamese layer with merge_mode = None. Outputs the output of the Siamese layer at a given index,

This is the combination of a sample-wise L2 normalization with the concatenation of the positive part of the input with the negative part

Average pooling operation for spatial data. # Input shape 4D tensor with shape: `(samples, channels, rows, cols)` if dim_ordering

Gated Recurrent Unit - Cho et al. 2014. # Arguments output_dim: dimension of the internal projections and the final output. init:

Used for evaluating an arbitrary Theano / TensorFlow expression on the output of the previous layer. # Input shape Arbitrary. Use the

LambdaMerge layer for evaluating an arbitrary Theano / TensorFlow function over multiple inputs. # Output shape Specified by output_s

Permute the dimensions of the input according to a given pattern. Useful for e.g. connecting RNNs and convnets together. # Input shape

Repeat the input n times. # Input shape 2D tensor of shape `(nb_samples, features)`. # Output shape 3D tensor of shape `(nb_

Fully-connected RNN where the output is to fed back to input. # Arguments output_dim: dimension of the internal projections and the final

Repeat the rows and columns of the data by size[0] and size[1] respectively. # Input shape 4D tensor with shape: `(samples, c

Adadelta optimizer. It is recommended to leave the parameters of this optimizer at their default values. # Arguments lr: float >

Adagrad optimizer. It is recommended to leave the parameters of this optimizer at their default values. # Arguments lr: float >=

Adam optimizer. Default parameters follow those provided in the original paper. # Arguments lr: float >= 0. Learning rate. b

Adamax optimizer from Adam paper's Section 7. It is a variant of Adam based on the infinity norm. Default parameters follow those provided i

A customizable autoencoder model. # Input shape Same as encoder input. # Output shape If `output_reconstruction = True` then

Average pooling for temporal data. # Input shape 3D tensor with shape: `(samples, steps, features)`. # Output shape 3D t

Given a set of characters: + Encode them to a one hot integer representation + Decode the one hot integer representation to their charact

# Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, does not include the samples axis) wh

Generate minibatches with realtime data augmentation.

Implementation of the scikit-learn classifier API for Keras. Parameters ---------- model : object An un-compiled Keras model

Implementation of the scikit-learn regressor API for Keras. Parameters ---------- model : object An un-compiled Keras model

Abstract base layer class. All Keras layers accept certain keyword arguments: trainable: boolean. Set to "False" before model compilatio

Special version of a Rectified Linear Unit that allows a small gradient when the unit is not active (`f(x) = alpha*x for x < 0`). # Input

Mask an input sequence by using a mask value to identify padding. This layer copies the input to the output layer with identified padding rep

This is a helper class which visits a keras model (Sequential or Graph) and returns a pydot.Graph representation. This is implemented as

Parametric Softplus of the form: alpha * log(1 + exp(beta * X)) # Input shape Arbitrary. Use the keyword argument `input_shape` (

Thresholded Linear Activation. # Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, does not inclu

Thresholded Rectified Activation. # Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, does not in

Repeat each temporal step `length` times along the time axis. # Input shape 3D tensor with shape: `(samples, steps, features)`. # Ou

A helper class to index into a parameter vector.

Zero-padding layer for 1D input (e.g. temporal sequence). # Input shape 3D tensor with shape (samples, axis_to_pad, features) # Outp

Layer that passes through its input unchanged, but applies an update to the cost function based on the activity. # Input shape Arbitr

Callback that prints events to the standard output. This callback is automatically applied to every Keras model (it is the basis of the verbo

Base class for the Keras scikit-learn wrapper. Warning: This class should not be used directly. Use derived classes instead. Parameters

Abstract base class used to build new callbacks. # Properties params: dict. Training parameters (eg. verbosity, batch size, n

Stop training when a monitored quantity has stopped improving. # Arguments monitor: quantity to be monitored. patience: number of

Apply to the input an multiplicative one-centred gaussian noise with standard deviation `sqrt(p/(1-p))`. As it is a regularization layer, it

Apply to the input an additive zero-centred gaussian noise with standard deviation `sigma`. This is useful to mitigate overfitting (you could

Implement a NN graph with arbitrary layer connections, arbitrary number of inputs and arbitrary number of outputs. This class is also the bas

Densely connected highway network, a natural extension of LSTMs to feedforward networks. # Input shape 2D tensor with shape: `(nb_sam

Callback that records events into a `History` object. This callback is automatically applied to every Keras model. The `History` object

Learning rate scheduler. # Arguments schedule: a function that takes an epoch index as input (integer, indexed from 0) and re

If your layer trivially supports masking (by simply copying the input mask to the output), then subclass MaskedLayer instead of Layer, and

A dense maxout layer. A `MaxoutDense` layer takes the element-wise maximum of `nb_feature` `Dense(input_dim, output_dim)` linear layers.

Abstract base model class.

Save the model after every epoch. `filepath` can contain named formatting options, which will be filled the value of `epoch` and keys in

Abstract optimizer base class. Note: this is the parent class of all optimizers, not an actual optimizer that can be used for training models