@misc{chollet2015keras,

  author = {Chollet, François and others},

  title = {Keras},

  year = {2015},

  publisher = {GitHub},

  journal = {GitHub repository},

  howpublished = {\url{https://github.com/fchollet/keras}}

}

THEANO_FLAGS=device=gpu,floatX=float32 python my_keras_script.py

    import theano

    theano.config.device = 'gpu'

    theano.config.floatX = 'float32'

from keras.utils import multi_gpu_model

# Replicates `model` on 8 GPUs.

# This assumes that your machine has 8 available GPUs.

parallel_model = multi_gpu_model(model, gpus=8)

parallel_model.compile(loss='categorical_crossentropy',

                       optimizer='rmsprop')

# This `fit` call will be distributed on 8 GPUs.

# Since the batch size is 256, each GPU will process 32 samples.

parallel_model.fit(x, y, epochs=20, batch_size=256)

# Model where a shared LSTM is used to encode two different sequences in parallel

input_a = keras.Input(shape=(140, 256))

input_b = keras.Input(shape=(140, 256))

shared_lstm = keras.layers.LSTM(64)

# Process the first sequence on one GPU

with tf.device_scope('/gpu:0'):

    encoded_a = shared_lstm(tweet_a)

# Process the next sequence on another GPU

with tf.device_scope('/gpu:1'):

    encoded_b = shared_lstm(tweet_b)

# Concatenate results on CPU

with tf.device_scope('/cpu:0'):

    merged_vector = keras.layers.concatenate([encoded_a, encoded_b],

                                             axis=-1)

from keras.models import load_model

model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'

del model  # deletes the existing model

# returns a compiled model

# identical to the previous one

model = load_model('my_model.h5')

# save as JSON

json_string = model.to_json()

# save as YAML

yaml_string = model.to_yaml()

# model reconstruction from JSON:

from keras.models import model_from_json

model = model_from_json(json_string)

# model reconstruction from YAML

model = model_from_yaml(yaml_string)

model.save_weights('my_model_weights.h5')

model.load_weights('my_model_weights.h5')

model.load_weights('my_model_weights.h5', by_name=True)

"""

假如原模型为：

    model = Sequential()

    model.add(Dense(2, input_dim=3, name="dense_1"))

    model.add(Dense(3, name="dense_2"))

    ...

    model.save_weights(fname)

"""

# new model

model = Sequential()

model.add(Dense(2, input_dim=3, name="dense_1"))  # will be loaded

model.add(Dense(10, name="new_dense"))  # will not be loaded

# load weights from first model; will only affect the first layer, dense_1.

model.load_weights(fname, by_name=True)

from keras.models import Model

model = ...  # create the original model

layer_name = 'my_layer'

intermediate_layer_model = Model(input=model.input,

                                 output=model.get_layer(layer_name).output)

intermediate_output = intermediate_layer_model.predict(data)

from keras import backend as K

# with a Sequential model

get_3rd_layer_output = K.function([model.layers[0].input],

                                  [model.layers[3].output])

layer_output = get_3rd_layer_output([X])[0]

get_3rd_layer_output = K.function([model.layers[0].input, K.learning_phase()],

                                  [model.layers[3].output])

# output in test mode = 0

layer_output = get_3rd_layer_output([X, 0])[0]

# output in train mode = 1

layer_output = get_3rd_layer_output([X, 1])[0]

from keras.callbacks import EarlyStopping

early_stopping = EarlyStopping(monitor='val_loss', patience=2)

model.fit(X, y, validation_split=0.2, callbacks=[early_stopping])

hist = model.fit(X, y, validation_split=0.2)

print(hist.history)

X  # this is our input data, of shape (32, 21, 16)

# we will feed it to our model in sequences of length 10

model = Sequential()

model.add(LSTM(32, input_shape=(10, 16), batch_size=32, stateful=True))

model.add(Dense(16, activation='softmax'))

model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

# we train the network to predict the 11th timestep given the first 10:

model.train_on_batch(X[:, :10, :], np.reshape(X[:, 10, :], (32, 16)))

# the state of the network has changed. We can feed the follow-up sequences:

model.train_on_batch(X[:, 10:20, :], np.reshape(X[:, 20, :], (32, 16)))

# let's reset the states of the LSTM layer:

model.reset_states()

# another way to do it in this case:

model.layers[0].reset_states()

frozen_layer = Dense(32,trainable=False)

x = Input(shape=(32,))

layer = Dense(32)

layer.trainable = False

y = layer(x)

frozen_model = Model(x, y)

# in the model below, the weights of `layer` will not be updated during training

frozen_model.compile(optimizer='rmsprop', loss='mse')

layer.trainable = True

trainable_model = Model(x, y)

# with this model the weights of the layer will be updated during training

# (which will also affect the above model since it uses the same layer instance)

trainable_model.compile(optimizer='rmsprop', loss='mse')

frozen_model.fit(data, labels)  # this does NOT update the weights of `layer`

trainable_model.fit(data, labels)  # this updates the weights of `layer`

model = Sequential()

model.add(Dense(32, activation='relu', input_dim=784))

model.add(Dense(32, activation='relu'))

print(len(model.layers))  # "2"

model.pop()

print(len(model.layers))  # "1"

from keras.applications.vgg16 import VGG16

from keras.applications.vgg19 import VGG19

from keras.applications.resnet50 import ResNet50

from keras.applications.inception_v3 import InceptionV3

model = VGG16(weights='imagenet', include_top=True)

import h5py

with h5py.File('input/file.hdf5', 'r') as f:

    X_data = f['X_data']

    model.predict(X_data)

{

    "image_data_format": "channels_last",

    "epsilon": 1e-07,

    "floatx": "float32",

    "backend": "tensorflow"

}

import numpy as np

import tensorflow as tf

import random as rn

# The below is necessary in Python 3.2.3 onwards to

# have reproducible behavior for certain hash-based operations.

# See these references for further details:

# https://docs.python.org/3.4/using/cmdline.html#envvar-PYTHONHASHSEED

# https://github.com/fchollet/keras/issues/2280#issuecomment-306959926

import os

os.environ['PYTHONHASHSEED'] = ''

# The below is necessary for starting Numpy generated random numbers

# in a well-defined initial state.

np.random.seed(42)

# The below is necessary for starting core Python generated random numbers

# in a well-defined state.

rn.seed(12345)

# Force TensorFlow to use single thread.

# Multiple threads are a potential source of

# non-reproducible results.

# For further details, see: https://*.com/questions/42022950/which-seeds-have-to-be-set-where-to-realize-100-reproducibility-of-training-res

session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)

from keras import backend as K

# The below tf.set_random_seed() will make random number generation

# in the TensorFlow backend have a well-defined initial state.

# For further details, see: https://www.tensorflow.org/api_docs/python/tf/set_random_seed

tf.set_random_seed(1234)

sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)

K.set_session(sess)

# Rest of code follows ...