keras doc 10终结篇 激活函数 回调函数 正则项 约束项 预训练模型

from keras.layers.core import Activation, Dense

model.add(Dense(64))
model.add(Activation('tanh'))

model.add(Dense(64, activation='tanh'))

from keras import backend as Kdef tanh(x):
    return K.tanh(x)

model.add(Dense(64, activation=tanh))
model.add(Activation(tanh)

keras.callbacks.CallbackList(callbacks=[], queue_length=10)

keras.callbacks.Callback()

keras.callbacks.BaseLogger()

keras.callbacks.ProgbarLogger()

keras.callbacks.History()

keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=False, mode='auto')

keras.callbacks.EarlyStopping(monitor='val_loss', patience=0, verbose=0, mode='auto')

keras.callbacks.RemoteMonitor(root='http://localhost:9000')

keras.callbacks.LearningRateScheduler(schedule)

keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0)

tensorboard --logdir=/full_path_to_your_logs

class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = []    def on_batch_end(self, batch, logs={}):
        self.losses.append(logs.get('loss'))

class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = []    def on_batch_end(self, batch, logs={}):
        self.losses.append(logs.get('loss'))

model = Sequential()
model.add(Dense(10, input_dim=784, init='uniform'))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

history = LossHistory()
model.fit(X_train, Y_train, batch_size=128, nb_epoch=20, verbose=0, callbacks=[history])print history.losses# outputs'''
[0.66047596406559383, 0.3547245744908703, ..., 0.25953155204159617, 0.25901699725311789]

from keras.callbacks import ModelCheckpoint

model = Sequential()
model.add(Dense(10, input_dim=784, init='uniform'))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')'''
saves the model weights after each epoch if the validation loss decreased
'''checkpointer = ModelCheckpoint(filepath="/tmp/weights.hdf5", verbose=1, save_best_only=True)
model.fit(X_train, Y_train, batch_size=128, nb_epoch=20, verbose=0, validation_data=(X_test, Y_test), callbacks=[checkpointer])

model.add(Dense(64, init='uniform'))

from keras import backend as Kimport numpy as npdef my_init(shape, name=None):
    value = np.random.random(shape)    return K.variable(value, name=name)

model.add(Dense(64, init=my_init))

from keras import initializationsdef my_init(shape, name=None):
    return initializations.normal(shape, scale=0.01, name=name)

model.add(Dense(64, init=my_init))

from keras.regularizers import l2, activity_l2
model.add(Dense(64, input_dim=64, W_regularizer=l2(0.01), activity_regularizer=activity_l2(0.01)))

keras.regularizers.WeightRegularizer(l1=0., l2=0.)

keras.regularizers.ActivityRegularizer(l1=0., l2=0.)

from keras.constraints import maxnorm
model.add(Dense(64, W_constraint = maxnorm(2)))

from keras.applications.resnet50 import ResNet50from keras.preprocessing import imagefrom keras.applications.resnet50 import preprocess_input, decode_predictions

model = ResNet50(weights='imagenet')

img_path = 'elephant.jpg'img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

preds = model.predict(x)
print('Predicted:', decode_predictions(preds))# print: [[u'n02504458', u'African_elephant']]

from keras.applications.vgg16 import VGG16from keras.preprocessing import imagefrom keras.applications.vgg16 import preprocess_input

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

img_path = 'elephant.jpg'img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

features = model.predict(x)

from keras.applications.vgg19 import VGG19from keras.preprocessing import imagefrom keras.applications.vgg19 import preprocess_inputfrom keras.models import Model

base_model = VGG19(weights='imagenet')
model = Model(input=base_model.input, output=base_model.get_layer('block4_pool').output)

img_path = 'elephant.jpg'img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

block4_pool_features = model.predict(x)

from keras.applications.inception_v3 import InceptionV3from keras.preprocessing import imagefrom keras.models import Modelfrom keras.layers import Dense, GlobalAveragePooling2Dfrom keras import backend as K# create the base pre-trained modelbase_model = InceptionV3(weights='imagenet', include_top=False)# add a global spatial average pooling layerx = base_model.output
x = GlobalAveragePooling2D()(x)# let's add a fully-connected layerx = Dense(1024, activation='relu')(x)# and a logistic layer -- let's say we have 200 classespredictions = Dense(200, activation='softmax')(x)# this is the model we will trainmodel = Model(input=base_model.input, output=predictions)# first: train only the top layers (which were randomly initialized)# i.e. freeze all convolutional InceptionV3 layersfor layer in base_model.layers:
    layer.trainable = False# compile the model (should be done *after* setting layers to non-trainable)model.compile(optimizer='rmsprop', loss='categorical_crossentropy')# train the model on the new data for a few epochsmodel.fit_generator(...)# at this point, the top layers are well trained and we can start fine-tuning# convolutional layers from inception V3. We will freeze the bottom N layers# and train the remaining top layers.# let's visualize layer names and layer indices to see how many layers# we should freeze:for i, layer in enumerate(base_model.layers):
   print(i, layer.name)# we chose to train the top 2 inception blocks, i.e. we will freeze# the first 172 layers and unfreeze the rest:for layer in model.layers[:172]:
   layer.trainable = Falsefor layer in model.layers[172:]:
   layer.trainable = True# we need to recompile the model for these modifications to take effect# we use SGD with a low learning ratefrom keras.optimizers import SGD
model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy')# we train our model again (this time fine-tuning the top 2 inception blocks# alongside the top Dense layersmodel.fit_generator(...)

from keras.applications.inception_v3 import InceptionV3from keras.layers import Input# this could also be the output a different Keras model or layerinput_tensor = Input(shape=(224, 224, 3))  # this assumes K.image_dim_ordering() == 'tf'model = InceptionV3(input_tensor=input_tensor, weights='imagenet', include_top=True)

keras.applications.vgg16.VGG16(include_top=True, weights='imagenet', input_tensor=None)

keras.applications.vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None)

keras.applications.resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None)

keras.applications.inception_v3.InceptionV3(include_top=True, weights='imagenet', input_tensor=None)

from keras.datasets import cifar10

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

from keras.datasets import cifar100

(X_train, y_train), (X_test, y_test) = cifar100.load_data(label_mode='fine')

from keras.datasets import imdb

(X_train, y_train), (X_test, y_test) = imdb.load_data(path="imdb_full.pkl",
                                                      nb_words=None,
                                                      skip_top=0,
                                                      maxlen=None,
                                                      test_split=0.1)
                                                      seed=113,
                                                      start_char=1,
                                                      oov_char=2,
                                                      index_from=3)

from keras.datasets import reuters


(X_train, y_train), (X_test, y_test) = reuters.load_data(path="reuters.pkl",
                                                         nb_words=None,
                                                         skip_top=0,
                                                         maxlen=None,
                                                         test_split=0.2,
                                                         seed=113,
                                                         start_char=1,
                                                         oov_char=2,
                                                         index_from=3)

word_index = reuters.get_word_index(path="reuters_word_index.pkl")

from keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()