def __init__(self,
df,
params=[],
logify=False,
output='notebook',
notebook_url="http://localhost:8888",
**kwargs):
self.df = df
self.params = params
self.logify = logify
self.kwargs = kwargs
if output == 'notebook':
reset_output()
output_notebook()
show(self.modify_doc, notebook_url=notebook_url)
else:
reset_output()
server = Server({'/': self.modify_doc})
server.start()
try:
server = Server({'/': self.modify_doc})
server.run_until_shutdown()
except:
pass
#print("Server running")
server.show("/")
self.server = server
def plot_candles(self):
df = self.df[450:]
df["date"] = df["Open_time"]
df["date"] = pd.to_datetime(self.df['date'], unit='ms')
inc = df.Close > df.Open
dec = df.Open > df.Close
w = 12 * 60 * 60 * 1000 # half day in ms
TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
p = figure(x_axis_type="datetime",
tools=TOOLS,
plot_width=1000,
title="BITCOIN Candlestick")
p.xaxis.major_label_orientation = pi / 4
p.grid.grid_line_alpha = 0.3
p.segment(df.date, df.High, df.date, df.Low, color="black")
p.vbar(df.date[inc],
w,
df.Open[inc],
df.Close[inc],
fill_color="#006400",
line_color="black")
p.vbar(df.date[dec],
w,
df.Open[dec],
df.Close[dec],
fill_color="#F2583E",
line_color="black")
output_notebook()
return p
def __init__(self, addr=None, interval=1000.00, loop=None):
if addr is None:
scheduler = default_executor().scheduler
if isinstance(scheduler, rpc):
addr = (scheduler.ip, 9786)
elif isinstance(scheduler, Scheduler):
addr = ('127.0.0.1', scheduler.services['http'].port)
self.addr = addr
self.interval = interval
self.display_notebook = False
if is_kernel() and not curstate().notebook:
output_notebook()
assert curstate().notebook
self.task_source, self.task_table = task_table_plot()
self.worker_source, self.worker_table = worker_table_plot()
self.output = vplot(self.worker_table, self.task_table)
self.client = AsyncHTTPClient()
self.loop = loop or IOLoop.current()
self.loop.add_callback(self.update)
self._pc = PeriodicCallback(self.update, self.interval, io_loop=self.loop)
self._pc.start()
def plot_cross_points(self):
self.eval_boillinger_bands()
self.candles['up_cross'] = np.where(
(self.candles['Close'] >= self.candles['Upper Band']),
self.candles['Close'], None)
self.candles['down_cross'] = np.where(
(self.candles['Close'] <= self.candles['Lower Band']),
self.candles['Close'], None)
p = self.configure_plot(self.candles)
p.circle(self.candles.date,
self.candles['up_cross'],
size=5,
color="red",
alpha=1,
legend="Up cross")
p.circle(self.candles.date,
self.candles['down_cross'],
size=5,
color="green",
alpha=1,
legend="Down cross")
output_notebook()
return p
def viz_zone_stat(input_shapefile,poly,uid):
try:
os.remove('ndvi_stats.html')
except OSError:
pass
palette.reverse()
output_notebook()
output_file('ndvi_stats1.html')
props = OrderedDict()
with fiona.open(input_shapefile, 'r') as polys:
for i in polys:
prop = OrderedDict()
prop[i['properties'].get(uid)] = {}
prop[i['properties'].get(uid)].update({ stat : val for stat , val in i['properties'].items()})
props.update(prop)
px = []
py = []
for i in poly:
x,y = i.exterior.xy
x=x.tolist()
y=y.tolist()
px.append(x)
py.append(y)
polyID = []
mndvi = []
std_ndvi= []
color_mapper = LogColorMapper(palette=palette)
for key in props:
polyID.append(props[key][uid])
mndvi.append(props[key]['mean'])
std_ndvi.append(props[key]['std'])
source = ColumnDataSource(data=OrderedDict(
tid=polyID,mndvi=mndvi,stdndvi=std_ndvi,x=px,y=py))
TOOLS = "pan,wheel_zoom,reset,hover,save"
TOOLTIPS=[
((uid), "@tid"),
("Mean NDVI", "@mndvi"),
("Std. NDVI", "@stdndvi")]
p = figure(plot_width=500, plot_height=500,title="Zonal Statistics")
#p.hover.point_policy = "follow_mouse"
"fill color", "$color[hex, swatch]:fill_color"
plots = p.patches('x', 'y', source=source,
fill_color={'field': 'mndvi', 'transform': color_mapper},
fill_alpha=0.7, line_color="black", line_width=0.5)
p.add_tools(HoverTool(tooltips=TOOLTIPS, mode='mouse'))
show(p)
def __init__(self, addr=None, interval=1.00):
if addr is None:
scheduler = default_executor().scheduler
if isinstance(scheduler, rpc):
addr = (scheduler.ip, scheduler.port)
elif isinstance(scheduler, Scheduler):
addr = ('127.0.0.1', scheduler.port)
self.cds = ColumnDataSource({k: []
for k in ['host', 'cpu', 'memory',
'zero', 'left', 'mid', 'right']})
self.display_notebook = False
self.figure = figure(height=200, width=800, y_range=(0, 100))
self.figure.logo = None
cpu = self.figure.quad(legend='cpu', left='left', right='mid',
bottom='zero', top='cpu', source=self.cds,
color=(0, 0, 255, 0.5))
memory = self.figure.quad(legend='memory', left='mid', right='right',
bottom='zero', top='memory', source=self.cds,
color=(255, 0, 0, 0.5))
self.figure.add_tools(HoverTool(renderers=[cpu, memory],
tooltips=[("host", "@host"),
("cpu", "@cpu"),
("memory", "@memory")]))
self.future = self.update(addr, interval)
if is_kernel() and not curstate().notebook:
output_notebook()
assert curstate().notebook
def __init__(self, addr=None, interval=1000.00, loop=None):
if addr is None:
scheduler = default_executor().scheduler
if isinstance(scheduler, rpc):
addr = (scheduler.ip, 9786)
elif isinstance(scheduler, Scheduler):
addr = ('127.0.0.1', scheduler.services['http'].port)
self.addr = addr
self.interval = interval
self.display_notebook = False
if is_kernel() and not curstate().notebook:
output_notebook()
assert curstate().notebook
self.task_source, self.task_table = task_table_plot()
self.worker_source, self.worker_table = worker_table_plot()
self.output = vplot(self.worker_table, self.task_table)
self.client = AsyncHTTPClient()
self.loop = loop or IOLoop.current()
self.loop.add_callback(self.update)
self._pc = PeriodicCallback(self.update, self.interval, io_loop=self.loop)
self._pc.start()
def some_activities(constraint):
f'''
# Some Activities: {constraint}
'''
'''
$contents
'''
'''
## Build Maps
Loop over activities, retrieve data, and construct maps.
'''
s = session('-v2')
maps = [
map_thumbnail(100, 120, data)
for data in (activity_statistics(s,
SPHERICAL_MERCATOR_X,
SPHERICAL_MERCATOR_Y,
ACTIVE_DISTANCE,
TOTAL_CLIMB,
activity_journal=aj)
for aj in constrained_activities(s, constraint))
if len(data[SPHERICAL_MERCATOR_X].dropna()) > 10
]
print(f'Found {len(maps)} activities')
'''
## Display Maps
'''
output_notebook()
show(tile(maps, 8))
def init_bokeh_plot(umap_df):
bplt.output_notebook()
datasource = bokeh.models.ColumnDataSource(umap_df)
color_mapping = bokeh.models.CategoricalColorMapper(
factors=["sns", "goat"], palette=bokeh.palettes.Spectral10)
plot_figure = bplt.figure(title='UMAP projection VAE latent',
plot_width=1000,
plot_height=1000,
tools=('pan, wheel_zoom, reset'))
plot_figure.add_tools(
bokeh.models.HoverTool(tooltips="""
<div>
<div>
<img src='@image' style='float: left; margin: 5px 5px 5px 5px'/>
</div>
<div>
<span style='font-size: 14px'>@fname</span>
<span style='font-size: 14px'>@loss</span>
</div>
</div>
"""))
plot_figure.circle('x',
'y',
source=datasource,
color=dict(field='db', transform=color_mapping),
line_alpha=0.6,
fill_alpha=0.6,
size=4)
return plot_figure
def Make_TSNE2(n_component, model, wv, limit):
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import pandas as pd
from tqdm import tqdm
import bokeh.plotting as bp
from bokeh.models import HoverTool, BoxSelectTool
from bokeh.plotting import figure, show, output_notebook
output_notebook()
plot_tfidf = bp.figure(
plot_width=500,
plot_height=500,
title="A map of word vectors",
tools="pan,wheel_zoom,box_zoom,reset,hover,previewsave",
x_axis_type=None,
y_axis_type=None,
min_border=1)
word_vectors = [
model[w] for w in tqdm(list(model.wv.vocab.keys())[:limit])
]
tsne_model = TSNE(n_components=n_component, verbose=1, random_state=0)
tsne_w2v = tsne_model.fit_transform(word_vectors)
# putting everything in a dataframe
tsne_df = pd.DataFrame(tsne_w2v, columns=['x', 'y'])
tsne_df['words'] = list(model.wv.vocab.keys())[:limit]
# plotting. the corresponding word appears when you hover on the data point.
plot_tfidf.scatter(x='x', y='y', source=tsne_df)
hover = plot_tfidf.select(dict(type=HoverTool))
hover.tooltips = {"word": "@words"}
show(plot_tfidf)
def Return_Benchmark(result):
'''Plot algorithm_period_return and benchmark_period_return.
Change output_notebook() to get a file output.
Parameters
----------
result is the result passed into analyze in a zipline algorithm.
'''
rtn = list(result.algorithm_period_return)
rtn_bm = list(result.benchmark_period_return)
dates = list(result.index)
output_notebook()
p = figure(width=800, height=350, x_axis_type="datetime")
p.line(dates, rtn_bm, color='darkgrey', line_dash='dashed', legend='Benchmark')
p.line(dates, rtn, color='navy', legend='Algorithm')
p.legend.location = "top_left"
p.grid.grid_line_alpha=0
p.xaxis.axis_label = 'Date'
p.yaxis.axis_label = 'Return'
p.ygrid.band_fill_color="olive"
p.ygrid.band_fill_alpha = 0.1
show(p)
def explore_venues():
color_palette = ['#ea4335', '#fbbc05', '#34a853', '#673ab7']
categories = ['socializing', 'career-business', 'tech', 'music']
city_lat, city_lon = (42.361145, -71.057083)
plot_data = pd.read_pickle('boston_venue_category')
plot_data['coords_x'] = plot_data['lon'].apply(lambda x: h.merc_x(x))
plot_data['coords_y'] = plot_data['lat'].apply(lambda x: h.merc_y(x))
X_range = (h.merc_x(city_lon) - 9000, h.merc_x(city_lon) + 3000)
Y_range = (h.merc_y(city_lat) - 5000, h.merc_y(city_lat) + 5000)
p = figure(x_range=X_range,
y_range=Y_range,
x_axis_type="mercator",
y_axis_type="mercator")
# load map
p.add_tile(CARTODBPOSITRON)
# add venues
for ctg, cp in zip(categories, color_palette):
p.circle(x=plot_data.loc[plot_data.category == ctg, 'coords_x'],
y=plot_data.loc[plot_data.category == ctg, 'coords_y'],
line_alpha=0.05,
fill_color=cp,
size=np.log(plot_data.loc[plot_data.category == ctg,
'sum(host)']) * 2.5,
legend=ctg,
fill_alpha=0.3)
output_notebook()
show(p)
def viz_activeCol(self):
output_notebook()
N = self.columnCount
img = np.zeros([1, N, 4], dtype=np.uint8)
maxOverlap = np.sort(self.overlapped).copy()[-1]
for i in range(N):
if (self.activeColumns[i]):
img[0, i, 0:3] = 0 # r
else:
img[0, i, 0:3] = 255 # r
img[0, i, 3] = np.sqrt(self.overlapped[i] / maxOverlap) * 255 # a
#
p = figure(plot_width=1000, plot_height=100)
p.image_rgba(image=[img], x=[0], y=[0], dw=[self.columnCount], dh=[1])
show(p)
idx = []
for i in range((self.columnCount)):
if (self.activeColumns[i] == 1):
idx.append(i)
print("active columns : {} \ncount : {}".format(
idx, np.count_nonzero(self.activeColumns)))
def notebook_plot(x_key, y_keys, **kwargs):
r"""Live plot log entries in the current notebook.
Parameters
----------
x_key : str
The key in the serialized JSON object that contains the x-axis
value.
y_key : list of str
See `x_key`.
\*\*kwargs
Connection parameters passed to the `connect` function.
"""
subscriber, sequence, x, y = get_socket(x_key, y_keys, **kwargs)
output_notebook()
fig = figure()
plot = fig.line(x, y)
handle = show(fig, notebook_handle=True)
push_notebook(handle=handle)
while True:
update(x_key, y_keys, sequence, subscriber, plot)
push_notebook(handle=handle)
def all_group_activities(start, finish, activity_group):
f'''
# All Activities for {activity_group}: {start.split()[0]} - {finish.split()[0]}
'''
'''
$contents
'''
'''
## Build Maps
Loop over activities, retrieve data, and construct maps.
'''
s = session('-v2')
maps = [
map_thumbnail(100, 120, data)
for data in (Statistics(s, activity_journal=aj).by_name(
ActivityReader, N.SPHERICAL_MERCATOR_X, N.SPHERICAL_MERCATOR_Y
).by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME).df
for aj in s.query(ActivityJournal).filter(
ActivityJournal.start >= local_date_to_time(start),
ActivityJournal.start < local_date_to_time(finish),
ActivityJournal.activity_group_id ==
ActivityGroup.from_name(s, activity_group)).order_by(
ActivityJournal.start.desc()).all())
if len(data[N.SPHERICAL_MERCATOR_X].dropna()) > 10
]
print(f'Found {len(maps)} activities')
'''
## Display Maps
'''
output_notebook()
show(htile(maps, 8))
def show_error_vs_real_train(results_df_train):
source = ColumnDataSource(results_df_train)
# Creation d'un figure interactive bokeh affichant l'erreur vs la valeur reelle
p = figure(
title="Error vs real",
tools='pan, box_zoom, undo, reset, hover',
tooltips=
[("index", "@index"), ("prediction", "@prediction{0,0}"),
("real", "@real{0,0}"),
('Building surface', '@PropertyGFATotal{0,0}'),
('Primary usage',
'@LargestPropertyUseType, @LargestPropertyUseTypeGFA{0,0}'),
('Second usage',
'@SecondLargestPropertyUseType, @SecondLargestPropertyUseTypeGFA{0,0}'
),
('Third usage',
'@ThirdLargestPropertyUseType, @ThirdLargestPropertyUseTypeGFA{0,0}')
])
p.xaxis.axis_label = 'Real'
p.yaxis.axis_label = '% Error'
p.circle("real", '%_error', source=source)
output_notebook()
show(p)
def notebook_bokeh(stcs):
patch_xs = parse_s_region(stcs)['ra']
patch_ys = parse_s_region(stcs)['dec']
p = figure(plot_width=700,
x_axis_label="RA (deg)",
y_axis_label="Dec (deg)")
data = {'x': [patch_xs], 'y': [patch_ys]}
p.patches('x',
'y',
source=data,
fill_alpha=0.1,
line_color="black",
line_width=0.5)
p.add_layout(
Arrow(end=VeeHead(line_color="black", line_width=1),
line_width=2,
x_start=patch_xs[0],
y_start=patch_ys[0],
x_end=patch_xs[1],
y_end=patch_ys[1]))
p.y_range.flipped = True
output_notebook()
show(p)
def plot_flare_bokeh(time, flux_pca, flux = None, flux_type ="",width_fig = 900, height_fig = 500, title=""):
# output form
reset_output()
output_notebook()
TOOLTIPS = [
("index", "$index"),
("(x,y)", "($x, $y)"),
]
# graph setting
p = figure(tooltips=TOOLTIPS, title=title, x_axis_label="Time", y_axis_label="Flux", plot_width = width_fig, plot_height=height_fig)
# main body for plotting
#if flux is not None:
#p.circle(time, flux, legend="raw" + "(%s)" % flux_type, color="red")
#p.line(time, flux, legend="raw"+ "(%s)" % flux_type, color="red")
p.circle(time, flux_pca, color="black")
p.line(time, flux_pca, color="black")
#p.add_layout(p.legend[0], "right") # 凡例をグラフの外に出す（右側）
# Hide legend if you click
#p.legend.click_policy = "hide"
# Output format (svg or png)
p.output_backend = "svg"
# Show
show(p)
def plot_word_vectors(w2v):
"""
Scatter plot of word vectors
Parameters
----------
w2v : gensim.Word2Vec
word2vec model
"""
output_notebook()
plot_tools = "pan,wheel_zoom,box_zoom,reset,hover,previewsave"
plot_tfidf = bp.figure(plot_width=700,
plot_height=600,
title="A map of the word vectors",
tools=plot_tools,
x_axis_type=None,
y_axis_type=None,
min_border=1)
word_vectors = [w2v.wv[w] for w in w2v.wv.vocab.keys()]
tsne = TSNE(n_components=2, verbose=1, random_state=0)
tsne_w2v = tsne.fit_transform(word_vectors)
tsne_df = pd.DataFrame(tsne_w2v, columns=['x', 'y'])
tsne_df['words'] = w2v.wv.vocab.keys()
plot_tfidf.scatter(x='x', y='y', source=tsne_df)
hover = plot_tfidf.select(dict(type=HoverTool))
hover.tooltips = {"word": "@words"}
show(plot_tfidf)
def all_activities(start: to_date, finish: to_date):
f'''
# All Activities: {start.split()[0]} - {finish.split()[0]}
'''
'''
$contents
'''
'''
## Build Maps
Loop over activities, retrieve data, and construct maps.
'''
s = session('-v2')
maps = [
map_thumbnail(100, 120, data) for data in (
activity_statistics(s,
SPHERICAL_MERCATOR_X,
SPHERICAL_MERCATOR_Y,
ACTIVE_DISTANCE,
ACTIVE_TIME,
activity_journal=aj)
for aj in s.query(ActivityJournal).filter(
ActivityJournal.start >= local_date_to_time(start),
ActivityJournal.start < local_date_to_time(finish)).all())
if len(data[SPHERICAL_MERCATOR_X].dropna()) > 10
]
print(f'Found {len(maps)} activities')
'''
## Display Maps
'''
output_notebook()
show(tile(maps, 8))
def visualize_kmeans(self):
kmeans = self.run_k_means
# output to static HTML file
output_notebook()
TOOLTIPS = [
("index", "$index"),
("(x,y)", "($x, $y)")
]
p1 = figure(plot_width=500, plot_height=500, tooltips=TOOLTIPS,)
# Get the number of colors we'll need for the plot.
colors = d3["Category20"][len(kmeans[0].unique())]
# Create a map between factor and color.
colormap = {i: colors[i] for i in kmeans[0].unique()}
# Create a list of colors for each value that we will be looking at.
colors = [colormap[x] for x in kmeans[0]]
# add a square renderer with a size, color, and alpha
p1.circle(self._principalDf['principal component 1'],self._principalDf['principal component 2'], size=2, color=colors, alpha=0.7)
# show the results
show(p1)
def similar_activities(local_time: to_date, activity_group_name):
f'''
# Similar Activities: {local_time.split()[0]}
'''
'''
$contents
'''
'''
## Build Maps
Loop over activities, retrieve data, and construct maps.
'''
s = session('-v2')
maps = [map_thumbnail(100, 120, data)
for data in (activity_statistics(s, SPHERICAL_MERCATOR_X, SPHERICAL_MERCATOR_Y,
activity_journal_id=similar[0].id).resample('1min').mean()
for similar in nearby_activities(s, local_time=local_time,
activity_group_name=activity_group_name))
if len(data.dropna()) > 10]
print(f'Found {len(maps)} activities')
'''
## Display Maps
'''
output_notebook()
show(tile(maps, 8))
def plot_vertical():
"""
Plot of vertical jump by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
dfRB = dfRB[dfRB.vertical > 0]
dfWR = dfWR[dfWR.vertical > 0]
# Remove Alex Smith (incorrect measurement)
dfQB = dfQB[dfQB.vertical > 20]
output_notebook()
# output_file('40yd.html')
tab1 = rb('vertical', 'Vertical Jump (in)',
'RB: Total Yards by Vertical Jump', 'Vertical Jump (in)',
dfRB, dfWR, dfQB)
tab2 = wr('vertical', 'Vertical Jump (in)',
'WR: Total Yards by Vertical Jump', 'Vertical Jump (in)',
dfRB, dfWR, dfQB)
tab3 = qb('vertical', 'Vertical Jump (in)',
'QB: Total Yards by Vertical Jump',
'Vertical Jump (in)', dfRB, dfWR, dfQB)
tabs = Tabs(tabs=[tab1, tab2, tab3])
show(tabs)
def plot_eblanks(df, xcolname='econc_mgmL', ycolname='measurement'):
df['strdate'] = df.expdate.apply(str)
# sdf_dict={}
cds_dict = {}
for egroup in df.groupby(by=['ename', 'expdate']):
grpname = ''.join([str(x) + ' ' for x in egroup[0]])[:-1]
cds_dict[grpname] = ColumnDataSource.from_df(
egroup[1]) #df[df.expdate==expdate])#sdf_dict[expdate])
p = figure(plot_width=800)
ht=HoverTool(tooltips=[('enzyme','@ename'),('M','@econc_molar'),('date','@strdate'),('plateid','@plateid'),\
('thing','@predvlp_dlnfactor')])
for dnum, grpname in enumerate(cds_dict):
didx = dnum % 10
p.circle(xcolname,
ycolname,
legend=grpname,
size=10,
color=palettes.Category20[20][didx],
source=cds_dict[grpname])
p.tools = [ht, BoxZoomTool(), ResetTool()]
# p.tools=[ht,"box_zoom"]
p.x_range = Range1d(-0.1, 4.5)
output_notebook()
show(p)
def show_pred_vs_real_test(results_df_test):
source = ColumnDataSource(results_df_test)
# Creation d'un figure interactive bokeh affichant la valeur predite vs la valeur reelle
p = figure(
title="Prediction vs real",
tools='pan, box_zoom, undo, reset, hover',
tooltips=
[("index", "@index"), ("prediction", "@prediction{0,0}"),
("real", "@real{0,0}"),
('Primary usage',
'@LargestPropertyUseType, @LargestPropertyUseTypeGFA{0,0}'),
('Second usage',
'@SecondLargestPropertyUseType, @SecondLargestPropertyUseTypeGFA{0,0}'
),
('Third usage',
'@ThirdLargestPropertyUseType, @ThirdLargestPropertyUseTypeGFA{0,0}')
])
p.xaxis.axis_label = 'Real'
p.yaxis.axis_label = 'Prediction'
p.circle("real", "prediction", source=source)
p.line("real", "real", color='orange', source=source)
output_notebook()
show(p)
def plot_trajectory(df, output_file=None, output_notebook=False):
"""Plot scenario trajectory to static html and open browser
Parameters
----------
df : DataFrame
DataFrame containing a scenario with 'latitude', 'longitude',
'heading', and 'callsign' columns
output_file : str
Output file for html (if None, use bokeh default)
output_notebook : bool
If True, output to jupyter notebook
"""
if output_file is not None:
bkplot.output_file(output_file)
elif output_notebook:
bkplot.output_notebook()
p = bkplot.figure(x_axis_type='mercator', y_axis_type='mercator')
tile_provider = get_provider(Vendors.CARTODBPOSITRON)
p.add_tile(tile_provider)
df_plot = df[['latitude','longitude','heading','callsign']].copy()
df_plot['longitude'], df_plot['latitude'] = _merc(df_plot['latitude'].values, df_plot['longitude'].values)
points = p.triangle(x='longitude', y='latitude', angle='heading', angle_units='deg', alpha=0.5, source=df_plot)
callsigns = df_plot['callsign'].unique()
points.glyph.fill_color = bk.transform.factor_cmap('callsign', palette=bk.palettes.Category10[10], factors=callsigns)
points.glyph.line_color = bk.transform.factor_cmap('callsign', palette=bk.palettes.Category10[10], factors=callsigns)
bkplot.show(p)
def __init__(self,
df,
params=[],
trim_factor=1,
logify=False,
output='notebook',
port=5006,
notebook_url="http://localhost:8888",
**kwargs):
self.df = df.iloc[::trim_factor].reset_index(drop=True)
self.params = params
self.logify = logify
self.kwargs = kwargs
if output == 'notebook':
reset_output()
output_notebook()
show(self.modify_doc, notebook_url=notebook_url)
elif output == 'server':
reset_output()
server = Server({'/': self.modify_doc}, port=port)
server.start()
try:
server.run_until_shutdown()
except:
print("Server already running")
self.server = server
def notebook_plot(x_key, y_key, **kwargs):
r"""Live plot log entries in the current notebook.
Parameters
----------
x_key : str
The key in the serialized JSON object that contains the x-axis
value.
y_key : str
See `x_key`.
\*\*kwargs
Connection parameters passed to the `connect` function.
"""
subscriber, sequence, x, y = connect(x_key, y_key, **kwargs)
session = push_session(curdoc())
output_notebook()
fig = figure()
plot = fig.line(x, y)
show(fig)
def notebook_update():
update(x_key, y_key, sequence, subscriber, plot)
push_notebook()
curdoc().add_periodic_callback(notebook_update, 50)
session.loop_until_closed()
def bubble_scatter_plot(df, x, y, z, norm=1.6):
"""
bubble plot showing y vs x
with z as the size of bubbles
:param: df, dataset
:type: pandas dataframe
:param: x, attribute to be on x axis
:type: str
:param: y, attribute to be on y axis
:type: str
:param: z, attribute to be size of bubbles
:type: str
"""
assert isinstance(df, pd.DataFrame), 'Input must be a dataframe!'
assert isinstance(x, str), 'X-axis must be a string!'
assert isinstance(y, str), 'Y-axis must be a string!'
assert isinstance(z, str), 'Z-axis must be a string!'
assert x in att, 'Not an attribute!'
assert y in att, 'Not an attribute!'
assert z in att, 'Not an attribute!'
assert isinstance(norm, float)
output_notebook()
df_4e = df
#filter
df_4e = df_4e[[x, y, z]]
#group by rating
grouped = df_4e.set_index(x).groupby(x)
df_4e = grouped.agg([np.nanmean])
#plot
p = figure(title="%s vs %s vs %s" % (z, y, x),
plot_width=800,
plot_height=400)
p.grid.grid_line_color = None
p.background_fill_color = "white"
#bubbles
p.scatter(df[x],
df[y],
marker='o',
size=(df[z] - 18) * norm,
color="orange",
alpha=0.8)
#mean scatter
p.scatter(df_4e.index,
df_4e[y]['nanmean'],
marker='o',
size=15,
color="red",
alpha=0.9)
p.xaxis.axis_label = '%s' % x
p.yaxis.axis_label = '%s' % y
#legend
p
return p
def plot_bokeh_candle_dochl(date, p_open, close, high, low, symbol):
COLORUP = 'red'
COLORDOWN = 'green'
bp.output_notebook()
p = bp.figure(x_axis_type="datetime", plot_width=840, title=symbol)
p.xaxis.major_label_orientation = pi / 4
p.grid.grid_line_alpha = 0.3
w = 24 * 60 * 60 * 1000
mids = (p_open + close) / 2
spans = abs(close - p_open)
inc = close > p_open
dec = p_open > close
p.segment(date.to_datetime(), high, date.to_datetime(), low, color="black")
p.rect(date.to_datetime()[inc],
mids[inc],
w,
spans[inc],
fill_color=COLORUP,
line_color=COLORUP)
p.rect(date.to_datetime()[dec],
mids[dec],
w,
spans[dec],
fill_color=COLORDOWN,
line_color=COLORDOWN)
bp.show(p)
def plot_vertical():
"""
Plot of vertical jump by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
dfRB = dfRB[dfRB.vertical > 0]
dfWR = dfWR[dfWR.vertical > 0]
dfQB = dfQB[dfQB.vertical > 20] #Remove Alex Smith (incorrect measurement)
output_notebook()
# output_file('40yd.html')
tab1 = rb('vertical', 'Vertical Jump (in)',
'RB: Total Yards by Vertical Jump', 'Vertical Jump (in)', dfRB,
dfWR, dfQB)
tab2 = wr('vertical', 'Vertical Jump (in)',
'WR: Total Yards by Vertical Jump', 'Vertical Jump (in)', dfRB,
dfWR, dfQB)
tab3 = qb('vertical', 'Vertical Jump (in)',
'QB: Total Yards by Vertical Jump', 'Vertical Jump (in)', dfRB,
dfWR, dfQB)
tabs = Tabs(tabs=[tab1, tab2, tab3])
show(tabs)
def output_notebook(local=True, suppress_warnings=False):
if suppress_warnings:
warnings.simplefilter("ignore", BokehUserWarning)
if local:
bk.output_notebook(resources=INLINE)
else:
bk.output_notebook()
def plot_targets(self):
TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
p = figure(x_axis_type="datetime",
tools=TOOLS,
plot_width=1000,
title="Target Chart")
p.xaxis.major_label_orientation = pi / 4
p.grid.grid_line_alpha = 0.3
p.line(self.candles.date, self.candles.Close, line_color="black")
p.circle(self.candles.date,
self.candles['sell'],
size=5,
color="red",
alpha=1,
legend='buy')
p.circle(self.candles.date,
self.candles['buy'],
size=5,
color="green",
alpha=1,
legend='sell')
p.circle(self.candles.date,
self.candles['hold'],
size=2,
color="blue",
alpha=1,
legend='hold')
output_notebook()
return p
def plot_bokeh(self, xlim=None, ylim=None, title=None, figsize=None,
xlabel=None, ylabel=None, fontsize=None, show_legend=True):
"""
Plot data using bokeh library. Use show() method for bokeh to see result.
:param xlim: x-axis range
:param ylim: y-axis range
:type xlim: None or tuple(x_min, x_max)
:type ylim: None or tuple(y_min, y_max)
:param title: title
:type title: None or str
:param figsize: figure size
:type figsize: None or tuple(weight, height)
:param xlabel: x-axis name
:type xlabel: None or str
:param ylabel: y-axis name
:type ylabel: None or str
:param fontsize: font size
:type fontsize: None or int
:param bool show_legend: show or not labels for plots
"""
global _COLOR_CYCLE_BOKEH
global _BOKEH_OUTPUT_NOTEBOOK_ACTIVATED
import bokeh.plotting as bkh
from bokeh.models import Range1d
from bokeh.core.properties import value
figsize = self.figsize if figsize is None else figsize
xlabel = self.xlabel if xlabel is None else xlabel
ylabel = self.ylabel if ylabel is None else ylabel
title = self.title if title is None else title
xlim = self.xlim if xlim is None else xlim
ylim = self.ylim if ylim is None else ylim
fontsize = self.fontsize if fontsize is None else fontsize
self.fontsize_ = fontsize
self.show_legend_ = show_legend
figsize = (figsize[0] * self.BOKEH_RESIZE, figsize[1] * self.BOKEH_RESIZE)
if not _BOKEH_OUTPUT_NOTEBOOK_ACTIVATED:
bkh.output_notebook()
_BOKEH_OUTPUT_NOTEBOOK_ACTIVATED = True
current_plot = bkh.figure(title=title, plot_width=figsize[0], plot_height=figsize[1])
_COLOR_CYCLE_BOKEH = itertools.cycle(COLOR_ARRAY_BOKEH)
if xlim is not None:
current_plot.x_range = Range1d(start=xlim[0], end=xlim[1])
if ylim is not None:
current_plot.y_range = Range1d(start=ylim[0], end=ylim[1])
current_plot.title_text_font_size = value("{}pt".format(fontsize))
current_plot.xaxis.axis_label = xlabel
current_plot.yaxis.axis_label = ylabel
current_plot.legend.orientation = 'top_right'
current_plot = self._plot_bokeh(current_plot, show_legend)
bkh.show(current_plot)
def mzImages(filename_in_list,save_dir):
import sys
sys.path.append('C:\\Users\\Luca Rappez\\Desktop\\python_codebase\\')
from pyMS.centroid_detection import gradient
from pyIMS.hdf5.inMemoryIMS_hdf5 import inMemoryIMS_hdf5
from pyIMS.image_measures import level_sets_measure
import matplotlib.pyplot as plt
import numpy as np
#%matplotlib inline
import bokeh as bk
from bokeh.plotting import output_notebook
output_notebook()
ppm = 0.75
if len(list)>2:
raise ValueError('list should only have two entries')
c_thresh=0.05
mz_list_all=[]
for filename_in in filename_in_list:
# Parse data
IMS_dataset = inMemoryIMS_hdf5(filename_in)
hist_axis,freq_spec = IMS_dataset.generate_summary_spectrum(summary_type='freq',ppm=ppm/2)
# Centroid detection of frequency spectrum
mz_list,count_list,idx_list = gradient(np.asarray(hist_axis),np.asarray(freq_spec),weighted_bins=2)
mz_list=[m for m,c in zip(mz_list,count_list) if c>c_thresh]
mz_list_all.append(mz_list)
im_list = [m for m in mz_list_all[0] if any([1e6*(m-mm)/m<ppm for mm in mz_list_all[1]]) ]
"""# Calcualte MoC for images of all peaks
nlevels=30
im_list={}
for ii, c in enumerate(count_list):
ion_image = IMS_dataset.get_ion_image(np.asarray([mz_list[ii],]),ppm)
im = ion_image.xic_to_image(0)
m,im_moc,levels,nobjs = level_sets_measure.measure_of_chaos(im,nlevels,interp='median') #just output measure value
m=1-m
im_list[mz_list[ii]]={'image':im,'moc':m,'freq':c}
"""
from pySpatialMetabolomics.tools import colourmaps
c_map = colourmaps.get_colormap('grey')#if black images: open->save->rerun
c_pal=[[int(255*cc) for cc in c_map(c)] for c in range(0,254)]
# Export all images
import png as pypng
for filename_in in filename_in_list:
# Parse data
IMS_dataset = inMemoryIMS_hdf5(filename_in)
for mz in im_list:
with open('{}/{}_{}.png'.format(save_dir,mz,filename_in),'wb') as f_out:
im_out = IMS_dataset.get_ion_image([mz,],[ppm,]).xic_to_image(0)
im_out = 254*im_out/np.max(im_out)
w,h = np.shape(im_out)
w = pypng.Writer(h, w, palette=c_pal, bitdepth=8)
w.write(f_out,im_out)
def plot_spectrum(self):
##fig1, ax1 = plt.subplots(1, figsize=(20,10))
#ax1.plot(self.wls, self.data, self.wls, self.dataMEANlong, self.wls, self.dataMEANshort)
#plt.show()
output_notebook()
p = figure()
p.line(self.wls, self.data)
p.line(self.wls, self.dataMEANlong, legend='Continuum Mean')
p.line(self.wls, self.dataMEANshort, legend='Line mean')
show(p)
def _make_multiplot(self):
self._make_datasource()
self._make_hovertool_string()
figs = [self._make_patch_plot(title) for title in self.plot_params['plot_titles']]
for fig_i in figs[1:]:
fig_i.x_range = figs[0].x_range
fig_i.y_range = figs[0].y_range
for i, fig in enumerate(figs):
fig.title_text_color = 'black'
fig.axis.axis_label_text_color = 'black'
fig.axis.major_label_text_color = '#B3B3B3'
fig.title_text_font_size = '18pt'
fig.axis.axis_label_text_font_size = '12pt'
fig.axis.major_label_text_font_size= '9pt'
fig.axis.minor_tick_line_color = None
fig.axis.major_tick_in = -2
fig.axis.major_tick_out = 8
fig.axis.major_tick_line_color = '#B3B3B3'
fig.axis.major_tick_line_width = 2
fig.axis.major_tick_line_cap = 'butt'
fig.xaxis.axis_label = self.plot_params['x_label']
fig.yaxis.axis_label = self.plot_params['y_label']
fig.outline_line_width = 0.5
fig.outline_line_color = 'black'
if not self.logvals:
fig.xaxis[0].formatter = PrintfTickFormatter(format="%0.1e")
fig.yaxis[0].formatter = PrintfTickFormatter(format="%0.1e")
hover = fig.select_one(HoverTool)
hover.point_policy = "follow_mouse"
hover.tooltips = self._hovertool_html[i]
n_cols = self.plot_params['n_cols']
n_figs = len(figs)
figs = [figs[i*n_cols:(i+1)*n_cols] for i in range((n_figs//n_cols)+1)]
if n_figs % n_cols == 0:
figs=figs[:-1]
fig = gridplot(figs)
save_string = self.plot_params['save_string']
if not save_string:
output_notebook()
show(fig)
elif save_string == 'return':
return(fig)
elif save_string.endswith('.html'):
output_file(save_string)
save(fig)
def plot_height():
"""
Plot of height by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
output_notebook()
# output_file('40yd.html')
tab1 = rb('heightinchestotal', 'Height (in)', 'RB: Total Yards by Height', 'Height (in)', dfRB, dfWR, dfQB)
tab3 = qb('heightinchestotal', 'Height (in)', 'QB: Total Yards by Height', 'Height (in)', dfRB, dfWR, dfQB)
tab2 = wr('heightinchestotal', 'Height (in)', 'WR: Total Yards by Height', 'Height (in)', dfRB, dfWR, dfQB)
tabs = Tabs(tabs=[ tab1, tab2, tab3 ])
show(tabs)
def plot_40dash():
"""
Plot of 40 yard times by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
output_notebook()
# output_file('40yd.html')
tab1 = rb('fortyyd', '40 Yard Dash', 'RB: Total Yards by 40 Yard Dash', '40 Yard Dash', dfRB, dfWR, dfQB)
tab2 = wr('fortyyd', '40 Yard Dash', 'WR: Total Yards by 40 Yard Dash', '40 Yard Dash', dfRB, dfWR, dfQB)
tab3 = qb('fortyyd', '40 Yard Dash', 'QB: Total Yards by 40 Yard Dash', '40 Yard Dash', dfRB, dfWR, dfQB)
tabs = Tabs(tabs=[ tab1, tab2, tab3 ])
show(tabs)
def test_bernoulli():
values = 100
colors = gen_n_colors(100)
wealth=1000
output_notebook()
results=[]
iteration=50
index = 0
for fee in np.linspace(2,200,values):
results=bernoulli_st_petersburg_ufunc(wealth,iteration,fee)
x = np.arange(len(results))
line(x,results,line_color=colors[index])
index = index + 1
show()
def plot_speedscore():
"""
Plot of speedscore by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
output_notebook()
# output_file('40yd.html')
tab1 = rb('speedscore', 'Speed Score', 'RB: Total Yards by Speed Score', 'Speed Score', dfRB, dfWR, dfQB)
tab3 = qb('speedscore', 'Speed Score', 'QB: Total Yards by Speed Score', 'Speed Score', dfRB, dfWR, dfQB)
tab2 = wr('speedscore', 'Speed Score', 'WR: Total Yards by Speed Score', 'Speed Score', dfRB, dfWR, dfQB)
tabs = Tabs(tabs=[ tab1, tab2, tab3 ])
show(tabs)
def _plot_bokeh(self, metadata=None, title=''):
metadata = metadata if metadata is not None else pd.DataFrame(
index=self.reduced_space.index)
# Clean alias
import bokeh.plotting as bk
from bokeh.plotting import ColumnDataSource, figure, show
from bokeh.models import HoverTool
# Plots can be displayed inline in an IPython Notebook
bk.output_notebook(force=True)
# Create a set of tools to use
TOOLS = "pan,wheel_zoom,box_zoom,reset,hover"
x = self.reduced_space[self.x_pc]
y = self.reduced_space[self.y_pc]
radii = np.ones(x.shape)
colors = self.reduced_space.index.map(
lambda x: self.label_to_color[self.groupby[x]])
sample_ids = self.reduced_space.index
data = dict(
(col, metadata[col][self.reduced_space.index]) for
col in metadata)
tooltips = [('sample_id', '@sample_ids')]
tooltips.extend([(k, '@{}'.format(k)) for k in data.keys()])
data.update(dict(
x=x,
y=y,
colors=colors,
sample_ids=sample_ids
))
source = ColumnDataSource(
data=data
)
p = figure(title=title, tools=TOOLS)
p.circle(x, y, radius=radii, source=source,
fill_color=colors, fill_alpha=0.6, line_color=None)
hover = p.select(dict(type=HoverTool))
hover.tooltips = tooltips
show(p)
def dataVisualizationUsingBokeh(): # import modules from bokeh.plotting import figure, output_notebook, show # output to notebook output_notebook() # create figure p = figure(plot_width = 400, plot_height = 400) # add a circle renderer with # size, color and alpha p.circle([1, 2, 3, 4, 5], [4, 7, 1, 6, 3], size = 10, color = "navy", alpha = 0.5) # show the results show(p)
def init_from_matmodlab_magic(p):
if p == BOKEH:
from bokeh.plotting import output_notebook
output_notebook()
environ.plotter = BOKEH
i = 2
elif p == MATPLOTLIB:
environ.plotter = MATPLOTLIB
i = 1
environ.notebook = i
environ.verbosity = 0
try:
from sympy import init_printing
init_printing()
except ImportError:
pass
def plot_twentyss():
"""
Plot of 20 yard shuttle times by yardage with tabs for each position.
Calls:
make_dfs(), rb(), wr(), qb()
"""
dfRB, dfWR, dfQB = make_dfs()
dfRB = dfRB[dfRB.twentyss > 0]
dfWR = dfWR[dfWR.twentyss > 0]
dfQB = dfQB[dfQB.twentyss > 2] #Remove Alex Smith (incorrect time)
output_notebook()
# output_file('40yd.html')
tab1 = rb('twentyss', '20 Yd Shuttle', 'RB: Total Yards by Short Shuttle', '20 Yard Short Shuttle', dfRB, dfWR, dfQB)
tab2 = wr('twentyss', '20 Yd Shuttle', 'WR: Total Yards by Short Shuttle', '20 Yard Short Shuttle', dfRB, dfWR, dfQB)
tab3 = qb('twentyss', '20 Yd Shuttle', 'QB: Total Yards by Short Shuttle', '20 Yard Short Shuttle', dfRB, dfWR, dfQB)
tabs = Tabs(tabs=[ tab1, tab2, tab3 ])
show(tabs)
def __init__(self,title,lines,width=900,height=300): global plots_initialized if not plots_initialized: plots_initialized=True output_notebook() self.P=figure(title=title) self.P.plot_width=width self.P.plot_height=height self.src=[] i=0 for line in lines: s=ColumnDataSource(name=line) self.src.append(s) self.P.line([],[],source=s,legend=line,line_color=self.color[i]) i+=1 show(self.P)
def __init__(self, addr=None, interval=1.00):
if addr is None:
scheduler = default_executor().scheduler
if isinstance(scheduler, rpc):
addr = (scheduler.ip, scheduler.port)
elif isinstance(scheduler, Scheduler):
addr = ('127.0.0.1', scheduler.port)
self.cds = ColumnDataSource({k: []
for k in ['host', 'processing', 'stacks', 'waiting',
'zero', 'left', 'mid', 'right']})
self.display_notebook = False
left_range = Range1d(0, 1)
self.figure = figure(height=200, width=800, y_range=left_range)
self.figure.extra_y_ranges = {'waiting': Range1d(start=0, end=1)}
self.figure.add_layout(LinearAxis(y_range_name='waiting',
axis_label='waiting'), 'right')
self.figure.logo = None
proc = self.figure.quad(legend='processing', left='left', right='mid',
bottom='zero', top='nprocessing', source=self.cds,
color=(0, 0, 255, 0.5))
wait = self.figure.quad(legend='waiting', left='mid', right='right',
bottom='zero', top='waiting', source=self.cds,
y_range_name='waiting', color=(255, 0, 0, 0.5))
self.figure.add_tools(HoverTool(renderers=[proc, wait],
tooltips=[("host", "@host"),
("processing", "@processing"),
("waiting", "@waiting")]))
self.future = self.update(addr, interval)
if is_kernel() and not curstate().notebook:
output_notebook()
assert curstate().notebook
def plot(x, y, labels=None, **kwargs):
TOOLS="pan,wheel_zoom,box_zoom,reset,hover"
p = figure(tools=TOOLS, **kwargs)
try:
l = list(labels)
except:
l = list(x)
source = ColumnDataSource(
data=dict(
x = x,
y = y,
l = l,
)
)
p.scatter(x, y, size=10, source=source)
hover = p.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([
("Label", "@l"),
("X", "@x"),
("Y", "@y"),
])
output_notebook()
show(p)
def bokeh_zone_colour_map(data_source, notebook=False):
"""
Colour each station depending on the zone
:param data_source:
:return:
"""
"""
:param data_source:
:return:
"""
#define the colours for each zone
if notebook:
output_notebook()
else:
output_file("bokeh_zonecolourlondontuberandomsize.html")
TOOLS="resize,hover,save"
zonecolour_tubemap=figure(title="The London Underground", tools=TOOLS)
zonecolour_tubemap.plot_height=800
zonecolour_tubemap.plot_width=800
zonecolour_tubemap.xgrid.grid_line_color = None
zonecolour_tubemap.ygrid.grid_line_color = None
sizes=np.random.randint(5,25,len(data_source.data["longitudes"]))
zonecolour_tubemap.circle(data_source.data["longitudes"], data_source.data["latitudes"], sizes=10, color=data_source.data["colours"], alpha=0.6)
show(zonecolour_tubemap)
# Determine available solver interfaces
solvers = {}
try:
from optlang import glpk_interface
solvers['glpk'] = glpk_interface
except ImportError:
pass
try:
from optlang import cplex_interface
solvers['cplex'] = cplex_interface
except ImportError:
pass
# Determine if bokeh is available
try:
import bokeh
except ImportError:
use_bokeh = False
else:
if in_ipnb():
from bokeh.plotting import output_notebook
output_notebook(hide_banner=True)
use_bokeh = True
bokeh_url = 'default'
# Set default parallelization view
default_view = SequentialView()
def _init_bokeh_nb():
"""Cache this so it doesn't happen over and over again.
"""
from bokeh.plotting import output_notebook
from bokeh.resources import INLINE
output_notebook(resources=INLINE)
def mzImages(filename_in,save_dir):
import sys
sys.path.append('C:\\Users\\Luca Rappez\\Desktop\\python_codebase\\')
from pyMS.centroid_detection import gradient
from pyIMS.hdf5.inMemoryIMS_hdf5 import inMemoryIMS_hdf5
from pyIMS.image_measures import level_sets_measure
import matplotlib.pyplot as plt
import numpy as np
#%matplotlib inline
import bokeh as bk
from bokeh.plotting import output_notebook
output_notebook()
print 'step1'
#filename_in = '//psi.embl.de/alexandr/shared/Luca/20150825_CoCulture_Candida_Ecoli/20150821_ADP_LR_colony250K12_DHBsub_260x280_50um.hdf5' #using a temporary hdf5 based format
#save_dir= '//psi.embl.de/alexandr/shared/Luca/20150825_CoCulture_Candida_Ecoli/20150821_ADP_LR_colony250K12_DHBsub_260x280_50um_figures'
# Parse data
IMS_dataset = inMemoryIMS_hdf5(filename_in)
print 'In memory'
ppm = 1.5
# Generate mean spectrum
#hist_axis,mean_spec =IMS_dataset.generate_summary_spectrum(summary_type='mean')
hist_axis,freq_spec = IMS_dataset.generate_summary_spectrum(summary_type='freq',ppm=ppm/2)
#p1 = bk.plotting.figure()
#p1.line(hist_axis,mean_spec/np.max(mean_spec),color='red')
#p1.line(hist_axis,freq_spec/np.max(freq_spec),color='orange')
#bk.plotting.show(p1)
print len(hist_axis)
#plt.figure(figsize=(20,10))
#plt.plot(hist_axis,freq_spec)
#plt.show()
# Centroid detection of frequency spectrum
mz_list,count_list,idx_list = gradient(np.asarray(hist_axis),np.asarray(freq_spec),weighted_bins=2)
c_thresh=0.05
moc_thresh=0.99
print np.sum(count_list>c_thresh)
# Calcualte MoC for images of all peaks
nlevels=30
im_list={}
for ii, c in enumerate(count_list):
#print ii
#print c
if c>c_thresh:
ion_image = IMS_dataset.get_ion_image(np.asarray([mz_list[ii],]),ppm)
im = ion_image.xic_to_image(0)
m,im_moc,levels,nobjs = level_sets_measure.measure_of_chaos(im,nlevels,interp='median') #just output measure value
m=1-m
im_list[mz_list[ii]]={'image':im,'moc':m,'freq':c}
from pySpatialMetabolomics.tools import colourmaps
c_map = colourmaps.get_colormap('grey')#if black images: open->save->rerun
c_pal=[[int(255*cc) for cc in c_map(c)] for c in range(0,254)]
# Export all images
import png as pypng
for mz in im_list:
if im_list[mz]['moc']>moc_thresh:
with open('{}/{}_{}.png'.format(save_dir,mz,im_list[mz]['moc']),'wb') as f_out:
im_out = im_list[mz]['image']
im_out = 254*im_out/np.max(im_out)
w,h = np.shape(im_out)
w = pypng.Writer(h, w, palette=c_pal, bitdepth=8)
w.write(f_out,im_out)
#im_out = im_list[mz]['image']
mz=333.334188269
ion_image = IMS_dataset.get_ion_image(np.asarray([mz,]),ppm)
im_out=ion_image.xic_to_image(0)
m,im_moc,levels,nobjs = level_sets_measure.measure_of_chaos(im,nlevels,interp='') #just output measure value
print 1-m
im_out = 254.*im_out/np.max(im_out)
print mz
#print im_list[mz]['moc']
#plt.figure()
#plt.imshow(im_moc)
#plt.show()
## Disable autoscrolling
from IPython.display import display, Javascript
disable_js = """
IPython.OutputArea.prototype._should_scroll = function(lines) {
return false;
}
"""
display(Javascript(disable_js))
# load bokeh for jupyter
bkp.output_notebook(hide_banner=True)
#
def show(grid):
"""Display graphs, accepts a list of list of figures.
The postures(), goals() and effects() functions display their
graphs automatically unless the keyword argument `show` is set
to False.
"""
bkp.show(bkp.gridplot(grid))
def tweak_fig(fig):
tight_layout(fig)
three_ticks(fig)
def plot_design(design):
output_notebook()
sel_mult = SelectMultiple(options = [x for x in design.layers])
interactive_plot = interactive(layer_select, m=sel_mult, design=fixed(design))
display(interactive_plot)
all_scores.append(scores)
# ## Painting
# In[11]:
get_ipython().magic("matplotlib inline")
# In[12]:
from matplotlib import pyplot as plt
plt.plot(parameter_values, avg_scores, "-o")
# ## Painting with Bokeh
# In[18]:
from bokeh.plotting import figure, output_notebook, show
output_notebook()
p = figure()
p.line(parameter_values, avg_scores, line_width=2)
show(p)
# In[ ]:
def nb_view_patches(Yr, A, C, b, f, d1, d2, image_neurons=None, thr=0.99):
'''
Interactive plotting utility for ipython notbook
Parameters
-----------
Yr: np.ndarray
movie
A,C,b,f: np.ndarrays
outputs of matrix factorization algorithm
d1,d2: floats
dimensions of movie (x and y)
image_neurons: np.ndarray
image to be overlaid to neurons (for instance the average)
thr: double
threshold regulating the extent of the displayed patches
'''
colormap = cm.get_cmap("jet") # choose any matplotlib colormap here
grayp = [mpl.colors.rgb2hex(m) for m in colormap(np.arange(colormap.N))]
nr, T = C.shape
nA2 = np.sum(np.array(A)**2, axis=0)
b = np.squeeze(b)
f = np.squeeze(f)
#Y_r = np.array(spdiags(1/nA2,0,nr,nr)*(A.T*np.matrix(Yr-b[:,np.newaxis]*f[np.newaxis] - A.dot(C))) + C)
Y_r = np.array(spdiags(1 / nA2, 0, nr, nr) * (A.T * np.matrix(Yr) - (A.T *
np.matrix(b[:, np.newaxis])) * np.matrix(f[np.newaxis]) - (A.T.dot(A)) * np.matrix(C)) + C)
bpl.output_notebook()
x = np.arange(T)
z = np.squeeze(np.array(Y_r[:, :].T)) / 100
k = np.reshape(np.array(A), (d1, d2, A.shape[1]), order='F')
if image_neurons is None:
image_neurons = np.nanmean(k, axis=2)
fig = plt.figure()
coors = plot_contours(coo_matrix(A), image_neurons, thr=thr)
plt.close()
# cc=coors[0]['coordinates'];
cc1 = [cor['coordinates'][:, 0] for cor in coors]
cc2 = [cor['coordinates'][:, 1] for cor in coors]
c1 = cc1[0]
c2 = cc2[0]
npoints = range(len(c1))
source = ColumnDataSource(data=dict(x=x, y=z[:, 0], z=z))
source2 = ColumnDataSource(data=dict(x=npoints, c1=c1, c2=c2, cc1=cc1, cc2=cc2))
plot = bpl.figure(plot_width=600, plot_height=300)
plot.line('x', 'y', source=source, line_width=1, line_alpha=0.6)
callback = CustomJS(args=dict(source=source, source2=source2), code="""
var data = source.get('data');
var f = cb_obj.get('value')-1
x = data['x']
y = data['y']
z = data['z']
for (i = 0; i < x.length; i++) {
y[i] = z[i][f]
}
var data2 = source2.get('data');
c1 = data2['c1'];
c2 = data2['c2'];
cc1 = data2['cc1'];
cc2 = data2['cc2'];
for (i = 0; i < c1.length; i++) {
c1[i] = cc1[f][i]
c2[i] = cc2[f][i]
}
source2.trigger('change');
source.trigger('change');
""")
slider = bokeh.models.Slider(start=1, end=Y_r.shape[
0], value=1, step=1, title="Neuron Number", callback=callback)
xr = Range1d(start=0, end=image_neurons.shape[1])
yr = Range1d(start=image_neurons.shape[0], end=0)
plot1 = bpl.figure(x_range=xr, y_range=yr, plot_width=300, plot_height=300)
plot1.image(image=[image_neurons[::-1, :]], x=0,
y=image_neurons.shape[0], dw=d2, dh=d1, palette=grayp)
plot1.patch('c1', 'c2', alpha=0.6, color='purple', line_width=2, source=source2)
layout = vform(slider, hplot(plot1, plot))
bpl.show(layout)
return Y_r
def show_notebook(self, fig):
bkp.output_notebook()
bkp.show(fig)
def notebook_output(self):
"""Wrapper to execute the open notebook function just once to avoid
a javascript annoying bug when it is called multiple times."""
output_notebook()
self.has_run = True
#! coding: utf-8
"""getting start with bokeh"""
from bokeh.plotting import figure, output_file, output_notebook, show
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]
# output_file('lines.html', title='line plot example')
output_notebook('lines.html')
p = figure(title='simple line example', x_axis_label='x', y_axis_label='y')
p.line(x, y, legend="Temp.", line_width=2)
show(p)
from ipywidgets import interact
import numpy as np
from bokeh.io import push_notebook
from bokeh.plotting import figure, show, output_notebook
x = np.linspace(0, 2 * np.pi, 2000)
y = np.sin(x)
output_notebook()
p = figure(title='simple line example', plot_height=300, plot_width=600, y_range=(-5, 5))
r = p.line(x, y, color='#2222aa', line_width=3)
