def test_image_data_generator_training(): np.random.seed(1337) img_gen = ImageDataGenerator(rescale=1.) # Dummy ImageDataGenerator input_shape = (16, 16, 3) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=input_shape, classification=True, num_classes=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ layers.Conv2D(filters=8, kernel_size=3, activation='relu', input_shape=input_shape), layers.MaxPooling2D(pool_size=2), layers.Conv2D(filters=4, kernel_size=(3, 3), activation='relu', padding='same'), layers.GlobalAveragePooling2D(), layers.Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) history = model.fit_generator(img_gen.flow(x_train, y_train, batch_size=16), epochs=10, validation_data=img_gen.flow(x_test, y_test, batch_size=16), verbose=0) assert history.history['val_acc'][-1] > 0.75 model.evaluate_generator(img_gen.flow(x_train, y_train, batch_size=16))
def test_vector_clf(self): nb_hidden = 10 print("vector classification data:") (X_train, y_train), (X_test, y_test) = get_test_data( nb_train=1000, nb_test=200, input_shape=(10,), classification=True, nb_class=2 ) print("X_train:", X_train.shape) print("X_test:", X_test.shape) print("y_train:", y_train.shape) print("y_test:", y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(Dense(X_train.shape[-1], nb_hidden)) model.add(Activation("relu")) model.add(Dense(nb_hidden, y_train.shape[-1])) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") history = model.fit( X_train, y_train, nb_epoch=12, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=2, ) print(history.history) self.assertTrue(history.history["val_acc"][-1] > 0.9)
def test_img_clf(self): print("image classification data:") (X_train, y_train), (X_test, y_test) = get_test_data( nb_train=1000, nb_test=200, input_shape=(3, 32, 32), classification=True, nb_class=2 ) print("X_train:", X_train.shape) print("X_test:", X_test.shape) print("y_train:", y_train.shape) print("y_test:", y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(Convolution2D(32, 3, 32, 32)) model.add(Activation("sigmoid")) model.add(Flatten()) model.add(Dense(32, y_test.shape[-1])) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="sgd") history = model.fit( X_train, y_train, nb_epoch=12, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=2, ) self.assertTrue(history.history["val_acc"][-1] > 0.9)
def test_temporal_clf(self): print("temporal classification data:") (X_train, y_train), (X_test, y_test) = get_test_data( nb_train=1000, nb_test=200, input_shape=(5, 10), classification=True, nb_class=2 ) print("X_train:", X_train.shape) print("X_test:", X_test.shape) print("y_train:", y_train.shape) print("y_test:", y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(GRU(X_train.shape[-1], y_train.shape[-1])) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="adadelta") history = model.fit( X_train, y_train, nb_epoch=12, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=2, ) self.assertTrue(history.history["val_acc"][-1] > 0.9)
def test_vector_classification(): ''' Classify random float vectors into 2 classes with logistic regression using 2 layer neural network with ReLU hidden units. ''' (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=(20,), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # Test with Sequential API model = Sequential([ layers.Dense(16, input_shape=(x_train.shape[-1],), activation='relu'), layers.Dense(8), layers.Activation('relu'), layers.Dense(y_train.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=15, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert(history.history['val_acc'][-1] > 0.8) config = model.get_config() model = Sequential.from_config(config)
def test_temporal_classification_functional(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=200, num_test=20, input_shape=(3, 4), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) inputs = layers.Input(shape=(x_train.shape[1], x_train.shape[2])) x = layers.SimpleRNN(8)(inputs) outputs = layers.Dense(y_train.shape[-1], activation='softmax')(x) model = keras.models.Model(inputs, outputs) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) history = model.fit(x_train, y_train, epochs=4, batch_size=10, validation_data=(x_test, y_test), verbose=0) assert(history.history['acc'][-1] >= 0.8)
def test_image_classification(): np.random.seed(1337) input_shape = (16, 16, 3) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=input_shape, classification=True, num_classes=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ layers.Conv2D(filters=8, kernel_size=3, activation='relu', input_shape=input_shape), layers.MaxPooling2D(pool_size=2), layers.Conv2D(filters=4, kernel_size=(3, 3), activation='relu', padding='same'), layers.GlobalAveragePooling2D(), layers.Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=10, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert history.history['val_acc'][-1] > 0.75 config = model.get_config() model = Sequential.from_config(config)
def test_EarlyStopping(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) mode = 'max' monitor = 'val_acc' patience = 0 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20) mode = 'auto' monitor = 'val_acc' patience = 2 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20)
def test_tf_optimizer(): import tensorflow as tf num_hidden = 10 output_dim = 2 input_dim = 10 target = 0.8 optimizer = tf.train.AdadeltaOptimizer( learning_rate=1., rho=0.95, epsilon=1e-08) (x_train, y_train), (x_test, y_test) = get_test_data( num_train=1000, num_test=200, input_shape=(input_dim,), classification=True, num_classes=output_dim) model = keras.Sequential() model.add(layers.Dense(num_hidden, activation='relu', input_shape=(input_dim,))) model.add(layers.Dense(output_dim, activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) history = model.fit(x_train, y_train, epochs=8, batch_size=16, validation_data=(x_test, y_test), verbose=2) assert history.history['val_acc'][-1] >= target # Test saving. _, fname = tempfile.mkstemp('.h5') model.save(fname) model = keras.models.load_model(fname) assert len(model.weights) == 4 os.remove(fname)
def test_TensorBoard_with_ReduceLROnPlateau(tmpdir): import shutil np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) cbks = [ callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.5, patience=4, verbose=1), callbacks.TensorBoard( log_dir=filepath)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=2) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def test_temporal_classification(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=200, num_test=20, input_shape=(3, 4), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(layers.GRU(8, input_shape=(x_train.shape[1], x_train.shape[2]))) model.add(layers.Dense(y_train.shape[-1], activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=4, batch_size=10, validation_data=(x_test, y_test), verbose=0) assert(history.history['acc'][-1] >= 0.8) config = model.get_config() model = Sequential.from_config(config)
def test_ReduceLROnPlateau(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def make_model(): np.random.seed(1337) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=0.1), metrics=['accuracy']) return model model = make_model() # This should reduce the LR after the first epoch (due to high epsilon). cbks = [callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, epsilon=10, patience=1, cooldown=5)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5, verbose=2) assert np.allclose(float(K.get_value(model.optimizer.lr)), 0.01, atol=K.epsilon()) model = make_model() cbks = [callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, epsilon=0, patience=1, cooldown=5)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5, verbose=2) assert np.allclose(float(K.get_value(model.optimizer.lr)), 0.1, atol=K.epsilon())
def test_TerminateOnNaN(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) cbks = [callbacks.TerminateOnNaN()] model = Sequential() initializer = initializers.Constant(value=1e5) for _ in range(5): model.add(Dense(num_hidden, input_dim=input_dim, activation='relu', kernel_initializer=initializer)) model.add(Dense(num_class, activation='linear')) model.compile(loss='mean_squared_error', optimizer='rmsprop') history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20) loss = history.history['loss'] assert len(loss) == 1 assert loss[0] == np.inf
def test_img_clf(self): print('image classification data:') (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=1000, nb_test=200, input_shape=(3, 8, 8), classification=True, nb_class=2) print('X_train:', X_train.shape) print('X_test:', X_test.shape) print('y_train:', y_train.shape) print('y_test:', y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(Convolution2D(8, 8, 8, input_shape=(3, 8, 8))) model.add(Activation('sigmoid')) model.add(Flatten()) model.add(Dense(y_test.shape[-1])) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd') history = model.fit(X_train, y_train, nb_epoch=12, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=0) print(history.history['val_acc'][-1]) self.assertTrue(history.history['val_acc'][-1] > 0.9)
def test_LambdaCallback(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # Start an arbitrary process that should run during model training and be terminated after training has completed. def f(): while True: pass p = multiprocessing.Process(target=f) p.start() cleanup_callback = callbacks.LambdaCallback(on_train_end=lambda logs: p.terminate()) cbks = [cleanup_callback] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5) p.join() assert not p.is_alive()
def test_image_classification(): ''' Classify random 16x16 color images into several classes using logistic regression with convolutional hidden layer. ''' np.random.seed(1337) input_shape = (3, 16, 16) (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=500, nb_test=200, input_shape=input_shape, classification=True, nb_class=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # convolution kernel size nb_conv = 3 # size of pooling area for max pooling nb_pool = 2 model = Sequential([ Convolution2D(nb_filter=8, nb_row=nb_conv, nb_col=nb_conv, input_shape=input_shape), MaxPooling2D(pool_size=(nb_pool, nb_pool)), Flatten(), Activation('relu'), Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='sgd') history = model.fit(X_train, y_train, nb_epoch=10, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=0) assert(history.history['val_acc'][-1] > 0.85)
def test_temporal_classification(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=500, nb_test=500, input_shape=(3, 5), classification=True, nb_class=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(GRU(y_train.shape[-1], input_shape=(X_train.shape[1], X_train.shape[2]), activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adagrad', metrics=['accuracy']) history = model.fit(X_train, y_train, nb_epoch=20, batch_size=32, validation_data=(X_test, y_test), verbose=0) assert(history.history['val_acc'][-1] >= 0.85)
def test_vector_classification(): ''' Classify random float vectors into 2 classes with logistic regression using 2 layer neural network with ReLU hidden units. ''' np.random.seed(1337) nb_hidden = 10 (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=500, nb_test=200, input_shape=(20,), classification=True, nb_class=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ Dense(nb_hidden, input_shape=(X_train.shape[-1],), activation='relu'), Dense(y_train.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) history = model.fit(X_train, y_train, nb_epoch=15, batch_size=16, validation_data=(X_test, y_test), verbose=0) assert(history.history['val_acc'][-1] > 0.8)
def test_vector_clf(self): nb_hidden = 10 print('vector classification data:') (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=1000, nb_test=200, input_shape=(10,), classification=True, nb_class=2) print('X_train:', X_train.shape) print('X_test:', X_test.shape) print('y_train:', y_train.shape) print('y_test:', y_test.shape) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(Dense(nb_hidden, input_shape=(X_train.shape[-1],))) model.add(Activation('relu')) model.add(Dense(y_train.shape[-1])) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') history = model.fit(X_train, y_train, nb_epoch=15, batch_size=16, validation_data=(X_test, y_test), show_accuracy=True, verbose=0) self.assertTrue(history.history['val_acc'][-1] > 0.8)
def test_TensorBoard_with_ReduceLROnPlateau(): import shutil filepath = './logs' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim,), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) cbks = [ callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.5, patience=4, verbose=1), callbacks.TensorBoard( log_dir=filepath)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) assert os.path.exists(filepath) shutil.rmtree(filepath)
def get_test_data(): np.random.seed(1337) (x_train, y_train), _ = test_utils.get_test_data(num_train=1000, num_test=200, input_shape=(10,), classification=True, num_classes=2) y_train = to_categorical(y_train) return x_train, y_train
def get_data(): (x_train, y_train), _ = test_utils.get_test_data( num_train=batch_size, num_test=batch_size, input_shape=(data_dim,), classification=True, num_classes=num_classes) y_train = np_utils.to_categorical(y_train, num_classes) return x_train, y_train
def get_data_callbacks(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_classes): return get_test_data(num_train=num_train, num_test=num_test, input_shape=input_shape, classification=classification, num_classes=num_classes)
def test_arma_layer(): (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=100, nb_test=50, input_shape=(100, 1), output_shape=(1,), classification=False) model = Sequential() model.add(ARMA(inner_input_dim=10, input_shape=(100, 1), output_dim=1)) model.compile(loss='mean_squared_error', optimizer='sgd') model.fit(X_train, y_train)
def test_ModelCheckpoint(): filepath = 'checkpoint.h5' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim,), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) # case 1 monitor = 'val_loss' save_best_only = False mode = 'auto' model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) cbks = [callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 2 mode = 'min' cbks = [callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 3 mode = 'max' monitor = 'val_acc' cbks = [callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 4 save_best_only = True cbks = [callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath)
def _get_test_data(train_samples=100, test_samples=50): np.random.seed(1234) (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim,), classification=True, nb_class=4) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) return (X_train, y_train), (X_test, y_test)
def test_CSVLogger(tmpdir): np.random.seed(1337) filepath = str(tmpdir / 'log.tsv') sep = '\t' (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def make_model(): np.random.seed(1337) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=0.1), metrics=['accuracy']) return model # case 1, create new file with defined separator model = make_model() cbks = [callbacks.CSVLogger(filepath, separator=sep)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) with open(filepath) as csvfile: dialect = Sniffer().sniff(csvfile.read()) assert dialect.delimiter == sep del model del cbks # case 2, append data to existing file, skip header model = make_model() cbks = [callbacks.CSVLogger(filepath, separator=sep, append=True)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) # case 3, reuse of CSVLogger object model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) import re with open(filepath) as csvfile: output = " ".join(csvfile.readlines()) assert len(re.findall('epoch', output)) == 1 os.remove(filepath) assert not tmpdir.listdir()
def test_temporal_regression(): (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=500, nb_test=200, input_shape=(3, 5), output_shape=(2,), classification=False) model = Sequential() model.add(GRU(y_train.shape[-1], input_shape=(X_train.shape[1], X_train.shape[2]))) model.compile(loss='hinge', optimizer='adam') history = model.fit(X_train, y_train, nb_epoch=20, batch_size=16, validation_data=(X_test, y_test), verbose=0) assert(history.history['val_loss'][-1] < 0.8)
def _get_test_data(): np.random.seed(1234) train_samples = 100 test_samples = 50 (x_train, y_train), (x_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) return (x_train, y_train), (x_test, y_test)
def test_sequence_to_sequence(): (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=500, nb_test=200, input_shape=(3, 5), output_shape=(3, 5), classification=False) model = Sequential() model.add(TimeDistributedDense(y_train.shape[-1], input_shape=(X_train.shape[1], X_train.shape[2]))) model.compile(loss='hinge', optimizer='rmsprop') history = model.fit(X_train, y_train, nb_epoch=20, batch_size=16, validation_data=(X_test, y_test), verbose=0) assert(history.history['val_loss'][-1] < 0.8)
def test_TensorBoard(): import shutil filepath = './logs' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim, ), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: yield (X_train[i * batch_size:(i + 1) * batch_size], y_train[i * batch_size:(i + 1) * batch_size]) else: yield (X_test[i * batch_size:(i + 1) * batch_size], y_test[i * batch_size:(i + 1) * batch_size]) i += 1 i = i % max_batch_index def data_generator_graph(train): while 1: if train: yield {'X_vars': X_train, 'output': y_train} else: yield {'X_vars': X_test, 'output': y_test} # case 1 Sequential model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] # fit with validation data model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=3) # fit with validation data and accuracy model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) # fit generator with validation data model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, callbacks=cbks) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data and accuracy model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, callbacks=cbks) assert os.path.exists(filepath) shutil.rmtree(filepath)
def test_TensorBoard(): import shutil import tensorflow as tf import keras.backend.tensorflow_backend as KTF old_session = KTF._get_session() filepath = './logs' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim, ), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) # case 1 Sequential wo accuracy with tf.Graph().as_default(): session = tf.Session('') KTF._set_session(session) model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd') tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] model.fit(X_train, y_train, batch_size=batch_size, show_accuracy=True, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) assert os.path.exists(filepath) shutil.rmtree(filepath) # case 2 Sequential w accuracy with tf.Graph().as_default(): session = tf.Session('') KTF._set_session(session) model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd') tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] model.fit(X_train, y_train, batch_size=batch_size, show_accuracy=True, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) assert os.path.exists(filepath) shutil.rmtree(filepath) # case 3 Graph with tf.Graph().as_default(): session = tf.Session('') KTF._set_session(session) model = Graph() model.add_input(name='X_vars', input_shape=(input_dim, )) model.add_node(Dense(nb_hidden, activation="sigmoid"), name='Dense1', input='X_vars') model.add_node(Dense(nb_class, activation="softmax"), name='last_dense', input='Dense1') model.add_output(name='output', input='last_dense') model.compile(optimizer='sgd', loss={'output': 'mse'}) tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] model.fit({ 'X_vars': X_train, 'output': y_train }, batch_size=batch_size, validation_data={ 'X_vars': X_test, 'output': y_test }, callbacks=cbks, nb_epoch=2) assert os.path.exists(filepath) shutil.rmtree(filepath) KTF._set_session(old_session)
from keras.layers.core import Dense, Activation from keras.wrappers.scikit_learn import KerasClassifier, KerasRegressor np.random.seed(1337) input_dim = 10 nb_class = 3 batch_size = 32 nb_epoch = 1 verbosity = 0 optim = 'adam' loss = 'categorical_crossentropy' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=400, nb_test=200, input_shape=(input_dim, ), classification=True, nb_class=nb_class) y_train = np_utils.to_categorical(y_train, nb_classes=nb_class) y_test = np_utils.to_categorical(y_test, nb_classes=nb_class) (X_train_reg, y_train_reg), (X_test_reg, y_test_reg) = get_test_data(nb_train=400, nb_test=200, input_shape=(input_dim, ), classification=False, nb_class=1, output_shape=(1, ))
def test_TensorBoard(tmpdir): np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data( num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: yield (X_train[i * batch_size: (i + 1) * batch_size], y_train[i * batch_size: (i + 1) * batch_size]) else: yield (X_test[i * batch_size: (i + 1) * batch_size], y_test[i * batch_size: (i + 1) * batch_size]) i += 1 i = i % max_batch_index def data_generator_graph(train): while 1: if train: yield {'X_vars': X_train, 'output': y_train} else: yield {'X_vars': X_test, 'output': y_test} # case 1 Sequential model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dropout(0.1)) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1, write_images=True, write_grads=True, embeddings_freq=1, embeddings_layer_names=['dense_1'], batch_size=5) cbks = [tsb] # fit with validation data model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=3) # fit with validation data and accuracy model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=2) # fit generator with validation data model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=cbks) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data and accuracy model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=cbks) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def test_TensorBoard(tmpdir): np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data( num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: # simulate multi-input/output models yield (X_train[i * batch_size: (i + 1) * batch_size], y_train[i * batch_size: (i + 1) * batch_size]) else: yield (X_test[i * batch_size: (i + 1) * batch_size], y_test[i * batch_size: (i + 1) * batch_size]) i += 1 i = i % max_batch_index class DummyStatefulMetric(Layer): def __init__(self, name='dummy_stateful_metric', **kwargs): super(DummyStatefulMetric, self).__init__(name=name, **kwargs) self.stateful = True self.state = K.variable(value=0, dtype='int32') def reset_states(self): pass def __call__(self, y_true, y_pred): return self.state inp = Input((input_dim,)) hidden = Dense(num_hidden, activation='relu')(inp) hidden = Dropout(0.1)(hidden) output = Dense(num_classes, activation='softmax')(hidden) model = Model(inputs=inp, outputs=output) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy', DummyStatefulMetric()]) # we must generate new callbacks for each test, as they aren't stateless def callbacks_factory(histogram_freq, embeddings_freq=1): return [callbacks.TensorBoard(log_dir=filepath, histogram_freq=histogram_freq, write_images=True, write_grads=True, embeddings_freq=embeddings_freq, embeddings_layer_names=['dense_1'], embeddings_data=X_test, batch_size=5)] # fit without validation data model.fit(X_train, y_train, batch_size=batch_size, callbacks=callbacks_factory(histogram_freq=0, embeddings_freq=0), epochs=3) # fit with validation data and accuracy model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=callbacks_factory(histogram_freq=0), epochs=2) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=callbacks_factory(histogram_freq=0, embeddings_freq=0)) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=(X_test, y_test), callbacks=callbacks_factory(histogram_freq=1)) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def test_ReduceLROnPlateau(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim, ), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def make_model(): np.random.seed(1337) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=0.1), metrics=['accuracy']) return model model = make_model() # This should reduce the LR after the first epoch (due to high epsilon). cbks = [ callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, epsilon=10, patience=1, cooldown=5) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5, verbose=2) assert np.allclose(float(K.get_value(model.optimizer.lr)), 0.01, atol=K.epsilon()) model = make_model() cbks = [ callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, epsilon=0, patience=1, cooldown=5) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5, verbose=2) assert np.allclose(float(K.get_value(model.optimizer.lr)), 0.1, atol=K.epsilon())
def test_ModelCheckpoint(): filepath = 'checkpoint.h5' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim, ), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) # case 1 monitor = 'val_loss' save_best_only = False mode = 'auto' model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 2 mode = 'min' cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 3 mode = 'max' monitor = 'val_acc' cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath) # case 4 save_best_only = True cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=1) assert os.path.exists(filepath) os.remove(filepath)
from __future__ import print_function import numpy as np from keras.layers.core import Dense, Activation from keras.models import Sequential from keras.utils.np_utils import to_categorical from keras.utils.test_utils import get_test_data np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=1000, num_test=200, input_shape=(10, ), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) def get_model(input_dim, nb_hidden, output_dim): model = Sequential() model.add(Dense(nb_hidden, input_shape=(input_dim, ))) model.add(Activation('relu')) model.add(Dense(output_dim)) model.add(Activation('softmax')) return model def validate_optimizer(optimizer, target=0.89): model = get_model(X_train.shape[1], 10, y_train.shape[1]) model.compile(loss='categorical_crossentropy',
def test_ModelCheckpoint(tmpdir): np.random.seed(1337) filepath = str(tmpdir / 'checkpoint.h5') (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim, ), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) # case 1 monitor = 'val_loss' save_best_only = False mode = 'auto' model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) os.remove(filepath) # case 2 mode = 'min' cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) os.remove(filepath) # case 3 mode = 'max' monitor = 'val_acc' cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) os.remove(filepath) # case 4 save_best_only = True cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) os.remove(filepath) # case 5 save_best_only = False period = 2 mode = 'auto' filepath = 'checkpoint.{epoch:02d}.h5' cbks = [ callbacks.ModelCheckpoint(filepath, monitor=monitor, save_best_only=save_best_only, mode=mode, period=period) ] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=4) assert os.path.isfile(filepath.format(epoch=2)) assert os.path.isfile(filepath.format(epoch=4)) assert not os.path.exists(filepath.format(epoch=1)) assert not os.path.exists(filepath.format(epoch=3)) os.remove(filepath.format(epoch=2)) os.remove(filepath.format(epoch=4)) assert not tmpdir.listdir()
def test_TensorBoard(): import shutil import tensorflow as tf import keras.backend.tensorflow_backend as KTF old_session = KTF.get_session() filepath = './logs' (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim,), classification=True, nb_class=nb_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: yield (X_train[i * batch_size: (i + 1) * batch_size], y_train[i * batch_size: (i + 1) * batch_size]) else: yield (X_test[i * batch_size: (i + 1) * batch_size], y_test[i * batch_size: (i + 1) * batch_size]) i += 1 i = i % max_batch_index def data_generator_graph(train): while 1: if train: yield {'X_vars': X_train, 'output': y_train} else: yield {'X_vars': X_test, 'output': y_test} # case 1 Sequential with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) model = Sequential() model.add(Dense(nb_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(nb_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd') tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] # fit with validation data model.fit(X_train, y_train, batch_size=batch_size, show_accuracy=False, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) # fit with validation data and accuracy model.fit(X_train, y_train, batch_size=batch_size, show_accuracy=True, validation_data=(X_test, y_test), callbacks=cbks, nb_epoch=2) # fit generator with validation data model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, show_accuracy=False, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, show_accuracy=False, callbacks=cbks) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, show_accuracy=True, validation_data=(X_test, y_test), callbacks=cbks) # fit generator without validation data and accuracy model.fit_generator(data_generator(True), len(X_train), nb_epoch=2, show_accuracy=True, callbacks=cbks) assert os.path.exists(filepath) shutil.rmtree(filepath) # case 2 Graph with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) model = Graph() model.add_input(name='X_vars', input_shape=(input_dim, )) model.add_node(Dense(nb_hidden, activation="sigmoid"), name='Dense1', input='X_vars') model.add_node(Dense(nb_class, activation="softmax"), name='last_dense', input='Dense1') model.add_output(name='output', input='last_dense') model.compile(optimizer='sgd', loss={'output': 'mse'}) tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1) cbks = [tsb] # fit with validation model.fit({'X_vars': X_train, 'output': y_train}, batch_size=batch_size, validation_data={'X_vars': X_test, 'output': y_test}, callbacks=cbks, nb_epoch=2) # fit wo validation model.fit({'X_vars': X_train, 'output': y_train}, batch_size=batch_size, callbacks=cbks, nb_epoch=2) # fit generator with validation model.fit_generator(data_generator_graph(True), 1000, nb_epoch=2, validation_data={'X_vars': X_test, 'output': y_test}, callbacks=cbks) # fit generator wo validation model.fit_generator(data_generator_graph(True), 1000, nb_epoch=2, callbacks=cbks) assert os.path.exists(filepath) shutil.rmtree(filepath) KTF.set_session(old_session)
def test_TensorBoard_multi_input_output(tmpdir): np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data( num_train=train_samples, num_test=test_samples, input_shape=(input_dim, input_dim), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: # simulate multi-input/output models yield ([X_train[i * batch_size: (i + 1) * batch_size]] * 2, [y_train[i * batch_size: (i + 1) * batch_size]] * 2) else: yield ([X_test[i * batch_size: (i + 1) * batch_size]] * 2, [y_test[i * batch_size: (i + 1) * batch_size]] * 2) i += 1 i = i % max_batch_index inp1 = Input((input_dim, input_dim)) inp2 = Input((input_dim, input_dim)) inp_3d = add([inp1, inp2]) inp_2d = GlobalAveragePooling1D()(inp_3d) # test a layer with a list of output tensors inp_pair = Lambda(lambda x: x)([inp_3d, inp_2d]) hidden = dot(inp_pair, axes=-1) hidden = Dense(num_hidden, activation='relu')(hidden) hidden = Dropout(0.1)(hidden) output1 = Dense(num_classes, activation='softmax')(hidden) output2 = Dense(num_classes, activation='softmax')(hidden) model = Model(inputs=[inp1, inp2], outputs=[output1, output2]) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # we must generate new callbacks for each test, as they aren't stateless def callbacks_factory(histogram_freq, embeddings_freq=1): return [callbacks.TensorBoard(log_dir=filepath, histogram_freq=histogram_freq, write_images=True, write_grads=True, embeddings_freq=embeddings_freq, embeddings_layer_names=['dense_1'], embeddings_data=[X_test] * 2, batch_size=5)] # fit without validation data model.fit([X_train] * 2, [y_train] * 2, batch_size=batch_size, callbacks=callbacks_factory(histogram_freq=0, embeddings_freq=0), epochs=3) # fit with validation data and accuracy model.fit([X_train] * 2, [y_train] * 2, batch_size=batch_size, validation_data=([X_test] * 2, [y_test] * 2), callbacks=callbacks_factory(histogram_freq=1), epochs=2) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=callbacks_factory(histogram_freq=0, embeddings_freq=0)) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=([X_test] * 2, [y_test] * 2), callbacks=callbacks_factory(histogram_freq=1)) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def test_TensorBoard_histogram_freq_must_have_validation_data(tmpdir): np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data( num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: # simulate multi-input/output models yield (X_train[i * batch_size: (i + 1) * batch_size], y_train[i * batch_size: (i + 1) * batch_size]) else: yield (X_test[i * batch_size: (i + 1) * batch_size], y_test[i * batch_size: (i + 1) * batch_size]) i += 1 i = i % max_batch_index inp = Input((input_dim,)) hidden = Dense(num_hidden, activation='relu')(inp) hidden = Dropout(0.1)(hidden) output = Dense(num_classes, activation='softmax')(hidden) model = Model(inputs=inp, outputs=output) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # we must generate new callbacks for each test, as they aren't stateless def callbacks_factory(histogram_freq, embeddings_freq=1): return [callbacks.TensorBoard(log_dir=filepath, histogram_freq=histogram_freq, write_images=True, write_grads=True, embeddings_freq=embeddings_freq, embeddings_layer_names=['dense_1'], embeddings_data=X_test, batch_size=5)] # fit without validation data should raise ValueError if histogram_freq > 0 with pytest.raises(ValueError) as raised_exception: model.fit(X_train, y_train, batch_size=batch_size, callbacks=callbacks_factory(histogram_freq=1), epochs=3) assert 'validation_data must be provided' in str(raised_exception.value) # fit generator without validation data should raise ValueError if # histogram_freq > 0 with pytest.raises(ValueError) as raised_exception: model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=callbacks_factory(histogram_freq=1)) assert 'validation_data must be provided' in str(raised_exception.value) # fit generator with validation data generator should raise ValueError if # histogram_freq > 0 with pytest.raises(ValueError) as raised_exception: model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=data_generator(False), validation_steps=1, callbacks=callbacks_factory(histogram_freq=1)) assert 'validation_data must be provided' in str(raised_exception.value)
def ds_2(**kwargs): (X_train, Y_train), (X_test, Y_test) = get_test_data(**kwargs) X = np.concatenate((X_train, X_test)) Y = np.concatenate((Y_train, Y_test)) return X, Y
np.random.seed(1337) from keras import backend as K from keras.models import Graph, Sequential, model_from_json, model_from_yaml from keras.layers.core import Dense, Activation, Merge, Lambda, LambdaMerge, Siamese, add_shared_layer from keras.layers import containers from keras.utils.test_utils import get_test_data batch_size = 32 (X_train_graph, y_train_graph), (X_test_graph, y_test_graph) = get_test_data(nb_train=1000, nb_test=200, input_shape=(32, ), classification=False, output_shape=(4, )) (X2_train_graph, y2_train_graph), (X2_test_graph, y2_test_graph) = get_test_data(nb_train=1000, nb_test=200, input_shape=(32, ), classification=False, output_shape=(1, )) def test_graph_fit_generator(): def data_generator_graph(train): while 1: if train:
import os from keras.utils.layer_utils import model_summary input_dim = 32 nb_hidden = 16 nb_class = 4 batch_size = 32 nb_epoch = 1 train_samples = 2000 test_samples = 500 (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim, ), classification=True, nb_class=4) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) #################### # SEQUENTIAL TEST # #################### def test_sequential(): model = Sequential() model.add(Dense(nb_hidden, input_shape=(input_dim, ))) model.add(Activation('relu')) model.add(Dense(nb_class))
input_dim = 5 hidden_dims = 5 num_train = 100 num_test = 50 num_class = 3 batch_size = 32 epochs = 1 verbosity = 0 optim = 'adam' loss = 'categorical_crossentropy' np.random.seed(42) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=num_train, num_test=num_test, input_shape=(input_dim, ), classification=True, num_classes=num_class) def build_fn_clf(hidden_dims): model = Sequential() model.add(Dense(input_dim, input_shape=(input_dim, ))) model.add(Activation('relu')) model.add(Dense(hidden_dims)) model.add(Activation('relu')) model.add(Dense(num_class)) model.add(Activation('softmax')) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
def test_TensorBoard_multi_input_output(tmpdir): np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data( num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def data_generator(train): if train: max_batch_index = len(X_train) // batch_size else: max_batch_index = len(X_test) // batch_size i = 0 while 1: if train: # simulate multi-input/output models yield ([X_train[i * batch_size: (i + 1) * batch_size]] * 2, [y_train[i * batch_size: (i + 1) * batch_size]] * 2) else: yield ([X_test[i * batch_size: (i + 1) * batch_size]] * 2, [y_test[i * batch_size: (i + 1) * batch_size]] * 2) i += 1 i = i % max_batch_index inp1 = Input((input_dim,)) inp2 = Input((input_dim,)) inp = add([inp1, inp2]) hidden = Dense(num_hidden, activation='relu')(inp) hidden = Dropout(0.1)(hidden) output1 = Dense(num_class, activation='softmax')(hidden) output2 = Dense(num_class, activation='softmax')(hidden) model = Model(inputs=[inp1, inp2], outputs=[output1, output2]) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) tsb = callbacks.TensorBoard(log_dir=filepath, histogram_freq=1, write_images=True, write_grads=True, embeddings_freq=1, embeddings_layer_names=['dense_1'], batch_size=5) cbks = [tsb] # fit without validation data model.fit([X_train] * 2, [y_train] * 2, batch_size=batch_size, callbacks=cbks, epochs=3) # fit with validation data and accuracy model.fit([X_train] * 2, [y_train] * 2, batch_size=batch_size, validation_data=([X_test] * 2, [y_test] * 2), callbacks=cbks, epochs=2) # fit generator without validation data model.fit_generator(data_generator(True), len(X_train), epochs=2, callbacks=cbks) # fit generator with validation data and accuracy model.fit_generator(data_generator(True), len(X_train), epochs=2, validation_data=([X_test] * 2, [y_test] * 2), callbacks=cbks) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
from keras.models import Sequential, model_from_json, model_from_yaml from keras.layers.core import Dense, Activation, Merge from keras.utils import np_utils from keras.utils.test_utils import get_test_data input_dim = 32 nb_hidden = 16 nb_class = 4 batch_size = 64 nb_epoch = 1 train_samples = 5000 test_samples = 1000 (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=train_samples, nb_test=test_samples, input_shape=(input_dim,), classification=True, nb_class=4) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) print(X_train.shape) print(y_train.shape) class TestSequential(unittest.TestCase): def test_sequential(self): print('Test sequential') model = Sequential() model.add(Dense(nb_hidden, input_shape=(input_dim,))) model.add(Activation('relu')) model.add(Dense(nb_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
def test_CSVLogger(tmpdir): np.random.seed(1337) filepath = str(tmpdir / 'log.tsv') sep = '\t' (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim, ), classification=True, num_classes=num_classes) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) def make_model(): np.random.seed(1337) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=0.1), metrics=['accuracy']) return model # case 1, create new file with defined separator model = make_model() cbks = [callbacks.CSVLogger(filepath, separator=sep)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) assert os.path.isfile(filepath) with open(filepath) as csvfile: dialect = Sniffer().sniff(csvfile.read()) assert dialect.delimiter == sep del model del cbks # case 2, append data to existing file, skip header model = make_model() cbks = [callbacks.CSVLogger(filepath, separator=sep, append=True)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) # case 3, reuse of CSVLogger object model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=1) import re with open(filepath) as csvfile: output = " ".join(csvfile.readlines()) assert len(re.findall('epoch', output)) == 1 os.remove(filepath) assert not tmpdir.listdir()
from __future__ import print_function import unittest import numpy as np np.random.seed(1337) from keras.models import Graph, Sequential from keras.layers import containers from keras.layers.core import Dense, Activation from keras.utils.test_utils import get_test_data X = np.random.random((100, 32)) X2 = np.random.random((100, 32)) y = np.random.random((100, 4)) y2 = np.random.random((100,)) (X_train, y_train), (X_test, y_test) = get_test_data(nb_train=1000, nb_test=200, input_shape=(32,), classification=False, output_shape=(4,)) (X2_train, y2_train), (X2_test, y2_test) = get_test_data(nb_train=1000, nb_test=200, input_shape=(32,), classification=False, output_shape=(1,)) class TestGraph(unittest.TestCase): def test_1o_1i(self): print('test a non-sequential graph with 1 input and 1 output') graph = Graph() graph.add_input(name='input1', ndim=2) graph.add_node(Dense(32, 16), name='dense1', input='input1') graph.add_node(Dense(32, 4), name='dense2', input='input1') graph.add_node(Dense(16, 4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') graph.compile('rmsprop', {'output1':'mse'})