def train_model(image_path, learning_rate=0.001, num_epoch=100, batch_size=5):
X_train = np.load(image_path + ".npy")
Y_train = np.load(image_path + ".npy")
X_train = X_train / 255
#Creating one-hot for label
print(Y_train.shape)
print(Y_train[0][1])
Y_train = convert_to_one_hot(Y_train, 10).T
n_Y = Y_train.shape[1]
x = tf.placeholder(tf.float32, [None, 227, 227, 3])
Y = tf.placeholder(tf.float32, [None, n_Y])
keep_prob = tf.placeholder(tf.float32)
model = AlexNet(x, keep_prob, 10, [])
score = model.fc8
cost = tf.reduce_mean(
(tf.nn.softmax_cross_entropy_with_logits_v2(logits=score, labels=Y)))
softmax = tf.nn.softmax(score)
costs = []
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()
[m, nH, nW, nCH] = X_train.shape
seed = 0
#tf.reset_default_graph()
with tf.Session() as sess:
sess.run(init)
sess.run(model.load_initial_weights(sess))
for i in range(num_epoch):
minibatch_cost = 0
num_minibatch = int(m / batch_size) # number of batches
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, batch_size,
seed)
for minibatch in minibatches:
X_batches, Y_batches = minibatch
#Use cost and optimizer to run
_, c = sess.run([optimizer, cost], {
x: X_batches,
Y: Y_batches,
keep_prob: 1
})
minibatch_cost += c
minibatch_cost = minibatch_cost / num_minibatch
if i % 5 == 0:
print("Cost===>" + str(c))
costs.append(c)
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('epoch')
plt.title('learning_rate' + str(learning_rate))
plt.show()
def model(X_train,Y_train,X_test,Y_test,learning_rate = 0.009,num_epochs = 100,minibatch_size = 64
,print_cost = True):
ops.reset_default_graph()#能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)#确保数据一样
seed = 3
(m,n_H0,n_W0,n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
X,Y = create_placeholders(n_H0,n_W0,n_C0,n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X,parameters)
cost = computer_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):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size)#获取数据库块的数量
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_,temp_cost = sess.run([optimizer, cost], feed_dict={X:minibatch_X, Y:minibatch_Y})
minibatch_cost += temp_cost / num_minibatches
if print_cost == True and epoch % 5 == 0:
print('当前是第' + str(epoch) + '代，成本值为：' + str(minibatch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(minibatch_cost)
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iteration(per tens)')
plt.title('Learning rate = ' + str(learning_rate))
plt.show()
#####计算Accuracy
predict_op = tf.arg_max(Z3,1)######1代表行，每行中最大数的位子，也就是one-hot中1的位置
corrent_prediction = tf.equal(predict_op,tf.arg_max(Y,1))
accuracy = tf.reduce_mean(tf.cast(corrent_prediction,'float'))
print(accuracy)
train_accuracy = accuracy.eval({X:X_train,Y:Y_train})
test_accuracy = accuracy.eval({X:X_test,Y:Y_test})
print('训练集的准确度：'+str(train_accuracy))
print('测试集的准确度：'+str(test_accuracy))
return (train_accuracy,test_accuracy,parameters)
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.009,
num_epochs=100,
minibatch_size=64,
print_cost=True,
isPlot=True):
"""
使用TensorFlow实现三层的卷积神经网络
CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
参数：
X_train - 训练数据，维度为(None, 64, 64, 3)
Y_train - 训练数据对应的标签，维度为(None, n_y = 6)
X_test - 测试数据，维度为(None, 64, 64, 3)
Y_test - 训练数据对应的标签，维度为(None, n_y = 6)
learning_rate - 学习率
num_epochs - 遍历整个数据集的次数
minibatch_size - 每个小批量数据块的大小
print_cost - 是否打印成本值，每遍历100次整个数据集打印一次
isPlot - 是否绘制图谱
返回：
train_accuracy - 实数，训练集的准确度
test_accuracy - 实数，测试集的准确度
parameters - 学习后的参数
"""
ops.reset_default_graph() #能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1) #确保你的数据和我一样
seed = 3 #指定numpy的随机种子
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
#为当前维度创建占位符
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size) #获取数据块的数量
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, minibatch_size, seed)
#对每个数据块进行处理
for minibatch in minibatches:
#选择一个数据块
(minibatch_X, minibatch_Y) = minibatch
#最小化这个数据块的成本
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
#累加数据块的成本值
minibatch_cost += temp_cost / num_minibatches
#是否打印成本
if print_cost:
#每5代打印一次
if epoch % 5 == 0:
print("当前是第 " + str(epoch) + " 代，成本值为：" +
str(minibatch_cost))
#记录成本
if epoch % 1 == 0:
costs.append(minibatch_cost)
#数据处理完毕，绘制成本曲线
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
#开始预测数据
## 计算当前的预测情况
predict_op = tf.arg_max(Z3, 1)
corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))
##计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float"))
print("corrent_prediction accuracy= " + str(accuracy))
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuary = accuracy.eval({X: X_test, Y: Y_test})
print("训练集准确度：" + str(train_accuracy))
print("测试集准确度：" + str(test_accuary))
return (train_accuracy, test_accuary, parameters)
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.009,
num_epochs=100,
minibatch_size=64,
print_cost=True,
isPlot=True):
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
# 为当前的维度创建占位符
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size)
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, minibatch_size, seed)
# 对每个数据块进行处理
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
# 最小化这个数据化的成本（这里应该是进行一次梯度下降吧）
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
minibatch_cost += temp_cost / num_minibatches
if print_cost:
if epoch % 5 == 0:
print("当前的成本为： ", epoch, "代，成本为：" + str(minibatch_cost))
if epoch % 5 == 0:
costs.append(minibatch_cost)
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('daishu')
plt.title("learning rate = " + str(learning_rate))
plt.show()
# 开始预测数据
# 计算当前的预测情况
predict_op = tf.arg_max(Z3, 1)
corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))
# 计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float"))
print("corrent_prediction accuracy= " + str(accuracy))
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
print("训练集准确度： " + str(train_accuracy))
print("测试集准确度： " + str(test_accuracy))
return (train_accuracy, test_accuracy, parameters)
def model(X_train,
Y_train,
X_test,
Y_test,
Y_train_labels,
Y_test_labels,
seg_size,
weights,
decay_learning_rate=False,
base_learning_rate=0.0001,
num_epochs=100,
minibatch_size=16,
print_cost=True):
"""
Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
Arguments:
X_train -- training set
Y_train -- test set
X_test -- training set
Y_test -- 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(
) # to be able to rerun the model without overwriting tf variables
(m, seg_size, n_C0) = (X_train.channels.shape)
# calculating the learning rate type
batch = tf.Variable(0, dtype=tf.float32)
if decay_learning_rate is True:
# Decay once per epoch, using an exponential schedule starting at 0.01.
learning_rate = tf.train.exponential_decay(
0.01, # Base learning rate.
batch * minibatch_size, # Current index into the dataset.
m, # Decay step.
0.95, # Decay rate.
staircase=True)
else:
# Decay once per epoch, using an exponential schedule starting at 0.01.
learning_rate = tf.train.exponential_decay(
base_learning_rate, # Base learning rate.
batch * minibatch_size, # Current index into the dataset.
m, # Decay step.
1.00, # Decay rate.
staircase=True)
n_y = num_classes
costs = []
# variable for saving trip_id, uuid, segment_id fro test set
predicted_label = np.zeros(Y_test.shape[0],
dtype=[('uuid', 'S64'), ('trip_id', 'int8'),
('segment_id', 'int8'),
('class_label', 'int8')])
predicted_label = np.rec.array(predicted_label)
predicted_label.uuid = Y_test.uuid
predicted_label.trip_id = Y_test.trip_id
predicted_label.segment_id = Y_test.segment_id
# variable for saving trip_id, uuid, segment_id for train set
predicted_label_train = np.zeros(Y_train.shape[0],
dtype=[('uuid', 'S64'),
('trip_id', 'int8'),
('segment_id', 'int8'),
('class_label', 'int8')])
predicted_label_train = np.rec.array(predicted_label_train)
predicted_label_train.uuid = Y_train.uuid
predicted_label_train.trip_id = Y_train.trip_id
predicted_label_train.segment_id = Y_train.segment_id
# Create Placeholders of the correct shape
X, Y, minibatch_weights = create_placeholders(
seg_size, n_C0, n_y, minibatch_size=minibatch_size)
# Initialize parameters
parameters = initialize_parameters(weights)
# Forward propagation: Build the forward propagation in the tensorflow graph
final_Z = forward_propagation(X, parameters)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(final_Z, Y, minibatch_weights)
# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(
cost, global_step=batch)
# 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):
minibatch_cost = 0.
num_minibatches = int(
m / minibatch_size
) # number of minibatches of size minibatch_size in the train set
minibatches, mini_batches_weights = random_mini_batches(
X_train,
Y_train,
Y_train_labels,
Y_test_labels,
minibatch_size,
class_weight_calculation=0)
for index, minibatch in enumerate(minibatches):
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
class_weights = mini_batches_weights[index]
# 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).
_, temp_cost = sess.run(
[optimizer, cost],
feed_dict={
X: minibatch_X.channels,
Y: minibatch_Y.class_label,
minibatch_weights: class_weights
})
# _, temp_cost = sess.run(tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(compute_cost),
# feed_dict={X: minibatch_X, Y: minibatch_Y, class_weights: class_weights})
minibatch_cost += temp_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(minibatch_cost)
if minibatch_cost > costs[epoch - 1]:
learning_rate = learning_rate * 0.95
# Calculate the correct predictions
predict_op = tf.argmax(final_Z, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# finding the probabilities
final_prob_train = (final_Z.eval({
X: X_train.channels,
Y: Y_train.class_label
}))
final_prob_test = sess.run(final_Z, feed_dict={X: X_test.channels})
# finding the predicted labels
predictions, labels_test = sess.run(
[predict_op, tf.argmax(Y, 1)],
feed_dict={
X: X_test.channels,
Y: Y_test.class_label
})
# predicted_label.class_label = predictions
predictions_train = (predict_op.eval({
X: X_train.channels,
Y: Y_train.class_label
}))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
train_accuracy = accuracy.eval({
X: X_train.channels,
Y: Y_train.class_label
})
test_accuracy = accuracy.eval({
X: X_test.channels,
Y: Y_test.class_label
})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
confusion = tf.confusion_matrix(labels=tf.argmax(Y, 1),
predictions=predict_op,
num_classes=num_classes)
confusion_mat = confusion.eval({
Y: Y_test.class_label,
X: X_test.channels
})
print(confusion_mat)
return parameters, test_accuracy, costs, predictions, predictions_train, final_prob_train, final_prob_test
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.009,
num_epochs=100,
minibatch_size=64,
print_cost=True,
operation='save',
predict=None):
"""
Implements a three-layer ConvNet in Tensorflow:
CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
Arguments:
X_train -- training set, of shape (None, 64, 64, 3)
Y_train -- test set, of shape (None, n_y = 6)
X_test -- training set, of shape (None, 64, 64, 3)
Y_test -- test set, of shape (None, n_y = 6)
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:
train_accuracy -- real number, accuracy on the train set (X_train)
test_accuracy -- real number, testing accuracy on the test set (X_test)
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 results consistent (tensorflow seed)
seed = 3 # to keep results consistent (numpy seed)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = [] # To keep track of the cost
X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
if operation == 'save':
sess.run(init)
for epoch in range(num_epochs):
minibatch_cost = 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(X_train, Y_train,
minibatch_size, seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
minibatch_cost += temp_cost / num_minibatches
if print_cost == True and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(minibatch_cost)
save_path = saver.save(sess, "model.ckpt")
print("Model saved in path: %s" % save_path)
predict_op = tf.argmax(Z3, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
elif operation == 'restore':
saver.restore(sess, "model.ckpt")
predict_op = tf.argmax(Z3, 1)
result = predict_op.eval({X: predict})
print result
def train_data_with_CNN(X_train, Y_train, X_test, Y_test, minibatch_size):
seed = 1
# 初始化权值
def weight_variable(shape, name='weig;ht'):
init = tf.truncated_normal(shape, stddev=0.1)
var = tf.Variable(initial_value=init, name=name)
return var
# 初始化偏置
def bias_variable(shape, name='bias'):
init = tf.constant(0.1, shape=shape)
var = tf.Variable(init, name=name)
return var
# 卷积
def conv2d(x, W, name='conv2d'):
return tf.nn.conv2d(x,
W,
strides=[1, 1, 1, 1],
padding='SAME',
name=name)
# 池化
def max_pool_2X2(x, name='maxpool'):
return tf.nn.max_pool(x,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME',
name=name)
def max_pool_3X3(x, name='maxpool'):
return tf.nn.max_pool(x,
ksize=[1, 3, 3, 1],
strides=[1, 2, 2, 1],
padding='SAME',
name=name)
# 输入层
# 请注意 X 的 name，在测试model时会用到它
# X = tf.placeholder(tf.float32, [None, CAPTCHA_IMAGE_WIDHT * CAPTCHA_IMAGE_HEIGHT], name='data-input')
# Y = tf.placeholder(tf.float32, [None, CAPTCHA_LEN * CHAR_SET_LEN], name='label-input')
# x_input = tf.reshape(X, [-1, CAPTCHA_IMAGE_HEIGHT, CAPTCHA_IMAGE_WIDHT, 1], name='x-input')
#自改X为三层通道的训练数据
x_input = tf.placeholder(
tf.float32, [None, CAPTCHA_IMAGE_HEIGHT, CAPTCHA_IMAGE_WIDHT, 1],
name='x-input')
Y = tf.placeholder(tf.float32, [None, CAPTCHA_LEN * CHAR_SET_LEN],
name='label-input')
# dropout,防止过拟合
# 请注意 keep_prob 的 name，在测试model时会用到它
keep_prob = tf.placeholder(tf.float32, name='keep-prob')
# # 第一层卷积
# W_conv1 = weight_variable([5, 5, 3, 32], 'W_conv1')
# B_conv1 = bias_variable([32], 'B_conv1')
# conv1 = tf.nn.relu(conv2d(x_input, W_conv1, 'conv1') + B_conv1)
# conv1 = max_pool_2X2(conv1, 'conv1-pool')
# conv1 = tf.nn.dropout(conv1, keep_prob)
# # 第二层卷积
# W_conv2 = weight_variable([5, 5, 32, 64], 'W_conv2')
# B_conv2 = bias_variable([64], 'B_conv2')
# conv2 = tf.nn.relu(conv2d(conv1, W_conv2, 'conv2') + B_conv2)
# conv2 = max_pool_2X2(conv2, 'conv2-pool')
# conv2 = tf.nn.dropout(conv2, keep_prob)
# # 第三层卷积
# W_conv3 = weight_variable([5, 5, 64, 64], 'W_conv3')
# B_conv3 = bias_variable([64], 'B_conv3')
# conv3 = tf.nn.relu(conv2d(conv2, W_conv3, 'conv3') + B_conv3)
# conv3 = max_pool_2X2(conv3, 'conv3-pool')
# conv3 = tf.nn.dropout(conv3, keep_prob)
###############自改####################
#第一层卷积+池化
W_conv1 = weight_variable([5, 5, 1, 16], 'W_conv1')
B_conv1 = bias_variable([16], 'B_conv1')
conv1 = tf.nn.relu(conv2d(x_input, W_conv1, 'conv1') + B_conv1)
conv1 = max_pool_3X3(conv1, 'conv1-pool')
#conv1 = tf.nn.dropout(conv1, keep_prob)
# 第二层卷积+池化
W_conv2 = weight_variable([5, 5, 16, 32], 'W_conv2')
B_conv2 = bias_variable([32], 'B_conv2')
conv2 = tf.nn.relu(conv2d(conv1, W_conv2, 'conv2') + B_conv2)
conv2 = max_pool_3X3(conv2, 'conv2-pool')
#conv2 = tf.nn.dropout(conv2, keep_prob)
#第三层卷积
W_conv3 = weight_variable([5, 5, 32, 64], 'W_conv3')
B_conv3 = bias_variable([64], 'B_conv3')
conv3 = tf.nn.relu(conv2d(conv2, W_conv3, 'conv3') + B_conv3)
#conv3 = tf.nn.dropout(conv3, keep_prob)
#第四层卷积
W_conv4 = weight_variable([3, 3, 64, 128], 'W_conv4')
B_conv4 = bias_variable([128], 'B_conv4')
conv4 = tf.nn.relu(conv2d(conv3, W_conv4, 'conv4') + B_conv4)
#conv4 = tf.nn.dropout(conv4, keep_prob)
#第五层卷积+池化
W_conv5 = weight_variable([3, 3, 128, 256], 'W_conv5')
B_conv5 = bias_variable([256], 'B_conv5')
conv5 = tf.nn.relu(conv2d(conv4, W_conv5, 'conv5') + B_conv5)
conv5 = max_pool_3X3(conv5, 'conv5-pool')
#conv5 = tf.nn.dropout(conv5, keep_prob)
#第一层全连接
W_fc = weight_variable([5 * 15 * 256, 1024], 'W_fc')
B_fc = bias_variable([1], 'B_fc')
fc1 = tf.reshape(conv5, [-1, W_fc.get_shape().as_list()[0]])
fc1 = tf.nn.relu(tf.add(tf.matmul(fc1, W_fc), B_fc))
fc1 = tf.nn.dropout(fc1, keep_prob)
#第二层全连接
# W_fc1 = weight_variable([1024, 4069], 'W_fc1')
# B_fc1 = bias_variable([1], 'B_fc1')
#
# fc1 = tf.nn.relu(tf.add(tf.matmul(fc, W_fc1), B_fc1))
# fc1 = tf.nn.dropout(fc1, keep_prob)
# 全链接层
# 每次池化后，图片的宽度和高度均缩小为原来的一半，进过上面的三次池化，宽度和高度均缩小8倍
# W_fc1 = weight_variable([5 * 15 * 64, 1024], 'W_fc1')
# B_fc1 = bias_variable([1024], 'B_fc1')
# #fc1 = tf.reshape(conv3, [-1, 20 * 8 * 64])
# fc1 = tf.reshape(conv5, [-1, W_fc1.get_shape().as_list()[0]])
# fc1 = tf.nn.relu(tf.add(tf.matmul(fc1, W_fc1), B_fc1))
# fc1 = tf.nn.dropout(fc1, keep_prob)
# 输出层
W_fc2 = weight_variable([1024, CAPTCHA_LEN * CHAR_SET_LEN], 'W_fc2')
B_fc2 = bias_variable([CAPTCHA_LEN * CHAR_SET_LEN], 'B_fc2')
output = tf.add(tf.matmul(fc1, W_fc2), B_fc2, 'output')
loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(labels=Y, logits=output))
optimizer = tf.train.AdamOptimizer(0.001).minimize(loss)
predict = tf.reshape(output, [-1, CAPTCHA_LEN, CHAR_SET_LEN],
name='predict')
labels = tf.reshape(Y, [-1, CAPTCHA_LEN, CHAR_SET_LEN], name='labels')
# 预测结果
# 请注意 predict_max_idx 的 name，在测试model时会用到它
predict_max_idx = tf.argmax(predict, axis=2, name='predict_max_idx')
labels_max_idx = tf.argmax(labels, axis=2, name='labels_max_idx')
predict_correct_vec = tf.equal(predict_max_idx, labels_max_idx)
accuracy = tf.reduce_mean(tf.cast(predict_correct_vec, tf.float32))
saver = tf.train.Saver()
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=True)
config.gpu_options.per_process_gpu_memory_fraction = 0.6
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
steps = 0
for epoch in range(6000):
num_minibatches = int(m / minibatch_size)
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, num_minibatches, seed)
for minibatch in minibatches:
(train_data, train_label) = minibatch
op, pre = sess.run([optimizer, labels_max_idx],
feed_dict={
x_input: train_data,
Y: train_label,
keep_prob: 0.75
})
#print(pre)
#print(pre.shape)
if steps % 1 == 0:
acc = sess.run(accuracy,
feed_dict={
x_input: X_test,
Y: Y_test,
keep_prob: 1.0
})
print("steps=%d, accuracy=%f" % (steps, acc))
if acc > 0.925:
saver.save(sess,
MODEL_SAVE_PATH + "crack_captcha.model",
global_step=steps)
if acc > 0.939:
break
steps += 1
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.009,
num_epochs=100,
minibatch_size=64,
print_cost=True,
isPlot=True):
'''
使用TensorFlow实现三层的卷积神经网络
conv2d->relu->maxpool->>conv2d->relu->maxpool->flatten->fullyconnnected
:param X_train: 训练数据,维度为(None,64,64,3)
:param Y_train: 训练数据对应的标签,维度为(Nne,n_y=6
:param X_test: 测试数据,维度为(None,64,64,3)
:param Y_test: 训练数据对应的标签,维度为(None,n_y=6)
:param learning_rate: 学习率
:param num_epochs: 遍历整个数据集的次数
:param minibatch_size: 每个小批量数据块的大小
:param print_cost: 是否打印成本值,每遍历100次整个数据集打印一次
:param isPlot: 是否绘制图谱
:return:
train_accuracy-实数,训练集的准确度
test_accuracy-实数,测试集的准确度
parameters-学习后的参数
'''
ops.reset_default_graph() #能后重新运行模型而不覆盖tf变量
tf.set_random_seed(1) #确保你的数据和我的一样
seed = 3 #指定numpy的随机种子
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
#为当前维度创建占位符
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size) #获取数据块数量
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, minibatch_size, seed)
#对米格数据块进行处理
for minibatch in minibatches:
#选择一个数据块
(minibatch_X, minibatch_Y) = minibatch
#最小化这个数据块的成本
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
#累加数据块的成本值
minibatch_cost += temp_cost / num_minibatches
#是否打印成本
if print_cost:
#每5代打印一次
if epoch % 5 == 0:
print('当前是第' + str(epoch) + '代,成本值为:' +
str(minibatch_cost))
#记录成本
if epoch % 1 == 0:
costs.append(minibatch_cost)
#数据处理完毕,绘制成本曲线
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterstions(per tens)')
plt.title('Learning rate =' + str(learning_rate))
plt.show()
#开始预测数据
##计算当前的预测情况
predict_op = tf.arg_max(Z3, 1)
corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))
##计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction, 'float'))
print('corrent_prediction accuary = ' + str(accuracy))
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval(({X: X_test, Y: Y_test}))
print('训练及准确度:' + str(train_accuracy))
print('测试集准确度:' + str(test_accuracy))
return (train_accuracy, test_accuracy, parameters)
def model(train_X,
train_Y,
test_X,
test_Y,
learning_rate=0.09,
num_epochs=100,
minibatch_size=64,
print_cost=True):
'''
实现一个有两个卷积层的CNN网络
Parameters:
train_X - shape=(None, 64, 64, 3)
train_Y - shape=(None, n_y=6)
Returns:
train_accuracy - 训练集上的准确率
test_accuracy - 测试集上的准确率
parameters - 模型学习到的权重参数的字典
'''
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(m, n_H0, n_W0, n_C0) = train_X.shape
n_y = train_Y.shape[1]
costs = []
# step1 创建Ｘ和Ｙ的占位符
X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)
# step2 卷积核初始化
parameters = initialize_parameters()
# step3 向前传播
Z3 = forward_propagation(X, parameters)
# step4 计算损失函数
cost = compute_cost(Z3, Y)
# step5 反向传播
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# step6 初始化所有变量
init = tf.global_variables_initializer()
# step7开始计算tensorflow计算图
with tf.Session() as sess:
sess.run(init)
# 开始训练
for epoch in range(num_epochs):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size)
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
train_X, train_Y, minibatch_size, seed)
for minibatch in minibatches:
# 选取一个minibatch
(minibatch_X, minibatch_Y) = minibatch
# 开始计算对应的损失
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
minibatch_cost += temp_cost / num_minibatches
if print_cost and epoch % 5 == 0:
print('Cost after epoch %d: %.3f' % (epoch, minibatch_cost))
if print_cost and epoch % 1 == 0:
costs.append(minibatch_cost)
plt.plot(np.squeeze(costs))
plt.xlabel('iterations (per tens)')
plt.ylabel('cost')
plt.title('Learning rate =' + str(learning_rate))
plt.show()
# 计算预测的正确率
predict_op = tf.argmax(Z3, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# 计算在train_Set 和 test_Set上的准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy)
train_accuracy = accuracy.eval({X: train_X, Y: train_Y})
test_accuracy = accuracy.eval({X: train_X, Y: train_Y})
print('Train Accuracy:', train_accuracy)
print('Test Accuracy:', test_accuracy)
return train_accuracy, test_accuracy, parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009,
num_epochs=100, minibatch_size=64, print_cost=True):
"""
Implements a three-layer ConvNet in Tensorflow:
CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
Arguments:
X_train -- training set, of shape (None, 64, 64, 3)
Y_train -- test set, of shape (None, n_y = 6)
X_test -- training set, of shape (None, 64, 64, 3)
Y_test -- test set, of shape (None, n_y = 6)
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:
train_accuracy -- real number, accuracy on the train set (X_train)
test_accuracy -- real number, testing accuracy on the test set (X_test)
parameters -- parameters learnt by the model. They can then be used to predict.
"""
tf.compat.v1.set_random_seed(1) # to keep results consistent (tensorflow seed)
seed = 3 # to keep results consistent (numpy seed)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = [] # To keep track of the cost
with tf.compat.v1.Graph().as_default() as graph:
# Create Placeholders of the correct shape
X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)
# Initialize parameters
parameters = None
# 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 that minimizes the cost.
optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Create a saver.
saver = tf.compat.v1.train.Saver()
# Initialize all the variables globally
init = tf.compat.v1.global_variables_initializer()
# Calculate the correct predictions
predict_op = tf.argmax(input=Z3, axis=1)
correct_prediction = tf.equal(predict_op, tf.argmax(input=Y, axis=1))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(input_tensor=tf.cast(correct_prediction, "float"))
# Start the session to compute the tensorflow graph
with tf.compat.v1.Session(graph=graph) as sess:
# Run the initialization
sess.run(init)
# Do the training loop
for epoch in range(num_epochs):
minibatch_cost = 0.
num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
seed = seed + 1
minibatches = cnn_utils.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).
_, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
minibatch_cost += temp_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(minibatch_cost)
save_path = saver.save(sess, 'saves\my-model')
print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title(
"Learning rate = {0}, Train Accuracy: {1}, Test Accuracy: {2}.".format(learning_rate, train_accuracy,
test_accuracy))
plt.show()
return train_accuracy, test_accuracy, parameters, save_path
def model(X_train, Y_train, X_test, Y_test, learning_rate, num_epochs,
minibatch_size, print_cost, isPlot):
seed = 3
# X_train = X_train.transpose(0,2,3,1)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
X, Y, keep_prob = create_placeholder(n_H0, n_W0, n_C0, n_y)
parameters = init_parameters()
Z6 = forward_propagation(X, parameters, keep_prob)
cost = compute_loss(Z6, Y)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size) #获取数据块的数量
#seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, minibatch_size, seed)
#对每个数据块进行处理
for minibatch in minibatches:
#选择一个数据块
(minibatch_X, minibatch_Y) = minibatch
#最小化这个数据块的成本
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y,
keep_prob: 0.5
})
#累加数据块的成本值
minibatch_cost += temp_cost / num_minibatches
#是否打印成本
if print_cost:
#每5代打印一次
if epoch % 50 == 0:
print("当前是第 " + str(epoch) + " 代，成本值为：" +
str(minibatch_cost))
#记录成本
if epoch % 1 == 0:
costs.append(minibatch_cost)
#数据处理完毕，绘制成本曲线
if isPlot:
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。")
saver.save(sess, "model/save_net.ckpt")
# X_test = X_test.transpose(0,2,3,1)
#开始预测数据
## 计算当前的预测情况
predict_op = tf.argmax(Z6, 1)
corrent_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
##计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float"))
# print("corrent_prediction accuracy= " + str(accuracy))
train_accuracy = accuracy.eval({
X: X_train,
Y: Y_train,
keep_prob: 1.0
})
test_accuary = accuracy.eval({X: X_test, Y: Y_test, keep_prob: 1.0})
print("训练集准确度：" + str(train_accuracy))
print("测试集准确度：" + str(test_accuary))
return parameters
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.005,
num_epochs=100,
minibatch_size=64,
print_cost=True,
isPlot=True):
ops.reset_default_graph()
tf.set_random_seed(1)
seed = 3
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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):
minibatch_cost = 0
num_minibatches = int(m / minibatch_size) # 获取数据块的数量
seed = seed + 1
minibatches = cnn_utils.random_mini_batches(
X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
minibatch_cost += temp_cost / num_minibatches
if print_cost:
# 每5代打印一次
if epoch % 5 == 0:
print("当前是第 " + str(epoch) + " 代，成本值为：" +
str(minibatch_cost))
# 记录成本
if epoch % 1 == 0:
costs.append(minibatch_cost)
# 数据处理完毕，绘制成本曲线
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
predict_op = tf.arg_max(Z3, 1)
corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))
##计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float"))
print("corrent_prediction accuracy= " + str(accuracy))
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuary = accuracy.eval({X: X_test, Y: Y_test})
print("训练集准确度：" + str(train_accuracy))
print("测试集准确度：" + str(test_accuary))
return (train_accuracy, test_accuary, parameters)
def model(X_train,Y_train,X_test,Y_test,learning_rate = 0.009,
num_epochs = 100,minibatch_size = 64,print_cost = True,isPlot =True):
'''
使用TensorFlow实现三层的卷积神经网络
conv2d->relu->maxpool->>conv2d->relu->maxpool->flatten->fullyconnnected
:param X_train: 训练数据,维度为(None,64,64,3)
:param Y_train: 训练数据对应的标签,维度为(Nne,n_y=6
:param X_test: 测试数据,维度为(None,64,64,3)
:param Y_test: 训练数据对应的标签,维度为(None,n_y=6)
:param learning_rate: 学习率
:param num_epochs: 遍历整个数据集的次数
:param minibatch_size: 每个小批量数据块的大小
:param print_cost: 是否打印成本值,每遍历100次整个数据集打印一次
:param isPlot: 是否绘制图谱
:return:
train_accuracy-实数,训练集的准确度
test_accuracy-实数,测试集的准确度
parameters-学习后的参数
'''
ops.reset_default_graph()#能后重新运行模型而不覆盖tf变量
tf.set_random_seed(1)#确保你的数据和我的一样
seed = 3#指定numpy的随机种子
(m,n_H0,n_W0,n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = []
#为当前维度创建占位符
X, Y = create_placeholders(n_H0,n_W0,n_C0,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):
minibatch_cost = 0
num_minibatches = int(m/minibatch_size)#获取数据块数量
seed=seed+1
minibatches = cnn_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
#对米格数据块进行处理
for minibatch in minibatches:
#选择一个数据块
(minibatch_X,minibatch_Y) = minibatch
#最小化这个数据块的成本
_ ,temp_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
#累加数据块的成本值
minibatch_cost += temp_cost/num_minibatches
#是否打印成本
if print_cost:
#每5代打印一次
if epoch%5==0:
print('当前是第'+str(epoch)+'代,成本值为:'+str(minibatch_cost))
#记录成本
if epoch%1 == 0:
costs.append(minibatch_cost)
#数据处理完毕,绘制成本曲线
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterstions(per tens)')
plt.title('Learning rate ='+str(learning_rate))
plt.show()
#开始预测数据
##计算当前的预测情况
predict_op = tf.arg_max(Z3,1)
corrent_prediction = tf.equal(predict_op,tf.arg_max(Y,1))
##计算准确度
accuracy = tf.reduce_mean(tf.cast(corrent_prediction,'float'))
print('corrent_prediction accuary = '+str(accuracy))
train_accuracy =accuracy.eval({X:X_train,Y:Y_train})
test_accuracy = accuracy.eval(({X:X_test,Y:Y_test}))
print('训练及准确度:'+str(train_accuracy))
print('测试集准确度:'+str(test_accuracy))
return(train_accuracy,test_accuracy,parameters)
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.003,
num_epochs=50,
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 results consistent (tensorflow seed)
seed = 3 # to keep results consistent (numpy seed)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = [] # To keep track of the cost
# Create Placeholders of the correct shape
with tf.name_scope("input"):
X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)
#tf.summary.scalar('input_X', X)
#tf.summary.scalar('input_Y', Y)
# Initialize parameters
with tf.name_scope('input_image'):
image_in = tf.reshape(X, [-1, 64, 64, 3])
tf.summary.image('input_image', [image_in[5, :, :, :]], 5)
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 that minimizes the cost.
with tf.name_scope("optimizer"):
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
#tf.summary.scalar('Adam', optimizer)
# Initialize all the variables globally
init = tf.global_variables_initializer()
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter("/anaconda3/dnn/con4",
tf.get_default_graph())
# 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):
minibatch_cost = 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(X_train, Y_train, minibatch_size,
seed)
iiiii = 0
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).
iiiii += 1
if iiiii == 10:
run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
opti, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y}, \
options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, str(epoch))
elif iiiii == 20:
summary, _ = sess.run([merged, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
writer.add_summary(summary, epoch)
else:
opti, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
#tf.summary.scalar('opti', opti)
tf.summary.scalar('temp_cost', temp_cost)
minibatch_cost += temp_cost / num_minibatches
# Print the cost every epoch
if print_cost == True: #and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True: #and epoch % 1 == 0:
costs.append(minibatch_cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
#plt.title("Learning rate = 0.003" )
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# Calculate the correct predictions
predict_op = tf.argmax(Z3, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
#print("Train Accuracy: 0.99647886")
#print("Test Accuracy: 0.99")
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
#writer = tf.summary.FileWriter("/anaconda3/dnn/con1", tf.get_default_graph())
writer.close()
return train_accuracy, test_accuracy, parameters
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.004,
num_epochs=100,
minibatch_size=64,
print_cost=True):
"""
Implements a three-layer ConvNet in Tensorflow:
CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
Arguments:
X_train -- training set, of shape (None, 64, 64, 3)
Y_train -- test set, of shape (None, n_y = 6)
X_test -- training set, of shape (None, 64, 64, 3)
Y_test -- test set, of shape (None, n_y = 6)
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:
train_accuracy -- real number, accuracy on the train set (X_train)
test_accuracy -- real number, testing accuracy on the test set (X_test)
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 results consistent (tensorflow seed)
seed = 3 # to keep results consistent (numpy seed)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = [] # To keep track of the cost
# Create Placeholders of the correct shape
### START CODE HERE ### (1 line)
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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 that minimizes the cost.
### START CODE HERE ### (1 line)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
### END CODE HERE ###
# Initialize all the variables globally
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):
minibatch_cost = 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(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)
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
### END CODE HERE ###
minibatch_cost += temp_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True and epoch % 1 == 0:
costs.append(minibatch_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()
# plt.savefig('./totalTuple.png', bbox_inches='tight')
# Calculate the correct predictions
predict_op = tf.argmax(Z3, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
return train_accuracy, test_accuracy, parameters
def model(X_train,
Y_train,
X_test,
Y_test,
learning_rate=0.003,
num_epochs=50,
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 results consistent (tensorflow seed)
seed = 3 # to keep results consistent (numpy seed)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = Y_train.shape[1]
costs = [] # To keep track of the cost
# Create Placeholders of the correct shape
X, Y = create_placeholders(n_H0, n_W0, n_C0, 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 that minimizes the cost.
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# Initialize all the variables globally
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):
minibatch_cost = 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(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).
_, temp_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
minibatch_cost += temp_cost / num_minibatches
# Print the cost every epoch
if print_cost == True: #and epoch % 5 == 0:
print("Cost after epoch %i: %f" % (epoch, minibatch_cost))
if print_cost == True: #and epoch % 1 == 0:
costs.append(minibatch_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()
# Calculate the correct predictions
predict_op = tf.argmax(Z3, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
return train_accuracy, test_accuracy, parameters
def model(x_train,
y_train,
x_test,
y_test,
learning_rate=0.009,
num_epochs=10,
minibatch_size=128,
print_cost=True):
ops.reset_default_graph(
) # to be able to rerun the model without overwriting tf variables
tf.set_random_seed(1)
seed = 3
costs = list()
X_train, y_train, X_test, y_test = prepare_data(x_train, y_train, x_test,
y_test)
(m, n_H0, n_W0, n_C0) = X_train.shape
n_y = y_train.shape[1]
X, Y = create_placeholder(n_h=n_H0, n_w=n_W0, n_c=n_C0, n_y=n_y)
parameters = initialize_parameters()
ZL = forward_prop(X=X, parameters=parameters)
cost = compute_loss(ZL, Y=Y)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# Initialize all the variables globally
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.
num_minibatches = m // minibatch_size # nb of full minibatches
seed = seed + 1
for mini_batch_X, mini_batch_Y in random_mini_batches(
X_train, y_train, minibatch_size, seed):
_, minibatch_cost = sess.run([optimizer, cost], {
X: mini_batch_X,
Y: mini_batch_Y
})
epoch_cost += minibatch_cost / num_minibatches
# Print the cost every epoch
if print_cost == True and epoch % 2 == 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.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
# Calculate the correct predictions
predict_op = tf.argmax(ZL, 1)
correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
# Calculate accuracy on the test set
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print(accuracy)
train_accuracy = accuracy.eval({X: X_train, Y: y_train})
test_accuracy = accuracy.eval({X: X_test, Y: y_test})
print("Train Accuracy:", train_accuracy)
print("Test Accuracy:", test_accuracy)
return train_accuracy, test_accuracy, parameters
