def main(): # Parsing arguments parser = argparse.ArgumentParser(description='Training GANs or VAEs') parser.add_argument('--model', type=str, required=True) parser.add_argument('--dataset', type=str, required=True) parser.add_argument('--epoch', type=int, default=200) parser.add_argument('--initialepoch', type=int, default=0) parser.add_argument('--batchsize', type=int, default=50) parser.add_argument('--output', default='output') parser.add_argument('--zdims', type=int, default=256) parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--resume', type=str, default=None) parser.add_argument('--testmode', action='store_true') args = parser.parse_args() # select gpu os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu) # Make output direcotiry if not exists if not os.path.isdir(args.output): os.mkdir(args.output) # Load datasets if args.dataset == 'mnist': datasets = mnist.load_data() elif args.dataset == 'fashion_mnist': datasets = mnist.load_data() elif args.dataset == 'svhn': datasets = svhn.load_data() else: datasets = dts.load_data(args.dataset) # Construct model if args.model not in models: raise Exception('Unknown model:', args.model) model = models[args.model](input_shape=datasets.shape[1:], z_dims=args.zdims, output=args.output) if args.testmode: model.test_mode = True if args.resume is not None: model.load_model(args.resume) # Training loop datasets = datasets.images * 2.0 - 1.0 samples = np.random.normal(size=(100, args.zdims)).astype(np.float32) model.main_loop(datasets, samples, epochs=args.epoch, initial_epoch=args.initialepoch, batchsize=args.batchsize, reporter=['loss', 'g_loss', 'd_loss', 'g_acc', 'd_acc'])
def main(): yml_path = sys.argv[1] with open(yml_path) as f: config = yaml.load(f) inlier_classes = config['train_data_params']['labels'] outlier_classes = [i for i in range(10) if i not in inlier_classes] x, y = load_data('test', normalization='tanh', with_label=True) y = np.array(y) x = tf.constant(x, dtype=tf.float32) model = DeepSVDD(**config['model_params']) model.build(input_shape=(None, 32, 32, 1)) center = tf.Variable(np.zeros((model.output_dim)), dtype=tf.float32) radius = tf.Variable(0., dtype=tf.float32) checkpoint = tf.train.Checkpoint(center=center, radius=radius) model.load_weights( os.path.join(config['logdir'], 'model', 'model_%d' % config['test_epoch'])) checkpoint.restore( os.path.join(config['logdir'], 'model', 'center_radius_%d' % config['test_epoch'])) outputs = model.predict(x) df_inlier = create_dataframe(x, y, center, outputs, inlier_classes, model.output_dim, 'inlier') df_outlier = create_dataframe(x, y, center, outputs, outlier_classes, model.output_dim, 'outlier') df = pd.concat([df_inlier, df_outlier], axis=0) df.to_csv(os.path.join(config['logdir'], 'outputs.csv'), index=None)
def main(): yml_path = sys.argv[1] with open(yml_path) as f: config = yaml.load(f) inlier_classes = config['train_data_params']['labels'] outlier_classes = [i for i in range(10) if i not in inlier_classes] x, y = load_data('test', with_label=True, normalization='tanh') y = np.array(y) discriminator = Discriminator(**config['discriminator_params']) _ = tf.nn.sigmoid(discriminator(tf.constant(x[0][None, :], dtype=tf.float32), training=False)) discriminator.load_weights(os.path.join(config['logdir'], 'model/ocgan', 'discriminator_%d.h5' % config['test_epoch'])) outputs = tf.nn.sigmoid(discriminator(tf.constant(x, dtype=tf.float32), training=False)) outputs = np.squeeze(np.asarray(outputs)) inlier_outputs = np.zeros(shape=(0, )) for c in inlier_classes: inlier_outputs = np.append(inlier_outputs, outputs[y == c]) df_inlier = pd.DataFrame({'normality': inlier_outputs, 'label': 'inlier'}) outlier_outputs = np.zeros(shape=(0, )) for c in outlier_classes: outlier_outputs = np.append(outlier_outputs, outputs[y == c]) df_outlier = pd.DataFrame({'normality': outlier_outputs, 'label': 'outlier'}) df = pd.concat([df_inlier, df_outlier], axis=0) df.to_csv(os.path.join(config['logdir'], 'outputs.csv'), index=None)
def test_mnist(): (train_x, train_y), (test_x, test_y) = mnist.load_data() val_x = train_x[50000:] val_y = train_y[50000:] train_x = train_x[:50000] train_y = train_y[:50000] batch_size = 200 modle = models.Sequential() modle.add(layers.Linear(28, input_shape=(None, train_x.shape[1]))) modle.add(layers.ReLU()) modle.add(layers.Linear(10)) modle.add(layers.ReLU()) modle.add(layers.Linear(10)) modle.add(layers.Softmax()) acc = losses.categorical_accuracy.__name__ modle.compile(losses.CrossEntropy(), optimizers.SGD(lr=0.001), metrics=[losses.categorical_accuracy]) modle.summary() history = modle.train(train_x, train_y, batch_size, epochs=32, validation_data=(val_x, val_y)) epochs = range(1, len(history["loss"]) + 1) plt.plot(epochs, history["loss"], 'ro', label="Traning loss") plt.plot(epochs, history["val_loss"], 'go', label="Validating loss") plt.plot(epochs, history[acc], 'r', label="Traning accuracy") plt.plot(epochs, history["val_" + acc], 'g', label="Validating accuracy") plt.title('Training/Validating loss/accuracy') plt.xlabel('Epochs') plt.ylabel('Loss/Accuracy') plt.legend() plt.show(block=True)
def main(_): # Parsing arguments parser = argparse.ArgumentParser(description='Training GANs or VAEs') parser.add_argument('--model', type=str, required=True) parser.add_argument('--dataset', type=str, required=True) parser.add_argument('--datasize', type=int, default=-1) parser.add_argument('--epoch', type=int, default=200) parser.add_argument('--batchsize', type=int, default=50) parser.add_argument('--output', default='output') parser.add_argument('--zdims', type=int, default=256) parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--resume', type=str, default=None) parser.add_argument('--testmode', action='store_true') args = parser.parse_args() # select gpu os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu) # Make output direcotiry if not exists if not os.path.isdir(args.output): os.mkdir(args.output) # Load datasets if args.dataset == 'mnist': datasets = mnist.load_data() elif args.dataset == 'svhn': datasets = svhn.load_data() else: #datasets = load_data(args.dataset, args.datasize) datasets = load_images(args.dataset) # load # Construct model if args.model not in models: raise Exception('Unknown model:', args.model) #-------------------------------------------------------- print("input_shape", datasets.shape[1:]) #-------------------------------------------------------- model = models[args.model](batchsize=args.batchsize, input_shape=datasets.shape[1:], attr_names=None or datasets.attr_names, z_dims=args.zdims, output=args.output, resume=args.resume) if args.testmode: model.test_mode = True tf.set_random_seed(12345) # Training loop datasets.images = datasets.images.astype('float32') * 2.0 - 1.0 #-------------------------- print("datasets.images", datasets.images.shape) model.main_loop(datasets, epochs=args.epoch)
def main(): yml_path = sys.argv[1] with open(yml_path) as f: config = yaml.load(f) noise_sampler = NoiseSampler('normal') inlier_classes = config['train_data_params']['labels'] outlier_classes = [i for i in range(10) if i not in inlier_classes] x, y = load_data('test', with_label=True, normalization='tanh') y = np.array(y) generator = Generator(**config['generator_params']) discriminator = Discriminator(**config['discriminator_params']) generator.build(input_shape=(None, generator.latent_dim)) discriminator.build(input_shape=(None, 32, 32, 1)) generator.load_weights( os.path.join(config['logdir'], 'model', 'generator_%d' % config['test_epoch'])) discriminator.load_weights( os.path.join(config['logdir'], 'model', 'discriminator_%d' % config['test_epoch'])) inliers = np.zeros(shape=(0, *x.shape[1:])) for c in inlier_classes: inliers = np.append(inliers, x[y == c], axis=0) outliers = np.zeros(shape=(0, *x.shape[1:])) for c in outlier_classes: outliers = np.append(outliers, x[y == c], axis=0) inlier = inliers[np.random.randint(len(inliers))] outlier = outliers[np.random.randint(len(outliers))] computer = ScoreComputer(generator, discriminator, **config['score_computer_params']) _, inlier_history = computer.compute_score(inlier[None, :, :, :], noise_sampler, **config['compute_params'], with_history=True) _, outlier_history = computer.compute_score(outlier[None, :, :, :], noise_sampler, **config['compute_params'], with_history=True) inlier_scores = np.array(inlier_history['score']).squeeze() inlier_gens = np.array(inlier_history['generated']).squeeze() inlier_z = np.array(inlier_history['z']).squeeze() outlier_scores = np.array(outlier_history['score']).squeeze() outlier_gens = np.array(outlier_history['generated']).squeeze() outlier_z = np.array(outlier_history['z']).squeeze() plot_gen_score(inlier, inlier_gens, inlier_scores, 'inlier.gif') plot_gen_score(outlier, outlier_gens, outlier_scores, 'outlier.gif')
def test_mnist_with_cov2d(): (train_x, train_y), (test_x, test_y) = mnist.load_data(flatten=False, one_hot_label=False) val_x = train_x[50000:] val_y = train_y[50000:] train_x = train_x[:50000] train_y = train_y[:50000] net = Net() dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") net.to(dev) optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9) epochs = 20 batch_size = 200 batches = len(train_x)//batch_size history = {"loss":[], "val_loss":[], "accuracy":[], "val_accuracy":[]} for epoch in range(epochs): net.train() epoch_loss = 0.0 epoch_acc = 0.0 for batch in range(batches): x_true = torch.tensor(train_x[batch*batch_size: (batch+1)*batch_size], dtype=torch.float).to(dev) y_true = torch.tensor(train_y[batch*batch_size: (batch+1)*batch_size], dtype=torch.long).to(dev) y_pred = net(x_true) loss = F.cross_entropy(y_pred, y_true) loss.backward() optimizer.step() optimizer.zero_grad() epoch_loss += loss.item() epoch_acc += accuracy(y_pred, y_true) train_loss = epoch_loss/batches train_acc = epoch_acc/batches history["loss"].append(train_loss) history["accuracy"].append(train_acc) # Do validation after each epoch net.eval() with torch.no_grad(): x_true = torch.tensor(val_x, dtype=torch.float).to(dev) y_true = torch.tensor(val_y, dtype=torch.long).to(dev) y_pred = net(x_true) val_loss = F.cross_entropy(y_pred, y_true) val_acc = accuracy(y_pred, y_true) history["val_loss"].append(val_loss) history["val_accuracy"].append(val_acc) print(f"Epoch: {epoch+1} loss: {train_loss} accuracy:{train_acc} val_loss: {val_loss}, val_accuracy:{val_acc}") plt.plot(history["loss"], 'ro', label="Training loss") plt.plot(history["val_loss"], 'go',label="Validating loss") plt.plot(history["accuracy"], 'r', label="Training accuracy") plt.plot(history["val_accuracy"], 'g', label="Validating accuracy") plt.title('Training/Validating loss') plt.xlabel('Epochs') plt.ylabel('Loss/Accuracy') plt.legend() plt.show(block=True)
def main(): yml_path = sys.argv[1] with open(yml_path) as f: config = yaml.load(f) inlier_classes = config['train_data_params']['labels'] outlier_classes = [i for i in range(10) if i not in inlier_classes] x, y = load_data('test', normalization='tanh', with_label=True) y = np.array(y) x = tf.constant(x, dtype=tf.float32) autoencoder = AutoEncoder(**config['autoencoder_params']) estimation_network = EstimationNetwork(**config['estimator_params']) gmm = GMM(config['estimator_params']['dense_units'][-1], config['autoencoder_params']['latent_dim'] + 1) autoencoder.build(input_shape=(1, 32, 32, 1)) estimation_network.build( input_shape=(1, config['autoencoder_params']['latent_dim'] + 1)) gmm([ tf.random.normal((1, config['autoencoder_params']['latent_dim'] + 1)), tf.random.normal((1, config['estimator_params']['dense_units'][-1])) ]) # tf 2.1.0 doesn't accept # gmm.build(input_shape=[(1, config['autoencoder_params']['latent_dim']+1), # (1, config['estimator_params']['dense_units'][-1])]) dagmm = DAGMM(autoencoder, estimation_network, gmm) dagmm.load_weights( os.path.join(config['logdir'], 'model', 'dagmm_%d.h5' % config['test_epoch'])) outputs = dagmm(x, training=False) outputs = np.squeeze(np.asarray(outputs)) inlier_outputs = np.zeros(shape=(0, )) for c in inlier_classes: inlier_outputs = np.append(inlier_outputs, outputs[y == c]) df_inlier = pd.DataFrame({'energy': inlier_outputs, 'label': 'inlier'}) outlier_outputs = np.zeros(shape=(0, )) for c in outlier_classes: outlier_outputs = np.append(outlier_outputs, outputs[y == c]) df_outlier = pd.DataFrame({'energy': outlier_outputs, 'label': 'outlier'}) df = pd.concat([df_inlier, df_outlier], axis=0) df.to_csv(os.path.join(config['logdir'], 'outputs.csv'), index=None)
def main(): yml_path = sys.argv[1] with open(yml_path) as f: config = yaml.load(f) noise_sampler = NoiseSampler('normal') inlier_classes = config['train_data_params']['labels'] outlier_classes = [i for i in range(10) if i not in inlier_classes] x, y = load_data('test', with_label=True, normalization='tanh') y = np.array(y) generator = Generator(**config['generator_params']) discriminator = Discriminator(**config['discriminator_params']) generator.build(input_shape=(None, generator.latent_dim)) discriminator.build(input_shape=(None, 32, 32, 1)) generator.load_weights( os.path.join(config['logdir'], 'model', 'generator_%d' % config['test_epoch'])) discriminator.load_weights( os.path.join(config['logdir'], 'model', 'discriminator_%d' % config['test_epoch'])) computer = ScoreComputer(generator, discriminator, **config['score_computer_params']) outputs = computer.compute_score(x, noise_sampler, **config['compute_params']) inlier_outputs = np.zeros(shape=(0, )) for c in inlier_classes: inlier_outputs = np.append(inlier_outputs, outputs[y == c]) df_inlier = pd.DataFrame({'score': inlier_outputs, 'label': 'inlier'}) outlier_outputs = np.zeros(shape=(0, )) for c in outlier_classes: outlier_outputs = np.append(outlier_outputs, outputs[y == c]) df_outlier = pd.DataFrame({'score': outlier_outputs, 'label': 'outlier'}) df = pd.concat([df_inlier, df_outlier], axis=0) df.to_csv(os.path.join(config['logdir'], 'outputs.csv'), index=None)
def test_mnist(): (train_x, train_y), (test_x, test_y) = mnist.load_data() val_x = train_x[50000:] val_y = train_y[50000:] train_x = train_x[:50000] train_y = train_y[:50000] model = models.Sequential() model.add(layers.Dense(28, activation="relu", input_shape=(train_x.shape[1],))) model.add(layers.Dense(10, activation="relu")) model.add(layers.Dense(10, activation="softmax")) model.compile(optimizer=optimizers.SGD(lr=0.001), loss=losses.categorical_crossentropy, metrics=['accuracy']) model.summary() history = model.fit(train_x, train_y, batch_size=200, epochs=32, validation_data=(val_x, val_y)).history epochs = range(1, len(history["loss"])+1) plt.plot(epochs, history["loss"], 'ro', label="Traning loss") plt.plot(epochs, history["val_loss"], 'go',label="Validating loss") plt.plot(epochs, history["accuracy"], 'r', label="Traning accuracy") plt.plot(epochs, history["val_accuracy"], 'g', label="Validating accuracy") plt.title('Training/Validating loss/accuracy') plt.xlabel('Epochs') plt.ylabel('Loss/Accuracy') plt.legend() plt.show(block=True)
def test_mnist_with_cov2d(): (train_x, train_y), (test_x, test_y) = mnist.load_data(flatten=False) val_x = train_x[50000:] val_y = train_y[50000:] train_x = train_x[:50000] train_y = train_y[:50000] model = models.Sequential() model.add(layers.Conv2D(4, (3, 3), strides=(1,1), padding='same', data_format="channels_first", activation="relu", input_shape=(1, 28, 28))) model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2,2), data_format="channels_first")) model.add(layers.Flatten()) model.add(layers.Dense(10, activation="softmax")) model.compile(optimizer=optimizers.SGD(lr=0.001), loss=losses.categorical_crossentropy, metrics=['accuracy']) model.summary() history = model.fit(train_x, train_y, batch_size=200, epochs=20, validation_data=(val_x, val_y)).history epochs = range(1, len(history["loss"])+1) plt.plot(epochs, history["loss"], 'ro', label="Traning loss") plt.plot(epochs, history["val_loss"], 'go',label="Validating loss") plt.plot(epochs, history["acc"], 'r', label="Traning accuracy") plt.plot(epochs, history["val_acc"], 'g', label="Validating accuracy") plt.title('Training/Validating loss/accuracy') plt.xlabel('Epochs') plt.ylabel('Loss/Accuracy') plt.legend() plt.show(block=True)
Parameters --------- filename: str, optional Name of the ``.npz`` compressed binary in to be saved """ if not os.path.exists('models'): os.makedirs('models') np.savez_compressed( file=os.path.join(os.curdir, 'models', filename), weights=self.weights, biases=self.biases, batch_size=self.batch_size, epochs=self.epochs, eta=self.eta, cost=self.cost, ) if __name__ == '__main__': training_data, validation_data, test_data = mnist.load_data() nn = Network(sizes=[784, 30, 10], cost='cross_entropy') print "--------------- Training ---------------" nn.fit(training_data=training_data, validation_data=validation_data) print "Neural Network accuracy on test data is {} %".format( nn.validate(test_data) / 100.00) nn.save() print " -------------- Complete ---------------"
def load_dataset(dataset_name): if dataset_name == 'mnist': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( ) elif dataset_name == 'mnist-original': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( original=True) elif dataset_name == 'mnist-rgb': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( use_rgb=True) elif dataset_name == 'svhn': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = svhn.load_data( ) elif dataset_name == 'svhn-extra': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = svhn.load_data( include_extra=True) elif dataset_name == 'mnist-svhn': anchor = load_dataset('mnist-rgb') mirror = load_dataset('svhn') dataset = CrossDomainDatasets(dataset_name.replace('-', ''), anchor, mirror) elif dataset_name == 'cifar10': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = cifar10.load_data( ) elif dataset_name == 'moving-mnist': data = moving_mnist.load_data() dataset = TimeCorelatedDataset(dataset_name.replace('-', ''), data) elif dataset_name == 'lsun-bedroom': datapath = lsun.load_data() dataset = LargeDataset(datapath) elif dataset_name == 'celeba': datapath = celeba.load_data() dataset = LargeDataset(datapath) else: raise KeyError("Dataset not implemented") return dataset
def load_dataset(dataset_name): if dataset_name == 'mnist': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( ) if dataset_name == 'stacked-mnist': dataset = StackedDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( ) elif dataset_name == 'mnist-original': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( original=True) elif dataset_name == 'mnist-rgb': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = mnist.load_data( use_rgb=True) elif dataset_name == 'svhn': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = svhn.load_data( ) elif dataset_name == 'svhn-extra': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = svhn.load_data( include_extra=True) elif dataset_name == 'mnist-svhn': anchor = load_dataset('mnist-rgb') mirror = load_dataset('svhn') dataset = CrossDomainDatasets(dataset_name.replace('-', ''), anchor, mirror) elif dataset_name == 'cifar10': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.x_test, dataset.y_test, dataset.attr_names = cifar10.load_data( ) elif dataset_name == 'moving-mnist': data = moving_mnist.load_data() dataset = TimeCorelatedDataset(dataset_name.replace('-', ''), data) elif dataset_name == 'lsun-bedroom': datapath = lsun.load_data() dataset = LargeDataset(datapath) elif dataset_name == 'celeba': datapath = celeba.load_data() dataset = LargeDataset(datapath, buffer_size=20000) elif dataset_name == 'celeba-128': datapath = celeba.load_data(image_size=128) dataset = LargeDataset(datapath, buffer_size=5000) elif dataset_name == 'celeba-crop-128': datapath = celeba.load_data(image_size=128, center_crop=True) dataset = LargeDataset(datapath, buffer_size=5000) elif dataset_name == 'celeba-crop-64': datapath = celeba.load_data(image_size=64, center_crop=True) dataset = LargeDataset(datapath, buffer_size=20000) elif dataset_name == 'synthetic-8ring': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.attr_names = mixture.load_data( type="ring", n=8, std=.05, r=1, density=5000) elif dataset_name == 'synthetic-25grid': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.attr_names = mixture.load_data( type="grid", n=25, std=.05, density=2500) elif dataset_name == 'synthetic-high-dim': dataset = ConditionalDataset(name=dataset_name.replace('-', '')) dataset.images, dataset.attrs, dataset.attr_names = mixture.load_data( type="high-dim", n=10, d=1200, std=1., density=5000) elif dataset_name == 'mnist-anomaly': x, y, x_t, y_t, y_names = mnist.load_data() dataset = SimulatedAnomalyDetectionDataset(dataset_name.replace( '-', ''), x, y, anomaly_class=0, test_set=(x_t, y_t)) elif dataset_name == 'svhn-anomaly': x, y, x_t, y_t, y_names = svhn.load_data() dataset = SimulatedAnomalyDetectionDataset(dataset_name.replace( '-', ''), x, y, anomaly_class=0, test_set=(x_t, y_t)) elif dataset_name == 'cifar10-anomaly': x, y, x_t, y_t, y_names = cifar10.load_data() dataset = SimulatedAnomalyDetectionDataset(dataset_name.replace( '-', ''), x, y, anomaly_class=0, test_set=(x_t, y_t)) else: raise KeyError("Dataset not implemented") return dataset
return model CLASSES = 10 ROWS, COLS, CHS = 28, 28, 1 TRAIN_SIZE = 50000 TEST_SIZE = 10000 VALIDATION_SPLIT = TEST_SIZE / TRAIN_SIZE BATCH_SIZE = 128 EPOCHS = 16 if __name__ == '__main__': (X_train, Y_train), (X_test, Y_test) = mnist.load_data() model = LeNet().build(input_shape=(ROWS, COLS, CHS), classes=CLASSES) # keras.utils.plot_model(mode, to_file='model.png') model.compile(optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True), loss=keras.losses.categorical_crossentropy, metrics=[keras.metrics.categorical_accuracy]) # history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(X_test, Y_test), verbose=2) model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(X_test, Y_test), verbose=2, callbacks=[keras.callbacks.TensorBoard()]) score = model.evaluate(X_test, Y_test, verbose=0) print("loss: ", score[0]) print("acc: ", score[1])