plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# load image dataset: blue/red dots in circles
train_x, train_y, test_x, test_y = load_2D_dataset()
m_train = train_x.shape[1]
m_test = test_x.shape[1]
n = train_x.shape[0]
# Model
models = [default_model(n), l2reg_model(n), dropout_model(n)]
for model in models:
# Train
train_x = train_x.astype("float32")
start_time = time.time()
model.train(train_x, train_y, epochs=30_000)
# Predict
train_predictions = model.predict(train_x)
train_accuracy = m.accuracy(train_predictions, train_y)
print(f"Train accuracy = {train_accuracy}%")
test_predictions = model.predict(test_x)
test_accuracy = m.accuracy(test_predictions, test_y)
print(f"Test accuracy = {test_accuracy}%")
# Plot
plot_boundary("none", model, train_x, train_y)
train_set_y = train_set_y.astype(np.float32)
start_time = time.time()
costs = model.train(train_set_x,
train_set_y,
learning_rate=lr,
num_iterations=2000,
print_cost=True)
print("training time = ", time.time() - start_time)
plot_costs(costs, unit=ITERATIONS_UNIT, learning_rate=lr)
# Predict
train_predictions = model.predict(train_set_x)
test_predictions = model.predict(test_set_x)
print("Train accuracy = ", m.accuracy(train_predictions, train_set_y), "%")
print("Test accuracy = ", m.accuracy(test_predictions, test_set_y), "%")
# Analyze
# Example of a picture that was wrongly classified.
errors = (index for index, (
p, r) in enumerate(zip(test_predictions[0, :], test_set_y[0, :]))
if p != r)
index = next(errors)
label_prediction = test_set_y[0, index]
class_prediction = classes[int(test_predictions[0, index])].decode('utf-8')
print(f"y = {label_prediction}, you predicted that it is a "
f"{class_prediction} picture.")
# Dataset Loading
X, Y = load_planar_dataset()
X = X.astype("float32")
Y = Y.astype("float32")
shape_X = X.shape
shape_Y = Y.shape
m = shape_X[1] # training set size
# Test different hidden layer sizes
plt.figure()
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]
for i, h in enumerate(hidden_layer_sizes):
print(f"\n\n>>> Testing with hidden layer of size {h}")
# Model
model = ShallowNNModel(X.shape[0], h)
model.train(X, Y, num_iterations=5_000)
# Predict
train_predictions = model.predict(X)
train_accuracy = accuracy(train_predictions, Y)
print(f"Train accuracy = {train_accuracy}%")
# Plot
plt.subplot(5, 2, i + 1)
plt.title(f"Hidden Layer of size {h}")
plot_decision_boundary(lambda x: model.predict(x.T), X, Y)
plt.title(f"Decision Boundary for hidden layer size {h}")
plt.show()
plt.rcParams['image.cmap'] = 'gray'
# load image dataset: blue/red dots in circles
train_x, train_y = load_dataset()
train_x = train_x.astype('float32')
train_y = train_y.astype('int16')
m_train = train_x.shape[1]
n = train_x.shape[0]
# Model
model = model(n)
optimizers = OrderedDict()
optimizers["gradient descent"] = GradientDescentOptimizer(0.0007)
optimizers["momentum"] = MomentumOptimizer(0.0007, 0.9)
optimizers["adam"] = AdamOptimizer(0.0007, 0.9, 0.999)
for name, opt in optimizers.items():
training = MiniBatchTraining(batch_size=64,
optimizer=opt,
listener=CostListener())
model.train(train_x.astype('float32'),
train_y,
epochs=10_000,
training=training)
train_predictions = model.predict(train_x)
train_accuracy = m.accuracy(train_predictions, train_y)
print(f"Train accuracy = {train_accuracy}%")
plot_boundary(name, model, train_x, train_y)