开始 Keras 序列模型（Sequential model）

序列模型是一个线性的层次堆栈。
你可以通过传递一系列 实例给构造器来创建一个序列模型。

The Sequential model is a linear stack of s.

You can create a Sequential model by passing a list of instances to the constructor:

from keras.models import Sequentialfrom keras. s import Dense, Activationmodel = Sequential([    Dense(32, input_shape=(784,)),    Activation('relu'),    Dense(10),    Activation('softmax'),])

也可以简单的添加 通过 .add() 函数。

You can also simply add s via the .add() method:

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

Specifying the input shape

The model needs to know what input shape it should expect. For this reason, the first in a Sequential model (and only the first, because following s can do automatic shape inference) needs to receive information about its input shape. There are several possible ways to do this:

• Pass an input_shape argument to the first . This is a shape tuple (a tuple of integers or None entries, where None indicates that any positive integer may be expected). In input_shape, the batch dimension is not included.
• Some 2D s, such as Dense, support the specification of their input shape via the argument input_dim, and some 3D temporal s support the arguments input_dim and input_length.
• If you ever need to specify a fixed batch size for your inputs (this is useful for stateful recurrent networks), you can pass a batch_size argument to a . If you pass both batch_size=32 and input_shape=(6, 8) to a , it will then expect every batch of inputs to have the batch shape (32, 6, 8).

As such, the following snippets are strictly equivalent:

model = Sequential()model.add(Dense(32, input_shape=(784,)))

model = Sequential()model.add(Dense(32, input_dim=784))

Compilation

Before training a model, you need to configure the learning process, which is done via the compile method. It receives three arguments:

• An optimizer. This could be the string identifier of an existing optimizer (such as rmsprop or adagrad), or an instance of the Optimizer class. See: optimizers.
• A loss function. This is the ive that the model will try to minimize. It can be the string identifier of an existing loss function (such as categorical_crossentropy or mse), or it can be an ive function. See: losses.
• A list of metrics. For any classification problem you will want to set this to metrics=['accuracy']. A metric could be the string identifier of an existing metric or a custom metric function.

# For a multi-class classification problemmodel.compile(optimizer='rmsprop',              loss='categorical_crossentropy',              metrics=['accuracy'])# For a binary classification problemmodel.compile(optimizer='rmsprop',              loss='binary_crossentropy',              metrics=['accuracy'])# For a mean squared error regression problemmodel.compile(optimizer='rmsprop',              loss='mse')# For custom metricsimport keras.backend as Kdef mean_pred(y_true, y_pred):    return K.mean(y_pred)model.compile(optimizer='rmsprop',              loss='binary_crossentropy',              metrics=['accuracy', mean_pred])

Training

Keras models are trained on Numpy arrays of input data and labels. For training a model, you will typically use the fit function. Read its documentation here.

# For a single-input model with 2 classes (binary classification):model = Sequential()model.add(Dense(32, activation='relu', input_dim=100))model.add(Dense(1, activation='sigmoid'))model.compile(optimizer='rmsprop',              loss='binary_crossentropy',              metrics=['accuracy'])# Generate dummy dataimport numpy as npdata = np.random.random((1000, 100))labels = np.random.randint(2, size=(1000, 1))# Train the model, iterating on the data in batches of 32 samplesmodel.fit(data, labels, epochs=10, batch_size=32)

# For a single-input model with 10 classes (categorical classification):model = Sequential()model.add(Dense(32, activation='relu', input_dim=100))model.add(Dense(10, activation='softmax'))model.compile(optimizer='rmsprop',              loss='categorical_crossentropy',              metrics=['accuracy'])# Generate dummy dataimport numpy as npdata = np.random.random((1000, 100))labels = np.random.randint(10, size=(1000, 1))# Convert labels to categorical one-hot encodingone_hot_labels = keras.utils.to_categorical(labels, num_classes=10)# Train the model, iterating on the data in batches of 32 samplesmodel.fit(data, one_hot_labels, epochs=10, batch_size=32)

Examples

Here are a few examples to get you started!

In the examples folder, you will also find example models for real datasets:

• CIFAR10 small images classification: Convolutional Neural Network (CNN) with realtime data augmentation
• IMDB movie review sentiment classification: LSTM over sequences of words
• Reuters newswires topic classification: Mult Perceptron (MLP)
• MNIST handwritten digits classification: MLP & CNN
• Character-level text generation with LSTM

…and more.

Mult Perceptron (MLP) for multi-class softmax classification:

from keras.models import Sequentialfrom keras. s import Dense, Dropout, Activationfrom keras.optimizers import SGD# Generate dummy dataimport numpy as npx_train = np.random.random((1000, 20))y_train = keras.utils.to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10)x_test = np.random.random((100, 20))y_test = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)model = Sequential()# Dense(64) is a fully-connected   with 64 hidden units.# in the first  , you must specify the expected input data shape:# here, 20-dimensional vectors.model.add(Dense(64, activation='relu', input_dim=20))model.add(Dropout(0.5))model.add(Dense(64, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)model.compile(loss='categorical_crossentropy',              optimizer=sgd,              metrics=['accuracy'])model.fit(x_train, y_train,          epochs=20,          batch_size=128)score = model.evaluate(x_test, y_test, batch_size=128)

