def plot_on_graph (self):
lineList = []
lineList = self.ax.get_lines()
i = 0
for dataSet in self.data:
plt.pause(self.pause)
lineList[i].set_xdata(self.axis)
lineList[i].set_ydata(self.data[i])
plt.xticks(self.axis)
i += 1
newscale = self.ax.get_lines()
self.scaleList = []
i = 0
for line in newscale:
vis = newscale[i].get_visible()
if vis:
current = newscale[i].get_data()
self.scaleList.extend(current[1])
i += 1
low = min(set(self.scaleList)) - (abs(min(set(self.scaleList))) * 0.15)
high = max(set(self.scaleList)) + (abs(max(set(self.scaleList))) * 0.15)
self.ax.set_ylim(low, high)
plt.draw()
self.lines = lineList
self.lined = dict()
for legline, origline in zip(self.leg.get_lines(), self.lines):
legline.set_picker(5) # 5 pts tolerance
self.lined[legline] = origline
def __init__(self,
ref_params,
save_state_freq=500,
overwrite_state=True,
plot=False):
"""
:param ref_params: instance of refinement Parameters (LMP in code below)
:param save_state_freq: how often to save all models (will be overwritten each time)
"""
num_params = len(ref_params)
self.vary = np.zeros(num_params).astype(bool)
for p in ref_params.values():
self.vary[p.xpos] = not p.fix
self.x0 = np.ones(num_params)
self.g = None
self.ref_params = ref_params
self.iternum = 0
self.all_times = []
self.save_state_freq = save_state_freq
self.overwrite_state = overwrite_state
self.med_offsets = [
] # median prediction offsets(new number gets added everytime write_output_files is called)
self.med_iternums = []
self.plot = plot and COMM.rank == 0
if self.plot:
self.fig = plt.figure()
self.ax = plt.gca()
plt.draw()
plt.pause(0.1)
def do_plot():
if solver.iter % display == 0:
loss[solver.iter] = solver.net.blobs['loss3/loss3'].data.copy()
loss_disp = 'loss=' + str(loss[solver.iter])
print '%3d) %s' % (solver.iter, loss_disp)
train_loss[solver.iter / display] = loss[solver.iter]
ax1.plot(it_axes[0:solver.iter / display],
train_loss[0:solver.iter / display], 'r')
# if it > test_interval:
# ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g') #Val always on top
ax1.set_ylim([5, 7])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# VALIDATE Validation done this way only uses 1 GPU
if solver.iter % test_interval == 0 and solver.iter > 0:
loss_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val += solver.test_nets[0].blobs['loss3/loss3'].data
loss_val /= test_iters
print("Val loss: {:.3f}".format(loss_val))
val_loss[solver.iter / test_interval - 1] = loss_val
ax1.plot(it_val_axes[0:solver.iter / test_interval],
val_loss[0:solver.iter / test_interval], 'g')
ax1.set_ylim([5, 7])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../datasets/SocialMedia/models/training/' + training_id + str(
solver.iter) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
def draw(weightvect):
""" function that draw the graph so the line that separate the points from the special point
"""
axeofx = [-1, 2]
axeofy = calculate(axeofx, weightvect)
plt.xlim(-1, 2)
plt.ylim(-1, 2)
plt.plot(axeofx, axeofy, color="black")
pointx = [0, 0, 1]
pointy = [0, 1, 0]
plt.scatter(pointx, pointy, color="blue")
plt.scatter(1, 1, color="red")
plt.ylabel("x2")
plt.xlabel("x1")
title1 = "Weight Vector : " + str(weightvect)
plt.title(title1, backgroundcolor ="green",color="black")
plt.pause(0.2)
plt.cla()
return 0
def __call__(self, x, *args, **kwargs):
self.iternum += 1
t = time.time()
self.x0[self.vary] = x
#time_per_iter = (time.time()-self.tstart) / self.iternum
f, self.g, self.sigmaZ = target_and_grad(self.x0, self.ref_params,
*args, **kwargs)
t = time.time() - t
if COMM.rank == 0:
self.all_times.append(t)
time_per_iter = np.mean(self.all_times)
pred_offset_str = ", ".join(
map(lambda x: "%.4f" % x, self.med_offsets))
print(
"Iteration %d:\n\tResid=%f, sigmaZ %f, t-per-iter=%.4f sec, pred_offsets=%s"
%
(self.iternum, f, self.sigmaZ, time_per_iter, pred_offset_str),
flush=True)
if self.iternum % self.save_state_freq == 0 and self.iternum > 0:
if not self.overwrite_state:
params = args[-1] # phil params
temp_pandas_dir = params.geometry.pandas_dir
params.geometry.pandas_dir = params.geometry.pandas_dir + "-iter%d" % self.iternum
med_offset = write_output_files(self.x0, self.ref_params, *args,
**kwargs)
self.med_offsets.append(med_offset)
self.med_iternums.append(self.iternum)
if self.plot:
self.ax.clear()
self.ax.plot(self.med_iternums, self.med_offsets)
self.ax.set_ylabel("median |xobs-xcal| (pixels)")
self.ax.set_xlabel("iteration #")
plt.draw()
plt.pause(0.01)
if not self.overwrite_state:
params.geometry.pandas_dir = temp_pandas_dir
return f
def do_solve(niter, solvers, disp_interval, test_interval, test_iters):
"""Run solvers for niter iterations,
returning the loss and recorded each iteration.
`solvers` is a list of (name, solver) tuples."""
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import time
# SET PLOTS DATA
train_loss = zeros(niter / disp_interval)
val_loss = zeros(niter / test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
# ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss (r), val loss (g)')
# ax2.set_ylabel('val loss (g)')
# ax2.set_autoscaley_on(False)
# ax2.set_ylim([0, 1])
loss = {name: np.zeros(niter) for name, _ in solvers}
#RUN TRAINING
for it in range(niter):
for name, s in solvers:
# start = time.time()
s.step(1) # run a single SGD step in Caffe
# end = time.time()
# print "Time step: " + str((end - start))
loss[name][it] = s.net.blobs['loss3/loss3'].data.copy()
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
loss_disp = 'loss=' + str(loss['my_solver'][it])
print '%3d) %s' % (it, loss_disp)
train_loss[it / disp_interval] = loss['my_solver'][it]
ax1.plot(it_axes[0:it / disp_interval],
train_loss[0:it / disp_interval], 'r')
ax1.set_ylim([4, 7])
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# title = '../training/numbers/training-' + str(it) + '.png' # Save graph to disk
# savefig(title, bbox_inches='tight')
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val = 0
for i in range(test_iters):
solvers[0][1].test_nets[0].forward()
loss_val += solvers[0][1].test_nets[0].blobs[
'loss3/loss3'].data
loss_val /= test_iters
print("Val loss: {:.3f}".format(loss_val))
val_loss[it / test_interval - 1] = loss_val
ax1.plot(it_val_axes[0:it / test_interval],
val_loss[0:it / test_interval], 'g')
ax1.set_ylim([4, 7])
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../datasets/recipes5k/models/training/training-ingredients_Inception_frozen_500_raw' + str(
it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
#Save the learned weights from both nets at the end of the training
weight_dir = tempfile.mkdtemp()
weights = {}
for name, s in solvers:
filename = 'weights.%s.caffemodel' % name
weights[name] = os.path.join(weight_dir, filename)
s.net.save(weights[name])
return loss, weights
def do_solve(maxIter, solver, display, test_interval, test_iters):
# SET PLOTS DATA
train_loss_C = zeros(maxIter/display)
train_top1 = zeros(maxIter/display)
train_top5 = zeros(maxIter/display)
val_loss_C = zeros(maxIter/test_interval)
val_top1 = zeros(maxIter/test_interval)
val_top5 = zeros(maxIter/test_interval)
it_axes = (arange(maxIter) * display) + display
it_val_axes = (arange(maxIter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss C (r), val loss C (y)')
ax2.set_ylabel('train TOP1 (b), val TOP1 (g), train TOP-5 (c), val TOP-5 (k)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, 1])
lossC = np.zeros(maxIter)
acc1 = np.zeros(maxIter)
acc5 = np.zeros(maxIter)
#RUN TRAINING
for it in range(niter):
#st = time.time()
solver.step(1) # run a single SGD step in Caffepy()
#en = time.time()
#print "Time step: " + str((en-st))
#PLOT
if it % display == 0 or it + 1 == niter:
lossC[it] = solver.net.blobs['loss3/loss3'].data.copy()
acc1[it] = solver.net.blobs['loss3/top-1'].data.copy()
acc5[it] = solver.net.blobs['loss3/top-5'].data.copy()
loss_disp = 'loss3C= ' + str(lossC[it]) + ' top-1= ' + str(acc1[it])
print '%3d) %s' % (it, loss_disp)
train_loss_C[it / display] = lossC[it]
train_top1[it / display] = acc1[it]
train_top5[it / display] = acc5[it]
ax1.plot(it_axes[0:it / display], train_loss_C[0:it / display], 'r')
ax2.plot(it_axes[0:it / display], train_top1[0:it / display], 'b')
ax2.plot(it_axes[0:it / display], train_top5[0:it / display], 'c')
#ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val_C = 0
top1_val = 0
top5_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val_C += solver.test_nets[0].blobs['loss3/loss3'].data
top1_val += solver.test_nets[0].blobs['loss3/top-1'].data
top5_val += solver.test_nets[0].blobs['loss3/top-5'].data
loss_val_C /= test_iters
top1_val /= test_iters
top5_val /= test_iters
print("Val loss C: {:.3f}".format(loss_val_C))
val_loss_C[it / test_interval - 1] = loss_val_C
val_top1[it / test_interval - 1] = top1_val
val_top5[it / test_interval - 1] = top5_val
ax1.plot(it_val_axes[0:it / test_interval], val_loss_C[0:it/ test_interval], 'y')
ax2.plot(it_val_axes[0:it / test_interval], val_top1[0:it / test_interval], 'g')
ax2.plot(it_val_axes[0:it / test_interval], val_top5[0:it / test_interval], 'k')
#ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../datasets/WebVision/models/training/' + training_id + str(it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
return
def do_plot():
if solver.iter % display == 0:
lossC[solver.iter] = solver.net.blobs['loss3/loss3'].data.copy()
lossR[solver.iter] = solver.net.blobs['loss3/loss3/R'].data.copy()
acc1[solver.iter] = solver.net.blobs['loss3/top-1'].data.copy()
acc5[solver.iter] = solver.net.blobs['loss2/top-5'].data.copy()
loss_disp = 'loss3C= ' + str(lossC[solver.iter]) + ' loss3R= ' + str(lossR[solver.iter]) + ' top-1= ' + str(acc1[solver.iter])
print '%3d) %s' % (solver.iter, loss_disp)
train_loss_C[solver.iter / display] = lossC[solver.iter]
train_loss_R[solver.iter / display] = lossR[solver.iter]
train_top1[solver.iter / display] = acc1[solver.iter]
train_top5[solver.iter / display] = acc5[solver.iter]
ax1.plot(it_axes[0:solver.iter / display], train_loss_C[0:solver.iter / display], 'r')
ax1.plot(it_axes[0:solver.iter / display], train_loss_R[0:solver.iter / display], 'm')
ax2.plot(it_axes[0:solver.iter / display], train_top1[0:solver.iter / display], 'b')
ax2.plot(it_axes[0:solver.iter / display], train_top5[0:solver.iter / display], 'c')
ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# VALIDATE Validation done this way only uses 1 GPU
if solver.iter % test_interval == 0 and solver.iter > 0:
loss_val_R = 0
loss_val_C = 0
top1_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val_C += solver.test_nets[0].blobs['loss3/loss3'].data
loss_val_R += solver.test_nets[0].blobs['loss3/loss3/R'].data
top1_val += solver.test_nets[0].blobs['loss3/top-1'].data
loss_val_C /= test_iters
loss_val_R /= test_iters
top1_val /= test_iters
print("Val loss C: {:.3f}".format(loss_val_C))
val_loss_C[solver.iter / test_interval - 1] = loss_val_C
val_loss_R[solver.iter / test_interval - 1] = loss_val_R
val_top1[solver.iter / test_interval - 1] = top1_val
ax1.plot(it_val_axes[0:solver.iter / test_interval], val_loss_C[0:solver.iter / test_interval], 'y')
ax1.plot(it_val_axes[0:solver.iter / test_interval], val_loss_R[0:solver.iter / test_interval], 'k')
ax2.plot(it_val_axes[0:solver.iter / test_interval], val_top1[0:solver.iter / test_interval], 'g')
ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../datasets/WebVision/models/training/' + training_id + str(
solver.iter) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
def do_solve(niter, solvers, disp_interval, test_interval, test_iters):
"""Run solvers for niter iterations,
returning the loss and accuracy recorded each iteration.
`solvers` is a list of (name, solver) tuples."""
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import time
# SET PLOTS DATA
train_loss = zeros(niter/disp_interval)
train_acc = zeros(niter/disp_interval)
val_acc = zeros(niter/test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss (r)')
ax2.set_ylabel('train accuracy (b), val accuracy (g)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, 1])
blobs = ('loss','acc')
loss, acc = ({name: np.zeros(niter) for name, _ in solvers}
for _ in blobs)
#RUN TRAINING
for it in range(niter):
for name, s in solvers:
# print "FC7 data"
# print s.net.blobs['fc7'].data
# print "Classifier weights"
# print s.net.params['classifier'][0].data
# print "Classifier data"
# print s.net.blobs['classifier'].data
# start = time.time()
s.step(1) # run a single SGD step in Caffe
# end = time.time()
# print "Time step: " + str((end - start))
loss[name][it], acc[name][it] = (s.net.blobs[b].data.copy()
for b in blobs)
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
loss_disp = '; '.join('%s: loss=%.3f, acc=%2d%%' %
(n, loss[n][it], np.round(100*acc[n][it]))
for n, _ in solvers)
print '%3d) %s' % (it, loss_disp)
train_loss[it/disp_interval] = loss['my_solver'][it]
train_acc[it/disp_interval] = acc['my_solver'][it]
ax1.plot(it_axes[0:it/disp_interval], train_loss[0:it/disp_interval], 'r')
ax2.plot(it_axes[0:it/disp_interval], train_acc[0:it/disp_interval], 'b')
plt.ion()
plt.show()
plt.pause(0.001)
# title = '../training/numbers/training-' + str(it) + '.png' # Save graph to disk
# savefig(title, bbox_inches='tight')
#VALIDATE
if it % test_interval == 0 and it > 0:
accuracy = 0
for i in range(test_iters):
solvers[0][1].test_nets[0].forward()
accuracy += solvers[0][1].test_nets[0].blobs['acc'].data
accuracy /= test_iters
print("Test Accuracy: {:.3f}".format(accuracy))
val_acc[it/test_interval - 1] = accuracy
ax2.plot(it_val_axes[0:it/test_interval], val_acc[0:it/test_interval], 'g')
plt.ion()
plt.show()
plt.pause(0.001)
title = '../../../datasets/SocialMedia/models/training/training-' + str(it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
#Save the learned weights from both nets at the end of the training
weight_dir = tempfile.mkdtemp()
weights = {}
for name, s in solvers:
filename = 'weights.%s.caffemodel' % name
weights[name] = os.path.join(weight_dir, filename)
s.net.save(weights[name])
return loss, acc, weights
def get_linear_model_histogramDouble(code,
ptype='low',
dtype='d',
start=None,
end=None,
vtype='f',
filter='n',
df=None,
dl=None):
# 399001','cyb':'zs399006','zxb':'zs399005
# code = '999999'
# code = '601608'
# code = '000002'
# asset = get_kdate_data(code)['close'].sort_index(ascending=True)
# df = tdd.get_tdx_Exp_day_to_df(code, 'f').sort_index(ascending=True)
# ptype='close'
# if ptype == 'close' or ptype==''
# ptype=
if start is not None and filter == 'y':
if code not in ['999999', '399006', '399001']:
index_d, dl = tdd.get_duration_Index_date(dt=start)
log.debug("index_d:%s dl:%s" % (str(index_d), dl))
else:
index_d = cct.day8_to_day10(start)
log.debug("index_d:%s" % (index_d))
start = tdd.get_duration_price_date(code, ptype='low', dt=index_d)
log.debug("start:%s" % (start))
if start is None and df is None and dl is not None:
start = cct.last_tddate(dl)
# print start
df = tdd.get_tdx_append_now_df_api(code, start=start,
end=end).sort_index(ascending=True)
if df is None:
# df = tdd.get_tdx_append_now_df(code, ptype, start, end).sort_index(ascending=True)
df = tdd.get_tdx_append_now_df_api(code, start,
end).sort_index(ascending=True)
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df,
dtype).sort_index(ascending=True)
if len(df) == 0:
raise Exception("Code:%s error, df is None" % (code))
asset = df[ptype].round(2)
log.info("df:%s" % asset[:1])
asset = asset.dropna()
dates = asset.index
if not code.startswith('999') and not code.startswith('399'):
# print "code:",code
if code[:1] in ['5', '6', '9']:
code2 = '999999'
elif code[:2] in ['30']:
# print "cyb"
code2 = '399006'
else:
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
# if len(asset) < len(df1):
# asset1 = df1.loc[asset.index, ptype]
# else:
# asset1 = df1.loc[asset.index, ptype]
# startv = asset1[:1]
# asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print asset[:1].index[0] , df1[:1].index[0]
if asset[:1].index[0] > df1[:1].index[0]:
asset1 = df1.loc[asset.index, ptype]
startv = asset1[:1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
if code.startswith('399001'):
code2 = '399006'
elif code.startswith('399006'):
code2 = '399005'
else:
code2 = '399006'
if code2.startswith('3990'):
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
if len(df1) < int(len(df) / 4):
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(
code2, start, end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
if len(asset) < len(df1):
asset1 = df1.loc[asset.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print len(df),len(asset),len(df1),len(asset1)
if end is not None:
# print asset[-1:]
asset = asset[:-1]
dates = asset.index
asset1 = asset1[:-1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# 画出价格随时间变化的图像
# _, ax = plt.subplots()
# fig = plt.figure()
# plt.ion()
fig = plt.figure(figsize=(16, 10))
# fig = plt.figure(figsize=(16, 10), dpi=72)
# fig.autofmt_xdate() #(no fact)
# plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9)
plt.subplots_adjust(left=0.05,
bottom=0.08,
right=0.95,
top=0.95,
wspace=0.15,
hspace=0.25)
# set (gca,'Position',[0,0,512,512])
# fig.set_size_inches(18.5, 10.5)
# fig=plt.fig(figsize=(14,8))
ax1 = fig.add_subplot(321)
# asset=asset.apply(lambda x:round( x/asset[:1],2))
ax1.plot(asset)
# ax1.plot(asset1,'-r', linewidth=2)
ticks = ax1.get_xticks()
# start, end = ax1.get_xlim()
# print start, end, len(asset)
# print ticks, ticks[:-1]
# (ticks[:-1] if len(asset) > end else np.append(ticks[:-1], len(asset) - 1))
ax1.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15) # Label x-axis with dates
# 拟合
X = np.arange(len(asset))
x = sm.add_constant(X)
model = regression.linear_model.OLS(asset, x).fit()
a = model.params[0]
b = model.params[1]
# log.info("a:%s b:%s" % (a, b))
log.info("X:%s a:%s b:%s" % (len(asset), a, b))
Y_hat = X * b + a
# 真实值-拟合值，差值最大最小作为价值波动区间
# 向下平移
i = (asset.values.T - Y_hat).argmin()
c_low = X[i] * b + a - asset.values[i]
Y_hatlow = X * b + a - c_low
# 向上平移
i = (asset.values.T - Y_hat).argmax()
c_high = X[i] * b + a - asset.values[i]
Y_hathigh = X * b + a - c_high
plt.plot(X, Y_hat, 'k', alpha=0.9)
plt.plot(X, Y_hatlow, 'r', alpha=0.9)
plt.plot(X, Y_hathigh, 'r', alpha=0.9)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.title(code + " | " + str(dates[-1])[:11], fontsize=14)
plt.legend([asset.iat[-1]], fontsize=12, loc=4)
plt.grid(True)
# #plot volume
# pad = 0.25
# yl = ax1.get_ylim()
# ax1.set_ylim(yl[0]-(yl[1]-yl[0])*pad,yl[1])
# axx = ax1.twinx()
# axx.set_position(transforms.Bbox([[0.125,0.1],[0.9,0.32]]))
# volume = np.asarray(df.vol)
# pos = df['open']-df['close']<0
# neg = df['open']-df['close']>=0
# idx = np.asarray([x for x in range(len(df))])
# axx.bar(idx[pos],volume[pos],color='red',width=1,align='center')
# axx.bar(idx[neg],volume[neg],color='green',width=1,align='center')
# plt.legend([code]);
# plt.legend([code, 'Value center line', 'Value interval line']);
# fig=plt.fig()
# fig.figsize = [14,8]
scale = 1.1
zp = zoompan.ZoomPan()
figZoom = zp.zoom_factory(ax1, base_scale=scale)
figPan = zp.pan_factory(ax1)
# 将Y-Y_hat股价偏离中枢线的距离单画出一张图显示，对其边界线之间的区域进行均分，大于0的区间为高估，小于0的区间为低估，0为价值中枢线。
ax3 = fig.add_subplot(322)
# distance = (asset.values.T - Y_hat)
distance = (asset.values.T - Y_hat)[0]
# if code.startswith('999') or code.startswith('399'):
if len(asset) > len(df1):
ax3.plot(asset)
plt.plot(distance)
ticks = ax3.get_xticks()
ax3.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y - Y_hat, 'r', alpha=0.9)
c = c + d
ax3.plot(asset)
## plt.xlabel('Date', fontsize=12)
plt.ylabel('Price-center price', fontsize=14)
plt.grid(True)
else:
as3 = asset.apply(lambda x: round(x / asset[:1], 2))
ax3.plot(as3)
ticks = ax3.get_xticks()
ax3.plot(asset1, '-r', linewidth=2)
# show volume bar !!!
# assvol = df.loc[asset.index]['vol']
# assvol = assvol.apply(lambda x: round(x / assvol[:1], 2))
# ax3.plot(assvol, '-g', linewidth=0.5)
ax3.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
plt.grid(True)
zp3 = zoompan.ZoomPan()
figZoom = zp3.zoom_factory(ax3, base_scale=scale)
figPan = zp3.pan_factory(ax3)
# plt.title(code, fontsize=14)
if 'name' in df.columns:
plt.legend([df.name.values[-1:][0], df1.name.values[-1:][0]], loc=0)
else:
if code not in ['999999', '399006', '399001']:
indexIdx = False
else:
indexIdx = True
dm = tdd.get_sina_data_df(code, index=indexIdx)
if 'name' in dm.columns:
cname = dm.name[0]
else:
cname = '-'
# plt.legend([code, code2], loc=0)
plt.legend([cname, code2], loc=0)
ax2 = fig.add_subplot(323)
# ax2.plot(asset)
# ticks = ax2.get_xticks()
ax2.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
# plt.plot(X, Y_hat, 'k', alpha=0.9)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y, 'r', alpha=0.9)
c = c + d
# asset=asset.apply(lambda x:round(x/asset[:1],2))
ax2.plot(asset)
# ax2.plot(asset1,'-r', linewidth=2)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.grid(True)
# plt.title(code, fontsize=14)
# plt.legend([code])
if len(df) > 10:
ax6 = fig.add_subplot(324)
h = df.loc[:, ['open', 'close', 'high', 'low']]
highp = h['high'].values
lowp = h['low'].values
openp = h['open'].values
closep = h['close'].values
# print len(closep)
lr = LinearRegression()
x = np.atleast_2d(np.linspace(0, len(closep), len(closep))).T
lr.fit(x, closep)
LinearRegression(copy_X=True,
fit_intercept=True,
n_jobs=1,
normalize=False)
xt = np.atleast_2d(np.linspace(0,
len(closep) + 200,
len(closep) + 200)).T
yt = lr.predict(xt)
bV = []
bP = []
for i in range(1, len(highp) - 1):
if highp[i] <= highp[i - 1] and highp[i] < highp[
i + 1] and lowp[i] <= lowp[i - 1] and lowp[i] < lowp[i +
1]:
bV.append(lowp[i])
bP.append(i)
else:
bV.append(lowp[i - 1])
bP.append(i - 1)
if len(bV) > 0:
d, p = LIS(bV)
idx = []
for i in range(len(p)):
idx.append(bP[p[i]])
lr = LinearRegression()
X = np.atleast_2d(np.array(idx)).T
Y = np.array(d)
lr.fit(X, Y)
estV = lr.predict(xt)
ax6.plot(closep, linewidth=2)
ax6.plot(idx, d, 'ko')
ax6.plot(xt, estV, '-r', linewidth=3)
ax6.plot(xt, yt, '-g', linewidth=3)
plt.grid(True)
# plt.tight_layout()
zp2 = zoompan.ZoomPan()
figZoom = zp2.zoom_factory(ax6, base_scale=scale)
figPan = zp2.pan_factory(ax6)
# 统计出每个区域内各股价的频数，得到直方图，为了更精细的显示各个区域的频数，这里将整个边界区间分成100份。
ax4 = fig.add_subplot(325)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat),
(asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
# now_distanse=int((asset.iat[-1]-Y_hat[-1])/Y_hat[-1]*100)
# log.debug("dis:%s now:%s"%(distance[:2],now_distanse))
# log.debug("now_distanse:%s"%now_distanse)
distance = (asset.values.T - Y_hat)
now_distanse = asset.iat[-1] - Y_hat[-1]
# distance = (asset.values.T-Y_hat)[0]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel(
'Undervalue ------------------------------------------> Overvalue',
fontsize=12)
plt.ylabel('Frequency', fontsize=14)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1], str(dates[-1])[5:11]], fontsize=12)
plt.grid(True)
# plt.show()
# import os
# print(os.path.abspath(os.path.curdir))
ax5 = fig.add_subplot(326)
# fig.figsize=(5, 10)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat),
(asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
distance = (asset.values.T - Y_hat) / Y_hat * 100
now_distanse = ((asset.iat[-1] - Y_hat[-1]) / Y_hat[-1] * 100)
log.debug("dis:%s now:%s" % (distance[:2], now_distanse))
log.debug("now_distanse:%s" % now_distanse)
# n, bins = np.histogram(distance, 50)
# print n, bins[:2]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel(
'Undervalue ------------------------------------------> Overvalue',
fontsize=14)
plt.ylabel('Frequency', fontsize=12)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1]], fontsize=12)
plt.grid(True)
# plt.ion()
plt.draw()
plt.pause(0.001)
# plt.show(block=False)
# plt.draw()
# plt.pause(0.001)
# plt.close()
# print plt.get_backend()
# plt.show(block=True)
return df
def do_plot():
if solver.iter % display == 0:
lossC[solver.iter] = solver.net.blobs['loss3/loss3'].data.copy()
acc1[solver.iter] = solver.net.blobs['loss3/top-1'].data.copy()
acc5[solver.iter] = solver.net.blobs['loss3/top-5'].data.copy()
loss_disp = 'loss3C= ' + str(lossC[solver.iter]) + ' top-1= ' + str(acc1[solver.iter])
print '%3d) %s' % (solver.iter, loss_disp)
train_loss_C[solver.iter / display] = lossC[solver.iter]
train_top1[solver.iter / display] = acc1[solver.iter]
train_top5[solver.iter / display] = acc5[solver.iter]
ax1.plot(it_axes[0:solver.iter / display], train_loss_C[0:solver.iter / display], 'r')
ax2.plot(it_axes[0:solver.iter / display], train_top1[0:solver.iter / display], 'b')
ax2.plot(it_axes[0:solver.iter / display], train_top5[0:solver.iter / display], 'c')
ax1.set_ylim([0, 25])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# VALIDATE Validation done this way only uses 1 GPU
if solver.iter % test_interval == 0 and solver.iter > 0:
loss_val_C = 0
top1_val = 0
top5_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val_C += solver.test_nets[0].blobs['loss3/loss3'].data
top1_val += solver.test_nets[0].blobs['loss3/top-1'].data
top5_val += solver.test_nets[0].blobs['loss3/top-5'].data
loss_val_C /= test_iters
top1_val /= test_iters
top5_val /= test_iters
print("Val loss: " + str(loss_val_C))
val_loss_C[solver.iter / test_interval - 1] = loss_val_C
val_top1[solver.iter / test_interval - 1] = top1_val
val_top5[solver.iter / test_interval - 1] = top5_val
ax1.plot(it_val_axes[0:solver.iter / test_interval], val_loss_C[0:solver.iter / test_interval], 'y')
ax2.plot(it_val_axes[0:solver.iter / test_interval], val_top1[0:solver.iter / test_interval], 'g')
ax2.plot(it_val_axes[0:solver.iter / test_interval], val_top5[0:solver.iter / test_interval], 'k')
ax1.set_ylim([0, 25])
ax1.set_xlabel('iteration ' + 'Best it: ' + str(best_it[0]) + ' Best Val Loss: ' + str(int(lowest_val_loss[0])))
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../ssd2/iMaterialistFashion/models/training/' + training_id + '_' + str(solver.iter) + '.png'
savefig(title, bbox_inches='tight')
if loss_val_C < lowest_val_loss[0]:
print("Best Val loss!")
lowest_val_loss[0] = loss_val_C
best_it[0] = solver.iter
filename = '../../../ssd2/iMaterialistFashion/models/CNN/' + training_id + 'best_valLoss_' + str(
int(lowest_val_loss[0])) + '_it_' + str(best_it[0]) + '.caffemodel'
prefix = 30
for cur_filename in glob.glob(filename[:-prefix] + '*'):
print(cur_filename)
os.remove(cur_filename)
solver.net.save(filename)
def do_solve(maxIter, solver, display, test_interval, test_iters):
# SET PLOTS DATA
train_loss_C = zeros(maxIter / display)
train_loss_R = zeros(maxIter / display)
train_top1 = zeros(maxIter / display)
train_top5 = zeros(maxIter / display)
val_loss_C = zeros(maxIter / test_interval)
val_loss_R = zeros(maxIter / test_interval)
val_top1 = zeros(maxIter / test_interval)
it_axes = (arange(maxIter) * display) + display
it_val_axes = (arange(maxIter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel(
'train loss C (r), val loss C (y), train loss R (m), val loss R (k)')
ax2.set_ylabel('train TOP1 (b), val TOP1 (g), train TOP-5 (2) (c)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, 1])
lossC = np.zeros(maxIter)
lossR = np.zeros(maxIter)
acc1 = np.zeros(maxIter)
#RUN TRAINING
for it in range(niter):
#st = time.time()
solver.step(1) # run a single SGD step in Caffepy()
#en = time.time()
#print "Time step: " + str((en-st))
#PLOT
if it % display == 0 or it + 1 == niter:
lossC[solver.iter] = solver.net.blobs['loss3/loss3'].data.copy()
lossR[solver.iter] = solver.net.blobs['loss3/loss3/R'].data.copy()
acc1[solver.iter] = solver.net.blobs['loss3/top-1'].data.copy()
#acc5[solver.iter] = solver.net.blobs['loss2/top-5'].data.copy()
loss_disp = 'loss3C= ' + str(
lossC[solver.iter]) + ' loss3R= ' + str(
lossR[solver.iter]) + ' top-1= ' + str(acc1[solver.iter])
print '%3d) %s' % (solver.iter, loss_disp)
train_loss_C[solver.iter / display] = lossC[solver.iter]
train_loss_R[solver.iter / display] = lossR[solver.iter]
train_top1[solver.iter / display] = acc1[solver.iter]
#train_top5[solver.iter / display] = acc5[solver.iter]
ax1.plot(it_axes[0:solver.iter / display],
train_loss_C[0:solver.iter / display], 'r')
ax1.plot(it_axes[0:solver.iter / display],
train_loss_R[0:solver.iter / display], 'm')
ax2.plot(it_axes[0:solver.iter / display],
train_top1[0:solver.iter / display], 'b')
# ax2.plot(it_axes[0:solver.iter / display], train_top5[0:solver.iter / display], 'c')
ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val_R = 0
loss_val_C = 0
top1_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val_C += solver.test_nets[0].blobs['loss3/loss3'].data
loss_val_R += solver.test_nets[0].blobs['loss3/loss3/R'].data
top1_val += solver.test_nets[0].blobs['loss3/top-1'].data
loss_val_C /= test_iters
loss_val_R /= test_iters
top1_val /= test_iters
print("Val loss C: {:.3f}".format(loss_val_C))
val_loss_C[solver.iter / test_interval - 1] = loss_val_C
val_loss_R[solver.iter / test_interval - 1] = loss_val_R
val_top1[solver.iter / test_interval - 1] = top1_val
ax1.plot(it_val_axes[0:solver.iter / test_interval],
val_loss_C[0:solver.iter / test_interval], 'y')
ax1.plot(it_val_axes[0:solver.iter / test_interval],
val_loss_R[0:solver.iter / test_interval], 'k')
ax2.plot(it_val_axes[0:solver.iter / test_interval],
val_top1[0:solver.iter / test_interval], 'g')
ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
return
def do_solve(niter, solvers, disp_interval, test_interval, test_iters,
training_id, batch_size):
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import time
# SET PLOTS DATA
train_loss = zeros(niter / disp_interval)
train_correct_pairs = zeros(niter / disp_interval)
val_loss = zeros(niter / test_interval)
val_correct_pairs = zeros(niter / test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss (r), val loss (g)')
ax2.set_ylabel('train correct pairs (b) val correct pairs (m)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, batch_size])
loss = {name: np.zeros(niter) for name, _ in solvers}
correct_pairs = {name: np.zeros(niter) for name, _ in solvers}
#RUN TRAINING
for it in range(niter):
for name, s in solvers:
# start = time.time()
s.step(1) # run a single SGD step in Caffe
# end = time.time()
# print "Time step: " + str((end - start))
# print "Max before ReLU: " + str(np.max(s.net.blobs['inception_5b/pool_proj'].data))
# print "Max last FC: " + str(np.max(s.net.blobs['loss3/classifierCustom'].data))
loss[name][it] = s.net.blobs['loss3/loss3'].data.copy()
correct_pairs[name][it] = s.net.blobs['correct_pairs'].data.copy()
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
loss_disp = 'loss=' + str(
loss['my_solver'][it]) + ' correct_pairs=' + str(
correct_pairs['my_solver'][it])
print '%3d) %s' % (it, loss_disp)
train_loss[it / disp_interval] = loss['my_solver'][it]
train_correct_pairs[it /
disp_interval] = correct_pairs['my_solver'][it]
ax1.plot(it_axes[0:it / disp_interval],
train_loss[0:it / disp_interval], 'r')
ax2.plot(it_axes[0:it / disp_interval],
train_correct_pairs[0:it / disp_interval], 'b')
# if it > test_interval:
# ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g') #Val always on top
ax1.set_ylim([0, 0.05])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# title = '../training/numbers/training-' + str(it) + '.png' # Save graph to disk
# savefig(title, bbox_inches='tight')
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val = 0
cur_correct_pairs = 0
for i in range(test_iters):
solvers[0][1].test_nets[0].forward()
loss_val += solvers[0][1].test_nets[0].blobs[
'loss3/loss3'].data
cur_correct_pairs += solvers[0][1].test_nets[0].blobs[
'correct_pairs'].data
loss_val /= test_iters
cur_correct_pairs /= test_iters
print("Val loss: " + str(loss_val) + " Val correct pairs: " +
str(cur_correct_pairs))
val_loss[it / test_interval - 1] = loss_val
val_correct_pairs[it / test_interval - 1] = cur_correct_pairs
ax1.plot(it_val_axes[0:it / test_interval],
val_loss[0:it / test_interval], 'g')
ax2.plot(it_val_axes[0:it / test_interval],
val_correct_pairs[0:it / test_interval], 'm')
ax1.set_ylim([0, 0.05])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../hd/datasets/landmarks_recognition/models/training/' + training_id + str(
it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
#Save the learned weights from both nets at the end of the training
weight_dir = tempfile.mkdtemp()
weights = {}
for name, s in solvers:
filename = 'weights.%s.caffemodel' % name
weights[name] = os.path.join(weight_dir, filename)
s.net.save(weights[name])
return loss, weights
def do_solve(niter, solver, disp_interval, test_interval, test_iters, training_id):
"""Run solvers for niter iterations,
returning the loss and recorded each iteration.
`solvers` is a list of (name, solver) tuples."""
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import time
import glob
# SET PLOTS DATA
train_loss = zeros(niter/disp_interval)
val_loss = zeros(niter/test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
# ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss (r), val loss (g)')
# ax2.set_ylabel('val loss (g)')
# ax2.set_autoscaley_on(False)
# ax2.set_ylim([0, 1])
lowest_val_loss = 1000
best_it = 0
loss = np.zeros(niter)
#RUN TRAINING
for it in range(niter):
# start = time.time()
solver.step(1) # run a single SGD step in Caffe
# end = time.time()
# print "Time step: " + str((end - start))
loss[it] = solver.net.blobs['loss3/loss3'].data.copy()
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
loss_disp = 'loss=' + str(loss[it])
print '%3d) %s' % (it, loss_disp)
train_loss[it/disp_interval] = loss[it]
ax1.plot(it_axes[0:it/disp_interval], train_loss[0:it/disp_interval], 'r')
# if it > test_interval:
# ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g') #Val always on top
ax1.set_ylim([int(lowest_val_loss) - 1,int(lowest_val_loss) + 4])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# title = '../training/numbers/training-' + str(it) + '.png' # Save graph to disk
# savefig(title, bbox_inches='tight')
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val += solver.test_nets[0].blobs['loss3/loss3'].data
loss_val /= test_iters
print("Val loss: {:.3f}".format(loss_val))
val_loss[it/test_interval - 1] = loss_val
ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g')
ax1.set_ylim([int(lowest_val_loss) - 1,int(lowest_val_loss) + 4])
ax1.set_xlabel('iteration ' + 'Best it: ' + str(best_it) + ' Best Val Loss: ' + str(int(lowest_val_loss)))
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../hd/datasets/instaMiro/models/training/' + training_id + str(it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
if loss_val < lowest_val_loss:
print("Best Val loss!")
lowest_val_loss = loss_val
best_it = it
filename = '../../../hd/datasets/instaMiro/models/CNNRegression/' + training_id + '_best_valLoss_' + str(int(loss_val)) +'_it_' + str(it) + '.caffemodel'
prefix = 30
for cur_filename in glob.glob(filename[:-prefix] + '*'):
print(cur_filename)
os.remove(cur_filename)
solver.net.save(filename)
if plot:
ax1.plot(it_axes[0:epoch + 1], plot_data['train_loss'][0:epoch + 1],
'r')
ax2.plot(it_axes[0:epoch + 1],
plot_data['train_correct_pairs'][0:epoch + 1], 'b')
ax1.plot(it_axes[0:epoch + 1], plot_data['val_loss'][0:epoch + 1], 'y')
ax2.plot(it_axes[0:epoch + 1],
plot_data['val_correct_pairs'][0:epoch + 1], 'g')
plt.title(training_id + str(round(variance, 4)), fontsize=10)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# Save graph to disk
if epoch % 1 == 0 and epoch != 0:
title = dataset + '/training/' + training_id + '_epoch_' + str(
epoch) + '_var_' + str(round(variance, 4)) + '.png'
savefig(title, bbox_inches='tight')
variance += variance_step
print("Finished Training, saving checkpoint")
filename = dataset + '/models/' + training_id + '_epoch_' + str(epoch)
prefix_len = len('_epoch_' + str(epoch) + '_ValLoss_' +
str(round(plot_data['val_loss'][epoch], 2)))
train.save_checkpoint(model, filename, prefix_len)
def do_solve(niter, solver, disp_interval, test_interval, test_iters,
training_id, batch_size):
"""Run solvers for niter iterations,
returning the loss and recorded each iteration.
`solvers` is a list of (name, solver) tuples."""
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import glob
import time
# SET PLOTS DATA
# train_loss = zeros(niter/disp_interval)
train_loss_r = zeros(niter / disp_interval)
train_correct_pairs = zeros(niter / disp_interval)
# train_acc = zeros(niter/disp_interval)
# val_loss = zeros(niter/test_interval)
val_loss_r = zeros(niter / test_interval)
val_correct_pairs = zeros(niter / test_interval)
# val_acc = zeros(niter/test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel(
'train loss (r), val loss (g),') # train loss_r (c), val loss_r (o)')
ax2.set_ylabel('train correct pairs (b) val correct pairs (m)'
) # train top1 (y) val top1 (bk)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, batch_size])
# loss = {name: np.zeros(niter) for name, _ in solvers}
loss_r = np.zeros(niter)
correct_pairs = np.zeros(niter)
# acc = {name: np.zeros(niter) for name, _ in solvers}
lowest_val_loss = 1000
best_it = 0
#RUN TRAINING
for it in range(niter):
# start = time.time()
solver.step(1) # run a single SGD step in Caffe
# end = time.time()
# print "Time step: " + str((end - start))
# print "Max before ReLU: " + str(np.max(s.net.blobs['inception_5b/pool_proj'].data))
# print "Max last FC: " + str(np.max(s.net.blobs['loss3/classifierCustom'].data))
#loss[name][it] = s.net.blobs['loss3/loss3/classification'].data.copy()
loss_r[it] = solver.net.blobs['loss3/loss3/ranking'].data.copy()
correct_pairs[it] = solver.net.blobs['correct_pairs'].data.copy()
# acc[name][it] = s.net.blobs['loss3/top-1'].data.copy()
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
# loss_disp = 'loss=' + str(loss['my_solver'][it]) + ' correct_pairs=' + str(correct_pairs['my_solver'][it]) + ' loss ranking=' + str(loss_r['my_solver'][it])
loss_disp = ' correct_pairs=' + str(
correct_pairs[it]) + ' loss ranking=' + str(loss_r[it])
print '%3d) %s' % (it, loss_disp)
# train_loss[it/disp_interval] = loss[it]
train_loss_r[it / disp_interval] = loss_r[it]
train_correct_pairs[it / disp_interval] = correct_pairs[it]
# train_acc[it/disp_interval] = acc[it] *120
# ax1.plot(it_axes[0:it/disp_interval], train_loss[0:it/disp_interval], 'r')
ax1.plot(it_axes[0:it / disp_interval],
train_loss_r[0:it / disp_interval], 'c')
ax2.plot(it_axes[0:it / disp_interval],
train_correct_pairs[0:it / disp_interval], 'b')
# ax2.plot(it_axes[0:it/disp_interval], train_acc[0:it/disp_interval], 'gold')
# if it > test_interval:
# ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g') #Val always on top
ax1.set_ylim([0, 2])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
# title = '../training/numbers/training-' + str(it) + '.png' # Save graph to disk
# savefig(title, bbox_inches='tight')
#VALIDATE
if it % test_interval == 0 and it > 0:
# loss_val = 0
loss_val_r = 0
cur_correct_pairs = 0
# cur_acc = 0
for i in range(test_iters):
solver.test_nets[0].forward()
# loss_val += solver.test_nets[0].blobs['loss3/loss3/classification'].data
loss_val_r += solver.test_nets[0].blobs[
'loss3/loss3/ranking'].data
cur_correct_pairs += solver.test_nets[0].blobs[
'correct_pairs'].data
# cur_acc += solvers[0][1].test_nets[0].blobs['loss3/top-1'].data
# loss_val /= test_iters
loss_val_r /= test_iters
cur_correct_pairs /= test_iters
# cur_acc /= test_iters
# cur_acc *= 120
# print("Val loss: " + str(loss_val) + " Val correct pairs: " + str(cur_correct_pairs) + " Val loss ranking: " + str(loss_val_r) + "Val acc: "+ str(cur_acc))
print(" Val correct pairs: " + str(cur_correct_pairs) +
" Val loss ranking: " + str(loss_val_r))
# val_loss[it/test_interval - 1] = loss_val
val_loss_r[it / test_interval - 1] = loss_val_r
val_correct_pairs[it / test_interval - 1] = cur_correct_pairs
# val_acc[it/test_interval - 1] = cur_acc
# ax1.plot(it_val_axes[0:it/test_interval], val_loss[0:it/test_interval], 'g')
ax1.plot(it_val_axes[0:it / test_interval],
val_loss_r[0:it / test_interval], 'orange')
ax2.plot(it_val_axes[0:it / test_interval],
val_correct_pairs[0:it / test_interval], 'm')
# ax2.plot(it_val_axes[0:it/test_interval], val_acc[0:it/test_interval], 'k')
ax1.set_ylim([0, 2])
ax1.set_xlabel('iteration ' + 'Best it: ' + str(best_it) +
' Best Val Loss: ' + str(int(lowest_val_loss)))
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../hd/datasets/instaFashion/models/training/' + training_id + str(
it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
if loss_val_r < lowest_val_loss:
print("Best Val loss!")
lowest_val_loss = loss_val_r
best_it = it
filename = '../../../hd/datasets/instaFashion/models/CNNContrastive/' + training_id + 'best_valLoss_' + str(
int(loss_val_r)) + '_it_' + str(it) + '.caffemodel'
prefix = 30
for cur_filename in glob.glob(filename[:-prefix] + '*'):
print(cur_filename)
os.remove(cur_filename)
solver.net.save(filename)
def do_solve(niter, solvers, disp_interval, test_interval, test_iters,
training_id):
"""Run solvers for niter iterations,
returning the loss and recorded each iteration.
`solvers` is a list of (name, solver) tuples."""
import tempfile
import numpy as np
import os
from pylab import zeros, arange, subplots, plt, savefig
import time
# SET PLOTS DATA
train_loss = zeros(niter / disp_interval)
val_loss = zeros(niter / test_interval)
it_axes = (arange(niter) * disp_interval) + disp_interval
it_val_axes = (arange(niter) * test_interval) + test_interval
_, ax1 = subplots()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss (r), val loss (g)')
loss = {name: np.zeros(niter) for name, _ in solvers}
#RUN TRAINING
for it in range(niter):
for name, s in solvers:
s.step(1) # run a single SGD step in Caffe
loss[name][it] = s.net.blobs['loss3/loss3'].data.copy()
#PLOT
if it % disp_interval == 0 or it + 1 == niter:
loss_disp = 'loss=' + str(loss['my_solver'][it])
print '%3d) %s' % (it, loss_disp)
train_loss[it / disp_interval] = loss['my_solver'][it]
ax1.plot(it_axes[0:it / disp_interval],
train_loss[0:it / disp_interval], 'r')
ax1.set_ylim([170, 210])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.0001)
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val = 0
for i in range(test_iters):
solvers[0][1].test_nets[0].forward()
loss_val += solvers[0][1].test_nets[0].blobs[
'loss3/loss3'].data
loss_val /= test_iters
print("Val loss: {:.3f}".format(loss_val))
val_loss[it / test_interval - 1] = loss_val
ax1.plot(it_val_axes[0:it / test_interval],
val_loss[0:it / test_interval], 'g')
ax1.set_ylim([170, 210])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../hd/datasets/instaBarcelona/models/training/' + training_id + str(
it) + '.png'
savefig(title, bbox_inches='tight')
#Save the learned weights from both nets at the end of the training
weight_dir = tempfile.mkdtemp()
weights = {}
for name, s in solvers:
filename = 'weights.%s.caffemodel' % name
weights[name] = os.path.join(weight_dir, filename)
s.net.save(weights[name])
return loss, weights
fifteen_ago = time.time() - datetime.timedelta(minutes=20).total_seconds()
relevant_data = [(t, n) for t, n in grouped_data.items() if float(t) > fifteen_ago]
update_graph([format_timestamp(t) for t, n in relevant_data], [n for t, n in relevant_data])
def update_graph(times, nums):
plt.xlim(max(times) - datetime.timedelta(minutes=15), max(times))
plt.ylim(0, max(nums) * 1.2)
plt.plot_date(times, nums, "ro")
plt.draw()
path = "datastore.db"
time_checked = time.time() - 3000
size = os.path.getmtime(path)
plt.ion()
refresh()
formatter = DateFormatter("%H:%M")
plt.gcf().axes[0].xaxis.set_major_formatter(formatter)
while True:
try:
if os.path.getmtime(path) > size:
refresh()
size = os.path.getmtime(path)
plt.pause(10)
else:
plt.pause(1)
except TclError: # Can't sleep due to graph being closed
break
