def print_dataframe(df, n_rows=10, n_columns=3):
missing_val_str = '...'
config = helper.generate_config()
formatted_df = df.iloc[:n_rows, :n_columns]
formatted_df = formatted_df.applymap('{:.3f}'.format)
if len(df.columns) > n_columns:
formatted_df[missing_val_str] = [missing_val_str]*len(formatted_df.index)
if len(df.index) > n_rows:
formatted_df.loc[missing_val_str] = [missing_val_str]*len(formatted_df.columns)
trace = go.Table(
type='table',
columnwidth=[1, 3],
header={
'values': [''] + list(formatted_df.columns.values),
'line': {'color': helper.color_scheme['df_line']},
'fill': {'color': helper.color_scheme['df_header']},
'font': {'size': 13}},
cells={
'values': formatted_df.reset_index().values.T,
'line': {'color': helper.color_scheme['df_line']},
'fill': {'color': [helper.color_scheme['df_header'], helper.color_scheme['df_value']]},
'font': {'size': 13}})
offline_py.iplot([trace], config=config)
def plot_re_x(n):
def g(a):
fn, tp = a
return go.Scatter(
x = X,
y = [sin(fn, tp, n, x) for x in X],
mode = 'lines+markers',
name = fn + ' (' + tp + ')'
)
data = list(map(g, product(['sin1_ltr', 'sin1_rtl', 'sin2'], ['float', 'double', 'longdouble'])))
layout = go.Layout(
title='Błąd względny (%d wyrazów)' % (n,),
width=960,
height=720,
#hovermode='closest',
xaxis=dict(title='x',),
yaxis=dict(title='Błąd względny', type='log', autorange=True),
)
fig = go.Figure(data=data, layout=layout)
pl.iplot(fig, show_link=False)
def resistancePlot(self):
"""This just allows grouping by index (or die, etc)"""
scatter = [go.Scatter(
x = [float(line['area']) for line in self.data if line['index']==die],
y = [1/float(line['resistance']) for line in self.data if line['index']==die],
mode = 'markers',
name = 'Data'
) for die in np.unique([row['index'] for row in self.data])]
# linear fit based on all data
x = [float(line['area']) for line in self.data]
y = [1/float(line['resistance']) for line in self.data]
xfit = np.unique([0]+x)
m, b = self.fitData()
yfit = [m*xi+b for xi in xfit]
print("m = {} b = {} R_sub = {}".format(m,b,1/b))
fit = go.Scatter(
x = xfit,
y = yfit,
mode = 'lines',
name = 'Fit'
)
fig = dict(data = scatter+[fit],
layout = {'title':'',
'xaxis':{'title':'Junction Area [um^2]'},
'yaxis':{'title':'1/Room Temperature Resistance [$1/\Omega$]'}
}
)
iplot(fig)
def plot_signal_returns(prices, signal_return_list, titles):
config = helper.generate_config()
layout = go.Layout(
yaxis2={
'title': 'Signal Returns',
'titlefont': {'color': helper.color_scheme['y_axis_2_text_color']},
'tickfont': {'color': helper.color_scheme['y_axis_2_text_color']},
'overlaying': 'y',
'side': 'right'})
colors = Color(helper.color_scheme['low_value'])\
.range_to(Color(helper.color_scheme['high_value']), len(signal_return_list))
stock_trace = _generate_stock_trace(prices)
for (signal_return, signal, lookahead_days), color, title in zip(signal_return_list, colors, titles):
non_zero_signals = signal_return[signal_return != 0]
signal_return_trace = go.Scatter(
x=non_zero_signals.index,
y=non_zero_signals,
name='{} Day Lookahead'.format(lookahead_days),
line={'color': str(color)},
yaxis='y2')
buy_annotations = _generate_buy_annotations(prices, signal)
sell_annotations = _generate_sell_annotations(prices, signal)
layout['title'] = title
layout['annotations'] = buy_annotations + sell_annotations
offline_py.iplot({'data': [stock_trace, signal_return_trace], 'layout': layout}, config=config)
def fibplot(xsr,ysr,xsi,ysi):
frames = []
for i in range(len(xsr)+2):
frames.append({'data': [{'x': xsr[:i], 'y': ysr[:i]}, {'x':xsi[:i], 'y':ysi[:i]}]})
figure = {
'data': [
{
'x': xsr,
'y': ysr,
'mode':'lines',
'name': 'Recursive Fib'
}, {
'x': xsi,
'y': ysi,
'mode':'lines',
'name': 'Imperative Fib'
}
],
'layout': {'title': 'Fibonacci',
'updatemenus': [{
'buttons': [
{'args': [None],
'label': 'Play',
'method': 'animate'}
],
'pad': {'r': 10, 't': 87},
'showactive': False,
'type': 'buttons'
}]},
'frames': frames,
}
iplot(figure, filename='Fibonacci')
def plot_signal_to_normal_histograms(signal_list, title, subplot_titles):
assert len(signal_list) == len(subplot_titles)
signal_series_list = [signal.stack() for signal in signal_list]
all_values = pd.concat(signal_series_list)
x_range = [all_values.min(), all_values.max()]
y_range = [0, 1500]
config = helper.generate_config()
fig = py.tools.make_subplots(rows=1, cols=len(signal_series_list), subplot_titles=subplot_titles, print_grid=False)
fig['layout'].update(title=title)
for series_i, signal_series in enumerate(signal_series_list, 1):
filtered_series = signal_series[signal_series != 0].dropna()
filtered_series_trace = go.Histogram(
x=filtered_series,
marker={'color': helper.color_scheme['low_value']},
name='Signal Return Distribution',
showlegend=False)
normal_trace = go.Histogram(
x=np.random.normal(np.mean(filtered_series), np.std(filtered_series), len(filtered_series)),
marker={'color': helper.color_scheme['shadow']},
name='Normal Distribution',
showlegend=False)
fig.append_trace(filtered_series_trace, 1, series_i)
fig.append_trace(normal_trace, 1, series_i)
fig['layout']['xaxis{}'.format(series_i)].update(range=x_range)
fig['layout']['yaxis{}'.format(series_i)].update(range=y_range)
# Show legened
fig['data'][0]['showlegend'] = True
fig['data'][1]['showlegend'] = True
offline_py.iplot(fig, config=config)
def old_show(explanation, selector=None, index_map=None):
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected=True)
# if not show.imported:
# show.imported = True
if isinstance(selector, str):
if index_map is None:
print(
"If selector is a string, a list or dictionary index_map must be passed."
)
if isinstance(index_map, list):
selector = index_map.index(selector)
elif isinstance(index_map, dict):
selector = index_map[selector]
else:
print("Not supported index_feature_map type. Use list or dictionary.")
return None
elif isinstance(selector, int):
selector = selector
elif selector is None:
selector = None
else:
print("Argument 'selector' must be an int, string, or None.")
return None
fig = explanation.visualize(selector)
if fig is not None:
iplot(fig)
else:
print("No overall graph for this explanation. Pass in a selector.")
def display(m,wireframe=True,smooth=True,data=None):
""" The display function shows an interactive presentation of the Manifold, m, inside
a Jupyter Notebook. wireframe=True means that a wireframe view of the mesh is
superimposed on the 3D model. If smooth=True, the mesh is rendered with vertex
normals. Otherwise, the mesh is rendered with face normals. If data=None, the
mesh is shown in a light grey color. If data contains an array of scalar values
per vertex, these are mapped to colors used to color the mesh."""
xyz = array([ p for p in m.positions()])
m_tri = gel.Manifold(m)
gel.triangulate(m_tri)
ijk = array([[ idx for idx in m_tri.circulate_face(f,'v')] for f in m_tri.faces()])
mesh = go.Mesh3d(x=xyz[:,0],y=xyz[:,1],z=xyz[:,2],
i=ijk[:,0],j=ijk[:,1],k=ijk[:,2],color='#dddddd',flatshading=not smooth)
if data is not None:
mesh['intensity'] = data
mesh_data = [mesh]
if wireframe:
pos = m.positions()
xyze = []
for h in m.halfedges():
if h < m.opposite_halfedge(h):
p0 = pos[m.incident_vertex(m.opposite_halfedge(h))]
p1 = pos[m.incident_vertex(h)]
xyze.append(array(p0))
xyze.append(array(p1))
xyze.append(array([None, None, None]))
xyze = array(xyze)
trace1=go.Scatter3d(x=xyze[:,0],y=xyze[:,1],z=xyze[:,2],
mode='lines',
line=go.Line(color='rgb(125,0,0)', width=1),
hoverinfo='none')
mesh_data += [trace1]
lyt = go.Layout(scene=go.Scene(aspectmode='data'))
fig = go.Figure(data=mesh_data,layout=lyt)
py.iplot(fig)
def render(self, df, encoding, output):
if encoding.x is None or encoding.y is None:
with output:
print("\n\n\nPlease select an X and Y axis.")
return
try:
data = self._get_data(df, encoding)
except InvalidEncodingError as err:
with output:
print("\n\n\n{}".format(err))
return
type_x_axis = self._get_type_axis(encoding.logarithmic_x_axis)
type_y_axis = self._get_type_axis(encoding.logarithmic_y_axis)
layout = Layout(
xaxis=dict(type=type_x_axis, rangemode="tozero", title=encoding.x),
yaxis=dict(type=type_y_axis, rangemode="tozero", title=encoding.y),
)
with output:
try:
fig = Figure(data=Data(data), layout=layout)
iplot(fig, show_link=False)
except TypeError:
print(
"\n\n\nPlease select another set of X and Y axis, because the type of the current axis do\n"
"not support aggregation over it."
)
def show(self,save=False):
imagestr=None
data = self.traces
fig = go.Figure(data = data, layout = go.Layout(**self.layout))
if save:
imagestr = 'avg'
py.iplot(fig, image = imagestr)
def pretty_table(df, outfile=None):
"""
Display pandas dataframe as a nicely-formated HTML
Parameters
----------
outfile: filepath str
If provided, output to an HTML file at provided location
Example
-------
import pandas as pd
animals = pd.DataFrame([
['cat',10, 'housepet'],
['dog',20,'housepet'],
['fish',5,'housepet'],
['cat',20,'zooanimal'],
['dog',50,'zooanimal'],
['fish',20,'zooanimal'],], columns=['animal','value','group'])
pretty_table(animals)
"""
table = FF.create_table(df)
ol.iplot(table, show_link=False)
# write figure to HTML file
if outfile:
print('Exporting copy of figure to %s...' % outfile)
ol.plot(table, auto_open=False, filename=outfile)
def dist_plot(df,
groupby=None,
val=None,
bin_size=1,
title=None,
show_hist=True,
show_kde=True,
show_rug=True,
show_legend=True,
figsize=None,
outfile=None,
xlabel=None,
ylabel=None):
if groupby is None:
fig = FF.create_distplot([df[c] for c in df.columns],
df.columns.values.tolist(),
bin_size=bin_size,
show_rug=show_rug,
show_curve=show_kde)
else:
groups = sorted(df[groupby].unique().tolist(), reverse=True)
data = []
if val is None:
val = df.columns.drop(groupby)[0] # choose first non-groupby column
for group in groups:
mask = df[groupby] == group
data.append(df.loc[mask, val])
fig = FF.create_distplot(data,
groups,
bin_size=bin_size,
show_hist=show_hist,
show_rug=show_rug,
show_curve=show_kde)
fig['layout'].update(showlegend=show_legend)
if title:
fig['layout'].update(title=title)
if xlabel:
fig['layout'].update(xaxis=go.XAxis(title=xlabel))
if ylabel:
fig['layout'].update(yaxis=go.YAxis(title=ylabel))
if figsize and len(figsize) == 2:
fig['layout'].update(width=figsize[0])
fig['layout'].update(height=figsize[1])
ol.iplot(fig, show_link=False)
# write figure to HTML file
if outfile:
print('Exporting copy of figure to %s...' % outfile)
ol.plot(fig, auto_open=False, filename=outfile)
def resistancePlot(self):
"""Old version"""
x = [1/float(line['area']) for line in self.data]
y = [float(line['resistance']) for line in self.data]
scatter = go.Scatter(
x = x,
y = y,
mode = 'markers',
name = 'Data'
)
xfit = np.unique(x)
m, b = self.fitData()
yfit = [m*xi+b for xi in xfit]
fit = go.Scatter(
x = xfit,
y = yfit,
mode = 'lines',
name = 'Fit'
)
fig = dict(data = [scatter,fit],
layout = {'title':'',
'xaxis':{'title':'1/JJ Area [1/um^2]'},
'yaxis':{'title':'Room Temperature Resistance [\Omega]'}
}
)
iplot(fig)
def plot_stock(prices, title):
config = helper.generate_config()
layout = go.Layout(title=title)
stock_trace = _generate_stock_trace(prices)
offline_py.iplot({'data': [stock_trace], 'layout': layout}, config=config)
def plot_returns(returns, title):
config = helper.generate_config()
layout = go.Layout(title=title)
traces = _generate_traces([
('Returns', returns, helper.color_scheme['major_line'])])
offline_py.iplot({'data': traces, 'layout': layout}, config=config)
def save_plot(fig, file_name=None):
try:
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected=True)
iplot(fig, filename=file_name)
except:
from plotly.offline import plot
plot(fig, auto_open=False, filename=file_name)
def plot_resampled_prices(df_resampled, df, title):
config = helper.generate_config()
layout = go.Layout(title=title)
traces = _generate_traces([
('Monthly Close', df_resampled, helper.color_scheme['major_line']),
('Close', df, helper.color_scheme['minor_line'])])
offline_py.iplot({'data': traces, 'layout': layout}, config=config)
def plot_loss_reward(total_losses, total_rewards):
figure = tools.make_subplots(rows=1, cols=2, subplot_titles=('loss', 'reward'), print_grid=False)
figure.append_trace(Scatter(y=total_losses, mode='lines', line=dict(color='skyblue')), 1, 1)
figure.append_trace(Scatter(y=total_rewards, mode='lines', line=dict(color='orange')), 1, 2)
figure['layout']['xaxis1'].update(title='epoch')
figure['layout']['xaxis2'].update(title='epoch')
figure['layout'].update(height=400, width=900, showlegend=False)
iplot(figure)
def _plot(self, grobby, filename):
global notebook_mode, notebook_mode_init
if notebook_mode:
if not notebook_mode_init:
ply.init_notebook_mode()
notebook_mode_init = True
ply.iplot(grobby)
else:
ply.plot(grobby, filename=filename)
def plot_shifted_returns(df_shited, df, title):
config = helper.generate_config()
layout = go.Layout(title=title)
traces = _generate_traces([
('Shifted Returns', df_shited, helper.color_scheme['major_line']),
('Returns', df, helper.color_scheme['minor_line'])])
offline_py.iplot({'data': traces, 'layout': layout}, config=config)
def plot_scatter(xvals, yvals):
data = [
go.Scatter(
x=xvals,
y=yvals,
mode = 'markers'
)
]
py.iplot(data)
def plot_cost_and_trace(X, Y, trace, low=-10, high=10, size=100):
gr = calculate_cost_grid(X, Y, low, high, size)
lsp = np.linspace(low, high, size)
contour = go.Contour(z = np.log(gr), x = lsp, y = lsp, colorscale='Jet', contours={'coloring': 'heatmap'})
descent = go.Scatter(x = trace[:, 1], y = trace[:, 0], mode='markers')
iplot(go.Figure(data=[contour, descent], layout=go.Layout(hovermode='closest', width=600, height=600)))
def plot_color(color):
import plotly.graph_objs as go
from plotly import offline
layout = go.Layout(width=50, height=50, margin=dict(l=0, r=0, t=0, b=0))
fig = go.Figure(
data=[go.Scatter(x=[1, 2], y=[2, 2], marker=dict(color=color), fill='tozeroy')],
layout=layout
)
offline.iplot(fig, link_text='', show_link=False)
def plot_by_metro(df, trend_name, plot=True):
#generates graph for metro volume/percentages
df = cutoff(metro_analyses(df))
colors = ['#194769','#A0C1B8', '#E4D183', '#F2855E']
plot_config = {'kwargs': {'colors': colors},
'df': df}
if not plot:
return plot_config
fig = pf.plot_by_metro(df=df, trend=trend_name, colors=colors)
iplot(fig, filename ='stacked-bar')
def plot_by_income(df, trend_name, plot=True):
#generates graph for income volume/percentages
df = cutoff(income_analyses(df))
colors = ['rgb(0, 0, 102)', 'rgb(127, 166, 238)']
plot_config = {'kwargs': {'colors': colors},
'df': df}
if not plot:
return plot_config
fig = pf.plot_by_income(df=df, trend=trend_name, colors=colors)
iplot(fig, filename ='stacked-bar')
def plot_signal(price, signal, title):
config = helper.generate_config()
buy_annotations = _generate_buy_annotations(price, signal)
sell_annotations = _generate_sell_annotations(price, signal)
layout = go.Layout(
title=title,
annotations=buy_annotations + sell_annotations)
stock_trace = _generate_stock_trace(price)
offline_py.iplot({'data': [stock_trace], 'layout': layout}, config=config)
def plot_by_grade(df, trend_name, plot=True):
#generates graph for grade volume/percentages
df = cutoff(grade_analyses(df))
colors = ['#FDA403','#FFD6A0', '#404B69', '#7FA99B']
plot_config = {'kwargs': {'colors': colors},
'df': df}
if not plot:
return plot_config
fig = pf.plot_by_grade(df=df, trend=trend_name, colors=colors)
iplot(fig, filename ='stacked-bar')
def percent_by_subject(df, trend_name, plot=True):
#generates graph for subject percentages
analysis_df = cutoff(subject_analyses(df))
df = edit_cols(df, analysis_df)
df = bar_switch(df)
colors = ['#84B9EF','#FBE4C9', '#FF5D5D', '#952E4B' , '#FFFF9D', '#F38181', '#F12D2D', '#660000' ]
plot_config = {'kwargs': {'colors': colors},
'df': df}
if not plot:
return plot_config
fig = pf.percent_by_subject(df=df, trend=trend_name, colors=colors)
iplot(fig, filename ='stacked-bar')
def rfAvgAcc(rfModel, XTest, yTest):
preds = []
avgPred = []
df = []
for i,tree in enumerate(rfModel.estimators_):
predTree = tree.predict(XTest)
accTree = round(metrics.accuracy_score(yTest, predTree),2)
preds.append(accTree)
if i==0:
df = predTree
else:
df = np.vstack((df,predTree))
for j in np.arange(df.shape[0]):
j=j+1
mv = []
for i in np.arange(df.shape[1]):
(values,counts) = np.unique(df[:j,i],return_counts=True)
ind=np.argmax(counts)
mv.append(values[ind].astype(int))
avgPred.append(metrics.accuracy_score(yTest, mv))
trace = go.Scatter(
y=avgPred,
x=np.arange(df.shape[0]),
mode='markers+lines',
name = "Ensemble accuracy trend"
)
layout = go.Layout(
title = "Ensemble accuracy over increasing number of trees",
xaxis = dict(title = "Number of trees", nticks = 15),
yaxis = dict(title = "Accuracy"),
showlegend=False,
autosize=False,
width=1000,
height=500,
margin=Margin(
l=70,
r=50,
b=100,
t=50,
pad=4
),
)
data = [trace]
fig = dict(data=data, layout=layout)
iplot(fig)
def show(self):
annotations = []
pitch = self.pitch
center_die = self.center_die
wafer_diameter = self.wafer_diameter
sputter_diameter = self.sputter_diameter
trace = go.Heatmap(
z = self.dieMapData,
x = [c for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'],
# y = [str(self.ndie-i)+'a' for i in range(self.ndie)]
)
if self.title is None:
self.title = 'Wafer Die Map'
fig = dict(data = [trace],
layout = {'title': self.title,
'width':500,
'height':500,
'autosize':False,
'xaxis': {'ticks':'', 'side':'top'},
'yaxis':{'autorange':'reversed'},
'annotations':annotations,
'shapes': [
# outer circle
{
'type': 'circle',
'xref': 'x',
'yref': 'y',
'x0': center_die-wafer_diameter/2./pitch+1,
'y0': center_die-wafer_diameter/2./pitch+1,
'x1': center_die+wafer_diameter/2./pitch+1,
'y1': center_die+wafer_diameter/2./pitch+1,
'line': {
'color': 'rgba(50, 171, 96, 1)',
},
},
# middle circle
{
'type': 'circle',
'xref': 'x',
'yref': 'y',
'x0': center_die-sputter_diameter/2./pitch+1,
'y0': center_die-sputter_diameter/2./pitch+1,
'x1': center_die+sputter_diameter/2./pitch+1,
'y1': center_die+sputter_diameter/2./pitch+1,
'line': {
'color': 'rgba(171, 50, 96, 1)',
},
},]
}
)
iplot(fig)
plt.xticks(rotation=90)
# # Investigate Global Happiness Ranking
# In[ ]:
data = dict(type='choropleth',
locations=df['Country'],
locationmode='country names',
z=df['Happiness Rank'],
text=df['Country'],
colorbar={'title': 'Happiness'})
layout = dict(title='Global Happiness',
geo=dict(showframe=False, projection={'type': 'Mercator'}))
choromap3 = go.Figure(data=[data], layout=layout)
iplot(choromap3)
# # Setting up Linear Model to Predict Happiness
# In[ ]:
y = df['Happiness Score']
X = df.drop(['Happiness Score', 'Happiness Rank', 'Country', 'Region'], axis=1)
# In[ ]:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3,
def plot(self, symbol=None, engine='plotly', notebook=False):
if engine == 'plotly':
if type(symbol) == str:
df = pd.DataFrame(self.latest_bar_dict[symbol])
df.set_index('date', inplace=True)
df.index = pd.DatetimeIndex(df.index)
p_symbol = go.Scatter(x=df.index,
y=df.close,
xaxis='x3',
yaxis='y3',
name=symbol)
p_volume = go.Bar(x=df.index,
y=df['volume'],
xaxis='x3',
yaxis='y5',
opacity=0.5,
name='volume')
self.data.append(p_symbol)
self.data.append(p_volume)
if type(symbol) == list:
for i in symbol:
df = pd.DataFrame(self.latest_bar_dict[i])
df.set_index('date', inplace=True)
df.index = pd.DatetimeIndex(df.index)
p_symbol = go.Scatter(x=df.index,
y=df.close,
xaxis='x3',
yaxis='y3',
name=i)
p_volume = go.Bar(x=df.index,
y=df['volume'],
xaxis='x3',
yaxis='y5',
opacity=0.5,
name=i + 'volume')
self.data.append(p_symbol)
self.data.append(p_volume)
for i in self.holdings:
p_holdings = go.Scatter(x=self.holdings.index,
y=self.holdings[i],
xaxis='x2',
yaxis='y2',
name=i)
self.data.append(p_holdings)
p_returns = go.Scatter(x=self.enquity_curve.index,
y=self.enquity_curve.returns,
xaxis='x4',
yaxis='y4',
name='returns')
self.data.append(p_returns)
layout = go.Layout(xaxis2=dict(
domain=[0, 1],
anchor='y2',
),
xaxis3=dict(domain=[0, 1], anchor='y3'),
xaxis4=dict(domain=[0, 1], anchor='y4'),
yaxis2=dict(domain=[0, 0.2], ),
yaxis3=dict(domain=[0.2, 0.8]),
yaxis4=dict(domain=[0.8, 1], ),
yaxis5=dict(
domain=[0.2, 0.8],
side='right',
range=[0, 10000000],
overlaying='y3',
tickvals=[0, 1000000, 2000000, 2500000],
showgrid=False))
fig = go.Figure(data=self.data, layout=layout)
if notebook:
import plotly
plotly.offline.init_notebook_mode()
py.iplot(fig, filename='testplot', validate=False)
else:
py.plot(fig, filename='testplot', validate=False)
data = [
go.Scatter(x=bos_den.Weekend_Date, y=bos_den.Average_Price, name='Denver'),
go.Scatter(x=bos_lax.Weekend_Date,
y=bos_lax.Average_Price,
name='Los Angeles'),
go.Scatter(x=bos_sfo.Weekend_Date,
y=bos_sfo.Average_Price,
name='San Francisco'),
go.Scatter(x=bos_iah.Weekend_Date, y=bos_iah.Average_Price,
name='Houston'),
go.Scatter(x=bos_phx.Weekend_Date, y=bos_phx.Average_Price, name='Phoenix')
]
layout = go.Layout(
title="Weekend Return Trip Prices for major US cities from Boston",
xaxis=dict(title="Weekend dates"),
yaxis=dict(title="Return Ticket price in USD"),
)
figure = go.Figure(data=data, layout=layout)
offline.iplot(
figure,
filename='Weekend Return Trip Prices for major US cities from Boston')
# - From this graph I can plan my weekend trips to each of these cities and save on cost.
# - For instance I will plan my trip to Denver before 28 May 2017 to be able to save on the high prices at any later date.
# - Similarly for San Francisco 11 June 2017 is the cheapest date to travel.
# In[ ]:
stacked = py.get_figure("rmuir", 241)
for d in stacked['data']:
xVals = d['y']
yVals = d['x']
d.update({'orientation' : 'h',
'x' : xVals,
'y' : yVals})
fig.append_trace(d, row = 1, col = 3)
fig['layout']['xaxis2'].update({'tickformat' : '%',
'hoverformat' : '%'})
fig['layout'].update({'barmode' : 'stack',
'height' : 1000})
pyo.iplot(fig)
py.image.save_as(fig, r"C:\Users\Rytch\Google Drive\Financial\Passive Income\Online courses\Plotly\Course Content\Lessons\(06) Barcharts\Notebooks\images\Barcharts (11) - Creating our first Dashboard (2)\pyo.iplot-0.png")
#
# ## How many meteorites were found each year in each weight category?
#
# Let's add the traces for the number of meteorites in each weight category which were found each year. We'll get this data from my website:
# In[5]:
sizes = pd.read_csv("http://richard-muir.com/data/public/csv/MeteoriteLandingsbyWeightPerYear.csv", index_col = 0)
sizes.head()
def plot_data_preds_scaled_conv1d(model,
stock,
dfs,
scaled_ts,
scaled_fs,
train_test='all',
train_frac=0.85):
if train_test == 'all':
# vertical line should be on the first testing set point
train_size = int(train_frac * dfs[stock].shape[0])
print(train_size)
feats = scaled_fs[stock]
for_pred = feats.reshape(feats.shape[0], feats.shape[1], 1)
preds = model.predict(for_pred).ravel()
print(max([max(scaled_ts[stock].ravel()), max(preds)]))
layout = {
'shapes': [{
'type':
'rect',
# stupid hack to deal with pandas issue
'x0':
dfs[stock].iloc[train_size:train_size +
1].index[0].date().strftime('%Y-%m-%d'),
'y0':
1.1 * min([min(scaled_ts[stock].ravel()),
min(preds)]),
'x1':
dfs[stock].iloc[-2:-1].index[0].date().strftime('%Y-%m-%d'),
'y1':
1.1 * max([max(scaled_ts[stock].ravel()),
max(preds)]),
'line': {
'color': 'rgb(255, 0, 0)',
'width': 2,
},
'fillcolor':
'rgba(128, 0, 128, 0.05)',
}]
}
trace0 = go.Scatter(x=dfs[stock].index,
y=scaled_ts[stock].ravel(),
mode='lines+markers',
name='actual')
trace1 = go.Scatter(x=dfs[stock].index,
y=preds,
mode='lines+markers',
name='predictions')
f = iplot({'data': [trace0, trace1], 'layout': layout})
elif train_test == 'train':
train_size = int(train_frac * dfs[stock].shape[0])
feats = scaled_fs[stock][:train_size]
for_pred = feats.reshape(feats.shape[0], feats.shape[1], 1)
trace0 = go.Scatter(x=dfs[stock].iloc[:train_size].index,
y=scaled_ts[stock].ravel(),
mode='lines+markers',
name='actual')
trace1 = go.Scatter(x=dfs[stock].iloc[:train_size].index,
y=model.predict(for_pred).ravel(),
mode='lines+markers',
name='predictions')
f = iplot([trace0, trace1])
elif train_test == 'test':
train_size = int(train_frac * dfs[stock].shape[0])
feats = scaled_fs[stock][train_size:]
for_pred = feats.reshape(feats.shape[0], feats.shape[1], 1)
trace0 = go.Scatter(x=dfs[stock].iloc[train_size:].index,
y=scaled_ts[stock].ravel(),
mode='lines+markers',
name='actual')
trace1 = go.Scatter(x=dfs[stock].iloc[train_size:].index,
y=model.predict(for_pred).ravel(),
mode='lines+markers',
name='predictions')
f = iplot([trace0, trace1])
else:
print(
'error! You have to supply train_test as \'all\', \'train\', or \'test\''
)
def _ipython_display_(self):
if not ExpressFigure.offline_initialized:
init_notebook_mode()
ExpressFigure.offline_initialized = True
iplot(self, show_link=False, auto_play=False)
layout = dict(geo={'scope': 'usa'})
# Então usamos:
#
# go.Figure(data = [data],layout = layout)
#
# para configurar o objeto que finalmente é transmitido para iplot ()
# In[14]:
choromap = go.Figure(data=[data], layout=layout)
# In[15]:
iplot(choromap)
# ### Dados reais: Mapa dos EUA Choropleth
#
# Agora vamos mostrar um exemplo com alguns dados reais, bem como algumas outras opções que podemos adicionar aos dicionários em dados e layout.
# In[16]:
df = pd.read_csv('2011_US_AGRI_Exports')
df.head()
# Agora criamos um dicionário de dados com alguns argumentos adicionais e argumentos de barras de cores:
# In[22]:
data = dict(type='choropleth',
# ## Making a barchart
#
# In the same way that we make a scatter trace by specifying <code>{'type' : 'scatter'}</code>, we can make a bar trace by specifying <code>{'type' : 'bar'}</code>.
#
# For this barchart, we'll set the x-values as the year (the index in meteorite DataFrame), and the y-values as the number of meteorites found in that year:
# In[5]:
numberOfMeteorites = {
'type': 'bar',
'x': meteorite.index,
'y': meteorite['count']
}
pyo.iplot([numberOfMeteorites])
py.image.save_as([
numberOfMeteorites
], r"C:\Users\Rytch\Google Drive\Financial\Passive Income\Online courses\Plotly\Course Content\Lessons\(06) Barcharts\Notebooks\images\Barcharts (02) - making our first barchart\pyo.iplot-0.png"
)
#
# #### What happens if we don't set our x- and y-values correctly; will the chart still plot?
#
# Yes, it will, however for a vertical bar chart, Plotly expects each vlaue to be of a distinct category. As you can see from the chart below, Plotly has treated each distinct value of <code>'count'</code> as a separate category. If your bar charts don't come out as you expect, try switching your x- and y-values first - a simple mistake can make your chart look very strange indeed!
# In[10]:
pyo.iplot([{'type': 'bar', 'y': meteorite.index, 'x': meteorite['count']}])
import plotly.plotly as py
import plotly.graph_objs as go
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
data = [
{
'x': pivot_list[1],
'y': pivot_list[2],
'mode':'markers+text',
'marker': {
'size': list(map((lambda x: pow(x,0.6)*20), map(int, pivot_list[0]))),
},
'text': pivot_list[0],
'textposition':'middle center'
}
]
layout = dict(width = 800, height = 600, autosize= False, margin = go.layout.Margin(
l = 150,
r = 50,
b = 150,
t = 50,
pad = 4))
fig = dict(data = data, layout = layout)
iplot(fig, filename='bubblechart-text')
cf.set_config_file(theme='ggplot')
ds['course_rating'].iplot(kind='hist',title='Course Rating ',bargap=0.2,
xTitle='Rating', yTitle='Counts')
# In[90]:
cf.set_config_file(theme='pearl')
ds['course_difficulty'].iplot(kind='hist',title='Course Difficulty',
xTitle='Course Type',yTitle='Count')
# In[91]:
course_org = ds.groupby('course_organization').count().reset_index()
trace = go.Pie(labels = course_org['course_organization'], values =course_org['course_students_enrolled'] )
data = [trace]
fig = go.Figure(data = data)
iplot(fig)
# In[ ]:
def plot_plotly(
dataf: pd.DataFrame,
col_names=None,
title="",
labels=None,
x_label="",
y_label="",
file_name="1.html",
mode_line="lines",
in_jnb=False,
legend=None,
multiaxis=False,
automodeline=True,
width=None,
height=None,
auto_open=True,
annotations=None,
y2_label="",
linewiths=None,
x_range=None,
y_range=None,
png_name=None,
):
"""
Функция строит графики, используя библиотеку 'plotly'.
Parameters:
-----------
dataf -- данные, для построения графика (тип pandas.DataFrame)
col_names -- названия столбцов, которые необходимо отобразить
(по умолчанию все столбцы)
title -- название графика (по умолчанию '')
labels -- легенда (передается списком, по умолчанию '')
x_label -- название оси 'X' (по умолчанию '')
y_label -- название оси 'Y' (по умолчанию '')
file_name -- название файла (по умолчанию '', с сохранением в рабочую
директорию)
mode_line -- тип линий (лист, или одно значение)
возможные значения:'line' - линия, 'markers' - маркеры
in_jnb -- 'IN_JupyterNoteook' параметр определяет где будет
выводиться график: в строке (для Jupyter Notebook),
или в отдельный файл
multiaxis -- параметр, показывающий необходимо ли,
каждый график выводить на отдельной оси 'y' (только для двух линий!)
automodeline -- параметр, включающий атоматическое определение
типа линий (маркер, в случае отсутствия у значений графика более 40%
от длины всего датафрейма)
auto_open -- необходимо ли открыть график после создания.
Returns:
--------
График в формате html, или график в Jupyter Notebook.
"""
annotations = annotations or []
linewiths = linewiths or [2]
x_range = x_range or []
y_range = y_range or []
if not isinstance(dataf, pd.DataFrame):
raise ValueError("`dataf` is not pd.DataFrame.")
# проверяем названия столбцов (по умолчанию строим по всем столбцам)
if not col_names:
col_names = dataf.columns
# если список легенды не был передан, генерим список
# необходимой длины
if not labels:
labels = col_names
# определяем тип линий
# если параметр автоматического определения типа линий включен
if automodeline:
mode_line = []
# для всех столбцов, если количество значений мень 60%, то маркер
# иначе линия
for colname in col_names:
if len(dataf[colname].dropna()) / len(dataf) < 0.6:
mode_line.append("markers")
else:
mode_line.append("lines")
# если параметр атоматического определения типа линии выключен
elif len(col_names) > 1 and len(mode_line) != len(col_names):
mode_line = mode_line * len(col_names)
# проверить, необходимо ли построить график на двух разных осях y
if multiaxis:
if len(col_names) > 2:
raise ValueError("Required number of multiaxis is 2")
yaxis = ["y", "y2"]
else:
yaxis = ["y"] * len(col_names)
if len(linewiths) != len(col_names):
linewiths = [2] * len(col_names)
# помещаем в переменную 'data' все данные из dataf
data = []
for col, m_line, label, y_axis, linewith in zip(col_names, mode_line,
labels, yaxis, linewiths):
data.append(
go.Scatter(
x=dataf.index,
y=dataf[col],
mode=m_line,
line=dict(width=linewith),
marker=dict(size=5),
name=label,
yaxis=y_axis,
))
# параметры осей
layout = dict(
title=title,
xaxis=dict(title=x_label), # range=x_range),
yaxis=dict(title=y_label), # range=y_range),
yaxis2=dict(overlaying="y", side="right", title=y2_label),
annotations=annotations,
)
if x_range:
layout["xaxis"]["range"] = x_range
if y_range:
layout["yaxis"]["range"] = y_range
if width:
layout["width"] = width
if height:
layout["height"] = height
if legend:
layout["legend"] = legend
# создаем фигуру
fig = go.Figure(data=data, layout=layout)
fig.update_layout(legend_orientation="h")
# проверяем, где необходимо построить график:
# в строке, или сохранить в файл
if in_jnb:
# случае, если функция была вызвана из Jupyter
# для отрисовки графика inline,
# необходимо подклюить режим notebook
init_notebook_mode(connected=True)
iplot(fig, show_link=False, config={"scrollZoom": True})
# если указано название имени картинок в формате `*.png`
elif png_name:
pio.write_image(fig, png_name, width=800, height=500)
else:
plot(fig,
filename=file_name,
auto_open=auto_open,
config={"scrollZoom": True})
ax = sns.scatterplot(x='date',
y='recovered',
data=dataset,
color='blue',
label='recovered')
ax = sns.scatterplot(x='date',
y='dead',
data=dataset,
color='red',
label='dead')
plt.plot(dataset.date, dataset.confirmed, zorder=1, color='black')
plt.plot(dataset.date, dataset.recovered, zorder=1, color='blue')
plt.plot(dataset.date, dataset.dead, zorder=1, color='red')
abc = dataset.groupby('date')[['confirmed', 'recovered',
'dead']].sum().reset_index()
r_cm = (abc.recovered / abc.confirmed)
d_cm = (abc.dead / abc.confirmed)
#Prophet on confirmed
prop_con = dataset.iloc[:, [0, 6]]
prop_con.columns = ['ds', 'y']
m1 = Prophet()
m1.fit(prop_con)
future = m1.make_future_dataframe(periods=365)
forecast_con = m1.predict(future)
figure = plot_plotly(m1, forecast_con)
py.iplot(figure)
figure = m1.plot(forecast_con, xlabel='date', ylabel='confirmed')
figure = m1.plot_components(forecast_con)
# light times is a N vector of time
print('Light times: ')
print(lightTimes[0])
# clean up the kernels
spice.kclear()
# plot
plotly.offline.init_notebook_mode()
threeDPlot = go.Scatter3d(
x=positions[:, 0], # X coordinates
y=positions[:, 1], # Y coordinates
z=positions[:, 2], # Z coordinates
name='Cassini',
mode='lines',
line=dict(width=3))
barycenter = go.Scatter3d(x=[0],
y=[0],
z=[0],
name='bc',
mode='marker',
marker=dict(size=10, color='orange'))
data = [threeDPlot, barycenter]
layout = go.Layout(title="SpiceyPy Cassini Position Example")
fig = dict(data=data, layout=layout)
py.iplot(fig)
def plot(pca_results, plot_counter):
# Get results
pca = pca_results['pca']
var_explained = pca_results['var_explained']
sample_metadata = pca_results['sample_metadata']
color_by = pca_results.get('color_by')
color_type = pca_results.get('color_type')
color_column = pca_results['sample_metadata'][
color_by] if color_by else None
colors = [
'#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', '#fb9a99', '#e31a1c',
'#fdbf6f', '#ff7f00', '#cab2d6', '#6a3d9a', '#ffff99', '#b15928'
]
sample_titles = [
'<b>{}</b><br>'.format(index) +
'<br>'.join('<i>{key}</i>: {value}'.format(**locals())
for key, value in rowData.items())
for index, rowData in sample_metadata.iterrows()
]
if not color_by:
marker = dict(size=15)
trace = go.Scatter3d(x=pca.components_[0],
y=pca.components_[1],
z=pca.components_[2],
mode='markers',
hoverinfo='text',
text=sample_titles,
marker=marker)
data = [trace]
elif color_by and color_type == 'continuous':
marker = dict(size=15,
color=color_column,
colorscale='Viridis',
showscale=True)
trace = go.Scatter3d(x=pca.components_[0],
y=pca.components_[1],
z=pca.components_[2],
mode='markers',
hoverinfo='text',
text=sample_titles,
marker=marker)
data = [trace]
elif color_by and color_type == 'categorical':
# Get unique categories
unique_categories = color_column.unique()
# Define empty list
data = []
# Loop through the unique categories
for i, category in enumerate(unique_categories):
# Get the color corresponding to the category
# If signature
if color_by == 'Sample Group':
group_A, group_B = [
x.split(' vs ')
for x in pca_results['signature_metadata'].keys()
][0]
if category == group_A:
category_color = 'blue'
elif category == group_B:
category_color = 'red'
else:
category_color = 'black'
else:
category_color = colors[i]
# Get the indices of the samples corresponding to the category
category_indices = [
i for i, sample_category in enumerate(color_column)
if sample_category == category
]
# Create new trace
trace = go.Scatter3d(
x=pca.components_[0][category_indices],
y=pca.components_[1][category_indices],
z=pca.components_[2][category_indices],
mode='markers',
hoverinfo='text',
text=[sample_titles[x] for x in category_indices],
name=category,
marker=dict(size=15, color=category_color))
# Append trace to data list
data.append(trace)
colored = '' if str(color_by) == 'None' else 'Colored by {}'.format(
color_by)
layout = go.Layout(
title='<b>PCA Analysis | Scatter Plot</b><br><i>{}</i>'.format(
colored),
hovermode='closest',
margin=go.Margin(l=0, r=0, b=0, t=50),
width=900,
scene=dict(xaxis=dict(title=var_explained[0]),
yaxis=dict(title=var_explained[1]),
zaxis=dict(title=var_explained[2])))
fig = go.Figure(data=data, layout=layout)
if pca_results['plot_type'] == 'interactive':
iplot(fig)
else:
s.static_plot(fig)
display(
Markdown(
'** Figure ' + plot_counter() +
' | Principal Component Analysis results. ** The figure displays an interactive, three-dimensional scatter plot of the first three Principal Components (PCs) of the data. Each point represents an RNA-seq sample. Samples with similar gene expression profiles are closer in the three-dimensional space. If provided, sample groups are indicated using different colors, allowing for easier interpretation of the results. If you are experiencing issues visualizing the plot, please visit our <a href="https://amp.pharm.mssm.edu/biojupies/help#troubleshooting" target="_blank">Troubleshooting guide</a>'
.format(**locals())))
# Choropleth maps- draw data local or global scale
#build date dic
data = dict(
type='choropleth', #type geoplot
locations=['AZ', 'CA', 'NY'], #list state abbrev codes
locationmode='USA-states', #can go to county level
colorscale='Greens',
text=['text 1', 'text 2', 'text 3'], #labels for locations
z=[1.0, 2.0, 3.0], # value want to represent as a color, e.g. population
colorbar={'title': 'Colorbar title here'})
layout = dict(geo={'scope': 'usa'}) # use states choropleth
choromap = go.figure(data=[data], layout=layout)
iplot(choromap) #could also just do plot
df = pd.read_csv('2011_US_AGRI_Exports')
df.head()
data = dict(
type='choropleth',
colorscale='YlOrRd',
locations=df['code'],
locationmode='USA-states',
z=df['total exports'],
text=df['text'],
marker=dict(
line=dict(color='rgb(255,255,255)', width=2)), #spacing between states
colorbar={'title': 'Millions USD'})
def fc_plot(obj, title='', xTitle='Date', yTitle='', asFigure=False):
"""Plots actual, fitted, and predicted values from forecast class in plotly graph
Args:
obj: forecast object (dict for single series and dataframe for multiple series)
title: plot title
xTitle: xaxis title
yTitle: y axis title
asFigure: parameter to return as fig instead of the plot if set to True
Returns:
fig: plotly figure object
"""
try:
#handle dict (assumes it's forecast object)
if isinstance(obj, dict):
trace_actuals = go.Scatter(x=obj['x'].index,
y=obj['x'].values,
mode='lines',
name='actual')
trace_fitted = go.Scatter(x=obj['fitted'].index,
y=obj['fitted'].values,
mode='lines+markers',
name='fitted',
opacity=0.8)
trace_predicted = go.Scatter(x=obj['predicted'].index,
y=obj['predicted'].values,
mode='lines',
name='predicted')
trace_lower = go.Scatter(x=obj['predicted'].index,
y=obj['lower'],
fill=None,
mode='lines',
name='Lower PI (' + str(obj['level']) +
'%)',
line=dict(color='lightgreen', ))
trace_upper = go.Scatter(x=obj['predicted'].index,
y=obj['upper'],
fill='tonexty',
mode='lines',
name='Upper PI (' + str(obj['level']) +
'%)',
line=dict(color='lightgreen', ))
data = [
trace_actuals, trace_fitted, trace_predicted, trace_lower,
trace_upper
]
layout = dict(title=title,
yaxis=dict(title=yTitle),
xaxis=dict(title=xTitle,
rangeslider=dict(),
type='date'))
fig = dict(data=data, layout=layout)
elif isinstance(obj, pd.core.series.Series):
trace_series = go.Scatter(x=obj.index,
y=obj.values,
mode='lines',
name='series')
data = [trace_actuals]
layout = dict(title=title,
yaxis=dict(title=yTitle),
xaxis=dict(title=xTitle,
rangeslider=dict(),
type='date'))
fig = dict(data=data, layout=layout)
#separate logic if input is dataframe
elif isinstance(obj, pd.core.frame.DataFrame):
#return cufflinks figure and add rangeslider to layout
fig = obj.iplot(kind='scatter',
title=title,
yTitle=yTitle,
xTitle=xTitle,
asFigure=True)
fig['layout']['xaxis1']['rangeslider'] = dict()
else:
raise TypeError(
'only accepted objects are dictionary or dataframe returned from forecast class'
)
except TypeError:
print(
'only accepted objects are dictionary or dataframe returned from forecast class'
)
if asFigure == True:
return fig
return iplot(fig, show_link=False)
inplace=False)
data_city = pd.DataFrame({
'city': data['city'].value_counts().index,
'value': data['city'].value_counts().values
})
data = [{
'x': data_city['city'][0:10].values,
'y': data_city['value'][0:10].values,
'mode': 'markers',
'marker': {
'sizemode': 'area',
# 'sizeref': 'sizeref',
'size': data_city['value'][0:10]
}
}]
iplot(data)
City_State = pd.merge(data_city,
df1_filter,
how='left',
left_on='city',
right_on='city')
City_State = City_State.drop_duplicates(subset='city',
keep='first',
inplace=False)
count = City_State['value'].values
m = folium.Map(location=[28, 81], tiles="Mapbox Bright", zoom_start=4.5)
for i in range(0, 10):
folium.Circle(
location=[
City_State.iloc[i]['latitude'], City_State.iloc[i]['longitude']
],
def acc_plot(obj,
title='',
xTitle='',
yTitle='',
mode='lines+markers',
tablewidth=350,
asFigure=False):
""" plots accuracy measures
Args:
obj: accuracy object(dict for single series, dataframe for multiple series)
title: plot title
xTitle: xaxis title
yTitle: y axis title
mode: one of 'lines', 'markers', or 'lines+markers' (only applies to multiple series)
tablewidth:sets table width for accuracy measures of single instance
asFigure: parameter to return as fig instead of the plot if set to True
Returns:
fig: plotly figure object
"""
try:
#handle dict (assumes it's forecast object)
if isinstance(obj, dict):
#create dataframe from accuracy dictionary
table_df = pd.DataFrame.from_dict(obj, orient='index', dtype=None)
table_df.columns = ['Value']
#round decimals
table_df = table_df.round(5)
fig = ff.create_table(table_df,
index=True,
index_title='Accuracy Measure')
fig.layout.update({'width': tablewidth})
#separate logic if input is dataframe
elif isinstance(obj, pd.core.frame.DataFrame):
#return cufflinks figure, normalize error measures, then plot them without a y axis
normalized_df = obj.T.apply(lambda x: x / abs(x).max(), axis=0)
fig = normalized_df.T.iplot(kind='scatter',
title=title,
xTitle=xTitle,
yTitle=yTitle,
mode=mode,
asFigure=True)
fig['layout']['yaxis1']['visible'] = False
for error_measure in fig['data']:
#get correct text values from original dataframe and round values to 4 decimals
error_measure['text'] = np.around(
obj[error_measure['name']].values, decimals=4)
error_measure['hoverinfo'] = 'text+name'
else:
raise TypeError(
'only accepted objects are dictionary or dataframe returned from forecast class'
)
except TypeError:
print(
'only accepted objects are dictionary or dataframe returned from forecast class'
)
if asFigure == True:
return fig
return iplot(fig, show_link=False)
def per_contract(future_chain, field='Volume'):
"""Plot heatmap of the average Volume or Open Interest of the last 90 days. Display it by year for each contract.
This should be useful to find out which contract are traded/not traded and where
:param future_chain: object - Future Chain initialized with data
:param field: str - Volume or OI
:return: object - Plot Plotly chart
"""
log = logging.getLogger(__name__)
if field != 'Volume' and field != 'OI':
raise Exception('Field provided must be str Volume or OI!')
stem = future_chain.stem
df = future_chain.chain
data = future_chain.data
# Average Volume
df['Month'] = df.apply(lambda x: x['Ticker'][2:3], axis=1)
df['Year'] = df.apply(lambda x: 2000 + int(x['Ticker'][-2:]), axis=1)
# Add average volume of last 90 days
df['AvgVol'] = 0
for idx, row in df.iterrows():
mdf = data[row['Ticker']]
df.loc[idx, 'AvgVol'] = int(mdf[-90:][field].mean())
# Transformation to HeatMap DF
years = []
for year in df['Year'].unique():
ydf = df[df['Year'] == year][['Month', 'AvgVol']]
ydf.set_index('Month', drop=True, inplace=True)
ydf.index.names = [None]
ydf.columns = [year]
years.append(ydf)
hdf = pd.concat(years, axis=1)
# Index
cdf = oci.ctrmth(stem, we_trade=False)
cdf['Letter'] = cdf.apply(lambda x: oci.ym_maturity(x['CtrMth'])[0],
axis=1)
lw = cdf.groupby('Letter').mean()
lw['Index'] = lw.apply(lambda x: '{} (T: {})'.format(x.name, x['WeTrd']),
axis=1)
rlw = lw.reindex(index=lw.index[::-1])
# Plot
rhdf = hdf.reindex(index=hdf.index[::-1])
values = rhdf.values
values = [[int(vi) if not math.isnan(vi) else float('NaN') for vi in v]
for v in values]
try:
fig = pff.create_annotated_heatmap(values,
x=list(rhdf.columns),
y=list(rlw['Index']),
colorscale='Jet',
font_colors=['white'],
hoverinfo='z')
for i in range(len(fig.layout.annotations)): # Make text size smaller
fig.layout.annotations[i].font.size = 10
fig.layout.title = '{} - {}'.format(stem, field)
plo.iplot(fig)
except ple.PlotlyError:
log.error(
'Most likely a problem with axis length: x: {} - y: {} - z: {}'.
format(list(rhdf.columns), list(rlw['Index']), len(values)))
def telecom_churn_prediction(algorithm, training_x, testing_x, training_y,
testing_y, cols, cf, threshold_plot):
#model
algorithm.fit(training_x, training_y)
predictions = algorithm.predict(testing_x)
probabilities = algorithm.predict_proba(testing_x)
#coeffs
if cf == "coefficients":
coefficients = pd.DataFrame(algorithm.coef_.ravel())
elif cf == "features":
coefficients = pd.DataFrame(algorithm.feature_importances_)
column_df = pd.DataFrame(cols)
coef_sumry = (pd.merge(coefficients,
column_df,
left_index=True,
right_index=True,
how="left"))
coef_sumry.columns = ["coefficients", "features"]
coef_sumry = coef_sumry.sort_values(by="coefficients", ascending=False)
print(algorithm)
print("\n Classification report : \n",
classification_report(testing_y, predictions))
print("Accuracy Score : ", accuracy_score(testing_y, predictions))
#confusion matrix
conf_matrix = confusion_matrix(testing_y, predictions)
#roc_auc_score
model_roc_auc = roc_auc_score(testing_y, predictions)
print("Area under curve : ", model_roc_auc, "\n")
fpr, tpr, thresholds = roc_curve(testing_y, probabilities[:, 1])
#plot confusion matrix
trace1 = go.Heatmap(z=conf_matrix,
x=["Not churn", "Churn"],
y=["Not churn", "Churn"],
showscale=False,
colorscale="Picnic",
name="matrix")
#plot roc curve
trace2 = go.Scatter(x=fpr,
y=tpr,
name="Roc : " + str(model_roc_auc),
line=dict(color=('rgb(22, 96, 167)'), width=2))
trace3 = go.Scatter(x=[0, 1],
y=[0, 1],
line=dict(color=('rgb(205, 12, 24)'),
width=2,
dash='dot'))
#plot coeffs
trace4 = go.Bar(x=coef_sumry["features"],
y=coef_sumry["coefficients"],
name="coefficients",
marker=dict(color=coef_sumry["coefficients"],
colorscale="Picnic",
line=dict(width=.6, color="black")))
#subplots
fig = tls.make_subplots(
rows=2,
cols=2,
specs=[[{}, {}], [{
'colspan': 2
}, None]],
subplot_titles=('Confusion Matrix',
'Receiver operating characteristic',
'Feature Importances'))
fig.append_trace(trace1, 1, 1)
fig.append_trace(trace2, 1, 2)
fig.append_trace(trace3, 1, 2)
fig.append_trace(trace4, 2, 1)
fig['layout'].update(showlegend=False,
title="Model performance",
autosize=False,
height=900,
width=800,
plot_bgcolor='rgba(240,240,240, 0.95)',
paper_bgcolor='rgba(240,240,240, 0.95)',
margin=dict(b=195))
fig["layout"]["xaxis2"].update(dict(title="false positive rate"))
fig["layout"]["yaxis2"].update(dict(title="true positive rate"))
fig["layout"]["xaxis3"].update(
dict(showgrid=True, tickfont=dict(size=10), tickangle=90))
py.iplot(fig)
def plot_data_preds_unscaled(model,
stock,
t_scalers,
scaled_ts,
scaled_fs,
targs,
dates,
datapoints=300,
train_frac=0.85,
future_days=5):
dates = dates[stock]
train_size = int(train_frac * dates.shape[0])
for_preds = scaled_fs[stock].reshape(scaled_fs[stock].shape[0], 1,
scaled_fs[stock].shape[1])
preds = model.predict(for_preds).ravel()
unscaled_preds = t_scalers[stock].reform_data(preds, orig=True)
if datapoints == 'all':
datapoints = dates.shape[0]
layout = {
'shapes': [
{
'type':
'rect',
# first line is just before first point of test set
'x0':
dates[train_size].date().strftime('%Y-%m-%d'),
'y0':
1.1 * min([
min(targs[stock][-datapoints:]),
min(unscaled_preds.ravel()[-datapoints:])
]),
'x1':
dates[-1].date().strftime('%Y-%m-%d'),
'y1':
1.1 * max([
max(targs[stock][-datapoints:]),
max(unscaled_preds.ravel()[-datapoints:])
]),
'line': {
'color': 'rgb(255, 0, 0)',
'width': 2,
},
'fillcolor':
'rgba(128, 0, 128, 0.05)',
},
{
'type':
'line',
# first line is just before first point of test set
'x0':
dates[train_size + future_days].date().strftime('%Y-%m-%d'),
'y0':
1.1 * min([
min(targs[stock][-datapoints:]),
min(unscaled_preds.ravel()[-datapoints:])
]),
'x1':
dates[train_size + future_days].date().strftime('%Y-%m-%d'),
'y1':
1.1 * max([
max(targs[stock][-datapoints:]),
max(unscaled_preds.ravel()[-datapoints:])
]),
'line': {
'color': 'rgb(0, 255, 0)',
'width': 2,
}
}
],
'yaxis': {
'title': 'GLD price'
}
}
trace0 = go.Scatter(x=dates[-datapoints:],
y=targs[stock][-datapoints:],
mode='lines+markers',
name='actual')
trace1 = go.Scatter(x=dates[-datapoints:],
y=unscaled_preds.ravel()[-datapoints:],
mode='lines+markers',
name='predictions')
f = iplot({'data': [trace0, trace1], 'layout': layout})
def plotOneLine(x,y,mode='lines+markers',legend_name='',title=''):
d=[go.Scatter(x=x,y=y,mode=mode,name=legend_name)]
fig=go.Figure(data=d,layout=go.Layout(title=title))
iplot(fig,show_link=False)
'symbol': 0,
'size': 8
},
mode="markers+lines",
text=['Year: ' + str(i) for i in list(range(2002, 2018))], # hover text
name='Suicide rate in Females')
plotdata = go.Data([trace, trace1, trace2]) # Process the plots
layout = go.Layout(title="Age-adjusted Suicide Rates in United States",
xaxis={'title': 'Year'},
yaxis={'title': 'Suicide rate'}) # design layout
figure = go.Figure(data=plotdata,
layout=layout) # combine data and layout code
iplot(figure)
data1 = pd.read_csv(
"https://raw.githubusercontent.com/plotly/datasets/master/2014_world_gdp_with_codes.csv"
) #read csv for plot2
plotdata = go.Choropleth(
locations=data1['CODE'],
z=data1['GDP (BILLIONS)'],
text=data1['COUNTRY'],
autocolorscale=False,
colorscale='Picnic',
showscale=True,
) # Process the plots
layout = go.Layout(title="GDP of countries" # giving title to plot layout
)
def Plot_Streamflow(StreamDic, Rainfall=None, colors=ColorsDefault, **kwargs):
'''Function to plot streamflow data with dates axis and
rainfall
Parameters:
- Dates: pandas index dates format.
- StreamDic: Dictionary with the data and plot properties:
ej: {'Q1':{data:np.array(data),
'dates': pd.Series.index,
'color': 'rgb(30,114,36)',
'lw': 4, 'ls': '--'}}
Optional:
- Rainfall: Dictionary with rainfall data with the same
structure as StreamDic.'''
#Data definition
cont = 0
data = []
for k in StreamDic.keys():
#Set del trace
try:
setColor = StreamDic[k]['color']
except:
setColor = np.random.choice(list(ColorsDefault.keys()), 1)
setColor = ColorsDefault[setColor[0]]
try:
setWeight = StreamDic[k]['lw']
except:
setWeight = kwargs.get('lw', 4)
try:
setLineStyle = StreamDic[k]['ls']
except:
setLineStyle = kwargs.get('ls', None)
#Traces definitions
trace = go.Scatter(x=StreamDic[k]['dates'],
y=StreamDic[k]['data'],
name=k,
line=dict(color=setColor,
width=setWeight,
dash=setLineStyle),
opacity=1.0)
#Update data
data.append(trace)
#Rainfall
if type(Rainfall) == dict:
trace = go.Scatter(x=Rainfall['dates'],
y=Rainfall['data'],
line=dict(color='blue'),
opacity=0.8,
yaxis='y2',
fill='tozeroy',
fillcolor='rgba(0, 102, 153,0.2)')
data.append(trace)
#Layout definition
layout = dict(showlegend=False,
xaxis=dict(title='Dates'),
yaxis=dict(title="Streamflow [m3/s]"),
yaxis2=dict(autorange="reversed",
title="Caudal [m3/s]",
overlaying='y',
side='right'))
fig = dict(data=data, layout=layout)
iplot(fig)
how='inner',
on='settle_date')
# Step 02: plot atm_iv vs close
chart_title = f'{SYMBOL_TO_RESEARCH} atm vol vs close'
df_atm_vs_close = df_atmv[['settle_date', 'atm_iv', 'close']]
fig_atm_vs_close = plotly_plot(df_atm_vs_close,
x_column='settle_date',
yaxis2_cols=['close'],
y_left_label='atm_iv',
y_right_label='close',
plot_title=chart_title)
return fig_atm_vs_close
iplot(plot_atm_vs_close('CL', df_iv_final, df_cash_futures, year=2020))
for d in [.05, .1, .2]:
fig1, fig2 = plot_skew_vs_atm('CL',
df_iv_final,
df_iv_skew,
df_cash_futures,
dist_from_zero=d,
year=2020)
iplot(fig1)
iplot(fig2)
# ### Define initial banner and dropdowns
# In[ ]:
logger = dgc.init_root_logger('logfile.log', 'WARN')
def Plot_DurationCurve(StreamDic,
Rainfall=None,
colors=ColorsDefault,
Pinf=0.2,
Psup=99.8,
Nint=50,
**kwargs):
'''Function to plot streamflow data with dates axis and
rainfall
Parameters:
- Dates: pandas index dates format.
- StreamDic: Dictionary with the data and plot properties:
ej: {'Q1':{data:np.array(data),
'color': 'rgb(30,114,36)',
'lw': 4, 'ls': '--'}}
Optional:
- Pinf: Inferior percentile (0.2)
- Psup: Superior percentile (99.8)
- Nint: Total intervals (50)
- Rainfall: Dictionary with rainfall data with the same
structure as StreamDic.'''
#Obtains the excedance probability and
def GetExcedProb(X):
Qexc = []
for p in np.linspace(Pinf, Psup, Nint):
Qexc.append(np.percentile(X, p))
return Qexc, np.linspace(Pinf, Psup, Nint)[::-1] / 100.
#Data definition
cont = 0
data = []
for k in StreamDic.keys():
#Set del trace
try:
setColor = StreamDic[k]['color']
except:
setColor = np.random.choice(list(ColorsDefault.keys()), 1)
setColor = ColorsDefault[setColor[0]]
try:
setWeight = StreamDic[k]['lw']
except:
setWeight = kwargs.get('lw', 4)
try:
setLineStyle = StreamDic[k]['ls']
except:
setLineStyle = kwargs.get('ls', None)
#Values and P(x>X)
Qexc, P = GetExcedProb(StreamDic[k]['data'])
#Traces definitions
trace = go.Scatter(x=P,
y=Qexc,
name=k,
line=dict(color=setColor,
width=setWeight,
dash=setLineStyle),
opacity=1.0)
#Update data
data.append(trace)
#Layout definition
layout = dict(
showlegend=False,
xaxis=dict(
title='P(x>X)',
tickfont=dict(color='rgb(0, 102, 153)', size=16),
titlefont=dict(color='rgb(0, 102, 153)', size=20),
),
yaxis=dict(
title="Streamflow [m3/s]",
tickfont=dict(color='rgb(0, 102, 153)', size=16),
titlefont=dict(color='rgb(0, 102, 153)', size=20),
),
)
fig = dict(data=data, layout=layout)
iplot(fig)
def plot_log(self, symbol, engine='plotly', notebook=False):
if engine == 'plotly':
def draw(i):
tlog = self.tlog[self.tlog['symbol'] == i]
ltlog = tlog[tlog['s_type'] == 'LONG']
stlog = tlog[tlog['s_type'] == 'SHORT']
price = go.Scatter(x=tlog.index,
y=tlog['price'],
name=i + '_price',
xaxis='x3',
yaxis='y3')
qty = go.Scatter(x=tlog.index,
y=tlog['qty'],
name=i + '_qty',
xaxis='x4',
yaxis='y4')
LONG_cur_positions = go.Scatter(x=ltlog.index,
y=ltlog['cur_positions'],
name=i + 'LONG_cur_positions',
xaxis='x4',
yaxis='y4')
SHORT_cur_positions = go.Scatter(x=stlog.index,
y=stlog['cur_positions'],
name=i +
'SHORT_cur_positions',
xaxis='x4',
yaxis='y4')
LONG_period = go.Scatter(x=ltlog.index,
y=ltlog['period'].astype(int) /
(60 * 60 * 24 * 10**9),
name=i + 'LONG_period',
xaxis='x2',
yaxis='y2')
SHORT_period = go.Scatter(x=stlog.index,
y=stlog['period'].astype(int) /
(60 * 60 * 24 * 10**9),
name=i + 'SHORT_period',
xaxis='x2',
yaxis='y2')
LONG_PnL = go.Scatter(x=ltlog.index,
y=ltlog['PnL'],
name=i + 'LONG_PnL',
xaxis='x2',
yaxis='y2')
SHORT_PnL = go.Scatter(x=stlog.index,
y=stlog['PnL'],
name=i + 'SHORT_PnL',
xaxis='x2',
yaxis='y2')
self.data.append(price)
self.data.append(qty)
self.data.append(LONG_cur_positions)
self.data.append(SHORT_cur_positions)
self.data.append(LONG_period)
self.data.append(SHORT_period)
self.data.append(LONG_PnL)
self.data.append(SHORT_PnL)
if type(symbol) == list:
for i in symbol:
draw(i)
if type(symbol) == str:
draw(symbol)
layout = go.Layout(updatemenus=self.updatemenus,
xaxis2=dict(
domain=[0, 1],
anchor='y2',
),
xaxis3=dict(domain=[0, 1], anchor='y3'),
xaxis4=dict(domain=[0, 1], anchor='y4'),
yaxis2=dict(domain=[0, 0.3], ),
yaxis3=dict(domain=[0.3, 0.6]),
yaxis4=dict(domain=[0.6, 1], ))
fig = go.Figure(data=self.data, layout=layout)
if notebook:
import plotly
plotly.offline.init_notebook_mode()
py.iplot(fig, filename='testplot.html', validate=False)
else:
py.plot(fig, filename='testplot.html', validate=False)
def two_param_dist_plot(data, group_name, field_name):
fig = ff.create_distplot([
data[data[group_name] == i][field_name].dropna()
for i in data[group_name].value_counts().index
], data[group_name].value_counts().index)
py.iplot(fig)
# convert Spark dataframe to pandas in order to visualize data
grouped_by_rfmscore_pandas = grouped_by_rfmscore.toPandas()
# In[66]:
grouped_by_rfmscore_pandas
# In[67]:
grouped_by_rfmscore_pandas[
'RFM_Score'] = "Seg " + grouped_by_rfmscore_pandas['RFM_Score'].map(str)
# In[73]:
data = [
go.Bar(x=grouped_by_rfmscore_pandas['RFM_Score'],
y=grouped_by_rfmscore_pandas['count'])
]
layout = go.Layout(
title=go.layout.Title(text='Customer RFM Segments'),
xaxis=go.layout.XAxis(title=go.layout.xaxis.Title(text='RFM Segment')),
yaxis=go.layout.YAxis(title=go.layout.yaxis.Title(
text='Number of Customers')))
fig = go.Figure(data=data, layout=layout)
iplot(fig, filename='rfm_Segments')
# In[ ]:
# ## Bivariate Analysis:
# ### Bivariate Analysis on duration and protocol_type
# In[64]:
data = []
for col in connSample['protocol_type'].unique():
data.append(go.Box(y=connSample[connSample['protocol_type'] == col]['duration'], name=col))
iplot(data)
# - Conclusion: Regardless protocol_type feature most duration features are 0's.
# In[65]:
connSample['duration_log'] = np.log(connSample.duration+1)
# In[66]:
# Examine the distribution with duration_log > 0. Distributions of duration is very different between 'tcp' and 'udp'
connSample[connSample.duration_log > 0][[ "protocol_type"]].iplot(kind='hist' , color = "mediumpurple" , linecolor = 'black' , title= 'Top Protocol by Duration' , orientation = 'h' , xTitle='Duration_Log' , yTitle= 'Protocol_Type' , showlegend=True)
