def cost(self, theta_params, *args):
X, y, layer_size = args
theta_list = self.reshapeList(theta_params, layer_size)
A, Z = self.feedForward(theta_list, X)
h = A[0]
regular = 0
if self.lamda:
for tmp_theta in theta_list:
regular += tmp_theta.sum()
m, n = X.shape
y = y.transpose()
J = -1.0 / m * ((y * log(h)).sum() + (
(1 - y) * log(1 - h)).sum()) + self.lamda / (2.0 * m) * regular
self.trainingRecord.append(J)
self.hasIterTimes += 1
funcUtil.recordStatus(
self.id, 'Iteration %d|%d Cost: %f' %
(self.hasIterTimes, self.iterTimes, J))
return J
def globalGradient(self, X, y, iter_times):
learning_rate = NN.getLearningRate() # 生成学习率
last_rate = [learning_rate[0], 0] # 记录 最近一次迭代的学习率 和 已经使用该学习率的次数
J = 1000000000
cost_record = []
for i in range(iter_times):
tmp_J, grad = self.costFunc(self.theta.getTheta(), X, y)
cost_record.append(tmp_J)
J = min(J, tmp_J) # 为了保证以下进行的权值更新，更新后的网络的 cost 必须比原来的 cost 小
for k, lr in enumerate(learning_rate):
tmp_theta_list = self.theta.minusGrad(
grad, lr) # 以当前的学习率进行更新，测试该更新是否让 cost 变小
tmp_J, tmp_grad = self.costFunc(tmp_theta_list, X, y)
if tmp_J < J:
self.theta.setTheta(tmp_theta_list) # 若 cost 变少了，则更新 theta
if lr == last_rate[0]:
last_rate[1] += 1
if last_rate[1] >= 4:
if learning_rate[
0] > lr: # 若当前近几次的学习率，都比 learning_rate 靠前的学习率小，则将比 当前学习率大的数值从 learning_rate 中删除
l = learning_rate.index(lr)
learning_rate = learning_rate[l:]
last_rate[1] = 0
elif last_rate[1] >= 10: # 随机添加更大的学习率，以得到更高的学习效率
learning_rate.insert(
0,
random.random() * 0.0001 + lr)
learning_rate.insert(
0,
random.random() * 0.001 + lr)
learning_rate.insert(
0,
random.random() * 0.01 + lr)
learning_rate.insert(
0,
random.random() * 0.1 + lr)
else:
last_rate[0] = lr
last_rate[1] = 1
break
print 'Iteration %d|%d Cost: %f learning_rate: %f' % (
i, iter_times, J, last_rate[0])
funcUtil.recordStatus(
self.id, 'Iteration %d|%d Cost: %f learning_rate: %f' %
(i, iter_times, J, last_rate[0]))
print '\n'
return cost_record
if __name__ == '__main__':
print 'start main process ...\n'
s_time = time.time()
unique_id = sys.argv[1]
symbol = sys.argv[2]
# unique_id = 'test'
# symbol = 'sz002316'
# save_module = 'save4'
save_module = 'save'
funcUtil.killRunningProcess(unique_id)
funcUtil.recordPid(unique_id)
funcUtil.recordStatus(unique_id, 'Start ...')
training_start_date = '2008-01-01'
training_end_date = '2015-12-31'
test_start_date = '2016-01-01'
test_end_date = time.strftime('%Y-%m-%d', time.localtime())
# test_end_date = '2016-05-16'
input_node_num = 600
output_node_num = 100
cur_path = os.path.abspath(os.path.split(__file__)[0])
save_dir = os.path.join(cur_path, r'data')
X_training_file_path = os.path.join(
def randomGradient(self, X, y, iter_times, batch_base, batch_min):
learning_rate = NN.getLearningRate()
last_rate = [learning_rate[0], 0]
J = 1000000000
J_mean = 1000000000
min_theta_list = []
m = X.shape[0]
cost_record = []
for i in range(iter_times):
batch_size = int(random.random() * batch_base +
batch_min) # 随机生成 batch_size 和 batch_num
batch_num = int(m / batch_size)
if m % batch_size != 0:
batch_num += 1
randice = funcUtil.getShuffleList(m)
J_mean_list = []
for b in range(batch_num): # 根据 batch_size 随机去 batch_X 和 batch_y
if b < batch_num - 1:
batch_X = funcUtil.getListFromList(
X, randice[b * batch_size + 1:(b + 1) * batch_size])
batch_y = funcUtil.getListFromList(
y, randice[b * batch_size + 1:(b + 1) * batch_size])
else:
if not randice[b * batch_size + 1:]:
continue
batch_X = funcUtil.getListFromList(
X, randice[b * batch_size + 1:])
batch_y = funcUtil.getListFromList(
y, randice[b * batch_size + 1:])
batch_X = array(batch_X)
batch_y = array(batch_y)
tmp_J, grad = self.costFunc(self.theta.getTheta(), batch_X,
batch_y)
cost_record.append(tmp_J)
J_mean_list.append(tmp_J)
# J = min(J, tmp_J)
J = tmp_J
for k, lr in enumerate(learning_rate):
tmp_theta_list = self.theta.minusGrad(grad, lr)
tmp_J, tmp_grad = self.costFunc(tmp_theta_list, batch_X,
batch_y)
if tmp_J < J:
self.theta.setTheta(tmp_theta_list)
if lr == last_rate[0]:
last_rate[1] += 1
if last_rate[1] >= 4:
if learning_rate[0] > lr:
l = learning_rate.index(lr)
learning_rate = learning_rate[l:]
last_rate[1] = 0
elif last_rate[1] >= 10:
learning_rate.insert(
0,
random.random() * 0.0001 + lr)
learning_rate.insert(
0,
random.random() * 0.001 + lr)
learning_rate.insert(
0,
random.random() * 0.01 + lr)
learning_rate.insert(
0,
random.random() * 0.1 + lr)
else:
last_rate[0] = lr
last_rate[1] = 1
break
funcUtil.recordStatus(
self.id,
'Iteration %d|%d Batch_times: %d | %d Cost: %f learning_rate: %f'
% (i, iter_times, b, batch_num, J, last_rate[0]))
print 'Iteration %d|%d Batch_times: %d | %d Cost: %f learning_rate: %f' % (
i, iter_times, b, batch_num, J, last_rate[0])
J_mean_tmp = array(J_mean_list)
J_mean_tmp = J_mean_tmp.mean()
if J_mean_tmp < J_mean:
J_mean = J_mean_tmp
min_theta_list = self.theta.getTheta()
print 'Iteration %d|%d Cost: %f learning_rate: %f' % (
i, iter_times, J, last_rate[0])
self.theta.setTheta(min_theta_list)
return cost_record