Note that the same result can also be achieved via a Lambda layer. Because our custom layer is written with primitives from the Keras backend (`K`), our code can run both on TensorFlow and Theano. ''' from __future__ import print_function import keras from keras.models import Sequential from keras import layers from keras.datasets import mnist from keras import backend as K import missinglink missinglink_callback = missinglink.KerasCallback( owner_id="your-owner-id", project_token="your-project-token") missinglink_callback.set_properties("Antirectifier") class Antirectifier(layers.Layer): '''This is the combination of a sample-wise L2 normalization with the concatenation of the positive part of the input with the negative part of the input. The result is a tensor of samples that are twice as large as the input samples. It can be used in place of a ReLU. # Input shape 2D tensor of shape (samples, n)
metrics=[ 'accuracy', 'categorical_accuracy', 'mean_squared_error', 'hinge' ]) # Provide an alternative to provide MissingLinkAI credential parser = argparse.ArgumentParser() parser.add_argument('--owner-id') parser.add_argument('--project-token') # Override credential values if provided as arguments args = parser.parse_args() OWNER_ID = args.owner_id or OWNER_ID PROJECT_TOKEN = args.project_token or PROJECT_TOKEN missinglink_callback = missinglink.KerasCallback(owner_id=OWNER_ID, project_token=PROJECT_TOKEN) missinglink_callback.set_properties( display_name='Keras convolutional neural network', description='Two dimensional convolutional neural network') model.fit(x_train, y_train, batch_size=BATCH_SIZE, nb_epoch=EPOCHS, validation_split=VALIDATION_SPLIT, callbacks=[missinglink_callback]) with missinglink_callback.test(model): score = model.evaluate(x_test, y_test)
Gets to 99.25% test accuracy after 12 epochs (there is still a lot of margin for parameter tuning). 16 seconds per epoch on a GRID K520 GPU. ''' from __future__ import print_function import keras from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras import backend as K import missinglink missinglink_callback = missinglink.KerasCallback() batch_size = 12 num_classes = 10 epochs = 100 # input image dimensions img_rows, img_cols = 28, 28 # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data() if K.image_data_format() == 'channels_first': x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols)
# if using a 5 layer net of pool_size = 2 x_train = np.pad(x_train, [[0, 0], [0, 0], [2, 2], [2, 2]], mode='constant') x_test = np.pad(x_test, [[0, 0], [0, 0], [2, 2], [2, 2]], mode='constant') nlayers = 5 elif pool_size == 3: # if using a 3 layer net of pool_size = 3 x_train = x_train[:, :, :-1, :-1] x_test = x_test[:, :, :-1, :-1] nlayers = 3 else: import sys sys.exit('Script supports pool_size of 2 and 3.') missinglink_callback = missinglink.KerasCallback( owner_id="485aee1a-7f13-0dab-c470-0be21d273407", project_token="AojfcjXvLGftJDdc") missinglink_callback.set_properties("mnist_swwae") # Shape of input to train on (note that model is fully convolutional however) input_shape = x_train.shape[1:] # The final list of the size of axis=1 for all layers, including input nfeats_all = [input_shape[0]] + nfeats # First build the encoder, all the while keeping track of the 'where' masks img_input = Input(shape=input_shape) # We push the 'where' masks to the following list wheres = [None] * nlayers y = img_input for i in range(nlayers):
import missinglink from keras.applications import vgg16 model = vgg16.VGG16() missinglink_callback = missinglink.KerasCallback( owner_id='replace with owner id', project_token='replace with project token') path = 'http://l7.alamy.com/zooms' + \ '/b76d255dd51e493e8c0fd5d5aa85f96f/lumbermill-cp93p7.jpg' missinglink_callback.visual_back_prop(path, model)
model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=[ 'accuracy', 'categorical_accuracy', 'mean_squared_error', 'hinge', precision, recall, f1 ]) callback = missinglink.KerasCallback(owner_id=args.owner_id, project_token=args.project_token, host=args.host) callback.set_properties(display_name='KerasMnistTest', description='cool kerassing around') if args.is_sampling: callback.set_hyperparams( sampling_factor=1 - random_sampling_factor ) # we log how many samples in % we have from the total samples callback.set_hyperparams(train_sample_count=X_train.shape[0]) callback.set_hyperparams(test_sample_count=X_test.shape[0]) callback.set_hyperparams(total_epochs=epochs) model.fit(X_train,
parser = argparse.ArgumentParser() parser.add_argument('--owner-id') parser.add_argument('--project-token') # Override credential values if provided as arguments args = parser.parse_args() OWNER_ID = args.owner_id or OWNER_ID PROJECT_TOKEN = args.project_token or PROJECT_TOKEN def stopped_callback(): print('Experiment stopped from the web') missinglink_callback = missinglink.KerasCallback( owner_id=OWNER_ID, project_token=PROJECT_TOKEN, host='https://missinglink-staging.appspot.com') missinglink_callback.set_properties( display_name='Keras convolutional neural network', description='Two dimensional convolutional neural network') model.fit(x_train, y_train, batch_size=BATCH_SIZE, nb_epoch=EPOCHS, validation_split=VALIDATION_SPLIT, callbacks=[missinglink_callback]) with missinglink_callback.test(model): score = model.evaluate(x_test, y_test)
# Horovod: add Horovod Distributed Optimizer. opt = hvd.DistributedOptimizer(opt) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=opt, metrics=['accuracy']) callbacks = [ # Horovod: broadcast initial variable states from rank 0 to all other processes. # This is necessary to ensure consistent initialization of all workers when # training is started with random weights or restored from a checkpoint. hvd.callbacks.BroadcastGlobalVariablesCallback(0), ] # Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them. if hvd.rank() == 0: callbacks.append(keras.callbacks.ModelCheckpoint('./checkpoint-{epoch}.h5')) missinglink_callback = missinglink.KerasCallback(project='5740395606573056') callbacks.append(missinglink_callback) model.fit(x_train, y_train, batch_size=batch_size, callbacks=callbacks, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) score = model.evaluate(x_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1])
# Hyper paramaters EPOCHS = int(os.environ.get("EPOCHS", "4")) MODEL = os.environ.get("MODEL", "simple") SIMPLE_LAYER_DIMENSIONALITY = int( os.environ.get("SIMPLE_LAYER_DIMENSIONALITY", "64")) SIMPLE_LAYER_COUNT = int(os.environ.get("SIMPLE_LAYER_COUNT", "0")) BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "10")) OPTIMIZER = os.environ.get("OPTIMIZER", "sgd") LEARNING_RATE = float(os.environ.get("LEARNING_RATE", "0.01")) CLASS_COUNT = int(os.environ.get("CLASS_COUNT", "11")) QUERY = os.environ.get("QUERY", '@seed:1337 @split:0.1:0.2:0.7 @sample:0.2 yummy:True') DATA_VOLUME_ID = int(os.environ.get("DATA_VOLUME_ID", "5652757822308352")) missinglink_callback = missinglink.KerasCallback(project='5715594536026112') missinglink_callback.set_properties(display_name=EXPERIMENT_NAME, description=EXPERIMENT_NOTE) missinglink_callback.set_hyperparams( MODEL=MODEL, SIMPLE_LAYER_DIMENSIONALITY=SIMPLE_LAYER_DIMENSIONALITY, SIMPLE_LAYER_COUNT=SIMPLE_LAYER_COUNT, BATCH_SIZE=BATCH_SIZE, CLASS_COUNT=CLASS_COUNT, ) callbacks = [missinglink_callback] # Note Adam defaults lr to 0.001 # SGD defaults lr to 0.01
(there is still a lot of margin for parameter tuning). 16 seconds per epoch on a GRID K520 GPU. ''' from __future__ import print_function import keras from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras import backend as K import missinglink import logging missinglink_callback = missinglink.KerasCallback( owner_id='95444180-d97b-4d3d-83b1-a5ca63d426a1', project_token='EDeqiZjcSfNeKuxa', host='https://missinglink-staging.appspot.com') batch_size = 128 num_classes = 10 epochs = 12 missinglink_callback.set_hyperparams(epochs=epochs) # input image dimensions img_rows, img_cols = 28, 28 # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data() if K.image_data_format() == 'channels_first':