Here are the examples of the python api bokeh.models.PrintfTickFormatter taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
10 Examples
3
Source : render.py
with MIT License
from sfu-db
with MIT License
from sfu-db
def create_color_mapper(palette: Sequence[str]) -> Tuple[LinearColorMapper, ColorBar]:
"""
Create a color mapper and a colorbar for heatmap
"""
mapper = LinearColorMapper(palette=palette, low=-1, high=1)
colorbar = ColorBar(
color_mapper=mapper,
major_label_text_font_size="8pt",
ticker=BasicTicker(),
formatter=PrintfTickFormatter(format="%.2f"),
label_standoff=6,
border_line_color=None,
location=(0, 0),
)
return mapper, colorbar
######### Scatter #########
def render_scatter(
0
Source : combine.py
with MIT License
from microsoft
with MIT License
from microsoft
def combine(self, runs: List[Dict], img_save_path: str):
"""
Combine runs from several files.
:param paths: The paths to the runs to combine.
"""
output_file('combined_plots.html')
plot = figure(title="Balances & Accuracy on Hidden Test Set", )
plot.width = 800
plot.height = 800
plot.xaxis.axis_label = "Time (days)"
plot.yaxis.axis_label = "Percent"
plot.title.text_font_size = '20pt'
plot.xaxis.major_label_text_font_size = '16pt'
plot.xaxis.axis_label_text_font_size = '16pt'
plot.yaxis.major_label_text_font_size = '16pt'
plot.yaxis.axis_label_text_font_size = '16pt'
plot.xaxis[0].ticker = AdaptiveTicker(base=5 * 24 * 60 * 60)
plot.xgrid[0].ticker = AdaptiveTicker(base=24 * 60 * 60)
# JavaScript code.
plot.xaxis[0].formatter = FuncTickFormatter(code="""
return (tick / 86400).toFixed(0);
""")
plot.yaxis[0].formatter = PrintfTickFormatter(format="%0.1f%%")
# TODO Make plot wider (or maybe it's ok for the paper).
good_colors = cycle([
colors.named.green,
colors.named.lawngreen,
colors.named.darkgreen,
colors.named.limegreen,
])
bad_colors = cycle([
colors.named.red,
colors.named.darkred,
colors.named.orangered,
colors.named.indianred,
])
accuracy_colors = cycle([
colors.named.blue,
colors.named.cadetblue,
colors.named.cornflowerblue,
colors.named.darkblue,
])
baseline_accuracy_colors = cycle([
colors.named.black,
colors.named.darkgrey,
colors.named.slategrey,
colors.named.darkslategrey,
])
line_dashes = cycle([
'solid',
'dashed',
'dotted',
'dotdash',
'dashdot',
])
legend = []
for run in runs:
name = run['name']
path = run['path']
line_dash = next(line_dashes)
self._logger.info("Opening \"%s\".", path)
with open(path) as f:
data = json.load(f)
baseline_accuracy = data['baselineAccuracy']
if baseline_accuracy is not None:
self._logger.debug("Baseline accuracy: %s", baseline_accuracy)
r = plot.ray(x=[0], y=[baseline_accuracy * 100], length=0, angle=0, line_width=2,
line_dash=line_dash,
color=next(baseline_accuracy_colors))
legend.append((f"{name} accuracy when trained with all data: {baseline_accuracy * 100:0.1f}%", [r]))
agents: Dict[str, Agent] = dict()
for agent in data['agents']:
agent = Agent(**agent)
agents[agent.address] = agent
l = plot.line(x=[d['t'] for d in data['accuracies']],
y=[d['accuracy'] * 100 for d in data['accuracies']],
line_dash=line_dash,
line_width=2,
color=next(accuracy_colors),
)
legend.append((f"{name} Accuracy", [l]))
agent_balance_data = defaultdict(list)
for balance_data in data['balances']:
agent = balance_data['a']
agent_balance_data[agent].append(
(balance_data['t'], balance_data['b'] * 100 / agents[agent].start_balance))
for agent_id, balance_data in sorted(agent_balance_data.items(), key=itemgetter(0)):
agent = agents[agent_id]
if agent.good:
color = next(good_colors)
else:
color = next(bad_colors)
l = plot.line(x=list(map(itemgetter(0), balance_data)),
y=list(map(itemgetter(1), balance_data)),
line_dash=line_dash,
line_width=2,
color=color,
)
legend.append((f"{name} {agent.address} Agent Balance", [l]))
self._logger.info("Done going through runs.")
legend = Legend(items=legend, location='center_left')
plot.add_layout(legend, 'above')
plot.legend.label_text_font_size = '12pt'
self._logger.info("Saving image to: %s", img_save_path)
export_png(plot, img_save_path)
if __name__ == '__main__':
0
Source : simulate.py
with MIT License
from microsoft
with MIT License
from microsoft
def simulate(self,
agents: List[Agent],
baseline_accuracy: float = None,
init_train_data_portion: float = 0.1,
pm_test_sets: list = None,
accuracy_plot_wait_s=2E5,
train_size: int = None, test_size: int = None,
filename_indicator: str = None
):
"""
Run a simulation.
:param agents: The agents that will interact with the data.
:param baseline_accuracy: The baseline accuracy of the model.
Usually the accuracy on a hidden test set when the model is trained with all data.
:param init_train_data_portion: The portion of the data to initially use for training. Must be [0,1].
:param pm_test_sets: The test sets for the prediction market incentive mechanism.
:param accuracy_plot_wait_s: The amount of time to wait in seconds between plotting the accuracy.
:param train_size: The amount of training data to use.
:param test_size: The amount of test data to use.
:param filename_indicator: Path of the filename to create for the run.
"""
assert 0 < = init_train_data_portion < = 1
# Data to save.
save_data = dict(agents=[asdict(a) for a in agents],
baselineAccuracy=baseline_accuracy,
initTrainDataPortion=init_train_data_portion,
accuracies=[],
balances=[],
)
time_for_filenames = int(time.time())
save_path = f'saved_runs/{time_for_filenames}-{filename_indicator}-simulation_data.json'
model_save_path = f'saved_runs/{time_for_filenames}-{filename_indicator}-model.json'
plot_save_path = f'saved_runs/{time_for_filenames}-{filename_indicator}.png'
self._logger.info("Saving run info to \"%s\".", save_path)
os.makedirs(os.path.dirname(save_path), exist_ok=True)
# Set up plots.
doc: Document = curdoc()
doc.title = "DeCAI Simulation"
plot = figure(title="Balances & Accuracy on Hidden Test Set",
)
plot.width = 800
plot.height = 600
plot.xaxis.axis_label = "Time (days)"
plot.yaxis.axis_label = "Percent"
plot.title.text_font_size = '20pt'
plot.xaxis.major_label_text_font_size = '20pt'
plot.xaxis.axis_label_text_font_size = '20pt'
plot.yaxis.major_label_text_font_size = '20pt'
plot.yaxis.axis_label_text_font_size = '20pt'
plot.xaxis[0].ticker = AdaptiveTicker(base=5 * 24 * 60 * 60)
plot.xgrid[0].ticker = AdaptiveTicker(base=24 * 60 * 60)
balance_plot_sources_per_agent = dict()
good_colors = cycle([
colors.named.green,
colors.named.lawngreen,
colors.named.darkgreen,
colors.named.limegreen,
])
bad_colors = cycle([
colors.named.red,
colors.named.darkred,
])
for agent in agents:
source = ColumnDataSource(dict(t=[], b=[]))
assert agent.address not in balance_plot_sources_per_agent
balance_plot_sources_per_agent[agent.address] = source
if agent.calls_model:
color = 'blue'
line_dash = 'dashdot'
elif agent.good:
color = next(good_colors)
line_dash = 'dotted'
else:
color = next(bad_colors)
line_dash = 'dashed'
plot.line(x='t', y='b',
line_dash=line_dash,
line_width=2,
source=source,
color=color,
legend=f"{agent.address} Balance")
plot.legend.location = 'top_left'
plot.legend.label_text_font_size = '12pt'
# JavaScript code.
plot.xaxis[0].formatter = FuncTickFormatter(code="""
return (tick / 86400).toFixed(0);
""")
plot.yaxis[0].formatter = PrintfTickFormatter(format="%0.1f%%")
acc_source = ColumnDataSource(dict(t=[], a=[]))
if baseline_accuracy is not None:
plot.ray(x=[0], y=[baseline_accuracy * 100], length=0, angle=0, line_width=2,
legend=f"Accuracy when trained with all data: {baseline_accuracy * 100:0.1f}%")
plot.line(x='t', y='a',
line_dash='solid',
line_width=2,
source=acc_source,
color='black',
legend="Current Accuracy")
@gen.coroutine
def plot_cb(agent: Agent, t, b):
source = balance_plot_sources_per_agent[agent.address]
source.stream(dict(t=[t], b=[b * 100 / agent.start_balance]))
save_data['balances'].append(dict(t=t, a=agent.address, b=b))
@gen.coroutine
def plot_accuracy_cb(t, a):
acc_source.stream(dict(t=[t], a=[a * 100]))
save_data['accuracies'].append(dict(t=t, accuracy=a))
continuous_evaluation = not isinstance(self._decai.im, PredictionMarket)
def task():
(x_train, y_train), (x_test, y_test) = \
self._data_loader.load_data(train_size=train_size, test_size=test_size)
classifications = self._data_loader.classifications()
x_train, x_test, feature_index_mapping = self._feature_index_mapper.map(x_train, x_test)
x_train_len = x_train.shape[0]
init_idx = int(x_train_len * init_train_data_portion)
self._logger.info("Initializing model with %d out of %d samples.",
init_idx, x_train_len)
x_init_data, y_init_data = x_train[:init_idx], y_train[:init_idx]
x_remaining, y_remaining = x_train[init_idx:], y_train[init_idx:]
save_model = isinstance(self._decai.im, PredictionMarket) and self._decai.im.reset_model_during_reward_phase
self._decai.model.init_model(x_init_data, y_init_data, save_model)
if self._logger.isEnabledFor(logging.DEBUG):
s = self._decai.model.evaluate(x_init_data, y_init_data)
self._logger.debug("Initial training data evaluation: %s", s)
if len(x_remaining) > 0:
s = self._decai.model.evaluate(x_remaining, y_remaining)
self._logger.debug("Remaining training data evaluation: %s", s)
else:
self._logger.debug("There is no more remaining data to evaluate.")
self._logger.info("Evaluating initial model.")
accuracy = self._decai.model.log_evaluation_details(x_test, y_test)
self._logger.info("Initial test set accuracy: %0.2f%%", accuracy * 100)
t = self._time()
doc.add_next_tick_callback(
partial(plot_accuracy_cb, t=t, a=accuracy))
q = PriorityQueue()
random.shuffle(agents)
for agent in agents:
self._balances.initialize(agent.address, agent.start_balance)
q.put((self._time() + agent.get_next_wait_s(), agent))
doc.add_next_tick_callback(
partial(plot_cb, agent=agent, t=t, b=agent.start_balance))
unclaimed_data = []
next_data_index = 0
next_accuracy_plot_time = 1E4
desc = "Processing agent requests"
current_time = 0
with tqdm(desc=desc,
unit_scale=True, mininterval=2, unit=" requests",
total=len(x_remaining),
) as pbar:
while not q.empty():
# For now assume sending a transaction (editing) is free (no gas)
# since it should be relatively cheaper than the deposit required to add data.
# It may not be cheaper than calling `report`.
if next_data_index >= len(x_remaining):
if not continuous_evaluation or len(unclaimed_data) == 0:
break
current_time, agent = q.get()
update_balance_plot = False
if current_time > next_accuracy_plot_time:
self._logger.debug("Evaluating.")
next_accuracy_plot_time += accuracy_plot_wait_s
accuracy = self._decai.model.evaluate(x_test, y_test)
doc.add_next_tick_callback(
partial(plot_accuracy_cb, t=current_time, a=accuracy))
if continuous_evaluation:
self._logger.debug("Unclaimed data: %d", len(unclaimed_data))
pbar.set_description(f"{desc} ({len(unclaimed_data)} unclaimed)")
with open(save_path, 'w') as f:
json.dump(save_data, f, separators=(',', ':'))
self._decai.model.export(model_save_path, classifications,
feature_index_mapping=feature_index_mapping)
if os.path.exists(plot_save_path):
os.remove(plot_save_path)
self.save_plot_image(plot, plot_save_path)
self._time.set_time(current_time)
balance = self._balances[agent.address]
if balance > 0 and next_data_index < len(x_remaining):
# Pick data.
x, y = x_remaining[next_data_index], y_remaining[next_data_index]
if agent.calls_model:
# Only call the model if it's good.
if random.random() < accuracy:
update_balance_plot = True
self._decai.predict(Msg(agent.address, agent.pay_to_call), x)
else:
if not agent.good:
y = 1 - y
if agent.prob_mistake > 0 and random.random() < agent.prob_mistake:
y = 1 - y
# Bad agents always contribute.
# Good agents will only work if the model is doing well.
# Add a bit of chance they will contribute since 0.85 accuracy is okay.
if not agent.good or random.random() < accuracy + 0.15:
value = agent.get_next_deposit()
if value > balance:
value = balance
msg = Msg(agent.address, value)
try:
self._decai.add_data(msg, x, y)
# Don't need to plot every time. Plot less as we get more data.
update_balance_plot = next_data_index / len(x_remaining) + 0.1 < random.random()
balance = self._balances[agent.address]
if continuous_evaluation:
unclaimed_data.append((current_time, agent, x, y))
next_data_index += 1
pbar.update()
except RejectException:
# Probably failed because they didn't pay enough which is okay.
# Or if not enough time has passed since data was attempted to be added
# which is okay too because a real contract would reject this
# because the smallest unit of time we can use is 1s.
if self._logger.isEnabledFor(logging.DEBUG):
self._logger.exception("Error adding data.")
if balance > 0:
q.put((current_time + agent.get_next_wait_s(), agent))
claimed_indices = []
for i in range(len(unclaimed_data)):
added_time, adding_agent, x, classification = unclaimed_data[i]
if current_time - added_time < self._decai.im.refund_time_s:
break
if next_data_index >= len(x_remaining) \
and current_time - added_time < self._decai.im.any_address_claim_wait_time_s:
break
balance = self._balances[agent.address]
msg = Msg(agent.address, balance)
if current_time - added_time > self._decai.im.any_address_claim_wait_time_s:
# Attempt to take the entire deposit.
try:
self._decai.report(msg, x, classification, added_time, adding_agent.address)
update_balance_plot = True
except RejectException:
if self._logger.isEnabledFor(logging.DEBUG):
self._logger.exception("Error taking reward.")
elif adding_agent.address == agent.address:
try:
self._decai.refund(msg, x, classification, added_time)
update_balance_plot = True
except RejectException:
if self._logger.isEnabledFor(logging.DEBUG):
self._logger.exception("Error getting refund.")
else:
try:
self._decai.report(msg, x, classification, added_time, adding_agent.address)
update_balance_plot = True
except RejectException:
if self._logger.isEnabledFor(logging.DEBUG):
self._logger.exception("Error taking reward.")
stored_data = self._decai.data_handler.get_data(x, classification,
added_time, adding_agent.address)
if stored_data.claimable_amount < = 0:
claimed_indices.append(i)
for i in claimed_indices[::-1]:
unclaimed_data.pop(i)
if update_balance_plot:
balance = self._balances[agent.address]
doc.add_next_tick_callback(
partial(plot_cb, agent=agent, t=current_time, b=balance))
self._logger.info("Done going through data.")
if continuous_evaluation:
pbar.set_description(f"{desc} ({len(unclaimed_data)} unclaimed)")
if isinstance(self._decai.im, PredictionMarket):
self._time.add_time(agents[0].get_next_wait_s())
self._decai.im.end_market()
for i, test_set_portion in enumerate(pm_test_sets):
if i != self._decai.im.test_reveal_index:
self._decai.im.verify_next_test_set(test_set_portion)
with tqdm(desc="Processing contributions",
unit_scale=True, mininterval=2, unit=" contributions",
total=self._decai.im.get_num_contributions_in_market(),
) as pbar:
finished_first_round_of_rewards = False
while self._decai.im.remaining_bounty_rounds > 0:
self._time.add_time(agents[0].get_next_wait_s())
self._decai.im.process_contribution()
pbar.update()
if not finished_first_round_of_rewards:
accuracy = self._decai.im.prev_acc
# If we plot too often then we end up with a blob instead of a line.
if random.random() < 0.1:
doc.add_next_tick_callback(
partial(plot_accuracy_cb, t=self._time(), a=accuracy))
if self._decai.im.state == MarketPhase.REWARD_RESTART:
finished_first_round_of_rewards = True
if self._decai.im.reset_model_during_reward_phase:
# Update the accuracy after resetting all data.
accuracy = self._decai.im.prev_acc
else:
# Use the accuracy after training with all data.
pass
doc.add_next_tick_callback(
partial(plot_accuracy_cb, t=self._time(), a=accuracy))
pbar.total += self._decai.im.get_num_contributions_in_market()
self._time.add_time(self._time() * 0.001)
for agent in agents:
balance = self._balances[agent.address]
market_bal = self._decai.im._market_balances[agent.address]
self._logger.debug("\"%s\" market balance: %0.2f Balance: %0.2f",
agent.address, market_bal, balance)
doc.add_next_tick_callback(
partial(plot_cb, agent=agent, t=self._time(), b=max(balance + market_bal, 0)))
self._time.add_time(self._time() * 0.02)
for agent in agents:
msg = Msg(agent.address, 0)
# Find data submitted by them.
data = None
for key, stored_data in self._decai.data_handler:
if stored_data.sender == agent.address:
data = key[0]
break
if data is not None:
self._decai.refund(msg, np.array(data), stored_data.classification, stored_data.time)
balance = self._balances[agent.address]
doc.add_next_tick_callback(
partial(plot_cb, agent=agent, t=self._time(), b=balance))
self._logger.info("Balance for \"%s\": %.2f (%+.2f%%)",
agent.address, balance,
(balance - agent.start_balance) / agent.start_balance * 100)
else:
self._logger.warning("No data submitted by \"%s\" was found."
"\nWill not update it's balance.", agent.address)
self._logger.info("Done issuing rewards.")
accuracy = self._decai.model.log_evaluation_details(x_test, y_test)
doc.add_next_tick_callback(
partial(plot_accuracy_cb, t=current_time + 100, a=accuracy))
with open(save_path, 'w') as f:
json.dump(save_data, f, separators=(',', ':'))
self._decai.model.export(model_save_path, classifications, feature_index_mapping=feature_index_mapping)
if os.path.exists(plot_save_path):
os.remove(plot_save_path)
self.save_plot_image(plot, plot_save_path)
doc.add_root(plot)
thread = Thread(target=task)
thread.start()
0
Source : plot_apple_watch_data.py
with Apache License 2.0
from openPfizer
with Apache License 2.0
from openPfizer
def plot_distance(apple_watch):
"""
Generate grid heat map of miles walked or ran for a given hour and date, grouped by start timestamp.
:param apple_watch: instance of apple watch data object
:return: None
"""
logger.info('Loading and Plotting Distance Walked/Ran Data')
df = apple_watch.load_distance_data()
df = df[(df['start_timestamp'] > START_DATE) & (df['start_timestamp'] < END_DATE)]
df['date'] = list(map(lambda d: d.strftime('%m/%d/%y'), df['start_timestamp']))
df['hour'] = list(map(lambda d: int(d.strftime('%H')), df['start_timestamp']))
# group by hour and date and calculate sum of steps
hourly_distance = df.groupby(['hour', 'date'])['distance_walk_run'].agg(['sum']).reset_index()
hourly_distance.rename(columns={'sum': 'distance'}, inplace=True)
# resort by date
hourly_distance['datetime'] = pd.to_datetime(hourly_distance['date'])
hourly_distance.sort_values(by=['datetime'], inplace=True)
dates = hourly_distance['date'].unique()
# create heat map of hourly sum grouped by date
TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom"
colors = ["#000080", "#1874CD", "#63B8FF", "#C6E2FF", "#E6E6FA", "#dfccce", "#ddb7b1", "#cc7878", "#933b41"]
mapper = LinearColorMapper(palette=colors,
low=hourly_distance.distance.min(),
high=hourly_distance.distance.max())
source = ColumnDataSource(hourly_distance)
plot = figure(title="Apple Watch Hourly Distance Walked/Ran",
x_range=[str(h) for h in range(24)],
y_range=list(dates),
x_axis_location="below",
plot_width=1000,
plot_height=600,
tools=TOOLS,
toolbar_location='above',
sizing_mode='scale_both')
plot.rect(x='hour', y='date', width=1, height=1,
source=source,
fill_color={'field': 'distance', 'transform': mapper},
line_color=None)
plot.grid.grid_line_color = None
plot.axis.axis_line_color = None
plot.axis.major_tick_line_color = None
plot.xaxis.axis_label_text_font_size = '14pt'
plot.xaxis.major_label_text_font_size = '12pt'
plot.yaxis.axis_label_text_font_size = '14pt'
plot.yaxis.major_label_text_font_size = '12pt'
plot.title.text_font_size = '16pt'
color_bar = ColorBar(color_mapper=mapper, major_label_text_font_size="10pt",
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=PrintfTickFormatter(format="%d mi"),
label_standoff=9, border_line_color=None, location=(0, 0))
plot.add_layout(color_bar, 'right')
plot.select_one(HoverTool).tooltips = [
('date', '@date'),
('hour', '@hour'),
('miles', '@distance')
]
if SHOW_PLOTS:
show(plot, browser='chrome')
save_plot(plot, 'distance_walked_ran')
# clear output mode for next plot
reset_output()
# save dataframe
df.to_csv('apple_watch_data/distance_walked_ran.csv', index=False)
def plot_basal_energy(apple_watch):
0
Source : plot_apple_watch_data.py
with Apache License 2.0
from openPfizer
with Apache License 2.0
from openPfizer
def plot_basal_energy(apple_watch):
"""
Generate grid heat map of basal Calories burned for a given hour and date, grouped by start timestamp.
:param apple_watch: instance of apple watch data object
:return: None
"""
logger.info('Generating Basal Energy Plot')
df = apple_watch.load_basal_energy_data()
df = df[(df['start_timestamp'] > START_DATE) & (df['start_timestamp'] < END_DATE)]
df['date'] = list(map(lambda d: d.strftime('%m/%d/%y'), df['start_timestamp']))
df['hour'] = list(map(lambda d: int(d.strftime('%H')), df['start_timestamp']))
# group by hour and date and calculate sum of steps
basal_energy = df.groupby(['hour', 'date'])['energy_burned'].agg(['sum']).reset_index()
basal_energy.rename(columns={'sum': 'energy_burned'}, inplace=True)
# resort date
basal_energy['datetime'] = pd.to_datetime(basal_energy['date'])
basal_energy.sort_values(by=['datetime'], inplace=True)
dates = basal_energy['date'].unique()
# create heat map of hourly counts grouped by date
# follow example from https://bokeh.pydata.org/en/latest/docs/gallery/unemployment.html
TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom"
colors = ["#000080", "#1874CD", "#63B8FF", "#C6E2FF", "#E6E6FA", "#dfccce", "#ddb7b1", "#cc7878", "#933b41"]
mapper = LinearColorMapper(palette=colors, low=basal_energy.energy_burned.min(), high=basal_energy.energy_burned.max())
source = ColumnDataSource(basal_energy)
plot = figure(title="Apple Watch Hourly Calories Burned",
x_range=[str(h) for h in range(24)],
y_range=list(dates),
x_axis_location="below",
plot_width=1000,
plot_height=600,
tools=TOOLS,
toolbar_location='above',
sizing_mode='scale_both')
plot.grid.grid_line_color = None
plot.axis.axis_line_color = None
plot.axis.major_tick_line_color = None
plot.xaxis.axis_label_text_font_size = '14pt'
plot.xaxis.major_label_text_font_size = '12pt'
plot.yaxis.axis_label_text_font_size = '14pt'
plot.yaxis.major_label_text_font_size = '12pt'
plot.title.text_font_size = '16pt'
plot.rect(x='hour', y='date', width=1, height=1,
source=source,
fill_color={'field': 'energy_burned', 'transform': mapper},
line_color=None)
color_bar = ColorBar(color_mapper=mapper, major_label_text_font_size="10pt",
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=PrintfTickFormatter(format="%d Cal"),
label_standoff=10, border_line_color=None, location=(0, 0))
plot.add_layout(color_bar, 'right')
plot.select_one(HoverTool).tooltips = [
('date', '@date'),
('hour', '@hour'),
('Cal', '@energy_burned')
]
if SHOW_PLOTS:
show(plot, browser='chrome')
save_plot(plot, 'basal_energy')
# clear output mode for next plot
reset_output()
# save dataframe
df.to_csv('apple_watch_data/basal_energy.csv', index=False)
def plot_stand_hour(apple_watch):
0
Source : plot_apple_watch_data.py
with Apache License 2.0
from openPfizer
with Apache License 2.0
from openPfizer
def plot_steps(apple_watch):
"""
Generate grid heat map of step counts for a given hour and date, grouped by start timestamp.
:param apple_watch: instance of apple watch data object
:return: None
"""
logger.info('Loading and Generating Steps Heat Map')
df = apple_watch.load_step_data()
df = df[(df['start_timestamp'] > START_DATE) & (df['start_timestamp'] < END_DATE)]
df['date'] = list(map(lambda d: d.strftime('%m/%d/%y'), df['start_timestamp']))
df['hour'] = list(map(lambda d: int(d.strftime('%H')), df['start_timestamp']))
# group by hour and date and calculate sum of steps
step_counts = df.groupby(['hour', 'date'])['steps'].agg(['sum']).reset_index()
step_counts.rename(columns={'sum': 'steps'}, inplace=True)
# resort by date
step_counts['datetime'] = pd.to_datetime(step_counts['date'])
step_counts.sort_values(by=['datetime'], inplace=True)
dates = step_counts['date'].unique()
# create grid heat map of hourly counts grouped by date
# follow example from https://bokeh.pydata.org/en/latest/docs/gallery/unemployment.html
TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom"
colors = ["#000080", "#1874CD", "#63B8FF", "#C6E2FF", "#E6E6FA", "#dfccce", "#ddb7b1", "#cc7878", "#933b41"]
mapper = LinearColorMapper(palette=colors, low=step_counts.steps.min(), high=step_counts.steps.max())
source = ColumnDataSource(step_counts)
plot = figure(title="Apple Watch Hourly Step Counts",
x_range=[str(h) for h in range(24)],
y_range=list(dates),
x_axis_location="below",
plot_width=1000,
plot_height=600,
tools=TOOLS,
toolbar_location='above',
sizing_mode='scale_both')
plot.grid.grid_line_color = None
plot.axis.axis_line_color = None
plot.axis.major_tick_line_color = None
plot.xaxis.axis_label_text_font_size = '14pt'
plot.xaxis.major_label_text_font_size = '12pt'
plot.yaxis.axis_label_text_font_size = '14pt'
plot.yaxis.major_label_text_font_size = '12pt'
plot.title.text_font_size = '16pt'
plot.rect(x='hour',
y='date',
width=1,
height=1,
source=source,
fill_color={'field': 'steps', 'transform': mapper},
line_color=None)
color_bar = ColorBar(color_mapper=mapper, major_label_text_font_size="10pt",
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=PrintfTickFormatter(format="%d"),
label_standoff=6, border_line_color=None, location=(0, 0))
plot.add_layout(color_bar, 'right')
plot.select_one(HoverTool).tooltips = [
('date', '@date'),
('hour', '@hour'),
('count', '@steps')
]
if SHOW_PLOTS:
show(plot, browser='chrome')
save_plot(plot, 'step_counts')
# clear output mode for next plot
reset_output()
# save data frame
df.to_csv('apple_watch_data/step_counts.csv', index=False)
def run(apple_watch, start_date, end_date, show_plots):
0
Source : render.py
with MIT License
from sfu-db
with MIT License
from sfu-db
def geo_viz(
df: pd.DataFrame,
plot_width: int,
y: Optional[str] = None,
) -> Panel:
"""
Render a geo plot visualization
"""
# pylint: disable=too-many-arguments,too-many-locals,too-many-statements
# pylint: disable=too-many-function-args
# title = f"{y} by {x}"
minimum = min(df[y])
maximum = max(df[y])
# no_name=[]
value = {}
names = NAME_DICT.keys()
for i in range(df[y].shape[0]):
if df.index[i].lower().strip() in names:
value[NAME_DICT[df.index[i].lower().strip()]] = df[y][i]
# else:
# no_name.append(df.index[i])
temp_list = []
for itr in range(len(MAPS["name"])):
temp_list.append(value.get(MAPS["fip"][itr], "unknown"))
MAPS["value"] = temp_list
mapper = LinearColorMapper(
palette=YlGnBu[33:233], low=minimum, high=maximum, nan_color="#cccccc"
)
tools = "pan,wheel_zoom,box_zoom,reset,hover"
fig = Figure(
plot_width=plot_width,
plot_height=plot_width // 10 * 7,
tools=tools,
tooltips=[
("Name", "@name"),
(y, "@value"),
("(Long, Lat)", "($x, $y)"),
],
)
fig.grid.grid_line_color = None
fig.hover.point_policy = "follow_mouse"
fig.background_fill_color = "white"
fig.x_range = Range1d(start=-180, end=180)
fig.y_range = Range1d(start=-90, end=90)
fig.patches(
"xs",
"ys",
line_color="white",
source=MAPS,
fill_color={"field": "value", "transform": mapper},
line_width=0.5,
)
color_bar = ColorBar(
color_mapper=mapper,
major_label_text_font_size="7px",
ticker=BasicTicker(desired_num_ticks=11),
formatter=PrintfTickFormatter(format="%10.2f"),
label_standoff=6,
border_line_color=None,
location=(0, 0),
)
if minimum < maximum:
fig.add_layout(color_bar, "right")
return Panel(child=row(fig), title="World Map")
# this function should be removed when datetime is refactored
def box_viz_dt(
0
Source : render.py
with MIT License
from sfu-db
with MIT License
from sfu-db
def heatmap_viz(
df: pd.DataFrame,
x: str,
y: str,
grp_cnt_stats: Dict[str, int],
plot_width: int,
plot_height: int,
) -> Panel:
"""
Render a heatmap
"""
# pylint: disable=too-many-arguments
title = _make_title(grp_cnt_stats, x, y)
source = ColumnDataSource(data=df)
palette = RDBU[(len(RDBU) // 2 - 1) :]
mapper = LinearColorMapper(palette=palette, low=df["cnt"].min() - 0.01, high=df["cnt"].max())
if grp_cnt_stats[f"{x}_shw"] > 60:
plot_width = 16 * grp_cnt_stats[f"{x}_shw"]
if grp_cnt_stats[f"{y}_shw"] > 10:
plot_height = 70 + 18 * grp_cnt_stats[f"{y}_shw"]
fig = figure(
x_range=sorted(list(set(df[x]))),
y_range=sorted(list(set(df[y]))),
toolbar_location=None,
tools=[],
x_axis_location="below",
title=title,
plot_width=plot_width,
plot_height=plot_height,
)
renderer = fig.rect(
x=x,
y=y,
width=1,
height=1,
source=source,
line_color=None,
fill_color=transform("cnt", mapper),
)
color_bar = ColorBar(
color_mapper=mapper,
location=(0, 0),
ticker=BasicTicker(desired_num_ticks=7),
formatter=PrintfTickFormatter(format="%d"),
)
fig.add_tools(
HoverTool(
tooltips=[
(x, f"@{{{x}}}"),
(y, f"@{{{y}}}"),
("Count", "@cnt"),
],
mode="mouse",
renderers=[renderer],
)
)
fig.add_layout(color_bar, "right")
tweak_figure(fig, "heatmap")
fig.yaxis.formatter = FuncTickFormatter(
code="""
if (tick.length > 15) return tick.substring(0, 14) + '...';
else return tick;
"""
)
return Panel(child=fig, title="Heat Map")
def dt_line_viz(
0
Source : render.py
with MIT License
from sfu-db
with MIT License
from sfu-db
def create_color_mapper_heatmap(
palette: Sequence[str],
) -> Tuple[LinearColorMapper, ColorBar]:
"""
Create a color mapper and a colorbar for heatmap
"""
mapper = LinearColorMapper(palette=palette, low=-1, high=1)
colorbar = ColorBar(
color_mapper=mapper,
major_label_text_font_size="8pt",
ticker=BasicTicker(),
formatter=PrintfTickFormatter(format="%.2f"),
label_standoff=6,
border_line_color=None,
location=(0, 0),
)
return mapper, colorbar
def render_missing_impact(itmdt: Intermediate, cfg: Config) -> Dict[str, Any]:
0
Source : experimental.py
with MIT License
from uberdeveloper
with MIT License
from uberdeveloper
def calendar_plot(data, field="ret"):
"""
return a calendar plot
data
dataframe with year and month columns
field
field to plot values
Note
-----
Prototype copied from bokeh gallery
https://bokeh.pydata.org/en/latest/docs/gallery/unemployment.html
"""
from math import pi
from bokeh.models import (
LinearColorMapper,
BasicTicker,
PrintfTickFormatter,
ColorBar,
)
from bokeh.plotting import figure
from bokeh.palettes import Spectral
df = data.copy()
# Type conversion
df["year"] = df.year.astype("str")
df["month"] = df.month.astype("str")
years = list(df.year.unique())
months = [str(x) for x in range(12, 0, -1)]
colors = list(reversed(Spectral[6]))
mapper = LinearColorMapper(
palette=colors, low=df[field].min(), high=df[field].max()
)
TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom"
p = figure(
title="Calendar Plot",
x_range=years,
y_range=list(reversed(months)),
x_axis_location="above",
plot_width=1000,
plot_height=600,
tools=TOOLS,
toolbar_location="below",
tooltips=[("date", "@year-@month"), ("return", "@{}".format(field))],
)
# Axis settings
p.grid.grid_line_color = None
p.axis.axis_line_color = None
p.axis.major_tick_line_color = None
p.axis.major_label_text_font_size = "10pt"
p.axis.major_label_standoff = 0
p.xaxis.major_label_orientation = pi / 3
p.rect(
x="year",
y="month",
width=1,
height=1,
source=df,
fill_color={"field": field, "transform": mapper},
line_color="black",
line_width=0.5,
line_alpha=0.3,
)
color_bar = ColorBar(
color_mapper=mapper,
major_label_text_font_size="8pt",
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=PrintfTickFormatter(format="%d%%"),
label_standoff=6,
border_line_color=None,
location=(0, 0),
)
p.add_layout(color_bar, "right")
return p
def summary_plot(data):