4 |
5 | {{autogenerated}}
--------------------------------------------------------------------------------
/docs/templates/initializers.md:
--------------------------------------------------------------------------------
1 | ## Usage of initializers
2 |
3 | Initializations define the way to set the initial random weights of Keras layers.
4 |
5 | The keyword arguments used for passing initializers to layers will depend on the layer. Usually it is simply `kernel_initializer` and `bias_initializer`:
6 |
7 | ```python
8 | model.add(Dense(64,
9 | kernel_initializer='random_uniform',
10 | bias_initializer='zeros'))
11 | ```
12 |
13 | ## Available initializers
14 |
15 | The following built-in initializers are available as part of the `keras.initializers` module:
16 |
17 | {{autogenerated}}
18 |
19 |
20 | An initializer may be passed as a string (must match one of the available initializers above), or as a callable:
21 |
22 | ```python
23 | from keras import initializers
24 |
25 | model.add(Dense(64, kernel_initializer=initializers.random_normal(stddev=0.01)))
26 |
27 | # also works; will use the default parameters.
28 | model.add(Dense(64, kernel_initializer='random_normal'))
29 | ```
30 |
31 |
32 | ## Using custom initializers
33 |
34 | If passing a custom callable, then it must take the argument `shape` (shape of the variable to initialize) and `dtype` (dtype of generated values):
35 |
36 | ```python
37 | from keras import backend as K
38 |
39 | def my_init(shape, dtype=None):
40 | return K.random_normal(shape, dtype=dtype)
41 |
42 | model.add(Dense(64, kernel_initializer=my_init))
43 | ```
44 |
--------------------------------------------------------------------------------
/docs/templates/layers/about-keras-layers.md:
--------------------------------------------------------------------------------
1 | # About Keras layers
2 |
3 | All Keras layers have a number of methods in common:
4 |
5 | - `layer.get_weights()`: returns the weights of the layer as a list of Numpy arrays.
6 | - `layer.set_weights(weights)`: sets the weights of the layer from a list of Numpy arrays (with the same shapes as the output of `get_weights`).
7 | - `layer.get_config()`: returns a dictionary containing the configuration of the layer. The layer can be reinstantiated from its config via:
8 |
9 | ```python
10 | layer = Dense(32)
11 | config = layer.get_config()
12 | reconstructed_layer = Dense.from_config(config)
13 | ```
14 |
15 | Or:
16 |
17 | ```python
18 | from keras import layers
19 |
20 | config = layer.get_config()
21 | layer = layers.deserialize({'class_name': layer.__class__.__name__,
22 | 'config': config})
23 | ```
24 |
25 | If a layer has a single node (i.e. if it isn't a shared layer), you can get its input tensor, output tensor, input shape and output shape via:
26 |
27 | - `layer.input`
28 | - `layer.output`
29 | - `layer.input_shape`
30 | - `layer.output_shape`
31 |
32 | If the layer has multiple nodes (see: [the concept of layer node and shared layers](/getting-started/functional-api-guide/#the-concept-of-layer-node)), you can use the following methods:
33 |
34 | - `layer.get_input_at(node_index)`
35 | - `layer.get_output_at(node_index)`
36 | - `layer.get_input_shape_at(node_index)`
37 | - `layer.get_output_shape_at(node_index)`
--------------------------------------------------------------------------------
/docs/templates/layers/writing-your-own-keras-layers.md:
--------------------------------------------------------------------------------
1 | # Writing your own Keras layers
2 |
3 | For simple, stateless custom operations, you are probably better off using `layers.core.Lambda` layers. But for any custom operation that has trainable weights, you should implement your own layer.
4 |
5 | Here is the skeleton of a Keras layer, **as of Keras 2.0** (if you have an older version, please upgrade). There are only three methods you need to implement:
6 |
7 | - `build(input_shape)`: this is where you will define your weights. This method must set `self.built = True` at the end, which can be done by calling `super([Layer], self).build()`.
8 | - `call(x)`: this is where the layer's logic lives. Unless you want your layer to support masking, you only have to care about the first argument passed to `call`: the input tensor.
9 | - `compute_output_shape(input_shape)`: in case your layer modifies the shape of its input, you should specify here the shape transformation logic. This allows Keras to do automatic shape inference.
10 |
11 | ```python
12 | from keras import backend as K
13 | from keras.layers import Layer
14 |
15 | class MyLayer(Layer):
16 |
17 | def __init__(self, output_dim, **kwargs):
18 | self.output_dim = output_dim
19 | super(MyLayer, self).__init__(**kwargs)
20 |
21 | def build(self, input_shape):
22 | # Create a trainable weight variable for this layer.
23 | self.kernel = self.add_weight(name='kernel',
24 | shape=(input_shape[1], self.output_dim),
25 | initializer='uniform',
26 | trainable=True)
27 | super(MyLayer, self).build(input_shape) # Be sure to call this at the end
28 |
29 | def call(self, x):
30 | return K.dot(x, self.kernel)
31 |
32 | def compute_output_shape(self, input_shape):
33 | return (input_shape[0], self.output_dim)
34 | ```
35 |
36 | It is also possible to define Keras layers which have multiple input tensors and multiple output tensors. To do this, you should assume that the inputs and outputs of the methods `build(input_shape)`, `call(x)` and `compute_output_shape(input_shape)` are lists. Here is an example, similar to the one above:
37 |
38 | ```python
39 | from keras import backend as K
40 | from keras.layers import Layer
41 |
42 | class MyLayer(Layer):
43 |
44 | def __init__(self, output_dim, **kwargs):
45 | self.output_dim = output_dim
46 | super(MyLayer, self).__init__(**kwargs)
47 |
48 | def build(self, input_shape):
49 | assert isinstance(input_shape, list)
50 | # Create a trainable weight variable for this layer.
51 | self.kernel = self.add_weight(name='kernel',
52 | shape=(input_shape[0][1], self.output_dim),
53 | initializer='uniform',
54 | trainable=True)
55 | super(MyLayer, self).build(input_shape) # Be sure to call this at the end
56 |
57 | def call(self, x):
58 | assert isinstance(x, list)
59 | a, b = x
60 | return [K.dot(a, self.kernel) + b, K.mean(b, axis=-1)]
61 |
62 | def compute_output_shape(self, input_shape):
63 | assert isinstance(input_shape, list)
64 | shape_a, shape_b = input_shape
65 | return [(shape_a[0], self.output_dim), shape_b[:-1]]
66 | ```
67 |
68 | The existing Keras layers provide examples of how to implement almost anything. Never hesitate to read the source code!
69 |
--------------------------------------------------------------------------------
/docs/templates/losses.md:
--------------------------------------------------------------------------------
1 |
2 | ## Usage of loss functions
3 |
4 | A loss function (or objective function, or optimization score function) is one of the two parameters required to compile a model:
5 |
6 | ```python
7 | model.compile(loss='mean_squared_error', optimizer='sgd')
8 | ```
9 |
10 | ```python
11 | from keras import losses
12 |
13 | model.compile(loss=losses.mean_squared_error, optimizer='sgd')
14 | ```
15 |
16 | You can either pass the name of an existing loss function, or pass a TensorFlow/Theano symbolic function that returns a scalar for each data-point and takes the following two arguments:
17 |
18 | - __y_true__: True labels. TensorFlow/Theano tensor.
19 | - __y_pred__: Predictions. TensorFlow/Theano tensor of the same shape as y_true.
20 |
21 | The actual optimized objective is the mean of the output array across all datapoints.
22 |
23 | For a few examples of such functions, check out the [losses source](https://github.com/keras-team/keras/blob/master/keras/losses.py).
24 |
25 | ## Available loss functions
26 |
27 | {{autogenerated}}
28 |
29 | ----
30 |
31 | **Note**: when using the `categorical_crossentropy` loss, your targets should be in categorical format (e.g. if you have 10 classes, the target for each sample should be a 10-dimensional vector that is all-zeros except for a 1 at the index corresponding to the class of the sample). In order to convert *integer targets* into *categorical targets*, you can use the Keras utility `to_categorical`:
32 |
33 | ```python
34 | from keras.utils import to_categorical
35 |
36 | categorical_labels = to_categorical(int_labels, num_classes=None)
37 | ```
38 |
39 | When using the `sparse_categorical_crossentropy` loss, your targets should be *integer targets*.
40 | If you have categorical targets, you should use `categorical_crossentropy`.
41 |
42 | `categorical_crossentropy` is another term for [multi-class log loss](http://wiki.fast.ai/index.php/Log_Loss).
43 |
--------------------------------------------------------------------------------
/docs/templates/metrics.md:
--------------------------------------------------------------------------------
1 |
2 | ## Usage of metrics
3 |
4 | A metric is a function that is used to judge the performance of your model. Metric functions are to be supplied in the `metrics` parameter when a model is compiled.
5 |
6 | ```python
7 | model.compile(loss='mean_squared_error',
8 | optimizer='sgd',
9 | metrics=['mae', 'acc'])
10 | ```
11 |
12 | ```python
13 | from keras import metrics
14 |
15 | model.compile(loss='mean_squared_error',
16 | optimizer='sgd',
17 | metrics=[metrics.mae, metrics.categorical_accuracy])
18 | ```
19 |
20 | A metric function is similar to a [loss function](/losses), except that the results from evaluating a metric are not used when training the model. You may use any of the loss functions as a metric function.
21 |
22 | You can either pass the name of an existing metric, or pass a Theano/TensorFlow symbolic function (see [Custom metrics](#custom-metrics)).
23 |
24 | #### Arguments
25 | - __y_true__: True labels. Theano/TensorFlow tensor.
26 | - __y_pred__: Predictions. Theano/TensorFlow tensor of the same shape as y_true.
27 |
28 | #### Returns
29 | Single tensor value representing the mean of the output array across all
30 | datapoints.
31 |
32 | ----
33 |
34 | ## Available metrics
35 |
36 |
37 | {{autogenerated}}
38 |
39 | In addition to the metrics above, you may use any of the loss functions described in the [loss function](/losses) page as metrics.
40 |
41 | ----
42 |
43 | ## Custom metrics
44 |
45 | Custom metrics can be passed at the compilation step. The
46 | function would need to take `(y_true, y_pred)` as arguments and return
47 | a single tensor value.
48 |
49 | ```python
50 | import keras.backend as K
51 |
52 | def mean_pred(y_true, y_pred):
53 | return K.mean(y_pred)
54 |
55 | model.compile(optimizer='rmsprop',
56 | loss='binary_crossentropy',
57 | metrics=['accuracy', mean_pred])
58 | ```
59 |
--------------------------------------------------------------------------------
/docs/templates/models/model.md:
--------------------------------------------------------------------------------
1 | # Model class API
2 |
3 | In the functional API, given some input tensor(s) and output tensor(s), you can instantiate a `Model` via:
4 |
5 | ```python
6 | from keras.models import Model
7 | from keras.layers import Input, Dense
8 |
9 | a = Input(shape=(32,))
10 | b = Dense(32)(a)
11 | model = Model(inputs=a, outputs=b)
12 | ```
13 |
14 | This model will include all layers required in the computation of `b` given `a`.
15 |
16 | In the case of multi-input or multi-output models, you can use lists as well:
17 |
18 | ```python
19 | model = Model(inputs=[a1, a2], outputs=[b1, b2, b3])
20 | ```
21 |
22 | For a detailed introduction of what `Model` can do, read [this guide to the Keras functional API](/getting-started/functional-api-guide).
23 |
24 |
25 | ## Methods
26 |
27 | {{autogenerated}}
28 |
--------------------------------------------------------------------------------
/docs/templates/models/sequential.md:
--------------------------------------------------------------------------------
1 | # The Sequential model API
2 |
3 | To get started, read [this guide to the Keras Sequential model](/getting-started/sequential-model-guide).
4 |
5 | ----
6 |
7 | ## Sequential model methods
8 |
9 | {{autogenerated}}
--------------------------------------------------------------------------------
/docs/templates/optimizers.md:
--------------------------------------------------------------------------------
1 |
2 | ## Usage of optimizers
3 |
4 | An optimizer is one of the two arguments required for compiling a Keras model:
5 |
6 | ```python
7 | from keras import optimizers
8 |
9 | model = Sequential()
10 | model.add(Dense(64, kernel_initializer='uniform', input_shape=(10,)))
11 | model.add(Activation('softmax'))
12 |
13 | sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
14 | model.compile(loss='mean_squared_error', optimizer=sgd)
15 | ```
16 |
17 | You can either instantiate an optimizer before passing it to `model.compile()` , as in the above example, or you can call it by its name. In the latter case, the default parameters for the optimizer will be used.
18 |
19 | ```python
20 | # pass optimizer by name: default parameters will be used
21 | model.compile(loss='mean_squared_error', optimizer='sgd')
22 | ```
23 |
24 | ---
25 |
26 | ## Parameters common to all Keras optimizers
27 |
28 | The parameters `clipnorm` and `clipvalue` can be used with all optimizers to control gradient clipping:
29 |
30 | ```python
31 | from keras import optimizers
32 |
33 | # All parameter gradients will be clipped to
34 | # a maximum norm of 1.
35 | sgd = optimizers.SGD(lr=0.01, clipnorm=1.)
36 | ```
37 |
38 | ```python
39 | from keras import optimizers
40 |
41 | # All parameter gradients will be clipped to
42 | # a maximum value of 0.5 and
43 | # a minimum value of -0.5.
44 | sgd = optimizers.SGD(lr=0.01, clipvalue=0.5)
45 | ```
46 |
47 | ---
48 |
49 | {{autogenerated}}
50 |
--------------------------------------------------------------------------------
/docs/templates/preprocessing/image.md:
--------------------------------------------------------------------------------
1 |
2 | # Image Preprocessing
3 |
4 | {{autogenerated}}
5 |
--------------------------------------------------------------------------------
/docs/templates/preprocessing/text.md:
--------------------------------------------------------------------------------
1 |
2 | ### Text Preprocessing
3 |
4 | {{autogenerated}}
5 |
--------------------------------------------------------------------------------
/docs/templates/regularizers.md:
--------------------------------------------------------------------------------
1 | ## Usage of regularizers
2 |
3 | Regularizers allow to apply penalties on layer parameters or layer activity during optimization. These penalties are incorporated in the loss function that the network optimizes.
4 |
5 | The penalties are applied on a per-layer basis. The exact API will depend on the layer, but the layers `Dense`, `Conv1D`, `Conv2D` and `Conv3D` have a unified API.
6 |
7 | These layers expose 3 keyword arguments:
8 |
9 | - `kernel_regularizer`: instance of `keras.regularizers.Regularizer`
10 | - `bias_regularizer`: instance of `keras.regularizers.Regularizer`
11 | - `activity_regularizer`: instance of `keras.regularizers.Regularizer`
12 |
13 |
14 | ## Example
15 |
16 | ```python
17 | from keras import regularizers
18 | model.add(Dense(64, input_dim=64,
19 | kernel_regularizer=regularizers.l2(0.01),
20 | activity_regularizer=regularizers.l1(0.01)))
21 | ```
22 |
23 | ## Available penalties
24 |
25 | ```python
26 | keras.regularizers.l1(0.)
27 | keras.regularizers.l2(0.)
28 | keras.regularizers.l1_l2(l1=0.01, l2=0.01)
29 | ```
30 |
31 | ## Developing new regularizers
32 |
33 | Any function that takes in a weight matrix and returns a loss contribution tensor can be used as a regularizer, e.g.:
34 |
35 | ```python
36 | from keras import backend as K
37 |
38 | def l1_reg(weight_matrix):
39 | return 0.01 * K.sum(K.abs(weight_matrix))
40 |
41 | model.add(Dense(64, input_dim=64,
42 | kernel_regularizer=l1_reg))
43 | ```
44 |
45 | Alternatively, you can write your regularizers in an object-oriented way;
46 | see the [keras/regularizers.py](https://github.com/keras-team/keras/blob/master/keras/regularizers.py) module for examples.
47 |
--------------------------------------------------------------------------------
/docs/templates/scikit-learn-api.md:
--------------------------------------------------------------------------------
1 | # Wrappers for the Scikit-Learn API
2 |
3 | You can use `Sequential` Keras models (single-input only) as part of your Scikit-Learn workflow via the wrappers found at `keras.wrappers.scikit_learn.py`.
4 |
5 | There are two wrappers available:
6 |
7 | `keras.wrappers.scikit_learn.KerasClassifier(build_fn=None, **sk_params)`, which implements the Scikit-Learn classifier interface,
8 |
9 | `keras.wrappers.scikit_learn.KerasRegressor(build_fn=None, **sk_params)`, which implements the Scikit-Learn regressor interface.
10 |
11 | ### Arguments
12 |
13 | - __build_fn__: callable function or class instance
14 | - __sk_params__: model parameters & fitting parameters
15 |
16 | `build_fn` should construct, compile and return a Keras model, which
17 | will then be used to fit/predict. One of the following
18 | three values could be passed to `build_fn`:
19 |
20 | 1. A function
21 | 2. An instance of a class that implements the `__call__` method
22 | 3. None. This means you implement a class that inherits from either
23 | `KerasClassifier` or `KerasRegressor`. The `__call__` method of the
24 | present class will then be treated as the default `build_fn`.
25 |
26 | `sk_params` takes both model parameters and fitting parameters. Legal model
27 | parameters are the arguments of `build_fn`. Note that like all other
28 | estimators in scikit-learn, `build_fn` should provide default values for
29 | its arguments, so that you could create the estimator without passing any
30 | values to `sk_params`.
31 |
32 | `sk_params` could also accept parameters for calling `fit`, `predict`,
33 | `predict_proba`, and `score` methods (e.g., `epochs`, `batch_size`).
34 | fitting (predicting) parameters are selected in the following order:
35 |
36 | 1. Values passed to the dictionary arguments of
37 | `fit`, `predict`, `predict_proba`, and `score` methods
38 | 2. Values passed to `sk_params`
39 | 3. The default values of the `keras.models.Sequential`
40 | `fit`, `predict`, `predict_proba` and `score` methods
41 |
42 | When using scikit-learn's `grid_search` API, legal tunable parameters are
43 | those you could pass to `sk_params`, including fitting parameters.
44 | In other words, you could use `grid_search` to search for the best
45 | `batch_size` or `epochs` as well as the model parameters.
46 |
--------------------------------------------------------------------------------
/docs/templates/visualization.md:
--------------------------------------------------------------------------------
1 |
2 | ## Model visualization
3 |
4 | Keras provides utility functions to plot a Keras model (using `graphviz`).
5 |
6 | This will plot a graph of the model and save it to a file:
7 | ```python
8 | from keras.utils import plot_model
9 | plot_model(model, to_file='model.png')
10 | ```
11 |
12 | `plot_model` takes four optional arguments:
13 |
14 | - `show_shapes` (defaults to False) controls whether output shapes are shown in the graph.
15 | - `show_layer_names` (defaults to True) controls whether layer names are shown in the graph.
16 | - `expand_nested` (defaults to False) controls whether to expand nested models into clusters in the graph.
17 | - `dpi` (defaults to 96) controls image dpi.
18 |
19 | You can also directly obtain the `pydot.Graph` object and render it yourself,
20 | for example to show it in an ipython notebook :
21 | ```python
22 | from IPython.display import SVG
23 | from keras.utils import model_to_dot
24 |
25 | SVG(model_to_dot(model).create(prog='dot', format='svg'))
26 | ```
27 |
28 | ## Training history visualization
29 |
30 | The `fit()` method on a Keras `Model` returns a `History` object. The `History.history` attribute is a dictionary recording training loss values and metrics values at successive epochs, as well as validation loss values and validation metrics values (if applicable). Here is a simple example using `matplotlib` to generate loss & accuracy plots for training & validation:
31 |
32 | ```python
33 | import matplotlib.pyplot as plt
34 |
35 | history = model.fit(x, y, validation_split=0.25, epochs=50, batch_size=16, verbose=1)
36 |
37 | # Plot training & validation accuracy values
38 | plt.plot(history.history['acc'])
39 | plt.plot(history.history['val_acc'])
40 | plt.title('Model accuracy')
41 | plt.ylabel('Accuracy')
42 | plt.xlabel('Epoch')
43 | plt.legend(['Train', 'Test'], loc='upper left')
44 | plt.show()
45 |
46 | # Plot training & validation loss values
47 | plt.plot(history.history['loss'])
48 | plt.plot(history.history['val_loss'])
49 | plt.title('Model loss')
50 | plt.ylabel('Loss')
51 | plt.xlabel('Epoch')
52 | plt.legend(['Train', 'Test'], loc='upper left')
53 | plt.show()
54 | ```
55 |
--------------------------------------------------------------------------------
/docs/theme/404.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block content %}
4 |
5 | Page not found
8 | 9 | {% endblock %} 10 | -------------------------------------------------------------------------------- /docs/theme/breadcrumbs.html: -------------------------------------------------------------------------------- 1 | 42 | -------------------------------------------------------------------------------- /docs/theme/css/theme_extra.css: -------------------------------------------------------------------------------- 1 | /* 2 | * Wrap inline code samples otherwise they shoot of the side and 3 | * can't be read at all. 4 | * 5 | * https://github.com/mkdocs/mkdocs/issues/313 6 | * https://github.com/mkdocs/mkdocs/issues/233 7 | * https://github.com/mkdocs/mkdocs/issues/834 8 | */ 9 | .rst-content code { 10 | white-space: pre-wrap; 11 | word-wrap: break-word; 12 | padding: 2px 5px; 13 | } 14 | 15 | /** 16 | * Make code blocks display as blocks and give them the appropriate 17 | * font size and padding. 18 | * 19 | * https://github.com/mkdocs/mkdocs/issues/855 20 | * https://github.com/mkdocs/mkdocs/issues/834 21 | * https://github.com/mkdocs/mkdocs/issues/233 22 | */ 23 | .rst-content pre code { 24 | white-space: pre; 25 | word-wrap: normal; 26 | display: block; 27 | padding: 12px; 28 | font-size: 12px; 29 | } 30 | 31 | /* 32 | * Fix link colors when the link text is inline code. 33 | * 34 | * https://github.com/mkdocs/mkdocs/issues/718 35 | */ 36 | a code { 37 | color: #2980B9; 38 | } 39 | a:hover code { 40 | color: #3091d1; 41 | } 42 | a:visited code { 43 | color: #9B59B6; 44 | } 45 | 46 | /* 47 | * The CSS classes from highlight.js seem to clash with the 48 | * ReadTheDocs theme causing some code to be incorrectly made 49 | * bold and italic. 50 | * 51 | * https://github.com/mkdocs/mkdocs/issues/411 52 | */ 53 | pre .cs, pre .c { 54 | font-weight: inherit; 55 | font-style: inherit; 56 | } 57 | 58 | /* 59 | * Fix some issues with the theme and non-highlighted code 60 | * samples. Without and highlighting styles attached the 61 | * formatting is broken. 62 | * 63 | * https://github.com/mkdocs/mkdocs/issues/319 64 | */ 65 | .rst-content .no-highlight { 66 | display: block; 67 | padding: 0.5em; 68 | color: #333; 69 | } 70 | 71 | 72 | /* 73 | * Additions specific to the search functionality provided by MkDocs 74 | */ 75 | 76 | .search-results { 77 | margin-top: 23px; 78 | } 79 | 80 | .search-results article { 81 | border-top: 1px solid #E1E4E5; 82 | padding-top: 24px; 83 | } 84 | 85 | .search-results article:first-child { 86 | border-top: none; 87 | } 88 | 89 | form .search-query { 90 | width: 100%; 91 | border-radius: 50px; 92 | padding: 6px 12px; /* csslint allow: box-model */ 93 | border-color: #D1D4D5; 94 | } 95 | 96 | /* 97 | * Improve inline code blocks within admonitions. 98 | * 99 | * https://github.com/mkdocs/mkdocs/issues/656 100 | */ 101 | .rst-content .admonition code { 102 | color: #404040; 103 | border: 1px solid #c7c9cb; 104 | border: 1px solid rgba(0, 0, 0, 0.2); 105 | background: #f8fbfd; 106 | background: rgba(255, 255, 255, 0.7); 107 | } 108 | 109 | /* 110 | * Account for wide tables which go off the side. 111 | * Override borders to avoid weirdness on narrow tables. 112 | * 113 | * https://github.com/mkdocs/mkdocs/issues/834 114 | * https://github.com/mkdocs/mkdocs/pull/1034 115 | */ 116 | .rst-content .section .docutils { 117 | width: 100%; 118 | overflow: auto; 119 | display: block; 120 | border: none; 121 | } 122 | 123 | td, th { 124 | border: 1px solid #e1e4e5 !important; /* csslint allow: important */ 125 | border-collapse: collapse; 126 | } 127 | 128 | /*Keras extras*/ 129 | 130 | .keras-logo { 131 | max-height: 55px; 132 | width: 100%; 133 | background: #d00000; 134 | font-size: 140%; 135 | color: white; 136 | font-family: "Source Sans Pro", "ff-tisa-web-pro", "Georgia", Arial, sans-serif; 137 | } 138 | 139 | .keras-logo-img { 140 | max-width: 45px; 141 | margin: 10px; 142 | } 143 | 144 | h1, h2, h3, h4, h5, h6, legend { 145 | font-family: "Source Sans Pro", "ff-tisa-web-pro", "Georgia", Arial, sans-serif;, 146 | } 147 | 148 | -------------------------------------------------------------------------------- /docs/theme/footer.html: -------------------------------------------------------------------------------- 1 | 27 | -------------------------------------------------------------------------------- /docs/theme/main.html: -------------------------------------------------------------------------------- 1 | {% extends "base.html" %} 2 | -------------------------------------------------------------------------------- /docs/theme/nav.html: -------------------------------------------------------------------------------- 1 | {{ nav_item.title }} 2 | {%- set navlevel = navlevel + 1 %} 3 | {%- if navlevel <= config.theme.navigation_depth 4 | and ((nav_item.is_page and nav_item.toc.items 5 | and (not config.theme.titles_only 6 | and (nav_item == page or not config.theme.collapse_navigation))) 7 | or (nav_item.is_section and nav_item.children)) %} 8 |