Basic ideas on keras framework

Keras: Deep Learning library for Theano and TensorFlow
Alison Marczewski
UFMG
April 28, 2017
Alison Marczewski | UFMG | April 28, 2017 1 / 19

Introduction
Fast prototyping
Support combination of convolutional and recurrent networks
CPU and GPU

Guiding principles
User friendliness
Modularity
Easy extensibility
Work with Python
from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential([
Dense(32, input_shape=(784,)),
Activation('relu'),
Dense(10),
Activation('softmax'),
])

Core Layers
Dense(units, activation=None, use_bias=True) # Fully connected
Activation(activation) # linear, softmax, tanh...
Dropout(rate) # set values to zero
Flatten() # masks into vector
Reshape(target_shape)
Permute(dims) # Permute((2, 1), input_shape=(10, 64)) --> (64, 10)
RepeatVector(n) # RepeatVector(3, input_shape=(32,)) --> (3, 32)
ActivityRegularization(l1=0.0, l2=0.0)
# You can create your Layer

Layer wrappers
from keras.layers.wrappers import *
# This wrapper allows to apply a layer to every temporal slice of an input.
TimeDistributed(layer)
# Sample
model = Sequential()
model.add(TimeDistributed(Dense(8), input_shape=(10, 16)))
# now model.output_shape == (None, 10, 8)
#Bidirectional wrapper for RNNs.
Bidirectional(layer, merge_mode='concat', weights=None)

Preprocessings
For sequences: pad sequences, skipgrams...
For text: text to word, one hot, tokenizer
For image: ImageDataGenerator

Compilation and Training
#--> Loss for a multi-class classification problem: 'categorical_crossentropy'
#--> Loss for a binary classification problem: 'binary_crossentropy'
#--> Loss for a mean squared error regression problem: 'mse'
#--> Metrics: binary_accuracy, categorical_accuracy...
# For custom metrics
import keras.backend as K
def mean_pred(y_true, y_pred):
return K.mean(y_pred)
# optimizer: SGD, RMSprop, Adagrad, Adadelta, Adam, Adamax, Nadam, TFOptimizer
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy', mean_pred])
# training model
model.fit(x_train, y_train, epochs=5, batch_size=32,
callbacks = [CALLBACK_LIST])

Callbacks
from keras.callbacks import *
ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=False,
save_weights_only=False)
EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0,
mode='auto')
LearningRateScheduler(schedule) #schedule: a function that takes an epoch
#index as input (integer, indexed from 0) and returns a new learning
#rate as output (float).
ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0,
epsilon=0.0001, min_lr=0)
CSVLogger(filename, separator=',', append=False)
# You can create your callback

Constraints
Functions from the constraints module allow setting constraints on
network parameters during optimization
max norm(max value=2, axis=0)
non neg
unit norm
from keras.constraints import maxnorm
# example
model.add(Dense(64, kernel_constraint=max_norm(2.)))
#--> kernel_constraint: for the main weights matrix
#--> bias_constraint: for the bias

Utils
from keras.utils import *
# Conv a class vector to binary class matrix
# e.g: for use with categorical_crossentropy
to_categorical(y, num_classes=None)
plot_model(model, to_file='model.png', show_shapes=False,
show_layer_names=True)

Applications
Some models are available for image classiﬁcation with weights trained on
ImageNet: Xception, VGG16, VGG19, ResNet50, InceptionV3
from keras.applications.resnet50 import ResNet50
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
import numpy as np
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)
# decode the results into a list of tuples (class, description, probability)
print('Predicted:', decode_predictions(preds, top=3)[0])
# Predicted: [(u'n02504013', u'Indian_elephant', 0.82658225),
# (u'n01871265', u'tusker', 0.1122357),
# (u'n02504458', u'African_elephant', 0.061040461)]

Working with several experiments/conﬁgs
What are the main diﬀerences among experiments?

data preprocessing

data preprocessing
models/conﬁgs

data preprocessing
models/conﬁgs: for each data preprocessing, there are one or more
conﬁgs

data preprocessing
module for loading dataset according to some parameters
conﬁgs

data preprocessing
conﬁgs
module for creating a model according to parameters

data preprocessing
conﬁgs
For each experiment: one data preprocessing with 1 or more
models/conﬁgs

data preprocessing
configs
For each experiment: one data preprocessing with 1 or more
models/configs
Instead of writing a python code for each one, loading a file with these
parameters

Experiment/conﬁg ﬁle
# Basic example
experiment= {}
experiment['name']='experiment-01'
experiment['general'] = {'batch_size': 32, 'nb_epoch': 30,
'optimizer': 'adadelta'}
experiment['dataset'] = {'train': ['dataset_A', 'dataset_B'],
'percent_train': .8, 'percent_valid': .2, 'norm': 'unit_norm'}
experiment['classes'] = ['A', 'B', 'C']
experiment['configs'] = []
config = {}
config['name'] = 'config-01'
config['layers'] = []
config['layers'].append({'name': 'convolution_1', 'filter_length': 100,
'nb_filter': 128, 'activation': 'relu', 'border_mode': 'same'})
config['layers'].append({'name': 'maxpooling_1', 'pool_length': 200})
config['layers'].append({'name': 'dropout_1', 'p': 0.2})
config['layers'].append({'name': 'flatten_1'})
config['layers'].append({'name': 'dense_1', 'output_dim': 1000})
config['layers'].append({'name': 'dropout_2', 'p': 0.2})
config['layers'].append({'name': 'activation_1', 'activation': 'relu'})
experiment['configs'].append(config)

Executing
if __name__ == '__main__':
exec(open(sys.argv[1]).read(), globals())
sys.stdout = Logger('experiments/{0}.log'.format(experiment['name']))
... = load_dataset(experiment['dataset'])
input_shape = X_train.shape[1:]
for config in experiment['configs']:
model = create_model(input_shape, config['layers'], experiment['classes'])
model.compile(loss='categorical_crossentropy',
optimizer=experiment['general'].get('optimizer', 'SGD'),
metrics=['accuracy'])
print(model.summary())
model.fit(...)
...
plot_model(model, '%s-%s'%(experiment['name'], config['name']))

Create model I
def create_model(input_shape, layers, classes):
layers.append({'name': 'dense_final', 'output_dim': len(classes)})
layers.append({'name': 'activation_classifier',
'activation': 'softmax'})
model = Sequential()
for l in layers:
if len(model.layers) == 0:
l['input_shape'] = input_shape
print("layer:", l)
model.add(create_layer(**l))
return model

Create model II
# Basic example
def create_layer(**kwargs):
name = kwargs.get('name')
if name.startswith('convolution'):
layer = Convolution1D(**kwargs)
elif name.startswith('maxpooling'):
layer = MaxPooling1D(**kwargs)
elif name.startswith('dropout'):
layer = Dropout(**kwargs)
elif name.startswith('flatten'):
layer = Flatten(**kwargs)
elif name.startswith('dense'):
layer = Dense(**kwargs)
elif name.startswith('activation'):
layer = Activation(**kwargs)
else:
raise "layer not supported yet", name
return layer

Plot Model
Just for example

Questions?

Keras reference
https://keras.io

Basic ideas on keras framework

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Basic ideas on keras framework

Semelhante a Basic ideas on keras framework (20)

Último

Último (20)

Basic ideas on keras framework