def model(data,
ix_to_char,
char_to_ix,
num_iterations=200000,
n_a=50,
dino_names=7,
vocab_size=27):
"""
Trains the model and generates dinosaur names.
Arguments:
data -- text corpus
ix_to_char -- dictionary that maps the index to a character
char_to_ix -- dictionary that maps a character to an index
num_iterations -- number of iterations to train the model for
n_a -- number of units of the RNN cell
dino_names -- number of dinosaur names you want to sample at each iteration.
vocab_size -- number of unique characters found in the text, size of the vocabulary
Returns:
parameters -- learned parameters
"""
n_x, n_y = vocab_size, vocab_size
parameters = initialize_parameters(n_a, n_x, n_y)
loss = get_initial_loss(vocab_size, dino_names)
with open("Name.txt") as f:
examples = f.readlines()
examples = [x.lower().strip() for x in examples]
np.random.seed(0)
np.random.shuffle(examples)
a_prev = np.zeros((n_a, 1))
for j in range(num_iterations):
index = j % len(examples)
X = [None] + [char_to_ix[ch] for ch in examples[index]]
Y = X[1:] + [char_to_ix["\n"]]
curr_loss, gradients, a_prev = optimize(X, Y, a_prev, parameters, 0.01)
loss = smooth(loss, curr_loss)
if j % 2000 == 0:
print('Iteration: %d, Loss: %f' % (j, loss) + '\n')
seed = 0
for name in range(dino_names):
sampled_indices = sample(parameters, char_to_ix, seed)
print_sample(sampled_indices, ix_to_char)
seed += 1
print('\n')
return parameters
def model(X_train, Y_train, user, userName, layers_dim, C = 4, lr = 0.1):
L = len(layers_dim)
parameters = []
flag = False
with open("all_users.csv", "r+") as f:
for l in f:
l = np.array(l, dtype=np.int)
print(l)
if user in l:
prevLayer = pck.load(open("prevlayer.p", "rb"))
parameters = pck.load(open("users/" + userName + "_profile.p", "rb"))
if int(prevLayer) < C:
parameters = add_parameters(np.abs(C - prevLayer), parameters, layers_dim)
elif int(prevLayer) > C:
parameters = subtract_parameters(np.abs(C - prevLayer), parameters, layers_dim)
flag = True
break
if not flag:
parameters = initialize_parameters(L, layers_dim)
f.write(str(user) + "\n")
# global_cost = {}
# for id in all_user:
# global_cost[str(id)] = []
# Stochastic gradient descent
X = X_train.reshape((2,1))
Y_oh = convert_to_oh(Y_train, C).reshape((C, 1))
caches, AL = forward_probagation(X, layers_dim, parameters)
cost = cost_func(Y_oh, AL)
grads = backward_probagation(Y_oh, caches, layers_dim)
parameters = update_parameters(parameters, grads, layers_dim, lr)
pck.dump(parameters, open("users/" + userName + "_profile.p", "wb"))
pck.dump(C, open("prevLayer.p", "wb"))
# global_cost[str(userID)].append(cost)
# for id in all_user:
# plt.plot(global_cost[str(id)])
# plt.show()
return parameters
def model(data,
ix_to_char,
char_to_ix,
num_iterations=10001,
n_a=50,
dino_names=7,
vocab_size=27):
"""
Trains the model and generates dinosaur names.
Arguments:
data -- text corpus
ix_to_char -- dictionary that maps the index to a character
char_to_ix -- dictionary that maps a character to an index
num_iterations -- number of iterations to train the model for
n_a -- number of units of the RNN cell
dino_names -- number of dinosaur names you want to sample at each iteration.
vocab_size -- number of unique characters found in the text, size of the vocabulary
Returns:
parameters -- learned parameters
"""
# Retrieve n_x and n_y from vocab_size
n_x, n_y = vocab_size, vocab_size
# Initialize parameters
parameters = initialize_parameters(n_a, n_x, n_y)
# Initialize loss (this is required because we want to smooth our loss, don't worry about it)
loss = get_initial_loss(vocab_size, dino_names)
# Build list of all dinosaur names (training examples).
with open("dinos.txt") as f:
examples = f.readlines()
examples = [x.lower().strip() for x in examples]
# Shuffle list of all dinosaur names
np.random.seed(0)
np.random.shuffle(examples)
# Initialize the hidden state of your LSTM
a_prev = np.zeros((n_a, 1))
# Optimization loop
for j in range(num_iterations):
### START CODE HERE ###
# Use the hint above to define one training example (X,Y) (≈ 2 lines)
index = j % len(examples)
X = [None] + [char_to_ix[ch] for ch in examples[index]]
Y = X[1:] + [char_to_ix["\n"]]
# Perform one optimization step: Forward-prop -> Backward-prop -> Clip -> Update parameters
# Choose a learning rate of 0.01
curr_loss, gradients, a_prev = optimize(X,
Y,
a_prev,
parameters,
learning_rate=0.01)
### END CODE HERE ###
# Use a latency trick to keep the loss smooth. It happens here to accelerate the training.
loss = smooth(loss, curr_loss)
# Every 2000 Iteration, generate "n" characters thanks to sample() to check if the model is learning properly
if j % 2000 == 0:
print('Iteration: %d, Loss: %f' % (j, loss) + '\n')
# The number of dinosaur names to print
seed = 0
for name in range(dino_names):
# Sample indices and print them
sampled_indices = sample(parameters, char_to_ix, seed)
print_sample(sampled_indices, ix_to_char)
seed += 1 # To get the same result for grading purposed, increment the seed by one.
print('\n')
return parameters
def model(X, Y, learning_rate=0.3, num_iterations=30000, lambd=0, keep_prob=1):
"""
使用三层网络，激活函数为：LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.
第一个隐层：20个神经元
第二个隐层：3个神经元
输出层：1个神经元
"""
grads = {}
costs = []
m = X.shape[1]
layers_dims = [X.shape[0], 20, 3, 1]
# 初始化网络参数
parameters = initialize_parameters(layers_dims)
# 梯度下降循环逻辑
for i in range(0, num_iterations):
# 前向传播计算
# LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
# 如果keep_prob=1，进行正常前向传播
# 如果keep_prob<1，说明需要进行droupout计算
if keep_prob == 1:
a3, cache = forward_propagation(X, parameters)
elif keep_prob < 1:
a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)
# 计算损失
# 如果传入lambd不为0，判断加入正则化
if lambd == 0:
cost = compute_cost(a3, Y)
else:
cost = compute_cost_with_regularization(a3, Y, parameters, lambd)
# 只允许选择一个，要么L2正则化，要么Droupout
assert (lambd == 0 or keep_prob == 1)
if lambd == 0 and keep_prob == 1:
grads = backward_propagation(X, Y, cache)
elif lambd != 0:
grads = backward_propagation_with_regularization(X, Y, cache, lambd)
elif keep_prob < 1:
grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)
# 更新参数
parameters = update_parameters(parameters, grads, learning_rate)
# 每10000词打印损失结果
if i % 10000 == 0:
print("迭代次数为 {}: 损失结果大小：{}".format(i, cost))
costs.append(cost)
# 画出损失变化结果图
plt.plot(costs)
plt.ylabel('损失')
plt.xlabel('迭代次数')
plt.title("损失变化图，学习率为" + str(learning_rate))
plt.show()
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 = 784, number of training examples = 27455)
Y_train -- training set, of shape (output size = 24, number of training examples = 27455)
X_test -- test set, of shape (input size = 784, number of training examples = 7172)
Y_test -- test set, of shape (output size = 24, number of test examples = 7172)
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)
# 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
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 / minibatch_size
# 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 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(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, num_epochs, minibatch_size, print_cost = True):
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
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
print(cost)
# 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()
# check=sess.run(tf.test.compute_gradient_error(X_train, X_train.shape, Y_train, Y_train.shape))
# print(check)
# 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("X_test -------", X_test.shape)
print ("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
def model(X, Y, optimizer, learning_rate=0.0007, mini_batch_size=64, beta=0.9,
beta1=0.9, beta2=0.999, epsilon=1e-8, num_epochs=10000, print_cost=True):
"""
模型逻辑
定义一个三层网络（不包括输入层）
第一个隐层：5个神经元
第二个隐层：2个神经元
输出层：1个神经元
"""
# 计算网络的层数
layers_dims = [train_X.shape[0], 5, 2, 1]
L = len(layers_dims)
costs = []
t = 0
seed = 10
# 初始化网络结构
parameters = initialize_parameters(layers_dims)
# 初始化优化器参数
if optimizer == "momentum":
v = initialize_momentum(parameters)
elif optimizer == "adam":
v, s = initialize_adam(parameters)
# 优化逻辑
for i in range(num_epochs):
# 每次迭代所有样本顺序打乱不一样
seed = seed + 1
# 获取每批次数据
minibatches = random_mini_batches(X, Y, mini_batch_size, seed)
# 开始
for minibatch in minibatches:
# Mini-batch每批次的数据
(minibatch_X, minibatch_Y) = minibatch
# 前向传播minibatch_X, parameters，返回a3, caches
a3, caches = forward_propagation(minibatch_X, parameters)
# 计算损失，a3, minibatch_Y，返回cost
cost = compute_cost(a3, minibatch_Y)
# 反向传播，返回梯度
gradients = backward_propagation(minibatch_X, minibatch_Y, caches)
# 更新参数
if optimizer == "momentum":
parameters, v = update_parameters_with_momentum(parameters, gradients, v, beta, learning_rate)
elif optimizer == "adam":
t = t + 1
parameters, v, s = update_parameters_with_adam(parameters, gradients, v, s,
t, learning_rate, beta1, beta2, epsilon)
# 结束
# 每个1000批次打印损失
if print_cost and i % 1000 == 0:
print("第 %i 次迭代的损失值: %f" % (i, cost))
if print_cost and i % 100 == 0:
costs.append(cost)
# 画出损失的变化
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('epochs (per 100)')
plt.title("损失图")
plt.show()
return parameters
def model(self,
path_train_dataset,
path_test_dataset,
X_train_column,
Y_train_column,
X_test_column,
Y_test_column,
classes_list,
optimizer_algo='adam',
print_cost=True):
# load the datasets
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset(
path_train_dataset, path_test_dataset, X_train_column,
Y_train_column, X_test_column, Y_test_column, classes_list)
# pre-processing
X_train, Y_train, X_test, Y_test = flatten(X_train_orig, Y_train_orig,
X_test_orig, Y_test_orig,
classes)
# to be able to rerun the model without overwriting tf variables
ops.reset_default_graph()
# (n_x: input size, m : number of examples in the train set)
(n_x, m) = X_train.shape
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(self.layers_list, seed=1)
# Forward propagation: Build for-propagation in the tensorflow graph
Z_final_layer = forward_propagation(X, parameters)
# Cost function: Add cost function to tensorflow graph
cost = compute_cost(Z_final_layer, Y)
# Backpropagation: Define the tensorflow optimizer. Use AdamOptimizer
if optimizer_algo == 'gradient_descent':
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=self.learning_rate).minimize(cost)
elif optimizer_algo == 'momentum':
optimizer = tf.train.MomentumOptimizer(
learning_rate=self.learning_rate).minimize(cost)
elif optimizer_algo == 'adam':
optimizer = tf.train.AdamOptimizer(
learning_rate=self.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(self.n_epochs):
epoch_cost = 0. # Defines a cost related to an epoch
# number of minibatches of size minibatch_size in the train set
num_minibatches = int(m / minibatch_size)
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train,
self.minibatch_size, seed)
for minibatch in minibatches:
# Select a minibatch
(minibatch_X, minibatch_Y) = minibatch
_, minibatch_cost = sess.run([optimizer, cost],
feed_dict={
X: minibatch_X,
Y: minibatch_Y
})
epoch_cost += minibatch_cost / minibatch_size
# 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)
# lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# stores quantities useful for later
quantities = {
"X": X,
"Y": Y,
"Z_final_layer": Z_final_layer,
"X_train": X_train,
"Y_train": Y_train,
"X_test": X_test,
"Y_test": Y_test
}
return quantities, costs, parameters