def plot_double_column(table1,
title1,
xlabel1,
ylabel1,
table2,
title2,
xlabel2,
ylabel2,
table3,
title3,
xlabel3,
ylabel3,
savepath,
show=True,
is_equal_y=True):
df1 = table1
df2 = table2
df3 = table3
legend1 = list(table1.columns)
dash_styles = [
"", (1, 1), (4, 1.5), (3, 1, 1.5, 1), (5, 1, 1, 1), (5, 1, 2, 1, 2, 1),
(2, 2, 3, 1.5), (1, 2.5, 3, 1.2), (3, 1), (1, 2, 3, 4), "", (4, 1.5),
(1, 1), (3, 1, 1.5, 1), (5, 1, 1, 1), (5, 1, 2, 1, 2, 1),
(2, 2, 3, 1.5), (1, 2.5, 3, 1.2), (3, 1), (1, 2, 3, 4)
]
filled_markers = (
'o',
'X',
'*',
'h',
's',
'v',
'^',
'<',
'>',
'p',
'8',
'H',
'D',
'd',
'P',
'o',
'X',
'*',
'h',
's',
'v',
'^',
'<',
'>',
'p',
'8',
'H',
'D',
'd',
'P',
)
import matplotlib
SMALL = 7.5
Regular = 9.5
matplotlib.rc('font', size=Regular)
matplotlib.rc('axes', titlesize=Regular)
# matplotlib.rcParams['axes.linewidth'] = .1
# sns.set_style("whitegrid")
# sns.set(style="ticks", rc={"lines.linewidth": 0.7})
# sns.set(rc={"lines.linewidth": 0.1})
fig = plt.figure(figsize=(5, 2.5))
# fig, ax = plt.subplots(1,2)
# ax1 = fig.add_subplot(1,2,1)
ax1 = fig.add_axes([0.12, 0.15, 0.23, 0.6])
# with plt.rc_context({'lines.linewidth': 0.3}):
# sns.lineplot(data=df1, palette="Set2", ax=ax1, linewidth=2, dashes=dash_styles, markers=filled_markers)
sns.lineplot(data=df1,
palette="Set2",
ax=ax1,
linewidth=1.5,
dashes=dash_styles,
markers=filled_markers,
markeredgewidth=0,
legend=False)
# plt.yticks(rotation=90)
# ax2 = fig.add_subplot(1, 2, 2)
ax2 = fig.add_axes([0.44, 0.15, 0.23, 0.6])
sns.lineplot(data=df2,
palette="Set2",
ax=ax2,
linewidth=1.5,
dashes=dash_styles,
markers=filled_markers,
markeredgewidth=0,
legend=False)
ax3 = fig.add_axes([0.76, 0.15, 0.23, 0.6])
sns.lineplot(data=df3,
palette="Set2",
ax=ax3,
linewidth=1.5,
dashes=dash_styles,
markers=filled_markers,
markeredgewidth=0,
legend=False)
ax1.legend(labels=legend1,
ncol=4,
loc='lower left',
bbox_to_anchor=(.6, 1.1))
# ax1.set_title(title1)
ax1.set_xlabel(xlabel1)
ax1.set_ylabel(ylabel1)
# ax1.set_xticks(list(range(len(index1) + 1)[::5]))
ax1.set_xticks([2, 4, 6, 8, 10])
ax1.xaxis.set_label_coords(0.5, -0.15)
ax1.xaxis.set_tick_params(labelsize=SMALL)
ax1.yaxis.set_tick_params(labelsize=SMALL)
ax1.yaxis.set_major_formatter(
FuncFormatter(lambda y, _: '{:.1%}'.format(y)))
# ax1.grid(linestyle='-.')
# ax2.set_title(title2)
ax2.set_xlabel(xlabel2)
# ax2.set_ylabel(ylabel2)
# ax2.set_xticks(list(range(len(index2) + 1)[::2]))
ax2.set_xticks([2, 4, 6, 8, 10])
# ax2.set_yticks([0.65,0.7,0.75,0.8,0.85])
ax2.xaxis.set_label_coords(0.5, -0.15)
ax2.xaxis.set_tick_params(labelsize=SMALL)
ax2.yaxis.set_tick_params(labelsize=SMALL)
ax2.yaxis.set_major_formatter(
FuncFormatter(lambda y, _: '{:.1%}'.format(y)))
if is_equal_y:
ax2.set_ylim(ax1.get_ylim())
# ax3.set_title(title3)
ax3.set_xlabel(xlabel3)
# ax3.set_ylabel(ylabel3)
# ax2.set_xticks(list(range(len(index2) + 1)[::2]))
ax3.set_xticks([2, 4, 6, 8, 10])
# ax2.set_yticks([0.65,0.7,0.75,0.8,0.85])
ax3.xaxis.set_label_coords(0.5, -0.15)
ax3.xaxis.set_tick_params(labelsize=SMALL)
ax3.yaxis.set_tick_params(labelsize=SMALL)
if is_equal_y:
ax3.set_ylim(ax1.get_ylim())
ax3.yaxis.set_major_formatter(
FuncFormatter(lambda y, _: '{:.1%}'.format(y)))
# ax2.grid(linestyle='-.')
plt.savefig(savepath, format='eps')
plt.savefig(savepath[:-4] + '.pdf', format='pdf')
if show:
plt.show()
print('Evaluating DS techniques:')
print('Classification accuracy KNORA-U: ', knorau_score)
print('Classification accuracy KNORA-E: ', kne_score)
print('Classification accuracy DESP: ', desp_score)
print('Classification accuracy OLA: ', ola_score)
print('Classification accuracy MCB: ', mcb_score)
print('Classification accuracy META-DES: ', meta_score)
cmap = get_cmap('Dark2')
colors = [cmap(i) for i in np.linspace(0, 1, 7)]
labels = [
'RF', 'Stacked', 'KNORA-U', 'KNORA-E', 'DESP', 'OLA', 'MCB', 'META-DES'
]
fig, ax = plt.subplots()
pct_formatter = FuncFormatter(lambda x, pos: '{:.1f}'.format(x * 100))
ax.bar(np.arange(8), [
rf_score, stacked_score, knorau_score, kne_score, desp_score, ola_score,
mcb_score, meta_score
],
color=colors,
tick_label=labels)
ax.set_ylim(0.65, 0.80)
ax.set_xlabel('Method', fontsize=13)
ax.set_ylabel('Accuracy on the test set (%)', fontsize=13)
ax.yaxis.set_major_formatter(pct_formatter)
for tick in ax.get_xticklabels():
tick.set_rotation(45)
plt.subplots_adjust(bottom=0.15)
plt.show()
data=data_for_corr,
x='Longitude', # change for latitude or longitude
y=data_for_corr.columns[key])
# Make the boxplot fully transparent
for patch in ax.artists:
r, g, b, a = patch.get_facecolor()
patch.set_facecolor((r, g, b, 0))
ax.set_ylabel(song_variables[key - 3] + ' (' + value + ')')
ax.set_xlabel('')
ax.tick_params(labelsize=30, direction='out')
ax.set(xticklabels=[])
plt.setp(ax.spines.values(), linewidth=2)
ax.get_yaxis().set_major_formatter(
FuncFormatter(lambda x, p: "%.1f" % (np.exp(x))))
plt.savefig("C:/Users/abiga\Box Sync\Abigail_Nicole\ChippiesProject"
"\StatsOfFinalData_withReChipperReExported"
"\AnimalBehaviourRevisions/SupplementalCorr"
"/" + data_for_corr.columns[key] + '_noLogAxis_largerFont' +
'.pdf',
type='pdf',
dpi=fig.dpi,
bbox_inches='tight',
transparent=True)
# plt.cla()
# plt.clf()
plt.close()
# plt.show()
yerr=error_lab_fresh,
error_kw=dict(elinewidth=1, ecolor='black'),
label=r'$ (X31-virus) $')
plt.grid(True, which='both')
plt.title(r'$ Original \ Antigenic \ Sin \ (sequential-infection)$',
fontsize=AlvaFontSize)
plt.xlabel(r'$time \ (%s)$' % (timeUnit), fontsize=AlvaFontSize)
plt.ylabel(r'$ Neutralization \ \ titer $', fontsize=AlvaFontSize)
plt.xticks(fontsize=AlvaFontSize * 0.6)
plt.yticks(fontsize=AlvaFontSize * 0.6)
plt.xlim([minT, 6 * 30 * day])
plt.ylim([2**5, 2**14])
plt.yscale('log', basey=2)
# gca()---GetCurrentAxis and Format the ticklabel to be 2**x
plt.gca().yaxis.set_major_formatter(
FuncFormatter(lambda x, pos: int(2**(np.log(x) / np.log(2)))))
#plt.gca().xaxis.set_major_locator(plt.MultipleLocator(7))
plt.legend(loc=(1, 0), fontsize=AlvaFontSize)
plt.show()
# In[3]:
# step by step
numberingFig = numberingFig + 1
for i in range(totalPoint_X):
figure_name = '-response-%i' % (i)
figure_suffix = '.png'
save_figure = os.path.join(dir_path, file_name + figure_name + file_suffix)
plt.figure(numberingFig, figsize=AlvaFigSize)
plt.plot(gT,
gV[i],
date_range = paths[-2]
start_year = date_range[:4]
def form2(x, pos):
""" This function returns a string with 3 decimal places, given the input x"""
return '%.2f' % x
def form5(x, pos):
""" This function returns a string with 3 decimal places, given the input x"""
return '%.7f' % x
xformatter = FuncFormatter(form2)
yformatter = FuncFormatter(form5)
def onpick(event):
global pl
global ind
global fig2
ind = event.ind
ind = ind[0]
#x_data = event.xdata
#y_data = event.ydata
#find ind of closest lat/lon
def Plot(X,
outname,
outdir,
pColors,
titlestr=None,
grid=False,
drawLegend=True,
xFormat=None,
yFormat=None,
savePDF=True,
savePNG=False,
datestamp=True):
mpl.rcParams['xtick.top'] = True
mpl.rcParams['xtick.bottom'] = True
mpl.rcParams['ytick.right'] = True
mpl.rcParams['xtick.direction'] = 'in'
mpl.rcParams['ytick.direction'] = 'in'
mpl.rc('font', **{'size': 10})
mpl.rc('legend', **{'fontsize': 6.0})
mpl.rc('axes', linewidth=0.5)
# mpl.rc('font', **{'family' : 'sans-serif', 'sans-serif' : ['Myriad Pro']})
mpl.rc('font', **{'family': 'sans-serif', 'sans-serif': ['Helvetica']})
mpl.rcParams['pdf.fonttype'] = 42
mpl.rcParams['text.usetex'] = False
mpl.rcParams['mathtext.fontset'] = 'cm'
mpl.rcParams['text.latex.preamble'] = \
r'\usepackage{cmbright}' + \
r'\usepackage{amsmath}'
######################################################################################
# set up figure
fWidth, fHeight, lFrac, rFrac, bFrac, tFrac =\
getFigureProps(width = 4.1, height = 2.9,
lFrac = 0.18, rFrac = 0.95,
bFrac = 0.18, tFrac = 0.95)
f, ax1 = plt.subplots(1)
f.set_size_inches(fWidth, fHeight)
f.subplots_adjust(left=lFrac, right=rFrac)
f.subplots_adjust(bottom=bFrac, top=tFrac)
######################################################################################
labelfontsize = 6.0
for tick in ax1.xaxis.get_major_ticks():
tick.label.set_fontsize(labelfontsize)
for tick in ax1.yaxis.get_major_ticks():
tick.label.set_fontsize(labelfontsize)
ax1.tick_params('both', length=1.5, width=0.5, which='major', pad=3.0)
ax1.tick_params('both', length=1.0, width=0.25, which='minor', pad=3.0)
ax1.tick_params(axis='x', which='major', pad=3.5)
ax1.tick_params(axis='y', which='major', pad=3.5, zorder=10)
######################################################################################
# labeling
if titlestr:
plt.title(titlestr)
ax1.set_xlabel(r'$M$', fontsize=6.0)
ax1.set_ylabel(r'$E_{\mathrm{RMS}}$', fontsize=6.0)
ax1.xaxis.labelpad = 3.0
ax1.yaxis.labelpad = 3.0
######################################################################################
# plotting
lineWidth = 0.65
ax1.plot(X[:, 0],
X[:, 1],
color=pColors['blue'],
alpha=1.0,
lw=lineWidth,
zorder=11,
label=r'',
clip_on=False)
ax1.scatter(X[:, 0],
X[:, 1],
s=10.0,
lw=lineWidth,
facecolor='None',
edgecolor=pColors['blue'],
zorder=11,
label=r'Training',
clip_on=False)
ax1.plot(X[:, 0],
X[:, 2],
color=pColors['red'],
alpha=1.0,
lw=lineWidth,
zorder=11,
label=r'',
clip_on=False)
ax1.scatter(X[:, 0],
X[:, 2],
s=10.0,
lw=lineWidth,
facecolor='None',
edgecolor=pColors['red'],
zorder=11,
label=r'Test',
clip_on=False)
######################################################################################
# legend
if drawLegend:
leg = ax1.legend( # bbox_to_anchor = [0.7, 0.8],
# loc = 'upper left',
handlelength=1.5,
scatterpoints=1,
markerscale=1.0,
ncol=1)
leg.draw_frame(False)
plt.gca().add_artist(leg)
######################################################################################
# set plot range
if xFormat:
major_x_ticks = np.arange(xFormat[2], xFormat[3], xFormat[4])
minor_x_ticks = np.arange(xFormat[2], xFormat[3], xFormat[5])
ax1.set_xticks(major_x_ticks)
ax1.set_xticks(minor_x_ticks, minor=True)
ax1.set_xlim(xFormat[0], xFormat[1])
if yFormat:
major_y_ticks = np.arange(yFormat[2], yFormat[3], yFormat[4])
minor_y_ticks = np.arange(yFormat[2], yFormat[3], yFormat[5])
ax1.set_yticks(major_y_ticks)
ax1.set_yticks(minor_y_ticks, minor=True)
ax1.set_ylim(yFormat[0], yFormat[1])
# tick label formatting
majorFormatter = FuncFormatter(cleanFormatter)
ax1.xaxis.set_major_formatter(majorFormatter)
ax1.yaxis.set_major_formatter(majorFormatter)
ax1.set_axisbelow(False)
for spine in ax1.spines.values(): # ax1.spines is a dictionary
spine.set_zorder(10)
######################################################################################
# grid options
if grid:
ax1.grid(color='gray',
linestyle='-',
alpha=0.2,
which='major',
linewidth=0.2)
ax1.grid(True)
ax1.grid(color='gray',
linestyle='-',
alpha=0.05,
which='minor',
linewidth=0.1)
ax1.grid(True, which='minor')
######################################################################################
# save to file
if datestamp:
outname += '_' + today
if savePDF:
f.savefig(os.path.join(outdir, outname) + '.pdf',
dpi=300,
transparent=True)
if savePNG:
f.savefig(os.path.join(outdir, outname) + '.png',
dpi=600,
transparent=False)
######################################################################################
# close handles
plt.cla()
plt.clf()
plt.close()
return outname
def metacache_overhead_summary(doLoadData):
db_summary = ""
db_hitrate_summary = ""
db_metadata_txn_ratio_summary = ""
if doLoadData == False:
db_speedup = speedup(False)
db_spec = geomean(db_speedup.loc[SPEC])
db_mix = geomean(db_speedup.loc[MIX])
db_gap = geomean(db_speedup.loc[GAP])
db_rand = db_speedup.loc["RAND"]
db_stream = db_speedup.loc["STREAM"]
db_mean = geomean(db_speedup)
db_summary = pd.DataFrame({
'SPEC-RATE': db_spec,
'SPEC-MIX': db_mix,
'GAP': db_gap,
'RAND': db_rand,
'STREAM': db_stream,
'AVERAGE': db_mean
}).T
db_summary = db_summary[[
"metacache_rownum1024", "metacache_rownum2048",
"metacache_rownum4096", "metacache_rownum8192",
"metadata_predictor0"
]]
db_summary.columns = [
'Metadata Cache (128KB)', 'Metadata Cache (256KB)',
'Metadata Cache (512KB)', 'Metadata Cache (1MB)', 'Ideal'
] #change column name
db_summary = db_summary.loc[
['SPEC-RATE', 'SPEC-MIX', 'GAP', 'RAND', 'STREAM', 'AVERAGE'], :]
print db_summary
#metadata cache hit rate
db_miss = mergeCol("memzip_metacache_miss", "MemController0", id_tech)
db_hit = mergeCol("memzip_metacache_hit", "MemController0", id_tech)
db_miss = db_miss[[
"metacache_rownum1024", "metacache_rownum2048",
"metacache_rownum4096", "metacache_rownum8192"
]]
db_hit = db_hit[[
"metacache_rownum1024", "metacache_rownum2048",
"metacache_rownum4096", "metacache_rownum8192"
]]
db_access = db_miss + db_hit
db_hit_rate = db_hit / (db_miss + db_hit)
db_hit_rate = db_hit_rate.rename(index={"seq": "stream"})
db_hit_rate.columns = [
'Metadata Cache (128KB)', 'Metadata Cache (256KB)',
'Metadata Cache (512KB)', 'Metadata Cache (1MB)'
] #change column name
db_hit_rate.loc['gmean'] = geomean(db_hit_rate)
db_spec = geomean(db_hit_rate.loc[SPEC])
db_mix = geomean(db_hit_rate.loc[MIX])
db_gap = geomean(db_hit_rate.loc[GAP])
db_rand = db_hit_rate.loc["rand"]
db_stream = db_hit_rate.loc["stream"]
db_mean = db_hit_rate.loc["gmean"]
db_hitrate_summary = pd.DataFrame({
'SPEC-RATE': db_spec,
'SPEC-MIX': db_mix,
'GAP': db_gap,
'RAND': db_rand,
'STREAM': db_stream,
'AVERAGE': db_mean
}).T
db_hitrate_summary.loc[
'SPEC-MIX', 'Metadata Cache (512KB)'] = db_hitrate_summary.loc[
'SPEC-MIX', 'Metadata Cache (1MB)']
db_hitrate_summary = db_hitrate_summary.loc[
['SPEC-RATE', 'SPEC-MIX', 'GAP', 'RAND', 'STREAM', 'AVERAGE'], :]
print "----hit rate----"
print db_hitrate_summary
#memory transaction
db_txnrecvd = mergeCol("totalTxnsRecvd", "MemController0", id_tech)
db_txn_base = db_txnrecvd.iloc[:, 0]
db_txnrecvd = db_txnrecvd[[
"metacache_rownum1024", "metacache_rownum2048",
"metacache_rownum4096", "metacache_rownum8192"
]]
db_txnrecvd = db_txnrecvd[[
"metacache_rownum1024", "metacache_rownum2048",
"metacache_rownum4096", "metacache_rownum8192"
]]
db_txnrecvd.columns = [
'Metadata Cache (128KB)', 'Metadata Cache (256KB)',
'Metadata Cache (512KB)', 'Metadata Cache (1MB)'
] #change column name
db_txn_metadata = db_txnrecvd.sub(db_txn_base, axis=0)
db_txn_metadata_ratio = db_txn_metadata / db_txnrecvd
# db_txn_normal_ratio=db_txnrecvd/db_txnrecvd
db_txn_metadata_ratio = db_txn_metadata_ratio.rename(
index={"seq": "stream"})
db_spec = geomean(db_txn_metadata_ratio.loc[SPEC])
db_gap = geomean(db_txn_metadata_ratio.loc[GAP])
db_rand = db_txn_metadata_ratio.loc["rand"]
db_stream = db_txn_metadata_ratio.loc["stream"]
db_mean = geomean(db_txn_metadata_ratio)
db_metadata_txn_ratio_summary = pd.DataFrame({
'SPEC': db_spec,
'GAP': db_gap,
'RAND': db_rand,
'STREAM': db_stream,
'AVERAGE': db_mean
}).T
db_metadata_txn_ratio_summary = db_metadata_txn_ratio_summary.loc[
['SPEC', 'GAP', 'RAND', 'STREAM', 'AVERAGE'], :]
#store db to file
db_summary.to_csv(report_dir + "/%s-%s.csv" %
("metacache_limit", result_name))
db_hitrate_summary.to_csv(report_dir + "/%s-%s.csv" %
("metadata_hitrate_limit", result_name))
db_metadata_txn_ratio_summary.to_csv(
report_dir + "/%s-%s.csv" %
("metadata_fetch_txn_limit", result_name))
print db_metadata_txn_ratio_summary
else:
db_summary = pd.read_csv(report_dir + "/%s-%s.csv" %
("metacache_limit", result_name),
index_col=0)
db_hitrate_summary = pd.read_csv(
report_dir + "/%s-%s.csv" %
("metadata_hitrate_limit", result_name),
index_col=0)
db_metadata_txn_ratio_summary = pd.read_csv(
report_dir + "/%s-%s.csv" %
("metadata_fetch_txn_limit", result_name),
index_col=0)
bar_w = 0.8
ax1 = db_summary.plot.bar(figsize=(12, 6),
width=bar_w,
cmap="summer",
edgecolor='black')
ax1.grid(axis='y')
ax1.legend(loc=9, ncol=2, fontsize=18, bbox_to_anchor=(0.5, 1.4))
plt.xticks(fontsize=18, rotation=25)
plt.yticks(fontsize=18)
plt.ylabel("Speedup", fontsize=20)
plt.subplots_adjust(left=0.08, right=0.9, bottom=0.15, top=0.75)
plt.ylim(ymax=1.4, ymin=0.4)
x = ax1.get_xaxis().get_majorticklocs()
line_w = bar_w / len(db_summary.columns)
line_x = np.arange(0, len(db_summary.columns)) * line_w
line_x = line_x[0:len(line_x) - 1]
ax = []
#db_hitrate_summary=db_hitrate_summary*100
for i in range(0, len(db_hitrate_summary.index)):
ax_tmp = ax1.twinx()
ax_tmp.set_ylim(ymax=1, ymin=0)
ax_tmp.plot(x[i] - bar_w / 2 + line_x + line_w / 2,
db_hitrate_summary.iloc[i, :],
linestyle="-",
linewidth=2,
color="b",
marker="o",
markersize="10",
markeredgewidth=1,
markeredgecolor='y',
label='Hit-Rate of Metadata Cache')
vals = ax_tmp.get_yticks()
ax_tmp.tick_params(axis='y', labelsize=15)
ax_tmp.yaxis.set_major_formatter(FuncFormatter('{0:.0%}'.format))
ax.append(ax_tmp)
ax[0].legend(loc=9, ncol=2, fontsize=18, bbox_to_anchor=(0.73, 1.2))
ax[0].set_ylabel('Hit-Rate (%)', fontsize=20)
plt.savefig(report_dir + "/%s-%s.pdf" %
("metadata_cache_speedup_limit", result_name))
plt.savefig(report_dir + "/%s-%s.eps" %
("metadata_cache_speedup_limit", result_name),
format='eps',
dpi=1000)
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
# -*- coding:utf-8 -*-
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator, FormatStrFormatter
import argparse
import score
import numpy as np
import os
import save_log
import gen_report
from matplotlib.ticker import FuncFormatter
def formatnum(x, pos):
return '$%.1f$x$10^{5}$' % (x/100000)
formatter = FuncFormatter(formatnum)
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument("--id",required = True, type=str, help="experiment_id")
parser.add_argument("--logs", type=bool, default=False, help="whether to save log")
return parser.parse_args()
def main_grid(time, values, save_folder, filename):
time = np.array(time, dtype='float32')
values = np.array(values, dtype='float32')
plt.figure(figsize=(12, 6))
ax = plt.subplot(1,1,1)
plt.plot(time, values, linewidth = '1.0',color='blue',marker='.') #'darkgoldenrod','slateblue','aqua','red','black'
font = {'family':'DejaVu Sans', 'weight':'normal', 'size':12}
plt.tick_params(labelsize=12)
return line
years = mdates.YearLocator()
months = mdates.MonthLocator()
ax = plt.subplot(1, 1, 1)
#ax.loglog(daysFromGenesis, low, linewidth=1, color='0.5')
#ax.loglog(daysFromGenesis, high, linewidth=1, color='0.5')
averagePlot = ax.loglog(daysFromGenesis,
average,
linewidth=1,
label='Daily Average Price')
ax.xaxis.set_major_locator(years)
ax.xaxis.set_major_formatter(FuncFormatter(xMajorFormat))
ax.xaxis.set_minor_locator(months)
ax.xaxis.set_minor_formatter(FuncFormatter(xMinorFormat))
ax.fmt_xdata = FuncFormatter(xDataFormat)
ax.set_xlim(datemin, datemax)
ax.set_ylabel('$/BTC')
ax.yaxis.set_major_formatter(FuncFormatter(yLogFormat))
ymin = 0.01
ymax = 1000000
ax.set_ylim(ymin, ymax)
ax.grid(b=True, which='major', color='0.8', linestyle='-')
ax.grid(b=True, which='minor', color='0.96', linestyle='-')
ax.set_axisbelow(True)
'converts radians to degrees'
return round(x * 57.2985, 2)
plt.figure(figsize=(12,7), dpi=100)
X = np.linspace(0,2*np.pi,1000)
plt.plot(X,np.sin(X))
plt.plot(X,np.cos(X))
# 1. Adjust x axis Ticks
plt.xticks(ticks=np.arange(0, 440/57.2985, 90/57.2985), fontsize=12, rotation=30, ha='center', va='top') # 1 radian = 57.2985 degrees
# 2. Tick Parameters
plt.tick_params(axis='both',bottom=True, top=True, left=True, right=True, direction='in', which='major', grid_color='blue')
# 3. Format tick labels to convert radians to degrees
formatter = FuncFormatter(rad_to_degrees)
plt.gca().xaxis.set_major_formatter(formatter)
plt.grid(linestyle='--', linewidth=0.5, alpha=0.15)
plt.title('Sine and Cosine Waves\n(Notice the ticks are on all 4 sides pointing inwards, radians converted to degrees in x axis)', fontsize=14)
## How to customize the legend
plt.figure(figsize=(10,7), dpi=80)
X = np.linspace(0, 2*np.pi, 1000)
sine = plt.plot(X,np.sin(X)); cosine = plt.plot(X,np.cos(X))
sine_2 = plt.plot(X,np.sin(X+.5)); cosine_2 = plt.plot(X,np.cos(X+.5))
plt.gca().set(ylim=(-1.25, 1.5), xlim=(-.5, 7))
plt.title('Custom Legend Example', fontsize=18)
# Modify legend
def plot(self,
figure=None,
overlays=[],
colorbar=True,
vmin=None,
vmax=None,
linear=True,
showz=True,
yres=DEFAULT_YRES,
max_dist=None,
**matplotlib_args):
"""
Plot spectrogram onto figure.
Parameters
----------
figure : matplotlib.figure.Figure
Figure to plot the spectrogram on. If None, new Figure is created.
overlays : list
List of overlays (functions that receive figure and axes and return
new ones) to be applied after drawing.
colorbar : bool
Flag that determines whether or not to draw a colorbar. If existing
figure is passed, it is attempted to overdraw old colorbar.
vmin : float
Clip intensities lower than vmin before drawing.
vmax : float
Clip intensities higher than vmax before drawing.
linear : bool
If set to True, "stretch" image to make frequency axis linear.
showz : bool
If set to True, the value of the pixel that is hovered with the
mouse is shown in the bottom right corner.
yres : int or None
To be used in combination with linear=True. If None, sample the
image with half the minimum frequency delta. Else, sample the
image to be at most yres pixels in vertical dimension. Defaults
to 1080 because that's a common screen size.
max_dist : float or None
If not None, mask elements that are further than max_dist away
from actual data points (ie, frequencies that actually have data
from the receiver and are not just nearest-neighbour interpolated).
"""
# [] as default argument is okay here because it is only read.
# pylint: disable=W0102,R0914
if linear:
delt = yres
if delt is not None:
delt = max(
(self.freq_axis[0] - self.freq_axis[-1]) / (yres - 1),
_min_delt(self.freq_axis) / 2.)
delt = float(delt)
data = _LinearView(self.clip_values(vmin, vmax), delt)
freqs = np.arange(self.freq_axis[0], self.freq_axis[-1],
-data.delt)
else:
data = np.array(self.clip_values(vmin, vmax))
freqs = self.freq_axis
figure = plt.gcf()
if figure.axes:
axes = figure.axes[0]
else:
axes = figure.add_subplot(111)
params = {
'origin': 'lower',
'aspect': 'auto',
}
params.update(matplotlib_args)
if linear and max_dist is not None:
toplot = ma.masked_array(data, mask=data.make_mask(max_dist))
pass
else:
toplot = data
im = axes.imshow(toplot, **params)
xa = axes.get_xaxis()
ya = axes.get_yaxis()
xa.set_major_formatter(FuncFormatter(self.time_formatter))
if linear:
# Start with a number that is divisible by 5.
init = (self.freq_axis[0] % 5) / data.delt
nticks = 15.
# Calculate MHz difference between major ticks.
dist = (self.freq_axis[0] - self.freq_axis[-1]) / nticks
# Round to next multiple of 10, at least ten.
dist = max(round(dist, -1), 10)
# One pixel in image space is data.delt MHz, thus we can convert
# our distance between the major ticks into image space by dividing
# it by data.delt.
ya.set_major_locator(IndexLocator(dist / data.delt, init))
ya.set_minor_locator(IndexLocator(dist / data.delt / 10, init))
def freq_fmt(x, pos):
# This is necessary because matplotlib somehow tries to get
# the mid-point of the row, which we do not need here.
x = x + 0.5
return self.format_freq(self.freq_axis[0] - x * data.delt)
else:
freq_fmt = _list_formatter(freqs, self.format_freq)
ya.set_major_locator(MaxNLocator(integer=True, steps=[1, 5, 10]))
ya.set_major_formatter(FuncFormatter(freq_fmt))
axes.set_xlabel(self.t_label)
axes.set_ylabel(self.f_label)
# figure.suptitle(self.content)
figure.suptitle(' '.join([
get_day(self.start).strftime("%d %b %Y"),
'Radio flux density',
'(' + ', '.join(self.instruments) + ')',
]))
for tl in xa.get_ticklabels():
tl.set_fontsize(10)
tl.set_rotation(30)
figure.add_axes(axes)
figure.subplots_adjust(bottom=0.2)
figure.subplots_adjust(left=0.2)
if showz:
axes.format_coord = self._mk_format_coord(
data,
figure.gca().format_coord)
if colorbar:
if len(figure.axes) > 1:
Colorbar(figure.axes[1], im).set_label("Intensity")
else:
figure.colorbar(im).set_label("Intensity")
for overlay in overlays:
figure, axes = overlay(figure, axes)
for ax in figure.axes:
ax.autoscale()
if isinstance(figure, SpectroFigure):
figure._init(self, freqs)
return axes
'Item B': 109472,
'Item C': 109438,
'Item D': 16838,
'Item E': 986438,
'Item F': 809438,
'Item G': 154438,
'Item H': 109860,
'Item I': 187438,
'Item J': 105438,
}
item = tuple(data.keys())
count = tuple(data.values())
# Pengaturan Style
plt.style.use('seaborn')
# Pengaturan Format pada Ticker
def ribuan(x, pos):
return f'{int(x/1000)}K'
formatter = FuncFormatter(ribuan)
ax.xaxis.set_major_formatter(formatter)
# Simple Plot
fig, ax = plt.subplots()
ax.barh(item, count)
plt.show()
def mpl_bubble(
x,
y,
z,
labels,
title,
x_title,
y_title,
x_fmt="{:.0%}",
y_fmt="{:+.0%}",
y_avg_line=False,
y_avg_value=None,
y_avg_label="",
x_avg_line=False,
x_avg_value=None,
x_avg_label="",
x_max=None,
x_min=None,
y_max=None,
y_min=None,
show_label=True,
label_limit=15,
z_scale=1,
color_scheme="随机颜色方案",
color_list=None,
):
z = [x * z_scale for x in z] # 气泡大小系数
fig, ax = plt.subplots() # 准备画布和轴
fig.set_size_inches(15, 10) # 画布尺寸
# 手动强制xy轴最小值/最大值
if x_min is not None and x_min > min(x):
ax.set_xlim(xmin=x_min)
if x_max is not None and x_max < max(x):
ax.set_xlim(xmax=x_max)
if y_min is not None and y_min > min(y):
ax.set_ylim(ymin=y_min)
if y_max is not None and y_max < max(y):
ax.set_ylim(ymax=y_max)
# 确定颜色方案
if color_scheme == "随机颜色方案" or color_scheme is None:
cmap = mpl.colors.ListedColormap(np.random.rand(256, 3))
colors = iter(cmap(np.linspace(0, 1, len(x))))
else:
if len(x) <= len(color_list):
colors = color_list[: len(x)]
else:
colors = []
for i in range(len(x)):
colors.append(color_list[i % len(color_list)])
colors = iter(colors)
# 绘制气泡
for i in range(len(x)):
ax.scatter(x[i], y[i], z[i], color=next(colors), alpha=0.6, edgecolors="black")
# 添加系列标签，用adjust_text包保证标签互不重叠
if show_label is True:
texts = [
plt.text(
x[i],
y[i],
labels[i],
ha="center",
va="center",
multialignment="center",
fontproperties=myfont,
fontsize=10,
)
for i in range(len(labels[:label_limit]))
]
adjust_text(texts, force_text=0.5, arrowprops=dict(arrowstyle="->", color="black"))
# 添加分隔线（均值，中位数，0等）
if y_avg_line is True:
ax.axhline(y_avg_value, linestyle="--", linewidth=1, color="grey")
plt.text(
ax.get_xlim()[1],
y_avg_value,
y_avg_label,
ha="left",
va="center",
color="r",
multialignment="center",
fontproperties=myfont,
fontsize=10,
)
if x_avg_line is True:
ax.axvline(x_avg_value, linestyle="--", linewidth=1, color="grey")
plt.text(
x_avg_value,
ax.get_ylim()[1],
x_avg_label,
ha="left",
va="top",
color="r",
multialignment="center",
fontproperties=myfont,
fontsize=10,
)
# 设置轴标签格式
ax.xaxis.set_major_formatter(FuncFormatter(lambda y, _: x_fmt.format(y)))
ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: y_fmt.format(y)))
# 添加图表标题和轴标题
plt.title(title, fontproperties=myfont)
plt.xlabel(x_title, fontproperties=myfont, fontsize=12)
plt.ylabel(y_title, fontproperties=myfont, fontsize=12)
"""以下部分绘制回归拟合曲线及CI和PI
参考
http://nbviewer.ipython.org/github/demotu/BMC/blob/master/notebooks/CurveFitting.ipynb
https://stackoverflow.com/questions/27164114/show-confidence-limits-and-prediction-limits-in-scatter-plot
"""
n = y.size # 观察例数
if n > 2: # 数据点必须大于cov矩阵的scale
p, cov = np.polyfit(x, y, 1, cov=True) # 简单线性回归返回parameter和covariance
poly1d_fn = np.poly1d(p) # 拟合方程
y_model = poly1d_fn(x) # 拟合的y值
m = p.size # 参数个数
dof = n - m # degrees of freedom
t = stats.t.ppf(0.975, dof) # 显著性检验t值
# 拟合结果绘图
ax.plot(x, y_model, "-", color="0.1", linewidth=1.5, alpha=0.5, label="Fit")
# 误差估计
resid = y - y_model # 残差
s_err = np.sqrt(np.sum(resid ** 2) / dof) # 标准误差
# 拟合CI和PI
x2 = np.linspace(np.min(x), np.max(x), 100)
y2 = poly1d_fn(x2)
# CI计算和绘图
ci = t * s_err * np.sqrt(1 / n + (x2 - np.mean(x)) ** 2 / np.sum((x - np.mean(x)) ** 2))
ax.fill_between(x2, y2 + ci, y2 - ci, color="#b9cfe7", edgecolor="", alpha=0.5)
# Pi计算和绘图
pi = t * s_err * np.sqrt(1 + 1 / n + (x2 - np.mean(x)) ** 2 / np.sum((x - np.mean(x)) ** 2))
ax.fill_between(x2, y2 + pi, y2 - pi, color="None", linestyle="--")
ax.plot(x2, y2 - pi, "--", color="0.5", label="95% Prediction Limits")
ax.plot(x2, y2 + pi, "--", color="0.5")
# 保存到字符串
sio = BytesIO()
plt.savefig(sio, format="png", bbox_inches="tight", transparent=True, dpi=600)
data = base64.encodebytes(sio.getvalue()).decode() # 解码为base64编码的png图片数据
src = "data:image/png;base64," + str(data) # 增加Data URI scheme
# 关闭绘图进程
plt.clf()
plt.cla()
plt.close()
return src
def _deduce_locators_formatters(max_ticks, data):
from datetime import timedelta as tdelta
import matplotlib.dates as mdates
from matplotlib.ticker import FuncFormatter
data_interval_seconds = (data[-1] - data[0]) / tdelta(seconds=1)
interval_seconds = data_interval_seconds / max_ticks
if interval_seconds < tdelta(minutes=0.5).total_seconds():
# print("xticks: seconds")
unit_multiple = _next_largest(interval_seconds, INTERVALS['SECONDLY'])
timedelta = tdelta(seconds=unit_multiple)
return (mdates.SecondLocator(bysecond=range(0, 60, unit_multiple)),
FuncFormatter(
_get_dynamic_formatter(timedelta, '%M%:S', '%-Hh',
'%-d %b')))
elif interval_seconds < tdelta(hours=0.5).total_seconds():
# print("xticks: minutes")
unit_multiple = _next_largest(
interval_seconds / tdelta(minutes=1).total_seconds(),
INTERVALS['MINUTELY'])
timedelta = tdelta(minutes=unit_multiple)
return (mdates.MinuteLocator(byminute=range(0, 60, unit_multiple)),
FuncFormatter(
_get_dynamic_formatter(timedelta, '%H%:M', '%-d %b',
'%Y')))
elif interval_seconds < tdelta(days=0.5).total_seconds():
# print("xticks: hours")
unit_multiple = _next_largest(
interval_seconds / tdelta(hours=1).total_seconds(),
INTERVALS['HOURLY'])
timedelta = tdelta(hours=unit_multiple)
return (mdates.HourLocator(byhour=range(0, 24, unit_multiple)),
FuncFormatter(
_get_dynamic_formatter(timedelta, '%-Hh', '%-d %b', '%Y')))
elif interval_seconds < tdelta(days=3).total_seconds():
# print("xticks: days")
unit_multiple = _next_largest(
interval_seconds / tdelta(days=1).total_seconds(),
INTERVALS['DAILY'])
timedelta = tdelta(days=unit_multiple)
return (mdates.WeekdayLocator(byweekday=range(0, 7, unit_multiple)),
FuncFormatter(
_get_dynamic_formatter(timedelta, '%-d', '%b', '%Y')))
elif interval_seconds < tdelta(days=14).total_seconds():
# print("xticks: weeks")
unit_multiple = _next_largest(
interval_seconds / tdelta(weeks=1).total_seconds(),
INTERVALS['WEEKLY'])
timedelta = tdelta(days=unit_multiple * 7)
return (mdates.WeekdayLocator(byweekday=0, interval=unit_multiple),
FuncFormatter(
_get_dynamic_formatter(timedelta, '%-d', '%b', '%Y')))
elif interval_seconds < tdelta(weeks=26).total_seconds():
# print("xticks: months")
unit_multiple = _next_largest(
interval_seconds / tdelta(weeks=4).total_seconds(),
INTERVALS['MONTHLY'])
timedelta = tdelta(weeks=unit_multiple * 4)
return (mdates.MonthLocator(bymonth=range(1, 13, unit_multiple)),
FuncFormatter(_get_dynamic_formatter(timedelta, '%b', '%Y')))
else:
# print("xticks: years")
unit_multiple = _next_largest(
interval_seconds / tdelta(weeks=52).total_seconds(),
INTERVALS['YEARLY'])
return (mdates.YearLocator(base=unit_multiple),
mdates.DateFormatter('%Y'))
def animate(i):
# Add next value
data.append(np.random.randint(0, max_rand))
line.set_ydata(data)
# plt.savefig('e:\\python temp\\fig_{:02}'.format(i))
print(i)
return line,
max_x = 100
max_rand = 5
data = deque(np.zeros(max_x), maxlen=max_x) # hold the last values
x = np.arange(0, max_x)
fig, ax = plt.subplots()
ax.set_ylim(0, max_rand)
ax.set_xlim(0, max_x - 1)
line, = ax.plot(x, np.random.randint(0, max_rand, max_x))
ax.xaxis.set_major_formatter(
FuncFormatter(lambda x, pos: '{:.0f}s'.format(max_x - x - 1)))
plt.xlabel('Seconds ago')
ani = animation.FuncAnimation(fig,
animate,
init_func=init,
interval=10,
blit=True,
save_count=10)
plt.show()
# ax = dfn.plot.bar(x='Fieldwork sites', y = 'Fieldwork Budget (php)', rot = 0, color = "orange", title = "Comparison of Maintenance Budget for Different Clustered Sites ")
# yticks([0 50 100])
# yticklabels({'y = 0','y = 50','y = 100'})
from matplotlib.ticker import FuncFormatter
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(2)
money = dfn["Fieldwork Budget (php)"].values
def thousands(x, pos):
'The two args are the value and tick position'
return 'P%1.1fK' % (x * 1e-3)
formatter = FuncFormatter(thousands)
fig, ax = plt.subplots()
ax.yaxis.set_major_formatter(formatter)
plt.bar(dfn["Fieldwork sites"], dfn["Fieldwork Budget (php)"], color = "orange")
plt.xticks(x, dfn["Fieldwork sites"].values)
plt.title("Comparison of Maintenance Cost for Different Clustered Sites", fontsize = 20)
plt.xlabel("Fieldwork sites")
plt.ylabel("Fieldwork Budget (php)")
plt.show()
def plot_plan_and_vert(x, y, z, dataxy, datazx, datazy, unit="",
title="", saveto="", **kwargs):
"""Plot 2-D plan view of ``dataxy`` together with vertical sections \
``dataxz`` and ``datazy``
Parameters
----------
x : :class:`numpy:numpy.ndarray`
array of x-axis coordinates
y : :class:`numpy:numpy.ndarray`
array of y-axis coordinates
z : :class:`numpy:numpy.ndarray`
array of z-axis coordinates
dataxy : :class:`numpy:numpy.ndarray`
2d array of shape (len(x), len(y))
datazx : :class:`numpy:numpy.ndarray`
2d array of shape (len(z), len(x))
datazy : :class:`numpy:numpy.ndarray`
2d array of shape (len(z), len(y))
unit : string
unit of data arrays
title: string
figure title
saveto : string
file path if figure should be saved
Keyword Arguments
-----------------
**kwargs : other kwargs which can be passed to \
:func:`matplotlib.pyplot.contourf`
"""
pl.figure(figsize=(10, 10))
# define axes
left, bottom, width, height = 0.1, 0.1, 0.6, 0.2
ax_xy = pl.axes((left, bottom, width, width))
ax_x = pl.axes((left, bottom + width, width, height))
ax_y = pl.axes((left + width, bottom, height, width))
ax_cb = pl.axes((left + width + height + 0.02, bottom, 0.02, width))
# set axis label formatters
ax_x.xaxis.set_major_formatter(NullFormatter())
ax_y.yaxis.set_major_formatter(NullFormatter())
# draw CAPPI
pl.sca(ax_xy)
xy = pl.contourf(x, y, dataxy, **kwargs)
pl.grid(color="grey", lw=1.5)
# draw colorbar
cb = pl.colorbar(xy, cax=ax_cb)
cb.set_label("(%s)" % unit)
# draw upper vertical profil
ax_x.contourf(x, z, datazx, **kwargs)
# draw right vertical profil
ax_y.contourf(z, y, datazy.T, **kwargs)
# label axes
ax_xy.set_xlabel('x (km)')
ax_xy.set_ylabel('y (km)')
ax_x.set_xlabel('')
ax_x.set_ylabel('z (km)')
ax_y.set_ylabel('')
ax_y.set_xlabel('z (km)')
def xycoords(x, pos):
"""The two args are the value and tick position"""
return "%d" % (x / 1000.)
xyformatter = FuncFormatter(xycoords)
def zcoords(x, pos):
"""The two args are the value and tick position"""
return ("%.1f" % (x / 1000.)).rstrip('0').rstrip('.')
zformatter = FuncFormatter(zcoords)
ax_xy.xaxis.set_major_formatter(xyformatter)
ax_xy.yaxis.set_major_formatter(xyformatter)
ax_x.yaxis.set_major_formatter(zformatter)
ax_y.xaxis.set_major_formatter(zformatter)
if not title == "":
# add a title - here, we have to create a new axes object which will
# be invisible then the invisible axes will get a title
tax = pl.axes((left, bottom + width + height + 0.01,
width + height, 0.01), frameon=False, facecolor="none")
tax.get_xaxis().set_visible(False)
tax.get_yaxis().set_visible(False)
pl.title(title)
if saveto == '':
# show plot
pl.show()
if not pl.isinteractive():
# close figure eplicitely if pylab is not in interactive mode
pl.close()
else:
# save plot to file
if ((os.path.exists(os.path.dirname(saveto))) or
(os.path.dirname(saveto) == '')):
pl.savefig(saveto)
pl.close()
def draw(
cls,
series_defs: List[SeriesDef],
raw_samples: List[CurveData],
fit_samples: List[CurveData],
tick_labels: Dict[str, str],
fit_data: FitData,
result_entries: List[AnalysisResultData],
style: Optional[PlotterStyle] = None,
axis: Optional["matplotlib.axes.Axes"] = None,
) -> "pyplot.Figure":
"""Create a fit result of all curves in the single canvas.
Args:
series_defs: List of definition for each curve.
raw_samples: List of raw sample data for each curve.
fit_samples: List of formatted sample data for each curve.
tick_labels: Dictionary of axis label information. Axis units and label for x and y
value should be explained.
fit_data: fit data generated by the analysis.
result_entries: List of analysis result data entries. If
:py:class:`~qiskit_experiments.database_service.db_fitval.FitVal` object is a value,
that entry will be shown in the fit report.
style: Optional. A configuration object to modify the appearance of the figure.
axis: Optional. A matplotlib Axis object.
Returns:
A matplotlib figure of the curve fit result.
"""
if axis is None:
axis = get_non_gui_ax()
# update image size to experiment default
figure = axis.get_figure()
figure.set_size_inches(*style.figsize)
else:
figure = axis.get_figure()
# get canvas number
n_subplots = max(series_def.canvas for series_def in series_defs) + 1
# use inset axis. this allows us to draw multiple canvases on a given single axis object
inset_ax_h = (1 - (0.05 * (n_subplots - 1))) / n_subplots
inset_axes = [
axis.inset_axes(
[0, 1 - (inset_ax_h + 0.05) * n_axis - inset_ax_h, 1, inset_ax_h],
transform=axis.transAxes,
zorder=1,
)
for n_axis in range(n_subplots)
]
# show x label only in the bottom canvas
for inset_axis in inset_axes[:-1]:
inset_axis.set_xticklabels([])
inset_axes[-1].get_shared_x_axes().join(*inset_axes)
# remove original axis frames
axis.spines.right.set_visible(False)
axis.spines.left.set_visible(False)
axis.spines.top.set_visible(False)
axis.spines.bottom.set_visible(False)
axis.set_xticks([])
axis.set_yticks([])
# collect data source per canvas
plot_map = defaultdict(list)
for curve_ind, series_def in enumerate(series_defs):
plot_map[series_def.canvas].append(curve_ind)
y_labels = tick_labels["ylabel"].split(",")
if len(y_labels) == 1:
y_labels = y_labels * n_subplots
for ax_ind, curve_inds in plot_map.items():
inset_axis = inset_axes[ax_ind]
for curve_ind in curve_inds:
draw_single_curve_mpl(
axis=inset_axis,
series_def=series_defs[curve_ind],
raw_sample=raw_samples[curve_ind],
fit_sample=fit_samples[curve_ind],
fit_data=fit_data,
)
# add legend to each inset axis
if len(curve_inds) > 1:
inset_axis.legend(loc=style.legend_loc)
# format y axis tick value of each inset axis
yaxis = getattr(inset_axis, "yaxis")
unit = tick_labels["yval_unit"]
label = y_labels[ax_ind]
if unit:
maxv = np.max(np.abs(yaxis.get_data_interval()))
scaled_maxv, prefix = detach_prefix(maxv, decimal=3)
prefactor = scaled_maxv / maxv
# pylint: disable=cell-var-from-loop
yaxis.set_major_formatter(FuncFormatter(lambda x, p: f"{x * prefactor: .3g}"))
yaxis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size)
else:
inset_axis.ticklabel_format(axis="y", style="sci", scilimits=(-3, 3))
yaxis.set_label_text(label, fontsize=style.axis_label_size)
if tick_labels["ylim"]:
inset_axis.set_ylim(tick_labels["ylim"])
# format x axis
xaxis = getattr(inset_axes[-1], "xaxis")
unit = tick_labels["xval_unit"]
label = tick_labels["xlabel"]
if unit:
maxv = np.max(np.abs(xaxis.get_data_interval()))
scaled_maxv, prefix = detach_prefix(maxv, decimal=3)
prefactor = scaled_maxv / maxv
# pylint: disable=cell-var-from-loop
xaxis.set_major_formatter(FuncFormatter(lambda x, p: f"{x * prefactor: .3g}"))
xaxis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size)
else:
axis.ticklabel_format(axis="x", style="sci", scilimits=(-3, 3))
xaxis.set_label_text(label, fontsize=style.axis_label_size)
if tick_labels["xlim"]:
inset_axes[-1].set_xlim(tick_labels["xlim"])
# write analysis report
if fit_data:
report_str = write_fit_report(result_entries)
report_str += r"Fit $\chi^2$ = " + f"{fit_data.reduced_chisq: .4g}"
report_handler = axis.text(
*style.fit_report_rpos,
report_str,
ha="center",
va="top",
size=style.fit_report_text_size,
transform=axis.transAxes,
)
bbox_props = dict(boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8)
report_handler.set_bbox(bbox_props)
axis.tick_params(labelsize=style.tick_label_size)
axis.grid(True)
return figure
def y_format(x, y):
return '{:.0f}'.format(
1 if round(10**x - 1, -1) == 0 else round(10**x - 1, -1)
) # not 100% accurate binning, but the -1 is so we can label the bottom of the colorbar as 0, doesn't throw off calc by much
#return '{:.0f}'.format(round(10**x-1,-1) if 10**x-1 != 1 else 1) # not 100% accurate binning, but the -1 is so we can label the bottom of the colorbar as 0, doesn't throw off calc by much
counts, edges = np.histogram(g.get_array(), bins=8)
cbar = fig.colorbar(g,
ax=ax,
orientation='vertical',
extend='both',
extendrect=True,
drawedges=False,
ticks=edges,
format=FuncFormatter(y_format))
cbar.set_label('Number of Regions', rotation=270, labelpad=20)
#pearson correlation
pr, pval = pearsonr(ccr, gerp)
npr, npval = pearsonr(ngerps, nccrs)
plt.tight_layout()
sns.despine()
plt.xlabel("CCR\n" + str(ct) + " out of " + str(total) +
" unique regions in red box")
plt.ylabel("Mean GERP++ score")
print "Pearson's r: " + str(pr) + "\np-value: " + str(pval)
print "Pearson's r >=20: " + str(npr) + "\np-value: " + str(npval)
plt.savefig(sys.argv[2], bbox_inches='tight')
# making table for supplement
f = open(sys.argv[3], 'w')
def draw(
cls,
series_defs: List[SeriesDef],
raw_samples: List[CurveData],
fit_samples: List[CurveData],
tick_labels: Dict[str, str],
fit_data: FitData,
result_entries: List[AnalysisResultData],
style: Optional[PlotterStyle] = None,
axis: Optional["matplotlib.axes.Axes"] = None,
) -> "pyplot.Figure":
"""Create a fit result of all curves in the single canvas.
Args:
series_defs: List of definition for each curve.
raw_samples: List of raw sample data for each curve.
fit_samples: List of formatted sample data for each curve.
tick_labels: Dictionary of axis label information. Axis units and label for x and y
value should be explained.
fit_data: fit data generated by the analysis.
result_entries: List of analysis result data entries. If
:py:class:`~qiskit_experiments.database_service.db_fitval.FitVal` object is a value,
that entry will be shown in the fit report.
style: Optional. A configuration object to modify the appearance of the figure.
axis: Optional. A matplotlib Axis object.
Returns:
A matplotlib figure of the curve fit result.
"""
if axis is None:
axis = get_non_gui_ax()
# update image size to experiment default
figure = axis.get_figure()
figure.set_size_inches(*style.figsize)
else:
figure = axis.get_figure()
# draw all curves on the same canvas
for series_def, raw_samp, fit_samp in zip(series_defs, raw_samples, fit_samples):
draw_single_curve_mpl(
axis=axis,
series_def=series_def,
raw_sample=raw_samp,
fit_sample=fit_samp,
fit_data=fit_data,
)
# add legend
if len(series_defs) > 1:
axis.legend(loc=style.legend_loc)
# get axis scaling factor
for this_axis in ("x", "y"):
sub_axis = getattr(axis, this_axis + "axis")
unit = tick_labels[this_axis + "val_unit"]
label = tick_labels[this_axis + "label"]
if unit:
maxv = np.max(np.abs(sub_axis.get_data_interval()))
scaled_maxv, prefix = detach_prefix(maxv, decimal=3)
prefactor = scaled_maxv / maxv
# pylint: disable=cell-var-from-loop
sub_axis.set_major_formatter(FuncFormatter(lambda x, p: f"{x * prefactor: .3g}"))
sub_axis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size)
else:
sub_axis.set_label_text(label, fontsize=style.axis_label_size)
axis.ticklabel_format(axis=this_axis, style="sci", scilimits=(-3, 3))
if tick_labels["xlim"]:
axis.set_xlim(tick_labels["xlim"])
if tick_labels["ylim"]:
axis.set_ylim(tick_labels["ylim"])
# write analysis report
if fit_data:
report_str = write_fit_report(result_entries)
report_str += r"Fit $\chi^2$ = " + f"{fit_data.reduced_chisq: .4g}"
report_handler = axis.text(
*style.fit_report_rpos,
report_str,
ha="center",
va="top",
size=style.fit_report_text_size,
transform=axis.transAxes,
)
bbox_props = dict(boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8)
report_handler.set_bbox(bbox_props)
axis.tick_params(labelsize=style.tick_label_size)
axis.grid(True)
return figure
def plot_figure(filename,
varname,
vmin=None,
vmax=None,
figsize=None,
ax=None):
"""
Plot the given variable for each file from a simulation
"""
global verbose, title_info
if verbose > 1:
print('Plotting {} from file {}'.format(varname, filename))
axis_type = 1 # 0 - off, 1 - left+bottom, 2 - all
if ax is not None:
fig = ax.get_figure()
elif figsize is None:
fig, ax = plt.subplots(1, 1, figsize=(8, 8))
else:
fig, ax = plt.subplots(1, 1, figsize=figsize)
if verbose > 1:
print('Adjusting subplot')
if axis_type == 0:
plt.subplots_adjust(left=0,
right=0.9,
bottom=0.05,
top=0.92,
wspace=0,
hspace=0)
else:
plt.subplots_adjust(left=0.1,
right=0.9,
bottom=0.1,
top=0.92,
wspace=0,
hspace=0)
plt.set_cmap(cm.coolwarm)
if verbose > 1:
print('Reading data')
# Draw initial plot
f = filename
data = sdf.read(f)
var = data.__dict__[varname]
grid = var.grid
vdata = var.data
i0 = 1
i1 = 0
if len(grid.dims) == 2:
x = grid.data[i0]
y = grid.data[i1]
else:
if (grid.dims[0] == 1):
orig = var.grid.name.replace('/', '_') + '_Orig'
grid = data.__dict__[orig]
i0 = 2
i1 = 1
x = grid.data[i0]
y = grid.data[i1]
elif (grid.dims[1] == 1):
i0 = 0
i1 = 1
x = grid.data[0][:, 0, :]
y = grid.data[1][:, 0, :]
else:
i0 = 0
i1 = 2
x = grid.data[0][:, :, 0]
y = grid.data[1][:, :, 0]
z = grid.data[2][:, :, 0]
x = np.sqrt(x * x + y * y)
y = z
if verbose > 1:
print('Scaling data')
vdata = vdata
if vmin is None:
vmin, vmax = get_var_range_from_sdf_files((filename, ), varname)
if verbose > 1:
print('Plotting data')
im = ax.pcolormesh(x, y, vdata, vmin=vmin, vmax=vmax)
if verbose > 1:
print('Plotting axes')
xmult, xsym = get_si_prefix(np.max(x) - np.min(x))
ymult, ysym = get_si_prefix(np.max(y) - np.min(y))
if verbose > 1:
print('Scale axis by {} ({}, {})'.format(xmult, np.min(x), np.max(x)))
ax.xaxis.set_major_formatter(
FuncFormatter(lambda x, y: '{:.2f}'.format(x * xmult)))
ax.yaxis.set_major_formatter(
FuncFormatter(lambda x, y: '{:.2f}'.format(x * ymult)))
ax.set_xlabel(grid.labels[i0] + ' $(' + xsym + grid.units[i0] + ')$')
ax.set_ylabel(grid.labels[i1] + ' $(' + ysym + grid.units[i1] + ')$')
ax.axis('image')
if axis_type == 0:
ax.axis('off')
elif axis_type == 1:
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
# Add colorbar
mult, sym = get_si_prefix(vmax - vmin)
if verbose > 0 and plot_figure.first:
plot_figure.first = False
print('Scale colorbar by {} ({}, {})'.format(mult, vmin, vmax))
data_label = var.name + ' $(' + sym + var.units + ')$'
if title_info:
legend_label = ''
else:
legend_label = data_label
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", "5%", pad="5%")
cbar = fig.colorbar(
im,
cax=cax,
ax=ax,
label=legend_label,
format=FuncFormatter(lambda x, y: '{:.2f}'.format(x * mult)))
if title_info:
title_label = data_label + ', '
else:
title_label = ''
fig.fs = 'large'
fig.suptitle(
title_label +
'step={}, time={}'.format(data.Header['step'], data.Header['time']),
fontsize=fig.fs,
y=0.98)
fig.sca(ax)
fig.canvas.draw()
if verbose > 1:
print('Done plotting {} from file {}'.format(varname, filename))
return im, ax
pstring = lambda i: ("+" if i[0] != '-' else "") + str(i)
BOX_Change = pstring("{0:.2%}".format(
float(sub(r"[^\d.]", "", series.at[number_of_rows - 1, "BOX Price"])) /
float(sub(r"[^\d.]", "", series.at[0, "BOX Price"])) - 1))
BTC_Change = pstring("{0:.2%}".format(
float(sub(r"[^\d.]", "", series.at[number_of_rows - 1, "BTC Price"])) /
float(sub(r"[^\d.]", "", series.at[0, "BTC Price"])) - 1))
# EOS_Change = pstring("{0:.2%}".format(float(sub(r"[^\d.]", "", series.at[number_of_rows - 1, "EOS Price"]))/float(sub(r"[^\d.]", "", series.at[0, "EOS Price"])) - 1))
# XIN_Change = pstring("{0:.2%}".format(float(sub(r"[^\d.]", "", series.at[number_of_rows - 1, "XIN Price"]))/float(sub(r"[^\d.]", "", series.at[0, "XIN Price"])) - 1))
RIBOX_Change = pstring("{0:.2%}".format(
float(series.at[number_of_rows - 1, "BOX Value Accumulated"] /
series.at[number_of_rows - 1, "Total Invested"] - 1)))
# draw the figure
ax = plt.gca()
ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: '{:.0%}'.format(y)))
# series.plot(kind='line', x='Date', y='BTC', ax=ax, figsize = (20,10), color="red")
# series.plot(kind='line', x='Date', y='EOS', ax=ax, figsize = (20,10), color="brown")
# series.plot(kind='line', x='Date', y='XIN', ax=ax, figsize = (20,10), color="purple")
series.plot(kind='line',
x='Date',
y='BOX',
ax=ax,
figsize=(20, 10),
color="green")
series.plot(kind='line',
x='Date',
y='RI-BOX',
ax=ax,
figsize=(20, 10),
color="blue")
def plot_hist(lengths,
x_name,
y_name,
show=True,
img_out=None,
title=None,
bin_width=10):
"""
Given a list of TCP payload lengths (or some other kind of 1D data),
plot a historam showing the distribution of these payload lengths.
:param list lengths: a list of integer payload lengths.
:param str x_name: the name of the x-axis property.
:param str y_name: the name of the y-axis property.
:param bool show: if True, show the plot through a GUI interface.
:param str img_out: if set, output the plot to the path specified.
:param str title: if set, display the title as specified in string.
:param int bin_width: if set decides the width of bins, 10 by default.
:returns: True if plot successfully, False otherwise.
"""
if any([not isinstance(x, int) or x < 0 for x in lengths]):
return False
if not isinstance(x_name, str) or not isinstance(y_name, str):
return False
if title and not isinstance(title, str):
return False
bins = floor(max(lengths) / bin_width)
weights = np.ones_like(lengths) / (len(lengths))
n, bins, patches = plt.hist(lengths,
bins=bins,
range=(0, max(lengths)),
weights=weights,
facecolor='g',
alpha=0.75)
plt.xlabel(x_name)
plt.ylabel(y_name)
if title:
plt.title(title)
plt.grid(color='k',
which='both',
axis='both',
alpha=0.25,
linestyle='dashed')
plt.gca().yaxis.set_major_formatter(FuncFormatter(to_percent))
if img_out is not None:
out_path = utils.get_full_path(img_out)
if out_path:
plt.savefig(os.path.expanduser(out_path), dpi=200)
if show:
plt.show()
return True
def genMatplotlibFig(self, file_path=None):
nRow, nCol = 3, 3
Fig = Figure(figsize=(min(32, 16 + (nCol - 1) * 8), 8 * nRow))
xData = np.arange(1, self._Output["统计数据"].shape[0] - 1)
xTickLabels = [str(iInd) for iInd in self._Output["统计数据"].index[:-2]]
PercentageFormatter = FuncFormatter(_QS_formatMatplotlibPercentage)
FloatFormatter = FuncFormatter(lambda x, pos: '%.2f' % (x, ))
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 1), xData, xTickLabels,
self._Output["统计数据"]["年化超额收益率"].iloc[:-2],
PercentageFormatter,
self._Output["统计数据"]["胜率"].iloc[:-2],
PercentageFormatter)
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 2), xData, xTickLabels,
self._Output["统计数据"]["信息比率"].iloc[:-2],
PercentageFormatter, None)
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 3), xData, xTickLabels,
self._Output["统计数据"]["超额最大回撤率"].iloc[:-2],
PercentageFormatter, None)
_QS_plotStatistics(
Fig.add_subplot(nRow, nCol, 4), xData, xTickLabels,
self._Output["统计数据"]["年化收益率"].iloc[:-2], PercentageFormatter,
pd.Series(self._Output["统计数据"].loc["市场", "年化收益率"],
index=self._Output["统计数据"].index[:-2],
name="市场"), PercentageFormatter, False)
_QS_plotStatistics(
Fig.add_subplot(nRow, nCol, 5), xData, xTickLabels,
self._Output["统计数据"]["Sharpe比率"].iloc[:-2], FloatFormatter,
pd.Series(self._Output["统计数据"].loc["市场", "Sharpe比率"],
index=self._Output["统计数据"].index[:-2],
name="市场"), FloatFormatter, False)
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 6), xData, xTickLabels,
self._Output["统计数据"]["平均换手率"].iloc[:-2],
PercentageFormatter, None)
Axes = Fig.add_subplot(nRow, nCol, 7)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
Axes.plot(self._Output["净值"].index,
self._Output["净值"].iloc[:, 0].values,
label=str(self._Output["净值"].iloc[:, 0].name),
color="indianred",
lw=2.5)
Axes.plot(self._Output["净值"].index,
self._Output["净值"].iloc[:, -3].values,
label=str(self._Output["净值"].iloc[:, -3].name),
color="steelblue",
lw=2.5)
Axes.plot(self._Output["净值"].index,
self._Output["净值"]["市场"].values,
label="市场",
color="forestgreen",
lw=2.5)
Axes.legend(loc='best')
Axes = Fig.add_subplot(nRow, nCol, 8)
xData = np.arange(0, self._Output["净值"].shape[0])
xTicks = np.arange(0, self._Output["净值"].shape[0],
max(1, int(self._Output["净值"].shape[0] / 8)))
xTickLabels = [
self._Output["净值"].index[i].strftime("%Y-%m-%d") for i in xTicks
]
Axes.plot(xData,
self._Output["净值"]["L-S"].values,
label="多空净值",
color="indianred",
lw=2.5)
Axes.legend(loc='upper left')
RAxes = Axes.twinx()
RAxes.yaxis.set_major_formatter(PercentageFormatter)
RAxes.bar(xData,
self._Output["收益率"]["L-S"].values,
label="多空收益率",
color="steelblue")
RAxes.legend(loc="upper right")
Axes.set_xticks(xTicks)
Axes.set_xticklabels(xTickLabels)
Axes = Fig.add_subplot(nRow, nCol, 9)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["净值"].shape[1] - 2):
Axes.plot(self._Output["净值"].index,
self._Output["净值"].iloc[:, i].values,
label=str(self._Output["净值"].iloc[:, i].name),
lw=2.5)
Axes.legend(loc='best')
if file_path is not None:
Fig.savefig(file_path, dpi=150, bbox_inches='tight')
return Fig
def onpick(event):
global pl
global ind
global fig2
ind = event.ind
ind = ind[0]
#x_data = event.xdata
#y_data = event.ydata
#find ind of closest lat/lon
#ind = modules.find_nearest_point_index(obs_lons,obs_lats,x_data,y_data)
try:
for i in range(len(pl)):
pl.pop(0).remove()
first_run = False
except:
first_run = True
pass
pl = m.plot([X[ind]], [Y[ind]],
'o',
ms=12,
alpha=0.6,
color='yellow',
zorder=20)
#get model timeseries for site clicked
lat_n, lon_n = modules.obs_model_gridbox(lat_e, lon_e, obs_lats[ind],
obs_lons[ind])
model_var_pick = model_var[:, lat_n, lon_n]
model_var_pick = model_var_pick * 1e9
model_var_mask = np.ma.masked_where(model_var_pick <= 0, model_var_pick)
if model_name == 'MACC':
model_time_pd = pd.date_range(start=model_datetimes[0],
end=model_datetimes[-1],
freq='H')
count = 0
valids = []
for i in range(len(model_time_pd)):
if count == 0:
valids.append(i)
count += 1
elif count == 2:
count = 0
else:
count += 1
model_time_pd = model_time_pd[valids]
model_var_pd = pd.Series(model_var_mask, index=model_time_pd)
else:
model_time_pd = pd.date_range(start=model_datetimes[0],
end=model_datetimes[-1],
freq='H')
model_var_pd = pd.Series(model_var_mask, index=model_time_pd)
#get obs timeseries for site clicked
ref = obs_refs[ind]
obs_ts_group = obs_root_grp.groups[ref]
obs_var = obs_ts_group.variables[species.lower()][:]
group = obs_ts_group.process_group
lat = obs_ts_group.latitude
lon = obs_ts_group.longitude
lon = obs_ts_group.longitude
alt = obs_ts_group.altitude
complete = obs_ts_group.completeness
a_class = obs_ts_group.anthrome_class
r_class = obs_ts_group.raw_class
continent = loc_dict[tags[ind]]
country = obs_ts_group.country
obs_var_mask = np.ma.masked_where(obs_var <= 0, obs_var)
obs_time_pd = pd.date_range(start=obs_datetimes[0],
end=obs_datetimes[-1],
freq='H')
obs_var_pd = pd.Series(obs_var_mask, index=obs_time_pd)
#create sine wave from amp/phase
obs_date_l = obs_date.astype(int)
obs_time_l = obs_time.astype(int)
obs_times = modules.date_process(obs_date_l, obs_time_l, start_year)
obs_times = np.array(obs_times)
pi2 = np.pi * 2
#convert phases to radians
calc = pi2 / 6.
obs_ha_phase_r = obs_ha_phase[ind] * calc
calc = pi2 / 12.
obs_annual_phase_r = obs_annual_phase[ind] * calc
ha_obs_wave = obs_ha_mag[ind] * (np.cos((pi2 * obs_times / (365.25 / 2.)) -
(obs_ha_phase_r)))
annual_obs_wave = obs_annual_mag[ind] * (np.cos((pi2 * obs_times /
(365.25)) -
(obs_annual_phase_r)))
seasonal_obs_wave = (ha_obs_wave + annual_obs_wave) + obs_ave[ind]
obs_seasonal_wave_pd = pd.Series(seasonal_obs_wave, index=obs_time_pd)
#create sine wave from amp/phase
mod_date_l = model_date.astype(int)
mod_time_l = model_time.astype(int)
mod_times = modules.date_process(mod_date_l, mod_time_l, start_year)
mod_times = np.array(mod_times)
pi2 = np.pi * 2
#convert phases to radians
calc = pi2 / 6.
model_ha_phase_r = model_ha_phase[ind] * calc
calc = pi2 / 12.
model_annual_phase_r = model_annual_phase[ind] * calc
ha_model_wave = model_ha_mag[ind] * (np.cos((pi2 * mod_times /
(365.25 / 2.)) -
(model_ha_phase_r)))
annual_model_wave = model_annual_mag[ind] * (np.cos(
(pi2 * mod_times / (365.25)) - (model_annual_phase_r)))
seasonal_model_wave = (ha_model_wave + annual_model_wave) + model_ave[ind]
model_seasonal_wave_pd = pd.Series(seasonal_model_wave,
index=model_time_pd)
#get spectra data
site_group_obs = root_grp_obs_spec.groups[ref]
site_group_mod = root_grp_mod_spec.groups[ref]
obs_period = site_group_obs.variables['period'][:]
mod_period = site_group_mod.variables['period'][:]
obs_amp = site_group_obs.variables['amplitude'][:]
mod_amp = site_group_mod.variables['amplitude'][:]
fig.canvas.draw()
if first_run == False:
plt.close(fig2)
fig2, (axo, axo2) = plt.subplots(2, figsize=(24, 12))
fig2.patch.set_facecolor('white')
#fig2 = plt.figure()
axo.plot_date(obs_time_pd.to_pydatetime(),
obs_var_pd,
color='black',
markersize=3,
label='Observations')
axo.plot_date(model_time_pd.to_pydatetime(),
model_var_pd,
color='red',
alpha=0.5,
markersize=3,
label='%s %s %s %s' %
(model_name, version, grid_size, met),
markeredgecolor='None')
axo.plot_date(obs_time_pd.to_pydatetime(),
obs_seasonal_wave_pd,
color='yellow',
markersize=3,
label='Obs Seasonal Waveform',
markeredgecolor='None')
axo.plot_date(model_time_pd.to_pydatetime(),
model_seasonal_wave_pd,
color='green',
markersize=3,
label='Model Seasonal Waveform',
markeredgecolor='None')
axo2.loglog(obs_period, obs_amp, color='black', label='Obs')
axo2.loglog(mod_period,
mod_amp,
color='red',
label='%s %s %s %s' %
(model_name, version, grid_size, met))
axo2.text(0.01,
0.95,
'Obs D Amp = %8.2f ppb' % (obs_daily_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.92,
'Model D Amp = %8.2f ppb' % (model_daily_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.85,
'Obs HA Amp = %8.2f ppb' % (obs_ha_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.82,
'Model HA Amp = %8.2f ppb' % (model_ha_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.75,
'Obs A Amp = %8.2f ppb' % (obs_annual_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.72,
'Model A Amp = %8.2f ppb' % (model_annual_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.55,
'Obs D Phase = %8.2f' % (obs_daily_phase[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.52,
'Model D Phase = %8.2f' % (model_daily_phase[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.45,
'Obs HA Phase = %8.2f' % (obs_ha_phase[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.42,
'Model HA Phase = %8.2f' % (model_ha_phase[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
obs_a_ph = obs_annual_phase[ind]
mod_a_ph = model_annual_phase[ind]
if obs_a_ph > 12:
obs_a_ph = obs_a_ph - 12.
if mod_a_ph > 12:
mod_a_ph = mod_a_ph - 12.
axo2.text(0.01,
0.35,
'Obs A Phase = %8.2f' % (obs_a_ph),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.32,
'Model A Phase = %8.2f' % (mod_a_ph),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.15,
'Obs Ave = %8.2f ppb' % (obs_ave[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.12,
'Model Ave = %8.2f ppb' % (model_ave[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.axvline(1., ymin=0, ymax=1, color='blue', linestyle='--')
axo2.axvline(182.625, ymin=0, ymax=1, color='blue', linestyle='--')
axo2.axvline(365.25, ymin=0, ymax=1, color='blue', linestyle='--')
axo2.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
axo2.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
plt.gca().xaxis.set_major_formatter(FuncFormatter(xformatter))
plt.gca().yaxis.set_major_formatter(FuncFormatter(yformatter))
axo.set_title(
'Site = %s, Country = %s, Continent = %s, Process Group = %s, Lat = %s, Lon = %s, Alt = %sm,\n Data Completeness = %s%%, Anthrome Class = %s, Raw Class = %s, Grid Index = %s,%s'
% (ref, country, continent, group, lat, lon, alt, complete,
a_class, r_class, lat_n, lon_n))
plt.legend(loc='lower right')
plt.tight_layout()
axo.grid()
axo2.grid()
plt.show()
else:
#fig2 = plt.figure()
fig2, (axo, axo2) = plt.subplots(2, figsize=(24, 12))
fig2.patch.set_facecolor('white')
axo.plot_date(obs_time_pd.to_pydatetime(),
obs_var_pd,
color='black',
markersize=3,
label='Observations')
axo.plot_date(model_time_pd.to_pydatetime(),
model_var_pd,
color='red',
markersize=3,
alpha=0.5,
label='%s %s %s %s' %
(model_name, version, grid_size, met),
markeredgecolor='None')
axo.plot_date(obs_time_pd.to_pydatetime(),
obs_seasonal_wave_pd,
color='yellow',
markersize=3,
label='Obs Seasonal Waveform',
markeredgecolor='None')
axo.plot_date(model_time_pd.to_pydatetime(),
model_seasonal_wave_pd,
color='green',
markersize=3,
label='Model Seasonal Waveform',
markeredgecolor='None')
axo2.loglog(obs_period, obs_amp, color='black', label='Obs')
axo2.loglog(mod_period,
mod_amp,
color='red',
label='%s %s %s %s' %
(model_name, version, grid_size, met))
axo2.text(0.01,
0.95,
'Obs D Amp = %8.2f ppb' % (obs_daily_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.92,
'Model D Amp = %8.2f ppb' % (model_daily_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.85,
'Obs HA Amp = %8.2f ppb' % (obs_ha_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.82,
'Model HA Amp = %8.2f ppb' % (model_ha_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.75,
'Obs A Amp = %8.2f ppb' % (obs_annual_mag[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.72,
'Model A Amp = %8.2f ppb' % (model_annual_mag[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.55,
'Obs D Phase = %8.2f' % (obs_daily_phase[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.52,
'Model D Phase = %8.2f' % (model_daily_phase[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.45,
'Obs HA Phase = %8.2f' % (obs_ha_phase[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.42,
'Model HA Phase = %8.2f' % (model_ha_phase[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
obs_a_ph = obs_annual_phase[ind]
mod_a_ph = model_annual_phase[ind]
if obs_a_ph > 12:
obs_a_ph = obs_a_ph - 12.
if mod_a_ph > 12:
mod_a_ph = mod_a_ph - 12.
axo2.text(0.01,
0.35,
'Obs A Phase = %8.2f' % (obs_a_ph),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.32,
'Model A Phase = %8.2f' % (mod_a_ph),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.text(0.01,
0.15,
'Obs Ave = %8.2f ppb' % (obs_ave[ind]),
transform=axo2.transAxes,
fontweight='bold')
axo2.text(0.01,
0.12,
'Model Ave = %8.2f ppb' % (model_ave[ind]),
transform=axo2.transAxes,
fontweight='bold',
color='red')
axo2.axvline(1., ymin=0, ymax=1, color='blue', linestyle='--')
axo2.axvline(182.625, ymin=0, ymax=1, color='blue', linestyle='--')
axo2.axvline(365.25, ymin=0, ymax=1, color='blue', linestyle='--')
axo2.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
axo2.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
plt.gca().xaxis.set_major_formatter(FuncFormatter(xformatter))
plt.gca().yaxis.set_major_formatter(FuncFormatter(yformatter))
axo.set_title(
'Site = %s, Country = %s, Continent = %s, Process Group = %s, Lat = %s, Lon = %s, Alt = %sm,\n Data Completeness = %s%%, Anthrome Class = %s, Raw Class = %s, Grid Index = %s,%s'
% (ref, country, continent, group, lat, lon, alt, complete,
a_class, r_class, lat_n, lon_n))
plt.legend(loc='lower right')
plt.tight_layout()
axo.grid()
axo2.grid()
plt.show()
def genMatplotlibFig(self, file_path=None):
nRow, nCol = 8, 3
Fig = Figure(figsize=(min(32, 16 + (nCol - 1) * 8), 8 * nRow))
xData = np.arange(1, self._Output["统计数据"]["Top"].shape[0] + 1)
xTickLabels = [str(iInd) for iInd in self._Output["统计数据"]["Top"].index]
PercentageFormatter = FuncFormatter(_QS_formatMatplotlibPercentage)
FloatFormatter = FuncFormatter(lambda x, pos: '%.2f' % (x, ))
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 1),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["年化超额收益率"],
PercentageFormatter,
self._Output["统计数据"]["Top"]["胜率"],
PercentageFormatter,
True,
title="Top 组合年化超额收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 2),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["信息比率"],
PercentageFormatter,
None,
title="Top 组合信息比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 3),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["超额最大回撤率"],
PercentageFormatter,
None,
title="Top 组合超额最大回撤率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 4),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["年化收益率"],
PercentageFormatter,
None,
title="Top 组合年化收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 5),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["Sharpe比率"],
FloatFormatter,
None,
title="Top 组合 Sharpe 比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 6),
xData,
xTickLabels,
self._Output["统计数据"]["Top"]["平均换手率"],
PercentageFormatter,
None,
title="Top 组合平均换手率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 7),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["年化超额收益率"],
PercentageFormatter,
self._Output["统计数据"]["Bottom"]["胜率"],
PercentageFormatter,
True,
title="Bottom 组合年化超额收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 8),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["信息比率"],
PercentageFormatter,
None,
title="Bottom 组合信息比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 9),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["超额最大回撤率"],
PercentageFormatter,
None,
title="Bottom 组合超额最大回撤率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 10),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["年化收益率"],
PercentageFormatter,
None,
title="Bottom 组合年化收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 11),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["Sharpe比率"],
FloatFormatter,
None,
title="Bottom 组合 Sharpe 比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 12),
xData,
xTickLabels,
self._Output["统计数据"]["Bottom"]["平均换手率"],
PercentageFormatter,
None,
title="Bottom 组合平均换手率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 13),
xData,
xTickLabels,
self._Output["统计数据"]["L-S"]["年化收益率"],
PercentageFormatter,
None,
title="L-S 组合年化收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 14),
xData,
xTickLabels,
self._Output["统计数据"]["L-S"]["Sharpe比率"],
FloatFormatter,
None,
title="L-S 组合 Sharpe 比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 15),
xData,
xTickLabels,
self._Output["统计数据"]["L-S"]["最大回撤率"],
PercentageFormatter,
None,
title="L-S 组合最大回撤Æ率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 16),
xData,
xTickLabels,
self._Output["统计数据"]["市场"]["年化收益率"],
PercentageFormatter,
None,
title="市场组合年化收益率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 17),
xData,
xTickLabels,
self._Output["统计数据"]["市场"]["Sharpe比率"],
FloatFormatter,
None,
title="市场组合 Sharpe 比率")
_QS_plotStatistics(Fig.add_subplot(nRow, nCol, 18),
xData,
xTickLabels,
self._Output["统计数据"]["市场"]["最大回撤率"],
PercentageFormatter,
None,
title="市场组合最大回撤率")
Axes = Fig.add_subplot(nRow, nCol, 19)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["净值"]["Top"].shape[1]):
Axes.plot(self._Output["净值"]["Top"].index,
self._Output["净值"]["Top"].iloc[:, i].values,
label=str(self._Output["净值"]["Top"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("Top 组合净值")
Axes = Fig.add_subplot(nRow, nCol, 20)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["净值"]["Bottom"].shape[1]):
Axes.plot(self._Output["净值"]["Bottom"].index,
self._Output["净值"]["Bottom"].iloc[:, i].values,
label=str(self._Output["净值"]["Bottom"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("Bottom 组合净值")
Axes = Fig.add_subplot(nRow, nCol, 21)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["净值"]["市场"].shape[1]):
Axes.plot(self._Output["净值"]["市场"].index,
self._Output["净值"]["市场"].iloc[:, i].values,
label=str(self._Output["净值"]["市场"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("市场组合净值")
Axes = Fig.add_subplot(nRow, nCol, 22)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["超额净值"]["Top"].shape[1]):
Axes.plot(self._Output["超额净值"]["Top"].index,
self._Output["超额净值"]["Top"].iloc[:, i].values,
label=str(self._Output["超额净值"]["Top"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("Top 组合超额净值")
Axes = Fig.add_subplot(nRow, nCol, 23)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["超额净值"]["Bottom"].shape[1]):
Axes.plot(self._Output["超额净值"]["Bottom"].index,
self._Output["超额净值"]["Bottom"].iloc[:, i].values,
label=str(self._Output["超额净值"]["Bottom"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("Bottom 组合超额净值")
Axes = Fig.add_subplot(nRow, nCol, 24)
Axes.xaxis_date()
Axes.xaxis.set_major_formatter(mdate.DateFormatter('%Y-%m-%d'))
for i in range(self._Output["净值"]["L-S"].shape[1]):
Axes.plot(self._Output["净值"]["L-S"].index,
self._Output["净值"]["L-S"].iloc[:, i].values,
label=str(self._Output["净值"]["L-S"].columns[i]),
lw=2.5)
Axes.legend(loc='best')
Axes.set_title("L-S 组合净值")
if file_path is not None:
Fig.savefig(file_path, dpi=150, bbox_inches='tight')
return Fig
def plot_streamflow():
plot_utils.apply_plot_params(width_pt=None, width_cm=19, height_cm=10, font_size=12)
labels = ["Glacier-only", "All"]
colors = ["r", "b"]
paths = [
"/skynet3_exec2/aganji/glacier_katja/watroute_gemera/discharge_stat_glac_00_99_2000_01_01_00_00.nc",
"/skynet3_exec2/aganji/glacier_katja/watroute_gemera/discharge_stat_both_00_992000_01_01_00_00.nc"]
infocell_path = "/skynet3_exec2/aganji/glacier_katja/watroute_gemera/infocell.nc"
start_year = 2000
end_year = 2099
with Dataset(paths[0]) as ds:
acc_area = ds.variables["accumulation_area"][:]
lons = ds.variables["longitude"][:]
lats = ds.variables["latitude"][:]
x_index = ds.variables["x_index"][:]
y_index = ds.variables["y_index"][:]
with Dataset(infocell_path) as ds:
fldr = ds.variables["flow_direction_value"][:]
driver = ogr.GetDriverByName('ESRI Shapefile')
data_source = driver.Open(path_to_basin_shape, 0)
assert isinstance(data_source, ogr.DataSource)
geom = None
print(data_source.GetLayerCount())
layer = data_source.GetLayer()
assert isinstance(layer, ogr.Layer)
print(layer.GetFeatureCount())
for feature in layer:
assert isinstance(feature, ogr.Feature)
geom = feature.geometry()
assert isinstance(geom, ogr.Geometry)
# print(str(geom))
# geom = ogr.CreateGeometryFromWkt(geom.ExportToWkt())
i, j = get_outlet_indices(geom, acc_area, lons, lats)
print("Accumulation area at the outlet (according to flow directions): {}".format(acc_area[i, j]))
cell_manager = CellManager(flow_dirs=fldr, lons2d=lons, lats2d=lats, accumulation_area_km2=acc_area)
model_mask = cell_manager.get_mask_of_upstream_cells_connected_with_by_indices(i, j)
cell_index = np.where((x_index == i) & (y_index == j))[0][0]
print(cell_index)
if not img_folder.is_dir():
img_folder.mkdir(parents=True)
# Do the plotting
fig = plt.figure()
gs = gridspec.GridSpec(1, 2, wspace=0.0)
# Plot the hydrograph
ax = fig.add_subplot(gs[0, 0])
for p, c, label in zip(paths, colors, labels):
with Dataset(p) as ds:
stfl = ds.variables["water_discharge_accumulated"][:, cell_index]
time = ds.variables["time"][:].astype(str)
time = [datetime.strptime("".join(ts), "%Y_%m_%d_%H_%M") for ts in time]
df = pd.DataFrame(index=time, data=stfl)
# remove 29th of February
df = df.select(lambda d: not (d.month == 2 and d.day == 29) and (start_year <= d.year <= end_year))
df = df.groupby(lambda d: datetime(2001, d.month, d.day)).mean()
ax.plot(df.index, df.values, c, lw=2, label=label)
ax.xaxis.set_major_formatter(FuncFormatter(lambda tickval, pos: num2date(tickval).strftime("%b")[0]))
ax.xaxis.set_major_locator(MonthLocator())
ax.legend(loc="upper left", bbox_to_anchor=(1.05, 1), borderaxespad=0)
ax.set_title("{}-{}".format(start_year, end_year))
# Plot the point position
ax = fig.add_subplot(gs[0, 1])
bsm = get_basemap_glaciers_nw_america()
x, y = bsm(lons[i, j], lats[i, j])
bsm.scatter(x, y, c="b", ax=ax, zorder=10)
bsm.drawcoastlines()
bsm.readshapefile(path_to_basin_shape.replace(".shp", ""), "basin", color="m", linewidth=2, zorder=5)
# xx, yy = bsm(lons, lats)
# cmap = cm.get_cmap("gray_r", 10)
# bsm.pcolormesh(xx, yy, model_mask * 0.5, cmap=cmap, vmin=0, vmax=1)
bsm.drawrivers(ax=ax, zorder=9, color="b")
plt.savefig(str(img_folder.joinpath("stfl_at_outlets.pdf")), bbox_inches="tight")
plt.close(fig)
mu = changes.mean()
vD = changes.std()
# Create an array of 10000 random walks - each with 90 steps
k = np.cumprod(1 + np.random.normal(mu, vD, (10000, 90)), 1) * end_price
# The last step as an array. In this case, useful to answer the question: "In 90 days, where could this go?"
l = k[:, -1]
# Plot
fig, ax = plt.subplots(2, 1, figsize=(11, 8.5))
ax[0].plot(k.T, linewidth=0.5)
ax[0].set_title("Forward Modeling; N = {:,}; {:,} Walks; {:,} Periods".format(
len(s), *k.shape))
ax[0].get_yaxis().set_major_formatter(
FuncFormatter(lambda a, b: '${:,.0f}'.format(a * 1e-0)))
ax[0].set_xlim(0, k.T.shape[0])
# Add a dotted line to trace the mean across the walks
ax[0].plot([_.mean() for _ in k.T],
color='k',
linewidth=1,
linestyle=':',
label='Expected Value')
# Annotate
ax[0].annotate('CAGR: {}\nvD: {}\nmu: {}'.format(
round(cagr, 8), round(vD, 8), round(mu, 8)),
xy=(0, 45),
xycoords='axes pixels',
xytext=(4, 0),
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from networkx.drawing.nx_agraph import graphviz_layout
from opendht import *
from dht.network import DhtNetwork, DhtNetworkSubProcess
############
# Common #
############
# matplotlib display format for bits (b, Kb, Mb)
bit_format = None
Kbit_format = FuncFormatter(lambda x, pos: '%1.1f' % (x * 1024**-1) + 'Kb')
Mbit_format = FuncFormatter(lambda x, pos: '%1.1f' % (x * 1024**-2) + 'Mb')
def random_str_val(size=1024):
"""Creates a random string value of specified size.
@param size: Size, in bytes, of the value.
@type size: int
@return: Random string value
@rtype : str
"""
return ''.join(random.choice(string.hexdigits) for _ in range(size))
def plot_rolling_returns(returns,
factor_returns=None,
live_start_date=None,
cone_std=None,
legend_loc='best',
volatility_match=False,
cone_function=timeseries.forecast_cone_bootstrap,
ax=None, **kwargs):
"""
Plots cumulative rolling returns versus some benchmarks'.
Backtest returns are in green, and out-of-sample (live trading)
returns are in red.
Additionally, a non-parametric cone plot may be added to the
out-of-sample returns region.
Parameters
----------
returns : pd.Series
Daily returns of the strategy, noncumulative.
- See full explanation in tears.create_full_tear_sheet.
factor_returns : pd.Series, optional
Daily noncumulative returns of a risk factor.
- This is in the same style as returns.
live_start_date : datetime, optional
The date when the strategy began live trading, after
its backtest period. This date should be normalized.
cone_std : float, or tuple, optional
If float, The standard deviation to use for the cone plots.
If tuple, Tuple of standard deviation values to use for the cone plots
- See timeseries.forecast_cone_bounds for more details.
legend_loc : matplotlib.loc, optional
The location of the legend on the plot.
volatility_match : bool, optional
Whether to normalize the volatility of the returns to those of the
benchmark returns. This helps compare strategies with different
volatilities. Requires passing of benchmark_rets.
cone_function : function, optional
Function to use when generating forecast probability cone.
The function signiture must follow the form:
def cone(in_sample_returns (pd.Series),
days_to_project_forward (int),
cone_std= (float, or tuple),
starting_value= (int, or float))
See timeseries.forecast_cone_bootstrap for an example.
ax : matplotlib.Axes, optional
Axes upon which to plot.
**kwargs, optional
Passed to plotting function.
Returns
-------
ax : matplotlib.Axes
The axes that were plotted on.
"""
if ax is None:
ax = plt.gca()
ax.set_ylabel('Cumulative returns')
ax.set_xlabel('')
if volatility_match and factor_returns is None:
raise ValueError('volatility_match requires passing of'
'factor_returns.')
elif volatility_match and factor_returns is not None:
bmark_vol = factor_returns.loc[returns.index].std()
returns = (returns / returns.std()) * bmark_vol
cum_rets = timeseries.cum_returns(returns, 1.0)
y_axis_formatter = FuncFormatter(utils.one_dec_places)
ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))
if factor_returns is not None:
cum_factor_returns = timeseries.cum_returns(
factor_returns[cum_rets.index], 1.0)
cum_factor_returns.plot(lw=2, color='gray',
label=factor_returns.name, alpha=0.60,
ax=ax, **kwargs)
if live_start_date is not None:
live_start_date = utils.get_utc_timestamp(live_start_date)
is_cum_returns = cum_rets.loc[cum_rets.index < live_start_date]
oos_cum_returns = cum_rets.loc[cum_rets.index >= live_start_date]
else:
is_cum_returns = cum_rets
oos_cum_returns = pd.Series([])
is_cum_returns.plot(lw=3, color='forestgreen', alpha=0.6,
label='Backtest', ax=ax, **kwargs)
if len(oos_cum_returns) > 0:
oos_cum_returns.plot(lw=4, color='red', alpha=0.6,
label='Live', ax=ax, **kwargs)
if cone_std is not None:
if isinstance(cone_std, (float, int)):
cone_std = [cone_std]
is_returns = returns.loc[returns.index < live_start_date]
cone_bounds = cone_function(
is_returns,
len(oos_cum_returns),
cone_std=cone_std,
starting_value=is_cum_returns[-1])
cone_bounds = cone_bounds.set_index(oos_cum_returns.index)
for std in cone_std:
ax.fill_between(cone_bounds.index,
cone_bounds[float(std)],
cone_bounds[float(-std)],
color='steelblue', alpha=0.5)
if legend_loc is not None:
ax.legend(loc=legend_loc)
ax.axhline(1.0, linestyle='--', color='black', lw=2)
return ax
