def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True,
is_plot=True):
ops.reset_default_graph() # 能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape # 获取输入节点数量和样本数
n_y = Y_train.shape[0] # 获取输出节点数量
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters([12288, 25, 12, 6])
Z3 = forward_propagation(X, parameters)
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 i in range(num_epochs):
epoch_cost = 0 # 每代的成本
num_minibatches = int(m / minibatch_size) # minibatch的总数量
seed += 1
minibatches = tf_utils.random_mini_batches(
X_train, Y_train, mini_batch_size=minibatch_size, seed=seed)
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 / num_minibatches
if i % 5 == 0:
costs.append(epoch_cost)
if print_cost and i % 100 == 0:
print("epoch ={},epoch_cost ={}".format(i, epoch_cost))
if is_plot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
parameters = sess.run(parameters)
print("参数已经保存到session。")
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("训练集的准确率：", accuracy.eval({X: X_train, Y: Y_train}))
print("测试集的准确率:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.0001,
num_epochs=1500, minibatch_size=32, print_cost=True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
#cost is compute graph
cost = compute_cost(Z3, Y)
optimizer = tf.train.AdamOptimizer(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)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
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/num_minibatches
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 tens)')
plt.title('Learning rate =' + str(learning_rate))
plt.show()
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 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()
tf.set_random_seed(1)
seed = 3
(n_x,m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X,Y = create_placeholders(n_x,n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X,parameters)
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)
seed = seed + 1
minibatches = random_mini_batches(X_train,Y_train,minibatch_size,seed)
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 = epoch_cost + minibatch_cost / num_minibatches
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
#save the parameters in a variable
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 model(X_original, Y_original, layers_dims, learning_rate=0.0007, mini_batch_size=64, num_epochs=10000, print_cost=True):
ops.reset_default_graph() # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1)
seed = 10
costs = list()
n_x = X_original.shape[0]
n_y = Y_original.shape[0]
m = X_original.shape[1]
X, Y = create_placeholder(n_x=n_x, n_y=n_y)
parameters = initialize_parameters(layers_dims=layers_dims)
ZL = forward_prop(X=X, parameters=parameters)
cost = compute_loss(ZL=ZL, Y=Y)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
with tf.Session() as sesh:
sesh.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0.
num_minibatches = int(m / mini_batch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
mini_batches = random_mini_batches(X_original, Y_original, mini_batch_size, seed)
for mini_batch in mini_batches:
mini_batch_X, mini_batch_Y = mini_batch
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
_, mini_batch_cost = sesh.run([optimizer, cost], # don't need value from optimizer
feed_dict={X: mini_batch_X,
Y: mini_batch_Y})
epoch_cost += mini_batch_cost / num_minibatches
# Print the cost every 1000 epoch
if print_cost and epoch % 1000 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
if print_cost and epoch % 100 == 0:
costs.append(epoch_cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sesh.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(ZL), tf.argmax(Y))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Train Accuracy:", accuracy.eval({X: X_original, Y: Y_original}))
return parameters
def model(X_train, Y_train, X_test, Y_test,
learning_rate=0.0001, num_epochs=1500, minibatch_size=32,
print_cost=True, is_plot=True):
ops.reset_default_graph() # 能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
# 反向传播，使用Adam优化
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# 初始化所有的变量
init = tf.global_variables_initializer()
# 开始会话并计算
with tf.Session() as session:
session.run(init)
for epoch in range(num_epochs):
epoch_cost = 0
num_minibatches = int(m/minibatch_size)
seed = seed + 1
minibatches = tf_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_, minibatch_cost = session.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
epoch_cost = epoch_cost + minibatch_cost/num_minibatches
if epoch % 5 == 0:
costs.append(epoch_cost)
if print_cost and epoch % 100 == 0:
print("epoch = " + str(epoch) + " epoch_cost = " + str(epoch_cost))
if is_plot:
plt.plot(np.squeeze(costs))
plt.xlabel('iterations')
plt.ylabel('cost')
plt.title('learning_rate = ' + str(learning_rate))
plt.show()
parameters = session.run(parameters)
print("参数已经保存到session中")
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("训练集的准确率：", accuracy.eval({X: X_train, Y: Y_train}))
print("测试集的准确率：", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
def model(X_train,Y_train,X_test,Y_test,layers,learning_rate=0.0001,
num_epochs=200,minibatch_size=32,print_cost=True):
(d_x,num_pics)=X_train.shape
d_y=Y_train.shape[0]
#ops.reset_default_graph()
tf.set_random_seed(1)
seed=3
costs=[]
X,Y=creat_placeholders(d_x,d_y)
parameters=initial_parameters(layers)
Z=forward_propagation(X,parameters)
cost=compute_cost(Z,Y)
optmizer=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):
num_minibatches=int(num_pics/minibatch_size)
seed += 1
minibatches=random_mini_batches(X_train, Y_train, minibatch_size, seed)
epoch_cost=0
for mbatch_x,mbatch_y in minibatches:
_,minibatch_cost=sess.run([optmizer,cost],feed_dict={X:mbatch_x,Y:mbatch_y})
epoch_cost += minibatch_cost/num_minibatches
if print_cost == True and epoch % 10 == 0:
costs.append(epoch_cost)
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
#print(mbatch_x[0,:])
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
parameters=sess.run(parameters)
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z), tf.argmax(Y))
# Calculate accuracy on the test set
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 model(X_train, Y_train, X_test, Y_test, learning_rate = 0.00001,
num_epochs = 25, minibatch_size = 32, print_cost = True):
"""
调用函数进行训练
:param X_train:
:param Y_train:
:param X_test:
:param Y_test:
:param learning_rate:
:param num_epochs:
:param minibatch_size:
:param print_cost:
:return:
"""
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
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)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_ , minibatch_cost = sess.run([optimizer, cost], feed_dict=
{X: minibatch_X, Y: minibatch_Y})
print(minibatch_cost)
epoch_cost += minibatch_cost / num_minibatches
if print_cost == True and epoch % 15 == 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('损失')
plt.xlabel('迭代 ')
plt.title("学习率" + str(learning_rate))
plt.show()
parameters = sess.run(parameters)
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print ("训练集学习率:", accuracy.eval({X: X_train, Y: Y_train}))
print ("测试集学习率:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
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() # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(n_x, m) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
X, Y = create_placeholders(n_x,n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X,parameters)
cost = compute_cost(Z3,Y)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
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 / num_minibatches
# Print the cost every epoch
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
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))
# Calculate accuracy on the test set
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 model(X_train,Y_train,X_test,Y_test,learning_rate=0.0001,num_epochs=1500,minibatch_size=32,print_cost):
ops.reset_default_graph()
tf.set_random_seed(1)
seed=3
(n_x,m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X,Y = create_placeholders(n_x,n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X,parameters)
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)
seed=seed+1;
minibatches = random_mini_batches(X_train,Y_train,minibatch_size,seed)
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/num_minibatches
# Print the cost every epoch
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
parameters = sess.run(parameters)
return parameters
def model(X_train,
Y_train,
X_test,
layer_dims,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True):
#Variables
ops.reset_default_graph()
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
lambd = 25
beta = (lambd / m)
#Creating placeholders
X, Y = create_placeholders(n_x, n_y)
#Initialize parameters
parameters = initialize_parameters(layer_dims)
#Forward Propagation
ZL = forward_propagation(X, parameters)
#Cost
cost = compute_cost(ZL, Y, parameters, beta)
#Backpropagation and Optimizing
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
#Tensorflow init
init = tf.global_variables_initializer()
#Starting the Session and the Model
with tf.Session() as sess:
#Running the init
sess.run(init)
#Training Loop
for epoch in range(num_epochs):
#Making the Minibatches
epoch_cost = 0.
num_minibatches = int(m / minibatch_size)
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
#Iterating over the minibatches
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
#Running the session for the whole model
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / minibatch_size
#Printing the cost after 10 epochs
if print_cost and epoch % 10 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
if print_cost and epoch % 5 == 0:
costs.append(epoch_cost)
#Training Ends
print("Cost after epoch %i: %f" % (num_epochs, costs[-1]))
# Plotting the Cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per fives)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(ZL), tf.argmax(Y))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
return parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.0001, num_epoches=1500, minibatch_size=32, print_cost=True):
'''
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
'''
# to be able to rerun the model without overwriting tf variables
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
# Create placeholder
X, Y = create_placeholder(n_x, n_y)
# Initialize parameters
parameters = Initializing_parameters()
# Forward propagation
Z3 = forward_propagation(X, parameters)
# Cost function
cost = compute_cost(Z3, Y)
# Backward propagation
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epoches):
epoch_cost = 0
num_minibatches = int(m / minibatch_size)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
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 / num_minibatches
if print_cost and epoch % 100 == 0:
print('Cost after epoch {}: {}'.format(epoch, epoch_cost))
if print_cost and epoch % 5 == 0:
costs.append(epoch_cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title('Learning rate={}'.format(learning_rate))
plt.show()
# save parameters in a variable
parameters = sess.run(parameters)
print('Parameters have been trained!')
# Calculate the correct predictions
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 model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
epochs=1500,
minibatch_size=32,
keep_prob=[1, 1],
print_cost=True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
LINEAR (12288) --> RELU (25) --> RELU (12) --> SOFTMAX (6)
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
# time
tic = time.process_time()
tf.reset_default_graph(
) # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(
n_x, m
) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
### START CODE HERE ### (1 line)
X, Y = create_placeholders(n_x, n_y)
### END CODE HERE ###
# Initialize parameters
### START CODE HERE ### (1 line)
parameters = initialize_parameters()
### END CODE HERE ###
# Forward propagation: Build the forward propagation in the tensorflow graph
### START CODE HERE ### (1 line)
Z3 = forward_propagation(X, parameters, keep_prob)
### END CODE HERE ###
# Cost function: Add cost function to tensorflow graph
### START CODE HERE ### (1 line)
cost = compute_cost(Z3, Y)
### END CODE HERE ###
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
### START CODE HERE ### (1 line)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
### END CODE HERE ###
# Initialize all the variables
init = tf.global_variables_initializer()
# file for early stop (not recommended to use!)
early_stop = open("early_stop.txt", 'r')
print("\nStart training...")
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
### END CODE HERE ###
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 100 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
stdout.flush()
early_stop.seek(0)
if early_stop.read() == 'True':
print("Early Stopped (not recommended)!")
costs.append(epoch_cost)
break
if epoch % 5 == 0:
costs.append(epoch_cost)
# time
toc = time.process_time()
# close early stop file
early_stop.close()
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.draw()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("\nParameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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}))
print("\nnumber of trainable parameters: " + str(
np.sum([
np.prod(v.get_shape().as_list())
for v in tf.trainable_variables()
])))
print("\ntime: %.3f" % (toc - tic) + " sec, for parameters: ")
args, _, _, values = inspect.getargvalues(inspect.currentframe())
[print("{}: {}".format(i, values[i])) for i in args[4:]]
stdout.flush()
# Showing plots for non blocking
plt.show()
return parameters
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=10,
minibatch_size=10000,
print_cost=True):
"""
:param X_train: training set, input size = 2, real and imag parts, number of training examples = unknown
:param Y_train: test set, of shape( output size = 2, number of training examples = same as X_train)
:param X_test: training set, of shape( input size = 2, number of test examples = 120)
:param Y_test: test set, of shape( output size = 2, number of test examples = 120)
:param learning_rate: learning rate
:param num_epochs: epoch numbers
:param minibatch_size: size of minibatch
:param print_cost: True to print the cost every 100 expochs
:return:
:parameters -- parameters learnt by the model. They can then be used to predict
"""
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x=n_x, n_y=n_y)
parameters = initial_Parameter()
Z3 = forward_propogation(X, parameters)
cost = compute_cost(Z3, Y)
optimizer = tf.train.AdamOptimizer(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)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
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 / num_minibatches
if print_cost == True and epoch % 10 == 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 tens)')
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"))
accuracy = Y + Z3
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 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()
# to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1)
# to keep consistent results
seed = 3
# to keep consistent results
(n_x, m) = X_train.shape
# (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0]
# n_y : output size
costs = []
#X=tf.placeholder(X_train,shape=(n_x,m))
#Y=tf.placeholder(Y_train,shape=(n_y,1))
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=learning_rate).minimize(cost)
#_,c = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
init = tf.global_variables_initializer()
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
### END CODE HERE ###
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 GestureRecognition():
learning_rate = 0.0001
num_epochs = 1500
minibatch_size = 32
print_cost = True
is_plot = True
costs = []
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = tf_utils.load_dataset(
)
X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0],
-1).T #每一列就是一个样本
X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T
m = X_train_flatten.shape[1]
#归一化数据
X_train = X_train_flatten / 255
X_test = X_test_flatten / 255
#转换为独热矩阵
Y_train = tf_utils.convert_to_one_hot(Y_train_orig, 6)
Y_test = tf_utils.convert_to_one_hot(Y_test_orig, 6)
tf.set_random_seed(1)
seed = 3
tf.compat.v1.reset_default_graph() # 用于清除默认图形堆栈并重置全局默认图形。
X = tf.compat.v1.placeholder(tf.float32, [X_train.shape[0], None],
name="X")
Y = tf.compat.v1.placeholder(tf.float32, [Y_train.shape[0], None],
name="Y")
parameters = InitParameter([12288, 25, 12, 6])
z = ForwardPropagation(X, parameters)
cost = ComputeCost(z, Y)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
with tf.compat.v1.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost = 0 # 每代的成本
num_minibatches = int(m / minibatch_size) # minibatch的总数量
seed = seed + 1
minibatches = tf_utils.random_mini_batches(X_train, Y_train,
minibatch_size, seed)
for minibatch in minibatches:
# 选择一个minibatch
(minibatch_X, minibatch_Y) = minibatch
# 数据已经准备好了，开始运行session
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
# 计算这个minibatch在这一代中所占的误差
epoch_cost = epoch_cost + minibatch_cost / num_minibatches
# 记录并打印成本
## 记录成本
if epoch % 5 == 0:
costs.append(epoch_cost)
# 是否打印：
if print_cost and epoch % 100 == 0:
print("epoch = " + str(epoch) + " epoch_cost = " +
str(epoch_cost))
# 是否绘制图谱
if is_plot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# 保存学习后的参数
parameters = sess.run(parameters)
print("参数已经保存到session。")
# 计算当前的预测结果
correct_prediction = tf.equal(tf.argmax(z), tf.argmax(Y))
# 计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("训练集的准确率：", accuracy.eval({X: X_train, Y: Y_train}))
print("测试集的准确率:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,
num_epochs = 1500, minibatch_size = 64, print_cost = True):
ops.reset_default_graph() # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 1
# seed = np.random.randint(0,10000) # to keep consistent results
(n_x, m) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
layers_dims = [n_x, 15, 10, 10, n_y]
# Create Placeholders of shape (n_x, n_y)
X, Y = create_placeholders(n_x, n_y)
# Initialize parameters
parameters = initialize_parameters(layers_dims)
# Forward propagation: Build the forward propagation in the tensorflow graph
ZL = forward_propagation(X, parameters)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(ZL, Y)
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
_ , minibatch_cost = sess.run([optimizer, cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 1000 == 0:
print ("Cost after epoch %i: %f" % (epoch, epoch_cost))
if print_cost == True and epoch % 10 == 0:
costs.append(epoch_cost)
# plot the cost
#plt.plot(np.squeeze(costs))
#plt.ylabel('cost')
#plt.xlabel('iterations (per tens)')
#plt.title("Learning rate =" + str(learning_rate))
#plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(ZL), tf.argmax(Y))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print (accuracy)
print ("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
print ("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))
y_p = tf.argmax(ZL, axis = 0)
precision, update = tf.metrics.precision(tf.argmax(Y), tf.argmax(ZL))
sess.run(tf.local_variables_initializer())
val_precision = update.eval(feed_dict = {X: X_test, Y: Y_test})
# sess.run(precision, feed_dict = {X: X_train, Y: Y_train})
# recall, _ = tf.metrics.recall(labels = tf.argmax(Y), predictions = tf.argmax(ZL))
# auc, _ = tf.metrics.auc(labels = tf.argmax(Y), predictions = tf.argmax(ZL))
# cf = tf.confusion_matrix(labels = tf.argmax(Y), predictions = tf.argmax(ZL))
# val_precision, val_recall, val_auc, val_cf = sess.run([precision, reca], feed_dict= {X:np.random.randn(12288,1080), Y:np.random.randn(6,1080)})
# print ("Precision", sess.run(precision))
# print ("Precision", val_precision)
# print ("recall",val_recall)
# print ("auc", val_auc)
# print ("confusion_matrix")
print (val_precision)
y_true = np.argmax(Y_train, axis = 0)
print ("validation accuracy:")
val_accuracy, y_pred = sess.run([accuracy, y_p], feed_dict={X:X_test, Y: Y_test})
print (y_true, y_pred)
print ("Precision",sklearn.metrics.precision_score(y_true, y_pred, average = 'micro'))
print ("Recall", sklearn.metrics.recall_score(y_true, y_pred, average = 'micro'))
print ("f1_score", sklearn.metrics.f1_score(y_true, y_pred, average = 'micro'))
print ("confusion_matrix")
print (sklearn.metrics.confusion_matrix(y_true, y_pred))
# fpr, tpr, tresholds = sklearn.metrics.roc_curve(y_true, y_pred)
# predicted = y_pred
# actual = y_true
# TP = tf.count_nonzero(predicted * actual)
# TN = tf.count_nonzero((predicted - 1) * (actual - 1))
# FP = tf.count_nonzero(predicted * (actual - 1))
# FN = tf.count_nonzero((predicted - 1) * actual)
# precision = TP / (TP + FP)
# recall = TP / (TP + FN)
# f1 = 2 * precision * recall / (precision + recall)
return parameters, costs
def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,
num_epochs = 1500, minibatch_size = 32, print_cost = True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph() # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(n_x, m) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
### START CODE HERE ### (1 line)
X, Y = create_placeholders(n_x, n_y)
### END CODE HERE ###
# Initialize parameters
### START CODE HERE ### (1 line)
parameters = initialize_parameters()
### END CODE HERE ###
# Forward propagation: Build the forward propagation in the tensorflow graph
### START CODE HERE ### (1 line)
Z3 = forward_propagation(X, parameters)
### END CODE HERE ###
# Cost function: Add cost function to tensorflow graph
### START CODE HERE ### (1 line)
cost = compute_cost(Z3,Y)
### END CODE HERE ###
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
### START CODE HERE ### (1 line)
optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)
### END CODE HERE ###
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
### END CODE HERE ###
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 train(x_train, y_train):
input_x_flatten_size = x_train.shape[1]
with tf.name_scope('input'):
x = tf.placeholder(tf.float32,
shape=(None, input_x_flatten_size),
name='x-input')
y_ = tf.placeholder(tf.float32,
shape=(None, OUTPUT_NODE),
name='y-input')
regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
y = mnist_inference.inference(x, regularizer, None)
# Step of training number
global_step = tf.Variable(0, trainable=False)
with tf.name_scope('moving_average'):
variabl_averages = tf.train.ExponentialMovingAverage(
MOVING_AVERAGE_DECAY, global_step)
variabl_averages_op = variabl_averages.apply(tf.trainable_variables())
with tf.name_scope('loss_function'):
# loss function
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=y, labels=tf.argmax(y_, 1))
cross_entropy_mean = tf.reduce_mean(cross_entropy)
loss = cross_entropy_mean + tf.add_n(tf.get_collection('lossess'))
input_x_number_examples = x_train.shape[0]
with tf.name_scope('train_step'):
# learning rate decay
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE, global_step,
input_x_number_examples / BATCH_SIZE, LEARNING_RATE_DECAY)
# Note as from https://www.tensorflow.org/api_docs/python/tf/train/GradientDescentOptimizer
# global_step: Optional Variable to increment by one after the variables have been updated.
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(
loss, global_step=global_step)
with tf.control_dependencies([train_step, variabl_averages_op]):
train_op = tf.no_op(name='train')
saver = tf.train.Saver(tf.global_variables())
with tf.Session() as sess:
tf.global_variables_initializer().run()
seed = 3
mini_batches = random_mini_batches(tf.transpose(x_train),
tf.transpose(y_train), BATCH_SIZE,
seed)
for i in range(TRAINING_STEPS):
k = i % len(mini_batches)
if k == 0:
seed = seed + 1
mini_batches = random_mini_batches(tf.transpose(x_train),
tf.transpose(y_train),
BATCH_SIZE, seed)
mini_x_batches, mini_y_batches = mini_batches[k]
_, loss_value, step = sess.run([train_op, loss, global_step],
feed_dict={
x: mini_x_batches,
y_: mini_y_batches
})
if (i % 1000) == 0:
print(
"After %d training step(s), loss on training batch is %g" %
(step, loss_value))
print("----- global_step: ", sess.run(global_step))
if (step == 1):
saver.save(sess,
os.path.join(MODEL_SAVE_PATH, MODEL_NAME),
global_step=global_step)
else:
saver.save(sess,
os.path.join(MODEL_SAVE_PATH, MODEL_NAME),
global_step=global_step,
write_meta_graph=False)
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_sizes=32,
print_cost=True):
ops.reset_default_graph()
#some values
(n_x, m) = X_train.shape #64*64*3
n_y = Y_train.shape[0]
n_h1 = 25
n_h2 = 12
costs = []
tf.set_random_seed(1)
seed = 3
#input placeholser
X = tf.placeholder(tf.float32, shape=(n_x, None), name="X")
Y = tf.placeholder(tf.float32, shape=(n_y, None), name="Y")
#regularizer
regularizer = tf.contrib.layers.l2_regularizer(0.1)
#initialize parameters
W1 = tf.get_variable(
"W1", [n_h1, n_x],
initializer=tf.contrib.layers.xavier_initializer(seed=1),
regularizer=regularizer)
b1 = tf.get_variable("b1", [n_h1, 1], initializer=tf.zeros_initializer())
W2 = tf.get_variable(
"W2", [n_h2, n_h1],
initializer=tf.contrib.layers.xavier_initializer(seed=1),
regularizer=regularizer)
b2 = tf.get_variable("b2", [n_h2, 1], initializer=tf.zeros_initializer())
W3 = tf.get_variable(
"W3", [n_y, n_h2],
initializer=tf.contrib.layers.xavier_initializer(seed=1),
regularizer=regularizer)
b3 = tf.get_variable("b3", [n_y, 1], initializer=tf.zeros_initializer())
parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2, "W3": W3, "b3": b3}
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
#forward propagation
Z1 = tf.matmul(W1, X) + b1
A1 = tf.nn.relu(Z1)
Z2 = tf.matmul(W2, A1) + b2
A2 = tf.nn.relu(Z2)
Z3 = tf.matmul(W3, A2) + b3
#cost
logits = tf.transpose(Z3)
labels = tf.transpose(Y)
cost = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
reg_variables = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
reg_term = tf.contrib.layers.apply_regularization(regularizer,
reg_variables)
cost += reg_term
#backforward prop adn upadte
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
#initialize all the variables
init = tf.global_variables_initializer()
#start session
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost = 0
num_minibatches = int(m / minibatch_sizes)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train,
minibatch_sizes, seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
#execute the optimizer
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / num_minibatches
if print_cost == True and epoch % 100 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
#每100次计算一下正确率
#caculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
#caculate accuracy on the set
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}))
if print_cost == True and epoch % 5 == 0:
costs.append(epoch_cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
#save the parameters
# parameters_tf = {"W1": W1,
# "b1": b1,
# "W2": W2,
# "b2": b2,
# "W3": W3,
# "b3": b3}
parameters = sess.run(parameters)
#caculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
#caculate accuracy on the set
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
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_ , minibatch_cost = sess.run([optimizer, cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})
### END CODE HERE ###
epoch_cost += minibatch_cost / minibatch_size
# Print the cost every epoch
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True):
# Linear -> ReLU -> Linear -> ReLU -> Linear -> Softmax
ops.reset_default_graph()
#initialization of model
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
#frorward prop
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
#backprop
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=learning_rate).minimize(cost)
# Tensorflow variables initializer
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 = 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 / num_minibatches
if (print_cost and epoch % 100 == 0):
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
if (print_cost and epoch % 5 == 0):
costs.append(epoch_cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 train_mynetwork(x1_train_set, x2_train_set, x1_train_set_full, x2_train_set_full, x1_test_set, x2_test_set, y_train_set, y_test_set, MODEL,
learning_rate_base = 0.001, beta_reg = 0.001, num_epochs = 150, minibatch_size = 64, print_cost = True):
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 1
(m, n_x1) = x1_train_set.shape
(m, n_x2) = x2_train_set.shape
(m, n_y) = y_train_set.shape
costs = []
costs_dev = []
train_acc = []
val_acc = []
correct_prediction = 0
# Create Placeholders of shape (n_x, n_y)
x1, x2, x1_full, x2_full, y, isTraining = create_placeholders(n_x1, n_x2, n_y)
# Initialize parameters
parameters = initialize_parameters()
with tf.name_scope("network"):
joint_layer, l2_loss, x1_de, x2_de = mynetwork(x1, x2, parameters, isTraining)
global_step = tf.Variable(0, trainable = False)
learning_rate = tf.train.exponential_decay(learning_rate_base, global_step, 30 * m/minibatch_size, 0.5, staircase = True)
with tf.name_scope("optimization"):
# network optimization
cost, optimizer = mynetwork_optimaization(joint_layer, y, x1_de, x2_de, x1_full, x2_full, l2_loss, beta_reg, learning_rate, global_step)
with tf.name_scope("metrics"):
# Calculate the correct predictions
joint_layerT = tf.transpose(joint_layer)
yT = tf.transpose(y)
correct_prediction = tf.equal(tf.argmax(joint_layerT), tf.argmax(yT))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Initialize all the variables
init = tf.global_variables_initializer()
saver = tf.train.Saver()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs + 1):
epoch_cost = 0. # Defines a cost related to an epoch
epoch_acc = 0.
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(x1_train_set, x2_train_set, x1_train_set_full, x2_train_set_full, y_train_set, minibatch_size, seed)
for minibatch in minibatches:
# Select a minibatch
(batch_x1, batch_x2, batch_x1_full, batch_x2_full, batch_y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
_, minibatch_cost, minibatch_acc = sess.run([optimizer, cost, accuracy], feed_dict={x1: batch_x1, x2: batch_x2, x1_full: batch_x1_full, x2_full: batch_x2_full, y: batch_y, isTraining: True})
epoch_cost += minibatch_cost / (num_minibatches+ 1)
epoch_acc += minibatch_acc / (num_minibatches + 1)
if MODEL.strip() == 'MML':
# Multimodal Learning (MML): close BN by "isTraining: False"
feature, epoch_cost_dev, epoch_acc_dev = sess.run([joint_layerT, cost, accuracy], feed_dict={x1: x1_test_set, x2: x2_test_set, x1_full: x1_test_set, x2_full: x2_test_set, y: y_test_set, isTraining: False})
if MODEL.strip() == 'CML':
# Crossmodal Learning (CML): open BN by "isTraining: True"
feature, epoch_cost_dev, epoch_acc_dev = sess.run([joint_layerT, cost, accuracy], feed_dict={x1: x1_test_set, x2: x2_test_set, x1_full: x1_test_set, x2_full: x2_test_set, y: y_test_set, isTraining: True})
# Print the cost every epoch
if print_cost == True and epoch % 50 == 0:
print ("epoch %i: Train_loss: %f, Val_loss: %f, Train_acc: %f, Val_acc: %f" % (epoch, epoch_cost, epoch_cost_dev, epoch_acc, epoch_acc_dev))
if print_cost == True and epoch % 5 == 0:
costs.append(epoch_cost)
train_acc.append(epoch_acc)
costs_dev.append(epoch_cost_dev)
val_acc.append(epoch_acc_dev)
# plot the cost
plt.plot(np.squeeze(costs))
plt.plot(np.squeeze(costs_dev))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# plot the accuracy
plt.plot(np.squeeze(train_acc))
plt.plot(np.squeeze(val_acc))
plt.ylabel('accuracy')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
print("save model")
save_path = saver.save(sess,"D:\Python_Project\MDL-RS/save_EnDe_FC/model.ckpt")
print("save model:{0} Finished".format(save_path))
return parameters, val_acc, feature
def model_train_MLP(X_train, Y_train, X_test, Y_test,
learning_rate=0.0001, epochs=1500, minibatch_size=32,
seed=1, verbose=0):
"""
training a three-layer tensorflow neural network:
LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX
@param X_train: training set of shape [12288, m], m is the number of training sample size
@param Y_train: training label of shape [6, m]
@param X_test: testing set while training with shape [12288, m_tst], m_tst is the number of test sample size
@param Y_test: testing label of shape [6, m_tst]
@param learning_rate: learning rate of the optimization
@param epochs: number of epochs of training loop
@param minibatch_size: size of a minibatch
@param seed: random seed
@param verbose: 0 to keep silence
1 to print the cost of training for 10 epoch
2 to print the cost of training & testing for 10 epoch
@return: parameters - after model training
@return: cost of train and test if need
"""
tf.set_random_seed(seed)
ops.reset_default_graph() # re-run of model without overwriting variables
n_x, m = X_train.shape
n_y, _ = Y_train.shape
train_costs = [] # keep track of the train cost
test_costs = [] # keep track of the test cost
#---- create the computation graph ----#
# create placeholder of shape [n_x, n_y] in computation graph
X = tf.placeholder(dtype=tf.float32, shape=[n_x,None], name='X')
Y = tf.placeholder(dtype=tf.float32, shape=[n_y,None], name='Y')
# parameters initialization
parameters = initialize_parameters_MLP(seed)
# forward propagation
Z3 = forward_propagation_MLP(X, parameters)
# calculation of cost
cost = compute_cost_MLP(Z3, Y)
# construction of optimizer
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer() # initial all the variables of tf
#---- Start the session to compute the tensorflow graph ----#
with tf.Session() as sess:
sess.run(init)
# training loop
for epoch in range(epochs):
epoch_cost = 0.0 # this turn cost
num_minibatches = int(m/minibatch_size)
seed += 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) # subsample
for minibatch in minibatches:
minibatch_X, minibatch_Y = minibatch
# run the graph on a minibatch
_ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X:minibatch_X, Y:minibatch_Y})
epoch_cost += minibatch_cost/num_minibatches
# printing the cost every epoch
if verbose == 1 and epoch % 10 == 0:
print("epoch %i: train cost %f" % (epoch, epoch_cost))
train_costs.append(epoch_cost)
if verbose == 2 and epoch % 10 == 0:
# calculating test cost
Z3_2 = forward_propagation_MLP(X, sess.run(parameters)) # computation graph
cost_2 = compute_cost_MLP(Z3_2, Y)
with tf.Session() as sess_2: # session
test_cost = sess_2.run(cost_2, feed_dict={X:X_test, Y:Y_test})
print("epoch %i: train cost%f, test cost%f" % (epoch, epoch_cost, test_cost))
train_costs.append(epoch_cost)
test_costs.append(test_cost)
# save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
# get accuracy result
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, train_costs, test_costs
def model(X_train, Y_train, X_valid, Y_valid, learning_rate = 0.0001,
num_epochs = 100, minibatch_size = 8, print_cost = True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = N, number of training examples = ?)
Y_train -- test set, of shape (output size = 2, number of training examples = ?)
X_test -- training set, of shape (input size = N, number of training examples = ?)
Y_test -- test set, of shape (output size = 2, number of test examples = ?)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph() # to be able to rerun the model without overwriting tf variables
#tf.set_random_seed(1) # to keep consistent results
#seed = 3 # to keep consistent results
(n_x, m) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
X, Y = create_placeholders(n_x, n_y)
# Initialize parameters
parameters = initialize_parameters()
#with open("Multiscale_modeling_0-Copy1.txt", "rb") as myFile:
# old_parameters = pickle.load(myFile)
# print ('loading old parameters successfully')
#parameters = copy_parameters(old_parameters)
# Forward propagation: Build the forward propagation in the tensorflow graph
A3 = forward_propagation(X, parameters)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(A3, Y)
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = (int)(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
#seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_ , minibatch_cost = sess.run([optimizer, cost],
feed_dict={X: minibatch_X,
Y: minibatch_Y})
### END CODE HERE ###
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 10 == 0:
print ("Cost after epoch %i: %f" % (epoch, epoch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(epoch_cost)
# plot the cost
plt.figure()
plt.plot(np.log(np.squeeze(costs)))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.savefig('DNN_Multiscale_Modeling')
# lets save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
return parameters
def model(X_train,
y_train,
X_test,
y_test,
num_epochs=1500,
minibatch_size=64,
learning_rate=0.0001,
print_cost=True):
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
n_y = y_train.shape[0]
#costs=[]
X, y = create_placeholders(n_x, n_y)
parameters = initialize_params(n_x, n_y, l1=20, l2=15)
z3 = forward_prop(X, parameters)
cost = get_cost(z3, y)
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for epoch in range(0, num_epochs):
epoch_cost = 0.
num_minibatches = int(m / minibatch_size)
num_minibatches = int(m / minibatch_size)
seed += 1
minibatches = random_mini_batches(X_train, y_train, minibatch_size,
seed)
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 / num_minibatches
if print_cost == True and epoch % 100 == 0:
print(str(epoch_cost) + ' at epoch number ' + str(epoch))
# sess=tf.Session()
parameters = sess.run(parameters)
print('Training done')
correct_prediction = tf.equal(tf.argmax(z3), tf.argmax(y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Train Accuracy:", str((accuracy.eval({
X: X_train,
y: y_train
}))))
print("Test Accuracy:", str((accuracy.eval({X: X_test, y: y_test}))))
# sess.close()
return (parameters)
def train_model(X_train, Y_train, X_test, Y_test):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph(
) # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(
n_x, m
) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
X, Y = create_placeholders(n_x, n_y)
# Initialize parameters
parameters = initialize_parameters()
# Forward propagation: Build the forward propagation in the tensorflow graph
Z3 = forward_propagation(X, parameters)
# use softmax to select out the largest index from the one-hot matrix
predicts = tf.nn.softmax(Z3, name="predicts", axis=0)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(Z3, Y)
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
optimizer = tf.train.AdamOptimizer(
learning_rate=LEARNING_RATE).minimize(cost)
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# before epochs saving step 1
tf.train.write_graph(sess.graph_def, 'out', MODEL_NAME + '.pbtxt',
True)
# Do the training loop
for epoch in range(NUM_EPOCHS):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(
m / MINIBATCH_SIZE
) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, MINIBATCH_SIZE,
seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
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)
# after epoches saving step 2
saver = tf.train.Saver()
saver.save(sess, 'out/' + MODEL_NAME + '.chkp')
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.00001,
num_epochs=1500,
minibatch_size=16,
print_cost=True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(
n_x, m
) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
global_step = tf.Variable(0, trainable=False)
#learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
# 10000, 0.96, staircase=True)
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. # Defines a cost related to an epoch
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y,
keep_prob: 0.90
})
epoch_cost += minibatch_cost / num_minibatches
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 tens)')
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,
keep_prob: 1
}))
print("Test Accuracy:",
accuracy.eval({
X: X_test,
Y: Y_test,
keep_prob: 1
}))
return parameters
def model(X_train, Y_train, X_test, Y_test, costs, learning_rate = 0.001,#learning_rate = 0.0001,
num_epochs = 200, minibatch_size = 2048, print_cost = True):
#num_epochs = 100, minibatch_size = 32, print_cost = True):
"""
A three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set
Y_train -- test set
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph()
(n_x, m) = X_train.shape
n_y = Y_train.shape[0]
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters(n_x, n_y)
Zf = forward_propagation(X, parameters)
cost = compute_cost(Zf, Y, parameters)
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 = 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 / num_minibatches
# Print the cost every epoch
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)
# plot the cost
#plt.plot(np.squeeze(costs[1:]))
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print ("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Zf), tf.argmax(Y))
#correct_prediction = tf.equal(tf.argmax(Z3[1:,]), tf.argmax(Y[1:,]))
# Calculate accuracy on the test set
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}))
confusion = tf.confusion_matrix(labels=tf.argmax(Y), predictions=tf.argmax(Zf), num_classes=2)
print("Train Confusion Matrix:")
print(pd.DataFrame(confusion.eval({X: X_train, Y: Y_train}), index = ['Actual Survival', 'Actual Default'], columns = ['Predicted Survival', 'Predicted Default']))
print("Test Confusion Matrix:")
print(pd.DataFrame(confusion.eval({X: X_test, Y: Y_test}), index = ['Actual Survival', 'Actual Default'], columns = ['Predicted Survival', 'Predicted Default']))
# auc = tf.metrics.auc(labels=tf.argmax(Y), predictions=tf.argmax(Z3))
# print ("Train AUC:", auc.eval({X: X_train, Y: Y_train}))
# print ("Test AUC:", auc.eval({X: X_test, Y: Y_test}))
#########This part has been added to compute the AUC of the Model
#Vector of probabilities of surviving
Y_train_pred = tf.nn.softmax(Zf, axis = 0).eval({X: X_train})[0]
Y_test_pred = tf.nn.softmax(Zf, axis = 0).eval({X: X_test})[0]
#Vector of status with 0 for Surviving loan and 1 for defaulting loan
y_train = Y_train[1,]
y_test = Y_test[1,]
fpr_train, tpr_train, thresholds_train = metrics.roc_curve(y_train, Y_train_pred, pos_label=0)
print("Train AUC: ", metrics.auc(fpr_train, tpr_train) )
fpr_test, tpr_test, thresholds_test = metrics.roc_curve(y_test, Y_test_pred , pos_label=0)
print("Test AUC: ", metrics.auc(fpr_test, tpr_test) )
plt.figure()
plt.plot(fpr_train, tpr_train, color='darkslategray', lw=2, label='ROC curve Train (area = %0.2f)' % metrics.auc(fpr_train, tpr_train))
plt.plot(fpr_test, tpr_test, color='darkred', lw=2, label='ROC curve Test (area = %0.2f)' % metrics.auc(fpr_test, tpr_test))
plt.plot([0, 1], [0, 1], color='goldenrod', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC')
plt.legend(loc="lower right")
plt.show()
df = pd.DataFrame(confusion.eval({X: X_train, Y: Y_train}))
sn.set(font_scale=1.4)#for label size
sn.heatmap(df, annot=True,annot_kws={"size": 16})
return parameters
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True):
"""
Implements a three-layer (2 hidden) tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
(
n_x, m
) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
X, Y = utils.create_placeholders(n_x, n_y)
# Initialize parameters
parameters = initialize_parameters()
# Forward propagation: Build the forward propagation in the tensorflow graph
Z3 = forward_propagation(X, parameters)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(Z3, Y)
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
minibatches = utils.random_mini_batches(X_train, Y_train,
minibatch_size)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the optimizer and the cost,
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
if print_cost and epoch % 100 == 0:
print("epoch %i %f" % (epoch, epoch_cost))
if print_cost and epoch % 5 == 0:
costs.append(epoch_cost)
# print (parameters)
# lets save the parameters in a variable
parameters = sess.run(parameters)
# print (parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1000,
minibatch_size=32,
print_cost=True,
is_plot=True):
"""
实现一个三层的TensorFlow神经网络：LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX
参数：
X_train - 训练集，维度为（输入大小（输入节点数量） = 12288, 样本数量 = 1080）
Y_train - 训练集分类数量，维度为（输出大小(输出节点数量) = 6, 样本数量 = 1080）
X_test - 测试集，维度为（输入大小（输入节点数量） = 12288, 样本数量 = 120）
Y_test - 测试集分类数量，维度为（输出大小(输出节点数量) = 6, 样本数量 = 120）
learning_rate - 学习速率
num_epochs - 整个训练集的遍历次数
mini_batch_size - 每个小批量数据集的大小
print_cost - 是否打印成本，每100代打印一次
is_plot - 是否绘制曲线图
返回：
parameters - 学习后的参数
"""
ops.reset_default_graph() # 能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)
seed = 3
n_x = X_train.shape[0]
m = X_train.shape[1] # 获取输入节点数量12288和样本数1080
n_y = Y_train.shape[0] # 获取输出节点数量6
costs = [] # 成本集
# 给X和Y创建placeholder
X, Y = create_placeholders(
n_x, n_y) # 输入输入节点12288，输出节点6，返回输出矩阵和输出矩阵的规模[12288 ?] [6 ?]
# 初始化参数
parameters = initialize_parameters()
# 前向传播
Z3 = forward_propagation(X, parameters) # X需要压缩为12288 1080
# 计算成本
cost = compute_cost(Z3, Y)
# 反向传播，使用Adam优化
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) # m = 1080(样本总数)，minibatch的总数量
seed = seed + 1
minibatches = tf_utils.random_mini_batches(X_train, Y_train,
minibatch_size, seed)
for minibatch in minibatches:
# 选择一个minibatch
(minibatch_X, minibatch_Y) = minibatch # 一组训练样本的x和y
# 数据已经准备好了，开始运行session
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
# 计算这个minibatch在这一代中所占的误差
epoch_cost = epoch_cost + minibatch_cost / num_minibatches # 每一圈epoch平均误差
#记录并打印成本
## 记录成本
if epoch % 10 == 0:
costs.append(epoch_cost)
#是否打印：
if print_cost and epoch % 100 == 0:
print("epoch = " + str(epoch) + " epoch_cost = " +
str(epoch_cost))
# 是否绘制图谱
if is_plot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# 保存学习后的参数
parameters = sess.run(parameters)
print("参数已经保存到session。")
# 计算当前的预测结果
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# 计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("训练集的准确率：", accuracy.eval({X: X_train, Y: Y_train}))
print("测试集的准确率:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
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() # 将计算图返回到默认空状态
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape # (n_x: 特征数量, m : 训练集中的样本数)
n_y = Y_train.shape[0]
costs = []
# 创建占位符
X, Y = create_placeholders(n_x, n_y)
# 初始化参数
parameters = initialize_parameters()
# 构建前向传播操作
Z3 = forward_propagation(X, parameters)
# 构建成本计算操作
cost = computer_cost(Z3, Y)
# 构建反向传播，为反向传播指定优化算法和学习率以及成本函数，这里我们使用adam算法，
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# 定义初始化操作
init = tf.global_variables_initializer()
# 开始一个tensorflow的session
with tf.Session() as sess:
# 执行初始化操作
sess.run(init)
# 执行epochs指定的训练次数，一个epoch就是完整的向整个数据集学习一次
for epoch in range(num_epochs):
epoch_cost = 0.
num_minibatches = int(m / minibatch_size) # 计算有多少个子训练集
seed = seed + 1
# 将数据集分成若干子训练集
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
# 循环遍历每一个子训练集
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 / num_minibatches
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)
# 画出cost成本的走势图
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
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 model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.0001,
num_epochs=1500,
minibatch_size=32,
print_cost=True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
X_test -- training set, of shape (input size = 12288, number of training examples = 120)
Y_test -- test set, of shape (output size = 6, number of test examples = 120)
learning_rate -- learning rate of the optimization
num_epochs -- number of epochs of the optimization loop
minibatch_size -- size of a minibatch
print_cost -- True to print the cost every 100 epochs
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
ops.reset_default_graph(
) # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1) # to keep consistent results
seed = 3 # to keep consistent results
(
n_x, m
) = X_train.shape # (n_x: input size, m : number of examples in the train set)
n_y = Y_train.shape[0] # n_y : output size
costs = [] # To keep track of the cost
# Create Placeholders of shape (n_x, n_y)
### START CODE HERE ### (1 line)
X, Y = create_placeholders(n_x, n_y)
### END CODE HERE ###
# Initialize parameters
### START CODE HERE ### (1 line)
parameters = initialize_parameters()
### END CODE HERE ###
# Forward propagation: Build the forward propagation in the tensorflow graph
### START CODE HERE ### (1 line)
Z3 = forward_propagation(X, parameters)
### END CODE HERE ###
# Cost function: Add cost function to tensorflow graph
### START CODE HERE ### (1 line)
cost = compute_cost(Z3, Y)
### END CODE HERE ###
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
### START CODE HERE ### (1 line)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
### END CODE HERE ###
# Initialize all the variables
init = tf.global_variables_initializer()
# Start the session to compute the tensorflow graph
with tf.Session() as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size,
seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
# IMPORTANT: The line that runs the graph on a minibatch.
# Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
### START CODE HERE ### (1 line)
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
### END CODE HERE ###
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
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)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# Calculate the correct predictions
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
# Calculate accuracy on the test set
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 model(X_train,Y_train,X_test,Y_test,
learning_rate = 0.0001,num_epochs = 1500,minibatch_size = 32,
print_cost = True,is_plot = True):
'''
实现一个三层的TensorFlow神经网络:linear->relu->linear->relu->linear->softmax
:param X_train: 训练集,维度为(输入大小(输入节点数量) = 12288,样本数量=1080)
:param Y_train: 训练集分类数量,维度为(输出大小(输出节点数量)=6,样本数量=1080)
:param X_test: 测试集,维度为(输入大小(输入节点数量)=12288,,样本数量= 120)
:param Y_test: 测试集分类数量,维度为(输出大小(输出节点数量) = 6,样本数量= 120)
:param learning_rate: 学习速率
:param num_epochs: 整个训练集的遍历次数
:param minibatch_size: 每个小批量数据集的大小
:param print_cost: 是否打印成本,每100代打印一次
:param is_plot: 是否绘制曲线
:return:
parameters - 学习后的参数
'''
ops.reset_default_graph() #能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)
seed = 3
(n_x,m) = X_train.shape#获取输入节点数量和样本数
n_y = Y_train.shape[0]#获取输出节点数量
costs = []#成本集
#给X和Y创建placeholder
X,Y=creat_placeholders(n_x,n_y)
#初始化参数
parameters = initialize_parameters()
#前向传播
Z3 = forward_propagation(X,parameters)
#计算成本
cost = compute_cost(Z3,Y)
#反向传播,使用Adam优化
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)#minibatch的总数量
seed =seed +1
minibatches = tf_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
for minibatch in minibatches:
#选择一个minibatch
(minibatch_X,minibatch_Y) = minibatch
#数据已经准备好,开始运行session
_,minibatch_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
#计算这个minibatch在这一代中所占的误差
epoch__cost = epoch_cost +minibatch_cost/num_minibatches
#记录并打印成本
##记录成本
if epoch%5==0:
costs.append(epoch__cost)
#是否打印:
if print_cost and epoch%100 == 0:
print('epoch = '+str(epoch)+'epoch_cost'+str(epoch__cost))
#是否绘制图谱
if is_plot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations(per ten)')
plt.title('learning rate ='+str(learning_rate))
plt.show()
#保存学习后的参数
parameters = sess.run(parameters)
print('参数已保存到session')
#计算当前的预测结果
correct_prediction = tf.equal(tf.argmax(Z3),tf.argmax(Y))
#计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,'float'))
print('训练集的准确率:',accuracy.eval({X:X_train,Y:Y_train}))
print('测试集的准确率:',accuracy.eval({X:X_test,Y:Y_test}))
return parameters
