def main(args):
# Import data
mnist = input_data.read_data_sets(args.data_dir, one_hot=True)
relu = ReLU()
model = Model(layers=[
Conv2D(filter_size=(10, 10),
input_shape=(28, 28, 1),
stride=(1, 1),
channels=32,
activation=relu,
padding='same',
filter_initializer=weight_initializer,
bias_initializer=bias_initializer),
MaxPool2D(pool_size=(2, 2)),
Conv2D(filter_size=(5, 5),
stride=(1, 1),
channels=16,
activation=relu,
padding='same',
filter_initializer=weight_initializer,
bias_initializer=bias_initializer),
MaxPool2D(pool_size=(2, 2)),
Flatten(),
Dense(1024,
weight_initializer=weight_initializer,
bias_initializer=bias_initializer,
activation=relu),
Dense(10,
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
],
optimizer=AdaGrad(learning_rate=0.001, epsilon=1e-8),
loss=SoftMaxCrossEntropyWithLogits())
# Train
for _ in range(200):
batch_xs, batch_ys = mnist.train.next_batch(100)
batch_xs = np.reshape(batch_xs, [-1, 28, 28, 1])
model.fit_batch(batch_xs, batch_ys)
if args.verbose:
print('Batch {} loss: {}'.format(
model.batch_number,
model.loss.compute(model.predict(batch_xs), batch_ys)))
# Test trained model
actual_labels = np.argmax(mnist.test.labels, 1)
predictions = model.predict(np.reshape(mnist.test.images, [-1, 28, 28, 1]))
predicted_labels = np.argmax(predictions, 1)
accuracy = (actual_labels == predicted_labels).mean()
print("Test accuracy: {}".format(accuracy))
def main(args):
# Import data
mnist = input_data.read_data_sets(args.data_dir, one_hot=True)
model = Model(layers=[
Dense(10,
weight_initializer=weight_initializer,
bias_initializer=bias_initializer,
input_shape=(784, ))
],
optimizer=GradientDescent(learning_rate=0.5),
loss=SoftMaxCrossEntropyWithLogits())
# Train
for _ in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
model.fit_batch(batch_xs, batch_ys)
# Test trained model
actual_labels = np.argmax(mnist.test.labels, 1)
predictions = model.predict(mnist.test.images)
predicted_labels = np.argmax(predictions, 1)
accuracy = (actual_labels == predicted_labels).mean()
print("Test accuracy: {}".format(accuracy))
dense3 = Dense((batch_size, 100), 10)
loss_f = CrossEntropy()
optimizer = Adam()
# Initializing model
model = Model(input_shape=(batch_size, dataset.x_train.shape[1]),
layers=[dense1, relu1, dense2, relu2, drop1, dense3],
loss_f=loss_f,
optimizer=optimizer)
# Create hyper-param schedulers
lr_schedule = HyperParamScheduler(3e-4, 3e-3, True)
mom_schedule = HyperParamScheduler(0.8, 0.9, False)
# Train
model.fit_one_cycle(dataset.x_train, dataset.y_train, 50, lr_schedule,
mom_schedule, batch_size,
[dataset.x_val, dataset.y_val])
# Save model
save_path = pathlib.Path.home() / "Desktop" / "MNIST_model"
model.save_model_weights(save_path)
# Load model and test
model.load_model_weights(save_path)
pred = np.argmax(model.predict(dataset.x_test[0]))
act = np.argmax(dataset.y_test[0])
print(f"\nPrediction: {pred}, Actual: {act}")
split = int(0.8 * all_data.shape[0])
x_train = all_data[:split, 1:]
x_test = all_data[split:, 1:]
y_train = all_data[:split, 0]
y_test = all_data[split:, 0]
y_train = one_hot(y_train.astype('int'))
y_test = one_hot(y_test.astype('int'))
def accuracy(y, y_hat):
y = np.argmax(y, axis=1)
y_hat = np.argmax(y_hat, axis=1)
return np.mean(y==y_hat)
def relu(x):
return np.maximum(x, 0)
model = Model()
model.add_layer(Layer(784, 10, softmax))
#model.add_layer(Layer(64, 64, relu))
#model.add_layer(Layer(64, 10, softmax))
model.compile(CrossEntropyLoss, DataLoader, accuracy,
batches_per_epoch=x_train.shape[0] // 32 + 1,
n_workers=50, c1=1., c2=2.)
model.fit(x_train, y_train, 100)
y_hat = model.predict(x_test)
print('Accuracy on test:', accuracy(y_test, y_hat))
