def L_layer_model(X,
Y,
layers_dims,
learning_rate=0.0075,
num_iterations=3001,
print_cost=False):
lambd = 1
costs = []
parameters = initialize.initialize_parameters_deep(layers_dims)
for i in range(0, num_iterations):
AL, caches = forward.L_model_forward(X, parameters)
costVal = cost.compute_cost(AL, Y, parameters, lambd)
grads = backward.L_model_backward(AL, Y, caches, lambd)
parameters = update.update_parameters(parameters, grads, learning_rate)
if print_cost and i % 100 == 0:
print("Cost after iteration %i: %f" % (i, costVal))
if print_cost and i % 100 == 0:
costs.append(costVal)
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters
def compute_cost(self, AL, Y, func, l2, lambd):
if func == 'cross_entropy':
if l2 == True:
return compute_cost_with_regularization(
AL, Y, self.parameters, lambd)
else:
return compute_cost(AL, Y)
else:
pass
def cost_test():
tf.reset_default_graph()
with tf.Session() as sess:
X, Y = initialize.create_placeholders(12288, 6)
parameters = initialize.initialize_parameters()
Z3 = forward.forward_propagation(X, parameters)
cost = cost.compute_cost(Z3, Y)
print("cost = " + str(cost))
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True):
ops.reset_default_graph()
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = initialize.create_placeholders(n_x, n_y)
parameters = initialize.initialize_parameters()
Z3 = forward.forward_propagation(X, parameters)
cost = cost.compute_cost(Z3, Y)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost = 0
num_minibatches = int(m / minibatch_size)
minibatches = tools.random_mini_batches(X_train, Y_train,
minibatch_size)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / minibatch_size
if print_cost == True and epoch % 100 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
if print_cost == True and epoch % 5 == 0:
costs.append(epoch_cost)
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per fives)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
parameters = sess.run(parameters)
print("Parameters have been trained!")
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
print("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
def cost_test():
Y = np.asarray([[1, 1, 0]])
AL = np.array([[.8, .9, 0.4]])
print("cost = " + str(cost.compute_cost(AL, Y)))
def model(X,
Y,
layers_dims,
learning_rate=0.0075,
num_iterations=3000,
print_cost=False,
save_parametrs=False,
validation=None): #lr was 0.009
np.random.seed(1)
costs = [] # keep track of cost
test_accuracy = []
train_accuracy = []
# Parameters initialization.
parameters = None
iteration = None
if os.path.exists("parameters/parameters.h5"):
iteration, parameters = Parameters.load_last()
else:
if save_parametrs:
Parameters.save(mode='w', iteration=None, parameters=None)
if parameters == None:
iteration = -1
parameters = initialize_parameters(layers_dims)
# Loop (gradient descent)
for i in range(iteration + 1, num_iterations):
# Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
AL, caches = L_model_forward(X, parameters)
# Compute cost.
cost = compute_cost(AL, Y)
# Backward propagation.
grads = L_model_backward(AL, Y, caches)
# Update parameters.
parameters = update_parameters(parameters, grads, learning_rate)
# Print the cost every 100 training example
msg_save = ''
msg_acc = ''
if print_cost and i % 100 == 0:
if save_parametrs:
Parameters.save(mode='a', iteration=i, parameters=parameters)
msg_save = 'parameters saved'
if validation:
_pred, _train_accuracy = predict(X, Y, parameters)
_pred, _test_accuracy = predict(*validation, parameters)
train_accuracy.append(_train_accuracy)
test_accuracy.append(_test_accuracy)
msg_acc = "Train Acc: {}, Test Acc:{}".format(
_train_accuracy, _test_accuracy)
print("Cost after iteration %i: %f | %s | %s" %
(i, cost, msg_acc, msg_save))
if print_cost and i % 100 == 0:
costs.append(cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
plt.plot(train_accuracy, 'b')
plt.plot(test_accuracy, 'r')
plt.ylabel('Accuracy')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.legend(['train', 'test'])
plt.show()
return parameters