MLP for binary classification:

import numpy as npfrom keras.models import Sequentialfrom keras. s import Dense, Dropout# Generate dummy datax_train = np.random.random((1000, 20))y_train = np.random.randint(2, size=(1000, 1))x_test = np.random.random((100, 20))y_test = np.random.randint(2, size=(100, 1))model = Sequential()model.add(Dense(64, input_dim=20, activation='relu'))model.add(Dropout(0.5))model.add(Dense(64, activation='relu'))model.add(Dropout(0.5))model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])model.fit(x_train, y_train,          epochs=20,          batch_size=128)score = model.evaluate(x_test, y_test, batch_size=128)

VGG-like convnet:

import numpy as npimport kerasfrom keras.models import Sequentialfrom keras. s import Dense, Dropout, Flattenfrom keras. s import Conv2D, MaxPooling2Dfrom keras.optimizers import SGD# Generate dummy datax_train = np.random.random((100, 100, 100, 3))y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)x_test = np.random.random((20, 100, 100, 3))y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)model = Sequential()# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.# this applies 32 convolution filters of size 3x3 each.model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))model.add(Conv2D(32, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(256, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)model.compile(loss='categorical_crossentropy', optimizer=sgd)model.fit(x_train, y_train, batch_size=32, epochs=10)score = model.evaluate(x_test, y_test, batch_size=32)

Sequence classification with LSTM:

from keras.models import Sequentialfrom keras. s import Dense, Dropoutfrom keras. s import  dingfrom keras. s import LSTMmodel = Sequential()model.add( ding(max_features, output_dim=256))model.add(LSTM(128))model.add(Dropout(0.5))model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])model.fit(x_train, y_train, batch_size=16, epochs=10)score = model.evaluate(x_test, y_test, batch_size=16)

Sequence classification with 1D convolutions:

from keras.models import Sequentialfrom keras. s import Dense, Dropoutfrom keras. s import  dingfrom keras. s import Conv1D, GlobalAveragePooling1D, MaxPooling1Dmodel = Sequential()model.add(Conv1D(64, 3, activation='relu', input_shape=(seq_length, 100)))model.add(Conv1D(64, 3, activation='relu'))model.add(MaxPooling1D(3))model.add(Conv1D(128, 3, activation='relu'))model.add(Conv1D(128, 3, activation='relu'))model.add(GlobalAveragePooling1D())model.add(Dropout(0.5))model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])model.fit(x_train, y_train, batch_size=16, epochs=10)score = model.evaluate(x_test, y_test, batch_size=16)

Stacked LSTM for sequence classification

In this model, we stack 3 LSTM s on top of each other,
making the model capable of learning higher-level temporal representations.

The first two LSTMs return their full output sequences, but the last one only returns
the last step in its output sequence, thus dropping the temporal dimension
(i.e. converting the input sequence into a single vector).

from keras.models import Sequentialfrom keras. s import LSTM, Denseimport numpy as npdata_dim = 16timesteps = 8num_classes = 10# expected input data shape: (batch_size, timesteps, data_dim)model = Sequential()model.add(LSTM(32, return_sequences=True,               input_shape=(timesteps, data_dim)))  # returns a sequence of vectors of dimension 32model.add(LSTM(32, return_sequences=True))  # returns a sequence of vectors of dimension 32model.add(LSTM(32))  # return a single vector of dimension 32model.add(Dense(10, activation='softmax'))model.compile(loss='categorical_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])# Generate dummy training datax_train = np.random.random((1000, timesteps, data_dim))y_train = np.random.random((1000, num_classes))# Generate dummy validation datax_val = np.random.random((100, timesteps, data_dim))y_val = np.random.random((100, num_classes))model.fit(x_train, y_train,          batch_size=64, epochs=5,          validation_data=(x_val, y_val))

Same stacked LSTM model, rendered “stateful”

A stateful recurrent model is one for which the internal states (memories) obtained after processing a batch
of samples are reused as initial states for the samples of the next batch. This allows to process longer sequences
while keeping computational complexity manageable.

You can read more about stateful RNNs in the FAQ.

from keras.models import Sequentialfrom keras. s import LSTM, Denseimport numpy as npdata_dim = 16timesteps = 8num_classes = 10batch_size = 32# Expected input batch shape: (batch_size, timesteps, data_dim)# Note that we have to provide the full batch_input_shape since the network is stateful.# the sample of index i in batch k is the follow-up for the sample i in batch k-1.model = Sequential()model.add(LSTM(32, return_sequences=True, stateful=True,               batch_input_shape=(batch_size, timesteps, data_dim)))model.add(LSTM(32, return_sequences=True, stateful=True))model.add(LSTM(32, stateful=True))model.add(Dense(10, activation='softmax'))model.compile(loss='categorical_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])# Generate dummy training datax_train = np.random.random((batch_size * 10, timesteps, data_dim))y_train = np.random.random((batch_size * 10, num_classes))# Generate dummy validation datax_val = np.random.random((batch_size * 3, timesteps, data_dim))y_val = np.random.random((batch_size * 3, num_classes))model.fit(x_train, y_train,          batch_size=batch_size, epochs=5, shuffle=False,          validation_data=(x_val, y_val))