def generatePlot(db, limit, filename, title):
if limit != -1:
date1 = datetime.datetime.utcnow()
dayBefore = date1 - datetime.timedelta(days = 8)
list = db.timeSeries.find({"datetime":{"$gte": dayBefore }}).sort([("datetime", -1)]).limit(limit)
else:
list = db.timeSeries.find({}).sort([("datetime", -1)]).limit(100000)
twitter = []
instagram = []
datetime1 = []
for post in list:
twitter.append(post["twitterCount"])
instagram.append(post["instagramCount"])
datetime1.append(post["datetime"])
fig, ax = plt.subplots()
plt.plot(datetime1, twitter, 'r--', label = "Twitter")
plt.plot(datetime1, instagram, '-', label = "Instagram")
myFmt = mdates.DateFormatter('%d/%m/%y %H:%M')
loc = AutoDateLocator()
loc.intervald[MINUTELY] = [15]
ax.xaxis.set_major_locator(loc)
ax.xaxis.set_major_formatter(myFmt)
ax.legend(bbox_to_anchor=(1.1, 1.05), loc='upper center', shadow=True)
ax.set_title(title)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=60, fontsize=9)
path = os.path.join(os.getcwd(), 'ui')
plt.savefig(path + "/static/" + filename, bbox_inches='tight')
def tick(
self,
locator: Locator | None = None,
*,
upto: int | None = None,
) -> Temporal:
if locator is not None:
# TODO accept tuple for major, minor?
if not isinstance(locator, Locator):
err = (f"Tick locator must be an instance of {Locator!r}, "
f"not {type(locator)!r}.")
raise TypeError(err)
major_locator = locator
elif upto is not None:
# TODO atleast for minticks?
major_locator = AutoDateLocator(minticks=2, maxticks=upto)
else:
major_locator = AutoDateLocator(minticks=2, maxticks=6)
self._major_locator = major_locator
self._minor_locator = None
self.format()
return self
def __init__(self):
AutoDateLocator.__init__(self, minticks=5, interval_multiples=True)
# Remove 4 and 400
self.intervald[YEARLY] = [
1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000
]
self.create_dummy_axis()
def __init__(self):
AutoDateLocator.__init__(self, minticks=5,
interval_multiples=True)
# Remove 4 and 400
self.intervald[YEARLY] = [
1, 2, 5, 10, 20, 50, 100, 200, 500,
1000, 2000, 5000, 10000]
self.create_dummy_axis()
def plot_states_and_var(data,
hidden_states,
cmap=None,
columns=None,
by='Activity'):
"""
Make a plot of the data and the states
Parameters
----------
data : pandas DataFrame
Data to plot
hidden_states: iteretable
the hidden states corresponding to the timesteps
columns : list, optional
Which columns to plot
by : str
The column to group on
"""
fig, ax = plt.subplots(figsize=(15, 5))
if columns is None:
columns = data.columns
df = data[columns].copy()
stateseq = np.array(hidden_states)
stateseq_norep, durations = rle(stateseq)
datamin, datamax = np.array(df).min(), np.array(df).max()
y = np.array([datamin, datamax])
maxstate = stateseq.max() + 1
x = np.hstack(([0], durations.cumsum()[:-1], [len(df.index) - 1]))
C = np.array([[float(state) / maxstate]
for state in stateseq_norep]).transpose()
ax.set_xlim((min(x), max(x)))
if cmap is None:
num_states = max(hidden_states) + 1
colormap, cmap = get_color_map(num_states)
pc = ax.pcolorfast(x, y, C, vmin=0, vmax=1, alpha=0.3, cmap=cmap)
plt.plot(df.as_matrix())
locator = AutoDateLocator()
locator.create_dummy_axis()
num_index = pd.Index(df.index.map(date2num))
ticks_num = locator.tick_values(min(df.index), max(df.index))
ticks = [num_index.get_loc(t) for t in ticks_num]
plt.xticks(ticks, df.index.strftime('%H:%M')[ticks], rotation='vertical')
cb = plt.colorbar(pc)
cb.set_ticks(np.arange(1. / (2 * cmap.N), 1, 1. / cmap.N))
cb.set_ticklabels(np.arange(0, cmap.N))
# Plot the activities
if by is not None:
actseq = np.array(data[by])
sca = ax.scatter(
np.arange(len(hidden_states)), #data.index,
np.ones_like(hidden_states) * datamax,
c=actseq,
edgecolors='none')
plt.show()
return fig, ax
def plot_states_and_var(data, hidden_states, cmap=None, columns=None, by='Activity'):
"""
Make a plot of the data and the states
Parameters
----------
data : pandas DataFrame
Data to plot
hidden_states: iteretable
the hidden states corresponding to the timesteps
columns : list, optional
Which columns to plot
by : str
The column to group on
"""
fig, ax = plt.subplots(figsize=(15, 5))
if columns is None:
columns = data.columns
df = data[columns].copy()
stateseq = np.array(hidden_states)
stateseq_norep, durations = rle(stateseq)
datamin, datamax = np.array(df).min(), np.array(df).max()
y = np.array(
[datamin, datamax])
maxstate = stateseq.max() + 1
x = np.hstack(([0], durations.cumsum()[:-1], [len(df.index) - 1]))
C = np.array(
[[float(state) / maxstate] for state in stateseq_norep]).transpose()
ax.set_xlim((min(x), max(x)))
if cmap is None:
num_states = max(hidden_states) + 1
colormap, cmap = get_color_map(num_states)
pc = ax.pcolorfast(x, y, C, vmin=0, vmax=1, alpha=0.3, cmap=cmap)
plt.plot(df.as_matrix())
locator = AutoDateLocator()
locator.create_dummy_axis()
num_index = pd.Index(df.index.map(date2num))
ticks_num = locator.tick_values(min(df.index), max(df.index))
ticks = [num_index.get_loc(t) for t in ticks_num]
plt.xticks(ticks, df.index.strftime('%H:%M')[ticks], rotation='vertical')
cb = plt.colorbar(pc)
cb.set_ticks(np.arange(1./(2*cmap.N), 1, 1./cmap.N))
cb.set_ticklabels(np.arange(0, cmap.N))
# Plot the activities
if by is not None:
actseq = np.array(data[by])
sca = ax.scatter(
np.arange(len(hidden_states)), #data.index,
np.ones_like(hidden_states) * datamax,
c=actseq,
edgecolors='none'
)
plt.show()
return fig, ax
def _get_locators(self, locator, upto):
if locator is not None:
major_locator = locator
elif upto is not None:
major_locator = AutoDateLocator(minticks=2, maxticks=upto)
else:
major_locator = AutoDateLocator(minticks=2, maxticks=6)
minor_locator = None
return major_locator, minor_locator
def __init__(self, *args, **kwargs):
AutoDateLocator.__init__(self, *args, **kwargs)
freqs = self._freqs
self._freqconverter = {
freqs[0]: lambda x: x / 365.,
freqs[1]: lambda x: x / 31.,
freqs[2]: lambda x: x,
freqs[3]: lambda x: x * 24,
freqs[4]: lambda x: x * 24 * 60,
freqs[5]: lambda x: x * 24 * 60 * 60,
freqs[6]: lambda x: x * 24 * 60 * 60 * 1000000
}
def myplot(txtName):
# plot daily_temp_record
df = pd.read_table(txtName, sep='[ |\t]', header=None, engine='python')
columnNames = [
'time', 'floor_id', 'room_id', 'set_tmp', 'real_tmp', 'real_var_open',
'var_open'
]
df.columns = columnNames[0:df.shape[1]]
df['time'] = pd.to_datetime(df['time'], format='%d:%H:%M:%S')
# 配置时间坐标轴
plt.figure()
plt.subplot(2, 1, 1)
plt.plot_date(df['time'],
df['real_tmp'],
linestyle="-",
marker="None",
color='indigo')
# 坐标轴，标题设置
plt.xticks([])
plt.ylabel('Temperature', size=10)
plt.title(time.strftime("%H:%M"),
size=10) #plt.title('Temperature record',size=10)
plt.gcf().autofmt_xdate() # 自动旋转日期标记
plt.grid(True)
plt.axis("tight")
plt.gca().xaxis.set_major_formatter(
mdates.DateFormatter('%H:%M')) # 显示时间坐标的格式
autodates = AutoDateLocator() # 时间间隔自动选取
plt.gca().xaxis.set_major_locator(autodates)
plt.subplot(2, 1, 2)
plt.plot_date(df['time'],
df['real_var_open'],
linestyle="-",
marker="None",
color='firebrick')
# 坐标轴，标题设置
plt.xlabel('Time', size=10)
plt.ylabel('var_open', size=10)
plt.title('Var_open record', size=10)
plt.gcf().autofmt_xdate() # 自动旋转日期标记
plt.grid(True)
plt.axis("tight")
plt.gca().xaxis.set_major_formatter(
mdates.DateFormatter('%H:%M')) # 显示时间坐标的格式
autodates = AutoDateLocator() # 时间间隔自动选取
plt.gca().xaxis.set_major_locator(autodates)
plt.savefig("./realtime_figure/" + fig_name(txtName), dpi=500)
plt.close()
def data_visualize(train_data={}):
x_date = []
y_num = []
if len(train_data) == 0:
return -1
#要绘制的Vm类型
#target2plot = train_data.keys()时将在一张图绘制所有vm数据
#可赋值['num']绘制对应的vm数据
target2plot = train_data.keys() #['4'] #['5','6','7','8','9']
#绘图属性设置
figure = pyplot.figure()
autodates = AutoDateLocator()
yearsFmt = DateFormatter('%Y-%m-%d')
ax = figure.add_subplot(212)
ax.xaxis.set_major_locator(autodates) #设置时间间隔
ax.xaxis.set_major_formatter(yearsFmt) #设置时间显示格式
ax.set_xlabel('Time')
ax.set_ylabel('Numbers')
ax.set_title('Data Visualizaiton')
# figure.axes.
for target in target2plot:
# for key in train_data[target]:
## x_date.append(datetime.strptime(key, "%Y-%m-%d")) # datetime类型list
# x_date.append(key) #str类型list
x_date = train_data[target].keys()
#对时间数据进行排序处理，便于绘图
x_date.sort()
print date2num(x_date)
for key in x_date:
y_num.append((train_data[target])[key])
print y_num
ax.plot_date(datestr2num(x_date), y_num, '-', label="flavor" + target)
ax.legend()
figure.autofmt_xdate()
# x_num = date2num(x_date)
# if len(x_num) < 2:
# print "train data not enough"
# else:
# lq = LeastSquare(x_num, y_num, defaultOrder=4)
# y_pre = lq.predict(x_num)
#
#
## print x_num, y_num, y_pre
# bx = figure.add_subplot(212)
# bx.scatter(x_num, y_num)
# bx.plot(x_num, y_pre)
#
# x_test = arange(x_num[0],x_num[len(x_num)-1],0.1)
# y_test = lq.predict(x_test)
# bx.plot(x_test, y_test)
# print x_date
# print datestr2num(x_date)
#清空list下个循环再见
x_date = []
y_num = []
def plot_percentiles(sim, percentiles, obs=None):
discharges = [s.region_model.statistics.discharge([0]) for s in sim]
times = utc_to_greg(np.array([discharges[0].time(i) for i in range(discharges[0].size())], dtype='d'))
all_discharges = np.array([d.v for d in discharges])
perc_arrs = [a for a in np.percentile(all_discharges, percentiles, 0)]
h, fill_handles = plot_np_percentiles(times, perc_arrs, base_color=(51/256, 102/256, 193/256))
percentile_texts = ["{} - {}".format(percentiles[i], percentiles[-(i + 1)]) for i in range(len(percentiles)//2)]
ax = plt.gca()
maj_loc = AutoDateLocator(tz=pytz.UTC, interval_multiples=True)
ax.xaxis.set_major_locator(maj_loc)
set_calendar_formatter(Calendar())
if len(percentiles) % 2:
fill_handles.append(h[0])
percentile_texts.append("{}".format(percentiles[len(percentiles)//2]))
if obs is not None:
h_obs = plot_results(None, obs)
fill_handles.append(h_obs)
percentile_texts.append("Observed")
ax.legend(fill_handles, percentile_texts)
ax.grid(b=True, color=(51/256, 102/256, 193/256), linewidth=0.1, linestyle='-', axis='y')
plt.xlabel("Time in UTC")
plt.ylabel(r"Discharge in $\mathbf{m^3s^{-1}}$", verticalalignment="top", rotation="horizontal")
ax.yaxis.set_label_coords(0, 1.1)
return h, ax
def make_graph_cumm(df, what_to_display):
with _lock:
fig1yza, ax = subplots()
ax3 = ax.twinx()
ax.set_title('Cummulative cases and growth COVID-19 à la Levitt')
ax.scatter(df["date"],
df["what_to_display_cumm"].values,
color="green",
s=1,
label=f"reality {what_to_display}")
ax.scatter(df["date"],
df["what_to_display_predicted_cumm"].values,
color="#00b3b3",
s=1,
label=f"predicted {what_to_display}")
ax3.scatter(df["date"],
df["real_growth"].values,
color="#b300b3",
s=1,
label="real growth")
ax3.scatter(df["date"],
df["predicted_growth"].values,
color="#b3bbb3",
s=1,
label="predicted growth")
ax.set_xlim(df.index[0], df.index[-1])
ax.yaxis.set_major_formatter(
StrMethodFormatter('{x:,.0f}')) # comma separators
ax.grid()
ax.legend(loc="upper left")
ax.xaxis.set_major_formatter(
ConciseDateFormatter(AutoDateLocator(), show_offset=False))
st.pyplot(fig1yza)
def gen_temp_plot(temperature, maximums, minimums, timestamps):
# create figure with one axes
fig, ax = plt.subplots()
# prettify
ax.xaxis.set_major_formatter(ConciseDateFormatter(AutoDateLocator()))
fig.autofmt_xdate(rotation=40)
fig.tight_layout()
# plot all the data at one axes
ax.plot(timestamps, temperature, 'ko')
ax.plot(timestamps, maximums, 'r')
ax.plot(timestamps, minimums, 'b')
# create a bytes stream
img = io.BytesIO()
# save figure to stream
plt.savefig(img, format='png')
img.seek(0)
# encode bytes-like object using base64, than decode binary data
plot_url = base64.b64encode(img.getvalue()).decode()
# close bytes stream
img.close()
return plot_url
def _adjust_axe_timeaxis_view(ax: Axes) -> Axes:
locator = AutoDateLocator()
daysFmt = DateFormatter("%y%m%d\n%H:%M")
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(daysFmt)
ax.autoscale_view()
return ax
def defaultPlotOptions():
default = {}
default["colsPerRow"] = 2
default["suptitle"] = "Suptitle"
default["title"] = "Title"
default["logx"] = False
default["logxalt"] = False
default["logy"] = False
default["logyalt"] = False
default["grid"] = True
default["xlim"] = False
default["xlimalt"] = False
default["ylim"] = False
default["ylimalt"] = False
default["xlabel"] = ""
default["ylabel"] = ""
default["timeTicks"] = AutoDateLocator()
default["timeFormat"] = default["timeTicks"]
default["timeNum"] = 8
default["cTitle"] = "Time"
default["clim"] = [0.0, 1.0]
default["rowSize"] = 7
default["colSize"] = 8
default["notime"] = False
default["hist"] = False
default["gradients"] = False
default["eIndex"] = -1
return default
def _make_plot(self):
try:
from pandas.plotting._timeseries import (_decorate_axes,
format_dateaxis)
except ImportError:
from pandas.tseries.plotting import _decorate_axes, format_dateaxis
plotf = self._get_plot_function()
ax = self._get_ax(0)
data = self.data
data.index.name = 'Date'
data = data.to_period(freq=self.freq)
index = data.index
data = data.reset_index(level=0)
if self._is_ts_plot():
data['Date'] = data['Date'].apply(lambda x: x.ordinal)
_decorate_axes(ax, self.freq, self.kwds)
candles = plotf(data, ax, **self.kwds)
if PANDAS_0200:
format_dateaxis(ax, self.freq, index)
else:
format_dateaxis(ax, self.freq)
else:
from matplotlib.dates import date2num, AutoDateFormatter, AutoDateLocator
data['Date'] = data['Date'].apply(
lambda x: date2num(x.to_timestamp()))
candles = plotf(data, ax, **self.kwds)
locator = AutoDateLocator()
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(AutoDateFormatter(locator))
return candles
def graph_setup(self, *args):
"""
Handle graph setup
"""
plt.style.use('dark_background')
loc = AutoDateLocator()
formatter = DateFormatter('%m-%d-%y\n%H:%M')
dates = []
s = []
for idx in range(0, len(self.predicter.result), 24):
date = self.predicter.result[idx]
dates.append(
datetime.datetime(date[0].year, date[0].month, date[0].day,
date[0].hour, date[0].minute))
s.append(round(sum(date[2]) / date[4] * 100))
fig, ax = plt.subplots()
ax.xaxis.set_major_locator(loc)
ax.xaxis.set_major_formatter(formatter)
ax.set_facecolor('#232323')
fig.patch.set_facecolor('#2a2a2a')
plt.plot_date(dates,
s,
linestyle='solid',
marker='None',
color='#00f946',
linewidth=1)
plt.ylabel('Efficiency', fontproperties=avenir3, fontsize=10)
plt.xlabel('Date', fontproperties=avenir3, fontsize=10)
plt.yticks(fontproperties=segoeui, fontsize=8)
plt.xticks(fontproperties=segoeui, fontsize=7)
plt.grid(color='#686868', linestyle=':', linewidth=.5)
self.ids.test.add_widget(FigureCanvasKivyAgg(plt.gcf()))
def display_inputdata(input_data, time_data=None, label=['']):
colorstyle = ['r', 'b', 'g', 'tan', 'k', 'y', 'm']
yearsFmt = DateFormatter('%Y-%m')
autodates = AutoDateLocator()
fig = plt.figure(figsize=(16, 12), dpi=160)
ax1 = fig.add_subplot(211)
fig.autofmt_xdate() #设置x轴时间外观
ax1.xaxis.set_major_locator(autodates) #设置时间间隔
ax1.xaxis.set_major_formatter(yearsFmt) #设置时间显示格式
plt.title('WaterQualite')
plt.grid(True)
plt.xlabel("year-month")
time_begin = datetime.datetime(1990, 1, 1)
time_end = datetime.datetime(2007, 12, 1)
plt.xlim(time_begin, time_end)
plt.ylabel("WaterQualite")
if time_data != None:
x = time_data
for i in range(np.shape(input_data)[0]):
y = np.array(input_data[i, :])[0]
plt.plot(x, y, colorstyle[i], linewidth=2.0, label=label[i])
plt.legend(loc="upper left", shadow=True)
plt.show()
def plot_linechart(df, xcol, ycol, ax=None, title="", show_peak=True):
ax = df.plot(x=xcol,
y=[ycol],
title=title,
figsize=(8, 5),
grid=True,
ax=ax,
lw=3)
mn_l = DayLocator()
ax.xaxis.set_minor_locator(mn_l)
mj_l = AutoDateLocator()
mj_f = ConciseDateFormatter(mj_l, show_offset=False)
ax.xaxis.set_major_formatter(mj_f)
ax.legend(loc=2)
if show_peak:
# plot peak in agg
peakx = df[ycol].idxmax()
peak = df.loc[peakx]
peak_desc = peak[xcol].strftime("%d-%b") + "\n" + str(int(peak[ycol]))
_ = ax.annotate(peak_desc,
xy=(peak[xcol] + dt.timedelta(days=1), peak[ycol]),
xytext=(peak[xcol] + dt.timedelta(days=45),
peak[ycol] * .9),
arrowprops={},
bbox={'facecolor': 'white'})
_ = ax.axvline(x=peak[xcol], linewidth=1, color='r')
return ax
def flavor_month(flavor_type):
data_ori = pd.Series()
for file in fileList:
df = pd.read_csv(base_path+'\\'+file, header=None, names=['type', 'day'], sep='\t', usecols=[1, 2])
if(flavor_type in df['type'].values):
a = df.groupby(by='type').get_group(flavor_type)['day'].value_counts().sort_index()
data_ori=data_ori.append(a)
date_time = list(data_ori.index)
value_l = []
for ind in range(0, len(date_l)):
if date_l[ind] in date_time:
val_tmp=date_l[ind]
tmp = data_ori[val_tmp]
else:
tmp = 0
value_l.append(tmp)
plt.figure()
data_time_translation = [datetime.strptime(d, '%Y-%m-%d').date() for d in date_l]
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d')) # 显示时间坐标的格式
autodates = AutoDateLocator() # 时间间隔自动选取
plt.plot(data_time_translation, value_l, 'b', lw=2.5)
plt.gcf().autofmt_xdate() # 自动旋转日期标记
plt.grid(True)
plt.axis("tight")
plt.xlabel('Time')
plt.ylabel('count')
plt.title('flavor')
plt.gca().xaxis.set_major_locator(autodates)
plt.legend(loc=0)
# plt.show()
plt.savefig(base_path+r'\全部'+'\\'+flavor_type + '.png')
plt.close('all')
def __init__(self, parent=None):
super(SimpleViewer, self).__init__(parent)
self.setupUi(self)
self.figure = MplCanvas(self.centralwidget)
self.ax = None
self.ylim = (0, 0)
self.lfpfactor = 1
self.sleepstages = []
self.ts_start_nlx = None
self.ts_start_mpl = None
self.use_date = False
self.montage = None
self.positions = None
self.locator = AutoDateLocator()
self.formatter = FuncFormatter(fmtfunc)
self.offset = 150
self.setup_gui()
self.init_traces()
t1 = time()
self.init_h5man()
dt = time() - t1
debug('Init h5 took {:.1f} s'.format(dt))
self.setopts()
self.labelFolder.setText(os.path.split(os.getcwd())[1])
self.init_montages()
self.init_realtime()
self.display_sleep = None
if os.path.exists('sleepstages_clean.npy'):
self.display_sleep = np.load('sleepstages_clean.npy')
elif os.path.exists('sleepstages.npy'):
self.display_sleep = np.load('sleepstages.npy')
def plot_hourly(self, context, node_id, limits):
plt.yscale('log', basey=1000, subsy=range(100, 1000, 100))
plt.yticks([10**0, 10**3, 10**6, 10**9, 10**12, 10**15, 10**18],
['1 B', '1 KB', '1 MB', '1 GB', '1 TB', '1 PB', '1 EB'])
loc = AutoDateLocator(tz=pytz.timezone('US/Eastern'))
plt.gca().xaxis.set_major_locator(loc)
plt.gca().xaxis.set_major_formatter(AutoDateFormatter(loc))
plt.grid(b=True, axis='x')
plt.grid(b=True, axis='y', which='both')
plt.bar(*zip(*context.bytes_per_hour[node_id].items()),
color='#50a050',
linewidth=0,
width=1 / 24.,
label='total')
if 80 in context.bytes_per_port_per_hour[node_id]:
plt.bar(
*zip(*context.bytes_per_port_per_hour[node_id][80].items()),
color='#5050a0',
linewidth=0,
width=1 / 24.,
label='HTTP')
plt.xlabel('Time in EST/EDT')
plt.ylabel('Bytes transferred per hour')
plt.legend(prop=dict(size=10))
plt.ylim(bottom=1)
def plot(df, df_prev, xlabel="ds", ylabel="y"):
from matplotlib import pyplot as plt
from matplotlib.dates import (
AutoDateLocator,
AutoDateFormatter,
)
fig = plt.figure(facecolor="w", figsize=(10, 6))
ax = fig.add_subplot(111)
fcst_t = pd.to_datetime(df["ds"])
ax.plot(pd.to_datetime(df_prev["ds"]), df_prev["y"], "k.")
ax.plot(fcst_t, df["yhat"], ls="-", c="#0072B2")
if "cap" in df:
ax.plot(fcst_t, df["cap"], ls="--", c="k")
if "floor" in df:
ax.plot(fcst_t, df["floor"], ls="--", c="k")
ax.fill_between(
fcst_t, df["yhat_lower"], df["yhat_upper"], color="#0072B2", alpha=0.2
)
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.grid(True, which="major", c="gray", ls="-", lw=1, alpha=0.2)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
fig.tight_layout()
return fig
def showData(stock, predict):
data_time = [
datetime.strptime(d, "%Y%m%d").date() for d in stock["trade_date"]
]
# 配置时间坐标轴
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d"))
plt.gca().xaxis.set_major_locator(AutoDateLocator()) # 时间间隔自动选取
# 绘制历史数据
plt.plot(data_time,
stock["low"].values,
label="low",
color="yellow",
lw=1.5)
plt.plot(data_time,
predicted[:, 0] * stock["low"][0],
label="predicted_low",
color="red",
lw=1.5)
plt.gcf().autofmt_xdate() # 自动旋转日期标记
# 绘图细节
plt.grid(True)
plt.axis("tight")
plt.xlabel("Time", size=20)
plt.ylabel("Price", size=20)
plt.title("Graph", size=20)
plt.legend(loc=0) # 添加图例
plt.show() # 显示画布
def plot(m, fcst, splitFlag, ax=None, uncertainty=True, plot_cap=True, xlabel='时间', ylabel='流量',
figsize=(10, 6)):
""" prophet 绘图 """
if ax is None:
fig = plt.figure(facecolor='w', figsize=figsize)
ax = fig.add_subplot(111)
else:
fig = ax.get_figure()
fcst_t = fcst['ds'].dt.to_pydatetime()
ax.plot(m.history['ds'].dt.to_pydatetime(), m.history['y'], 'k.')
# ax.plot(fcst_t, fcst['yhat'], ls='-', c='#0072B2')
ax.plot(fcst_t[0: -splitFlag], fcst['yhat'][0: -splitFlag], ls='-', c='#0072B2')
ax.plot(fcst_t[-splitFlag:], fcst['yhat'][-splitFlag:], ls='-', c='r')
if uncertainty:
ax.fill_between(fcst_t, fcst['yhat_lower'], fcst['yhat_upper'],
color='#0072B2', alpha=0.2)
# Specify formatting to workaround matplotlib issue #12925
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.grid(True, which='major', c='gray', ls='-', lw=1, alpha=0.2)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
fig.tight_layout()
return fig
def plot_forecast_component(m, fcst, name, ax=None, uncertainty=True, plot_cap=False,
figsize=(10, 6), ylabel=""):
artists = []
if not ax:
fig = plt.figure(facecolor='w', figsize=figsize)
ax = fig.add_subplot(111)
fcst_t = fcst['ds'].dt.to_pydatetime()
artists += ax.plot(fcst_t, fcst[name], ls='-', c='#0072B2')
if 'cap' in fcst and plot_cap:
artists += ax.plot(fcst_t, fcst['cap'], ls='--', c='k')
if m.logistic_floor and 'floor' in fcst and plot_cap:
ax.plot(fcst_t, fcst['floor'], ls='--', c='k')
if uncertainty:
artists += [ax.fill_between(
fcst_t, fcst[name + '_lower'], fcst[name + '_upper'],
color='#0072B2', alpha=0.2)]
# Specify formatting to workaround matplotlib issue #12925
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.grid(True, which='major', c='gray', ls='-', lw=1, alpha=0.2)
ax.set_xlabel('时间')
ax.set_ylabel(name if ylabel == "" else ylabel)
if name in m.component_modes['multiplicative']:
ax = set_y_as_percent(ax)
return artists
def plot_column(self,
column,
region='',
state='',
city='',
ax=None,
data_source='Ministério da Saúde',
add_moving_average=False,
start_date=None,
end_date=None):
'''(String, String, String, String) -> None
Plota o gráfico de uma métrica em um local selecionado'''
if self.valid_col(column, data_source):
df = self.get_df(region, state, city, data_source, start_date,
end_date)
if not df.empty:
if ax is None:
fig = plt.figure(facecolor='w', figsize=(10, 6))
ax = fig.add_subplot(111)
show = True
else:
fig = ax.get_figure()
show = False
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.plot(df['date'],
df[column],
label='%s | %s' %
(self.correct_col_name[data_source][column],
self.format_location([region, state, city])))
if add_moving_average:
ax.plot(df['date'], df[column].expanding(min_periods=60).mean(), \
label='Média Móvel | %s | %s' % (self.correct_col_name[data_source][column], self.format_location( [region, state, city] ) ) )
if show:
fig.legend()
plt.show()
else:
self.messagebox.show_message(self.not_found_msg(
region, state, city),
type='Erro')
else:
valid_vals = [
k for k in self.correct_col_name[data_source] if k != 'date'
]
self.messagebox.show_message(
'''\nO nome %s não corresponde a uma coluna válida para dados do %s.
Os nomes válidos para colunas do conjunto atual são:\n- %s \n''' %
(data_source, column, '\n- '.join(valid_vals)))
def plot(
m,
fcst,
ax=None,
uncertainty=True,
plot_cap=True,
xlabel='ds',
ylabel='y',
figsize=(10, 6),
y_column='y',
):
"""Plot the Prophet forecast.
Parameters
----------
m: Prophet model.
fcst: pd.DataFrame output of m.predict.
ax: Optional matplotlib axes on which to plot.
uncertainty: Optional boolean to plot uncertainty intervals, which will
only be done if m.uncertainty_samples > 0.
plot_cap: Optional boolean indicating if the capacity should be shown
in the figure, if available.
xlabel: Optional label name on X-axis
ylabel: Optional label name on Y-axis
figsize: Optional tuple width, height in inches.
Returns
-------
A matplotlib figure.
"""
if ax is None:
fig = plt.figure(facecolor='w', figsize=figsize)
ax = fig.add_subplot(111)
else:
fig = ax.get_figure()
fcst_t = fcst['ds'].dt.to_pydatetime()
ax.plot(m.history['ds'].dt.to_pydatetime(), m.history[y_column], 'k.')
ax.plot(fcst_t, fcst['yhat'], ls='-', c='#0072B2')
if 'cap' in fcst and plot_cap:
ax.plot(fcst_t, fcst['cap'], ls='--', c='k')
if m.logistic_floor and 'floor' in fcst and plot_cap:
ax.plot(fcst_t, fcst['floor'], ls='--', c='k')
if uncertainty and m.uncertainty_samples:
ax.fill_between(fcst_t,
fcst['yhat_lower'],
fcst['yhat_upper'],
color='#0072B2',
alpha=0.2)
# Specify formatting to workaround matplotlib issue #12925
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.grid(True, which='major', c='gray', ls='-', lw=1, alpha=0.2)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
fig.tight_layout()
return fig
def plot(self, channel, t0=None, t1=None):
derived_channels = {'air density': ('weather','kg/m3')}
datafile = (channel in derived_channels) and derived_channels[channel][0] \
or DataSet.get_datafile_for_channel(channel)
data = self.dataset.get_data(t0, t1, datafile)
if channel == 'air density':
y = self.calc_airdensity(data)
else:
y = data[channel]
fig = plt.figure(1)
ax = fig.add_subplot(111)
ax.plot(data['time'], y,'.-')
locator = AutoDateLocator(minticks=8,interval_multiples=True)
locator.intervald[SECONDLY] = [3,6,12,15,30]
ax.xaxis.set_major_locator( locator )
formatter = SensibleDateFormatter(locator)
ax.xaxis.set_major_formatter( formatter )
ax.locator_params(axis='y', prune='lower')
yformatter = ScalarFormatter(useOffset=False)
ax.yaxis.set_major_formatter(yformatter)
ax.grid()
units = (channel in derived_channels) and derived_channels[channel][1] \
or DataSet.get_units(channel)
yformatter.set_locs(ax.yaxis.get_major_locator()()) # force update of yformatter
ax.set_title('%s (mean = %s %s)' % (channel.title(), yformatter(y.mean()), units))
ax.set_ylabel(units)
fig.autofmt_xdate()
ax.autoscale(False)
# symbols for comments
trans = transforms.blended_transform_factory(
ax.transData, ax.transAxes)
for t, drifthist, comment in self.comments.get(data['time'][0],data['time'][-1]):
m = re.match(r'ADJUST[^-+.0-9]*([-+.0-9]+)', comment)
adj = m and float(m.group(1)) or 0
if adj > 0: c,s = 'red', '^'
elif adj < 0: c,s = 'blue','v'
else: c,s = 'black','o'
ax.plot(t, 0.98, s, color=c, transform=trans)
ax.axvline(t, color=c, alpha=0.5)
def plot_trend(m,
ax=None,
plot_name="Trend",
figsize=(10, 6),
df_name="__df__"):
"""Make a barplot of the magnitudes of trend-changes.
Args:
m (NeuralProphet): fitted model.
ax (matplotlib axis): matplotlib Axes to plot on.
One will be created if this is not provided.
plot_name (str): Name of the plot Title.
figsize (tuple): width, height in inches. Ignored if ax is not None.
default: (10, 6)
df_name: name of dataframe to refer to data params from original list of train dataframes (used for local normalization in global modeling)
Returns:
a list of matplotlib artists
"""
artists = []
if not ax:
fig = plt.figure(facecolor="w", figsize=figsize)
ax = fig.add_subplot(111)
data_params = m.config_normalization.get_data_params(df_name)
t_start = data_params["ds"].shift
t_end = t_start + data_params["ds"].scale
if m.config_trend.n_changepoints == 0:
fcst_t = pd.Series([t_start, t_end]).dt.to_pydatetime()
trend_0 = m.model.bias.detach().numpy()
if m.config_trend.growth == "off":
trend_1 = trend_0
else:
trend_1 = trend_0 + m.model.trend_k0.detach().numpy()
data_params = m.config_normalization.get_data_params(df_name)
shift = data_params["y"].shift
scale = data_params["y"].scale
trend_0 = trend_0 * scale + shift
trend_1 = trend_1 * scale + shift
artists += ax.plot(fcst_t, [trend_0, trend_1], ls="-", c="#0072B2")
else:
days = pd.date_range(start=t_start, end=t_end, freq=m.data_freq)
df_y = pd.DataFrame({"ds": days})
df_trend = m.predict_trend(df={df_name: df_y})[df_name]
artists += ax.plot(df_y["ds"].dt.to_pydatetime(),
df_trend["trend"],
ls="-",
c="#0072B2")
# Specify formatting to workaround matplotlib issue #12925
locator = AutoDateLocator(interval_multiples=False)
formatter = AutoDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.grid(True, which="major", c="gray", ls="-", lw=1, alpha=0.2)
ax.set_xlabel("ds")
ax.set_ylabel(plot_name)
return artists
def manip_info(sessionName, quiet, line_to_print, var_to_plot):
"""
This function prints information about a session, and optionally
plot specified variables.
It can be accessed from the CLI tool ManipInfo
"""
if os.path.exists(sessionName + ".db"):
SavedAsyncSession(sessionName).print_description()
return
if sessionName.endswith(".hdf5"):
N = len(sessionName)
sessionName = sessionName[0:(N - 5)]
MI = Manip(sessionName).MI
if line_to_print is not None:
if line_to_print >= len(MI.log("t")):
print("Specified line is out of bound.")
sys.exit(1)
format_str = "{:>15} | {:>20}"
print("Printing saved values on line", line_to_print)
print(format_str.format("Variable", "Value"))
varlist = ["Time"]
varlist += MI.log_variable_list()
print("-" * 38)
for varname in varlist:
valtab = MI.log(varname)
if isinstance(valtab, (float, int)):
# might occur if only one line
print(format_str.format(varname, MI.log(varname)))
else:
print(
format_str.format(varname,
MI.log(varname)[line_to_print]))
elif not quiet:
MI.describe()
if var_to_plot is not None:
if var_to_plot in MI.log_variable_list():
t = epoch2num(MI.log("t"))
vardata = MI.log(var_to_plot)
fig = plt.figure()
xtick_locator = AutoDateLocator()
xtick_formatter = AutoDateFormatter(xtick_locator)
ax = plt.axes()
ax.xaxis.set_major_locator(xtick_locator)
ax.xaxis.set_major_formatter(xtick_formatter)
ax.plot(t, vardata, "o-")
plt.setp(ax.xaxis.get_majorticklabels(), rotation=70)
fig.subplots_adjust(bottom=0.2)
plt.ylabel(var_to_plot)
plt.title(sessionName)
plt.show()
else:
print("Variable", var_to_plot, "does not exist!")
sys.exit(1)
def draw_2(self, id):
data = libchart.get_chart_data(self.session,
self.dt_start,
self.dt_end,
[[id, datetime.timedelta()]],
daily=True)
x = []
y = []
for k, v in data.iteritems():
x.append(datetime.datetime.strptime(k, '%Y%m%d0000'))
if v[0] is None:
y.append(1)
else:
y.append(v[0])
fig = plt.figure(figsize=(400 / 80, 200 / 80))
ax = fig.add_subplot(1, 1, 1)
ax.bar(x, y, width=0.4, align='center', color='blue')
ax.grid(True, axis='y')
ax.set_ylim(0)
locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
formatter.scaled[(1.)] = '%m-%d'
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
def yaxis_formatter(y, pos):
def r(i):
i = round(i, 2)
if i == int(i):
i = int(i)
return i
if y < 1e3:
return int(y)
elif y < 1e6:
return '%sK' % r(y / 1e3)
else:
return '%sM' % r(y / 1e6)
ax.yaxis.set_major_formatter(FuncFormatter(yaxis_formatter))
for tick in ax.xaxis.get_major_ticks():
tick.label1.set_size(9)
for tick in ax.yaxis.get_major_ticks():
tick.label1.set_size(9)
f = StringIO.StringIO()
fig.savefig(f)
plt.close()
f.seek(0)
return f
def showBtResult(d):
"""
显示回测结果
"""
name = d.get('name')
timeList = d['timeList']
pnlList = d['pnlList']
capitalList = d['capitalList']
drawdownList = d['drawdownList']
print(u'显示回测结果')
# 输出
if len(timeList) > 0:
print('-' * 30)
print(u'第一笔交易：\t%s' % d['timeList'][0])
print(u'最后一笔交易：\t%s' % d['timeList'][-1])
print(u'总交易次数：\t%s' % formatNumber(d['totalResult']))
print(u'总盈亏：\t%s' % formatNumber(d['capital']))
print(u'最大回撤: \t%s' % formatNumber(min(d['drawdownList'])))
print(u'平均每笔盈亏：\t%s' % formatNumber(d['capital'] / d['totalResult']))
print(u'平均每笔佣金：\t%s' %
formatNumber(d['totalCommission'] / d['totalResult']))
print(u'胜率\t\t%s%%' % formatNumber(d['winningRate']))
print(u'平均每笔盈利\t%s' % formatNumber(d['averageWinning']))
print(u'平均每笔亏损\t%s' % formatNumber(d['averageLosing']))
print(u'盈亏比：\t%s' % formatNumber(d['profitLossRatio']))
print(u'显示回测结果')
# 绘图
import matplotlib.pyplot as plt
from matplotlib.dates import AutoDateLocator, DateFormatter
autodates = AutoDateLocator()
yearsFmt = DateFormatter('%m-%d')
pCapital = plt.subplot(3, 1, 1)
pCapital.set_ylabel("capital")
pCapital.plot(timeList, capitalList)
plt.gcf().autofmt_xdate() #设置x轴时间外观
plt.gcf().subplots_adjust(bottom=0.1)
plt.gca().xaxis.set_major_locator(autodates) #设置时间间隔
plt.gca().xaxis.set_major_formatter(yearsFmt) #设置时间显示格式
pDD = plt.subplot(3, 1, 2)
pDD.set_ylabel("dd")
pDD.bar(range(len(drawdownList)), drawdownList)
pPnl = plt.subplot(3, 1, 3)
pPnl.set_ylabel("pnl")
pPnl.hist(pnlList, bins=20)
plt.subplots_adjust(bottom=0.05, hspace=0.3)
plt.show()
def _set_xaxis_obspy_dates(ax, ticklabels_small=True):
"""
Set Formatter/Locator of x-Axis to use ObsPyAutoDateFormatter and do some
other tweaking.
In contrast to normal matplotlib ``AutoDateFormatter`` e.g. shows full
timestamp on first tick when zoomed in so far that matplotlib would only
show hours or minutes on all ticks (making it impossible to tell the date
from the axis labels) and also shows full timestamp in matplotlib figures
info line (mouse-over info of current cursor position).
:type ax: :class:`matplotlib.axes.Axes`
:rtype: None
"""
ax.xaxis_date()
locator = AutoDateLocator(minticks=3, maxticks=6)
locator.intervald[MINUTELY] = [1, 2, 5, 10, 15, 30]
locator.intervald[SECONDLY] = [1, 2, 5, 10, 15, 30]
ax.xaxis.set_major_formatter(ObsPyAutoDateFormatter(locator))
ax.xaxis.set_major_locator(locator)
if ticklabels_small:
import matplotlib.pyplot as plt
plt.setp(ax.get_xticklabels(), fontsize='small')
def tick_values(self, vmin, vmax):
# get locator
# if yearlocator
# change the vmin to turn of decade or half-decade
ticks = AutoDateLocator.tick_values(self, vmin, vmax)
return ticks
def __init__(self, tz=None, numticks=7):
AutoDateLocator.__init__(self, tz)
self.numticks = numticks