GitHub Repository: polakowo/vectorbt
Path: blob/master/tests/notebooks/plotting.ipynb
¹⁰⁷³ views

Kernel: Python 3 (ipykernel)

plotting

In [1]:

import vectorbt as vbt

In [2]:

import numpy as np
import pandas as pd
from datetime import datetime
from numba import njit
import itertools
import ipywidgets

In [3]:

big_df = pd.DataFrame(np.random.uniform(size=(100, 100)).astype(float))
big_df.columns = list(map(str, big_df.columns))
print(big_df.shape)

Out[3]:

(100, 100)

Indicator

In [4]:

gauge = vbt.plotting.Gauge(value=0, value_range=(-1, 1))
gauge.fig

Out[4]:

FigureWidget({
    'data': [{'domain': {'x': [0, 1], 'y': [0, 1]},
              'gauge': {'axis': {'range': […

In [5]:

gauge.update(1)

In [9]:

%timeit vbt.plotting.Gauge(value=0)

big_gauge = vbt.plotting.Gauge(value=0)
%timeit big_gauge.update(0)

Out[9]:

172 ms ± 1.65 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
468 µs ± 862 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [6]:

ipywidgets.Widget.close_all()

Bar

In [4]:

bar = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['a', 'b']).vbt.barplot(return_fig=False)
bar.fig

Out[4]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'bar',
     …

In [5]:

bar.update([[7, 8], [9, 10], [11, 12]])

In [6]:

bar1 = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['a', 'b']).vbt.barplot(return_fig=False)
bar2 = pd.DataFrame([[7, 8], [9, 10], [11, 12]], columns=['c', 'd']).vbt.barplot(return_fig=False, fig=bar1.fig)
bar2.fig

Out[6]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'bar',
     …

In [7]:

bar1.update([[7, 8], [9, 10], [11, 12]])

In [8]:

bar2.update([[1, 2], [3, 4], [5, 6]])

In [16]:

%timeit pd.DataFrame(big_df).vbt.barplot()

big_bar = pd.DataFrame(big_df).vbt.barplot(return_fig=False)
%timeit big_bar.update(big_df.values * 2)

Out[16]:

IOPub message rate exceeded.
The notebook server will temporarily stop sending output
to the client in order to avoid crashing it.
To change this limit, set the config variable
`--NotebookApp.iopub_msg_rate_limit`.

Current values:
NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)
NotebookApp.rate_limit_window=3.0 (secs)

350 ms ± 36.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
4.05 ms ± 17.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [9]:

ipywidgets.Widget.close_all()

Scatter

In [10]:

scatter = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['a', 'b']).vbt.plot(return_fig=False)
scatter.fig

Out[10]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'scatter',
 …

In [11]:

scatter.update([[6, 5], [4, 3], [2, 1]])

In [12]:

scatter1 = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['a', 'b']).vbt.plot(return_fig=False)
scatter2 = pd.DataFrame([[7, 8], [9, 10], [11, 12]], columns=['c', 'd']).vbt.plot(return_fig=False, fig=scatter1.fig)
scatter2.fig

Out[12]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'scatter',
 …

In [13]:

scatter1.update([[7, 8], [9, 10], [11, 12]])

In [14]:

scatter2.update([[1, 2], [3, 4], [5, 6]])

In [23]:

%timeit pd.DataFrame(big_df).vbt.plot()

big_scatter = pd.DataFrame(big_df).vbt.plot(return_fig=False)
%timeit big_scatter.update(big_df.values * 2)

Out[23]:

IOPub message rate exceeded.
The notebook server will temporarily stop sending output
to the client in order to avoid crashing it.
To change this limit, set the config variable
`--NotebookApp.iopub_msg_rate_limit`.

Current values:
NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)
NotebookApp.rate_limit_window=3.0 (secs)

2.34 ms ± 48.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [15]:

ipywidgets.Widget.close_all()

Histogram

In [16]:

hist = pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.histplot(return_fig=False)
hist.fig

Out[16]:

FigureWidget({
    'data': [{'name': 'a',
              'opacity': 0.75,
              'showlegend': True,
   …

In [17]:

hist.update([[4, 9], [4, 5], [3, 0]])

In [18]:

pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.histplot(horizontal=True)

Out[18]:

FigureWidget({
    'data': [{'name': 'a',
              'opacity': 0.75,
              'showlegend': True,
   …

In [19]:

hist1 = pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.histplot(return_fig=False)
hist2 = pd.DataFrame([[4, 9], [4, 5], [3, 0]], columns=['c', 'd']).vbt.histplot(return_fig=False, fig=hist1.fig)
hist2.fig

Out[19]:

FigureWidget({
    'data': [{'name': 'a',
              'opacity': 0.75,
              'showlegend': True,
   …

In [20]:

hist1.update([[4, 9], [4, 5], [3, 0]])

In [21]:

hist2.update([[1, 2], [3, 4], [2, 1]])

In [31]:

%timeit pd.DataFrame(big_df).vbt.histplot()

big_hist = pd.DataFrame(big_df).vbt.histplot(return_fig=False)
%timeit big_hist.update(big_df.values * 2)

Out[31]:

IOPub message rate exceeded.
The notebook server will temporarily stop sending output
to the client in order to avoid crashing it.
To change this limit, set the config variable
`--NotebookApp.iopub_msg_rate_limit`.

Current values:
NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)
NotebookApp.rate_limit_window=3.0 (secs)

331 ms ± 24.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
4.32 ms ± 43.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [22]:

ipywidgets.Widget.close_all()

Box

In [16]:

box = pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.boxplot(return_fig=False)
box.fig

Out[16]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'box',
     …

In [17]:

box.update([[4, 9], [4, 5], [3, 0]])

In [35]:

pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.boxplot(horizontal=True)

Out[35]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'box',
     …

In [36]:

box1 = pd.DataFrame([[1, 2], [3, 4], [2, 1]], columns=['a', 'b']).vbt.boxplot(return_fig=False)
box2 = pd.DataFrame([[4, 9], [4, 5], [3, 0]], columns=['c', 'd']).vbt.boxplot(return_fig=False, fig=box1.fig)
box2.fig

Out[36]:

FigureWidget({
    'data': [{'name': 'a',
              'showlegend': True,
              'type': 'box',
     …

In [37]:

box1.update([[4, 9], [4, 5], [3, 0]])

In [38]:

box2.update([[1, 2], [3, 4], [2, 1]])

In [39]:

%timeit pd.DataFrame(big_df).vbt.boxplot()

big_box = pd.DataFrame(big_df).vbt.boxplot(return_fig=False)
%timeit big_box.update(big_df.values * 2)

Out[39]:

IOPub message rate exceeded.
The notebook server will temporarily stop sending output
to the client in order to avoid crashing it.
To change this limit, set the config variable
`--NotebookApp.iopub_msg_rate_limit`.

Current values:
NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)
NotebookApp.rate_limit_window=3.0 (secs)

329 ms ± 25.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
4.29 ms ± 36.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [18]:

ipywidgets.Widget.close_all()

Heatmap

In [5]:

heatmap = pd.DataFrame(
    [[1, 2], [3, 4], [5, 6]], 
    columns=['a', 'b'], 
    index=['x', 'y', 'z']
).vbt.heatmap(return_fig=False)
heatmap.fig

Out[5]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [6]:

heatmap.update([[6, 5], [4, 3], [2, 1]])

In [8]:

pd.DataFrame(
    [[1, 2], [3, 4], [5, 6]], 
    columns=['a', 'b'], 
    index=['x', 'y', 'z']
).vbt.ts_heatmap()

Out[8]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [13]:

heatmap1 = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['a', 'b'], index=['x', 'y', 'z']).vbt.heatmap(
    return_fig=False, trace_kwargs=dict(showscale=False))
heatmap2 = pd.DataFrame([[6, 5], [4, 3], [2, 1]], columns=['c', 'd'], index=['x2', 'y2', 'z2']).vbt.heatmap(
    return_fig=False, fig=heatmap1.fig)
heatmap2.fig

Out[13]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [14]:

heatmap1.update([[6, 5], [4, 3], [2, 1]])

In [15]:

heatmap2.update([[1, 2], [3, 4], [5, 6]])

In [16]:

heatmap_sr = pd.Series(
    [1, 2, 3, 6, 5, 4], 
    index=vbt.base.index_fns.stack_indexes([
        pd.Index(['i1', 'i2', 'i3', 'i1', 'i2', 'i3'], name='first'),
        pd.Index(['i4', 'i5', 'i6', 'i4', 'i5', 'i6'], name='second'),
        pd.Index(['i7', 'i7', 'i7', 'i8', 'i8', 'i8'], name='third')
    ])
)
heatmap_sr.vbt.heatmap(x_level=0, y_level=1, symmetric=True)

Out[16]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [17]:

heatmap_sr.vbt.heatmap(x_level=0, y_level=1, symmetric=True, slider_level=2)

Out[17]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [50]:

%timeit pd.DataFrame(big_df).vbt.heatmap()

big_heatmap = pd.DataFrame(big_df).vbt.heatmap(return_fig=False)
%timeit big_heatmap.update(big_df.values * 2)

Out[50]:

427 ms ± 53.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
112 µs ± 7.16 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [18]:

ipywidgets.Widget.close_all()

Volume

In [27]:

x, y, z, g = np.mgrid[0:15, 15:25, 25:30, :2]
volume_sr = pd.Series(
    np.random.randint(1, 10, size=x.flatten().shape), 
    index=vbt.base.index_fns.stack_indexes([
        pd.Index(x.flatten(), name='first'),
        pd.Index(y.flatten(), name='second'),
        pd.Index(z.flatten(), name='third'),
        pd.Index(g.flatten(), name='fourth')
    ])
)
volume = volume_sr.vbt.volume(x_level='first', y_level='second', z_level='third', return_fig=False)
volume.fig

Out[27]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [24]:

volume.update(np.random.randint(1, 10, size=x.flatten().shape))

In [25]:

volume_sr.vbt.volume(x_level='first', y_level='second', z_level='third', slider_level='fourth')

Out[25]:

FigureWidget({
    'data': [{'colorscale': [[0.0, '#0d0887'], [0.1111111111111111, '#46039f'],
               …

In [55]:

x, y, z = np.mgrid[:50, :50, :50]
big_volume_sr = pd.Series(
    np.random.randint(1, 10, size=x.flatten().shape), 
    index=vbt.base.index_fns.stack_indexes(
        pd.Index(x.flatten(), name='i1'),
        pd.Index(y.flatten(), name='i2'),
        pd.Index(z.flatten(), name='i3')
    )
)
%timeit big_volume_sr.vbt.volume()

big_volume = big_volume_sr.vbt.volume(return_fig=False)
%timeit big_volume.update(big_volume_sr.values * 2)

Out[55]:

1.33 s ± 96.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
822 µs ± 478 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [28]:

ipywidgets.Widget.close_all()

In [ ]:

plotting

Indicator

Bar

Scatter

Histogram

Box

Heatmap

Volume

Product

Resources

Company