Datashader Charts

line chart

datashader.line(y, data_points=100, add_interaction=True, pixel_shade_type='linear', color=None, step_size=None, step_size_type=<class 'int'>, title='', timeout=100, unselected_alpha=0.2)

Parameters:

x: str

x-axis column name from the gpu dataframe

y: str

y-axis column name from the gpu dataframe

x_range: tuple, default(gpu_dataframe[x].min(), gpu_dataframe[x].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

y_range: tuple, default(gpu_dataframe[y].min(), gpu_dataframe[y].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

add_interaction: {True, False}, default True

pixel_shade_type: str, default ‘linear’

The “how” parameter in datashader.transfer_functions.shade() function. Available options: eq_hist, linear, log, cbrt

color: str, default #8735fb

step_size: int, default None

for the range_slider below the chart

step_size_type: type, default int

for the range_slider below the chart

title: str,

chart title

timeout: int (milliseconds), default 100

Determines the timeout after which the callback will process new events without the previous one having reported completion. Increase for very long running callbacks and if zooming feels laggy.

unselected_alpha: float [0, 1], default 0.2

if True, displays unselected data in the same color_palette but transparent(alpha=0.2)

Returns:

A cudashader scatter plot of type:

cuxfilter.charts.datashader.custom_extensions.InteractiveDatashaderLine

Example

from cuxfilter import DataFrame
from cuxfilter.charts.datashader import line
import numpy as np
import cudf
import random
import cuxfilter

n = 100000                           # Number of points
start = 1456297053                   # Start time
end = start + 60 * 60 * 24

cux_df = DataFrame.from_dataframe(cudf.DataFrame({'x': np.linspace(start, end, n), 'y':np.random.normal(0, 0.3, size=n).cumsum() + 50}))
line_chart_1 = line(x='x', y='y', unselected_alpha=0.2)

d = cux_df.dashboard([line_chart_1])
line_chart_1.view()

Scatter chart

datashader.scatter(y, x_range=None, y_range=None, add_interaction=True, color_palette=None, aggregate_col=None, aggregate_fn='count', point_size=15, point_shape='circle', pixel_shade_type='eq_hist', pixel_density=0.5, pixel_spread='dynspread', tile_provider=None, title='', timeout=100, legend=True, legend_position='top_right', unselected_alpha=0.2)

Parameters:

x: str

x-axis column name from the gpu dataframe

y: str, default None

y-axis column name from the gpu dataframe

x_range: tuple, default(gpu_dataframe[x].min(), gpu_dataframe[x].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

y_range: tuple, default(gpu_dataframe[y].min(), gpu_dataframe[y].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

add_interaction: {True, False}, default True

color_palette: bokeh.palettes or list/tuple of hex_color_codes,

or list/tuple of color names, default bokeh.palettes.Virisdis10

aggregate_col: str, default None

column from the gpu dataframe on which the aggregate_fn will be run on, if None, aggregate_fn is run on y-column

aggregate_fn: {‘count’, ‘mean’, ‘max’, ‘min’}, default ‘count’

point_size: int, default 1

Point size in the scatter plot.

point_shape: str, default ‘circle’

Available options: circle, square, rect_vertical, rect_horizontal.

pixel_shade_type: str, default ‘eq_hist’

The “how” parameter in datashader.transfer_functions.shade() function. Available options: eq_hist, linear, log, cbrt

pixel_density: float, default 0.5

A tuning parameter in [0, 1], with higher values giving more dense scatter plot.

pixel_spread: str, default ‘dynspread’

dynspread: Spread pixels in an image dynamically based on the image density. spread: Spread pixels in an image.

tile_provider: str, default None

Underlying map type.See https://holoviews.org/reference/elements/bokeh/Tiles.html

title: str,

chart title

timeout: int (milliseconds), default 100

Determines the timeout after which the callback will process new events without the previous one having reported completion. Increase for very long running callbacks and if zooming feels laggy.

legend: bool, default True

Adds Bokeh.models.LinearColorMapper based legend if True, Note: legend currently only works with pixel_shade_type=’linear’/’log’

legend_position: str, default top_right

position of legend on the chart. Valid places are: right, left, bottom, top, top_right, top_left,

bottom_left, bottom_right

unselected_alpha: float [0, 1], default 0.2

if True, displays unselected data in the same color_palette but transparent(alpha=0.2)

Returns:

A cudashader scatter plot of type:

cuxfilter.charts.datashader.custom_extensions.InteractiveDatashaderPoints

Example

from cuxfilter import DataFrame
from cuxfilter.charts import scatter
import cudf
import random

cux_df = DataFrame.from_dataframe(cudf.DataFrame({'x': [float(random.randrange(-8239000,-8229000)) for i in range(10000)], 'y':[float(random.randrange(4960000, 4980000)) for i in range(10000)]}))
# setting pixel_shade_type='linear' to display legend (currently supports only log/linear)
scatter_chart = scatter(x='x',y='y', pixel_shade_type="linear", unselected_alpha=0.2)

d = cux_df.dashboard([scatter_chart])
scatter_chart.view()

Stacked_Lines chart

datashader.stacked_lines(y, data_points=100, add_interaction=True, colors=[], step_size=None, step_size_type=<class 'int'>, title='', timeout=100, legend=True, legend_position='top_right', unselected_alpha=0.2)

stacked lines chart

Parameters:

x: str

x-axis column name from the gpu dataframe

y: list

y-axis column names from the gpu dataframe for the stacked lines

add_interaction: {True, False}, default True

colors: list, default [#8735fb, #8735fb, ….]

step_size: int, default None

for the range_slider below the chart

step_size_type: type, default int

for the range_slider below the chart

title: str,

chart title

timeout: int (milliseconds), default 100

Determines the timeout after which the callback will process new events without the previous one having reported completion. Increase for very long running callbacks and if zooming feels laggy.

legend: bool, default True

Adds Bokeh.models.LinearColorMapper based legend if True, Note: legend currently only works with pixel_shade_type=’linear’/’log’

legend_position: str, default top_right

position of legend on the chart. Valid places are: right, left, bottom, top, top_right, top_left,

bottom_left, bottom_right

unselected_alpha: float [0, 1], default 0.2

if True, displays unselected data in the same color_palette but transparent(alpha=0.2)

Returns:

A cudashader stacked_lines plot of type:

cuxfilter.charts.datashader.custom_extensions.InteractiveDatashaderMultiLine

Example

from cuxfilter.sampledata import signals_data
from cuxfilter import DataFrame
from cuxfilter.charts import stacked_lines

cux_df = DataFrame.from_dataframe(signals_data)

stacked_lines_chart = stacked_lines(x='Time', y=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'x', 'y', 'z'],
                                                    colors = ["red", "grey", "black", "purple", "pink",
                                                            "yellow", "brown", "green", "orange", "blue"],
                                                    unselected_alpha=0.2
                                                    )

d = cux_df.dashboard([stacked_lines_chart])

stacked_lines_chart.view()

cub/detail/detect_cuda_runtime.cuh(39): warning: cuda_runtime_api.h: [jitify] File not found

../util_type.cuh(42): warning: cuda.h: [jitify] File not found

cupy_jitify_exercise(10): warning: cooperative_groups.h: [jitify] File not found

cupy_jitify_exercise(11): warning: cooperative_groups/memcpy_async.h: [jitify] File not found

Heat Map chart

datashader.heatmap(y, x_range=None, y_range=None, add_interaction=True, color_palette=None, aggregate_col=None, aggregate_fn='mean', point_size=15, point_shape='rect_vertical', title='', timeout=100, legend=True, legend_position='top_right', unselected_alpha=0.2)

Heatmap using default datashader.scatter plot with slight modifications. Added for better defaults. In theory, scatter directly can be used to generate the same.

Parameters:

x: str

x-axis column name from the gpu dataframe

y: str, default None

y-axis column name from the gpu dataframe

x_range: tuple, default(gpu_dataframe[x].min(), gpu_dataframe[x].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

y_range: tuple, default(gpu_dataframe[y].min(), gpu_dataframe[y].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

add_interaction: {True, False}, default True

color_palette: bokeh.palettes or list/tuple of hex_color_codes,

or list/tuple of color names, default bokeh.palettes.Virisdis10

aggregate_col: str, default None

column from the gpu dataframe on which the aggregate_fn will be run on, if None, aggregate_fn is run on y-column

aggregate_fn: {‘count’, ‘mean’, ‘max’, ‘min’}, default ‘count’

point_size: int, default 1

Point size in the scatter plot.

point_shape: str, default ‘rect_vertical’

Available options: circle, square, rect_vertical, rect_horizontal.

pixel_density: float, default 0.5

A tuning parameter in [0, 1], with higher values giving more dense scatter plot.

pixel_spread: str, default ‘dynspread’

dynspread: Spread pixels in an image dynamically based on the image density. spread: Spread pixels in an image.

title: str,

chart title

timeout: int (milliseconds), default 100

Determines the timeout after which the callback will process new events without the previous one having reported completion. Increase for very long running callbacks and if zooming feels laggy.

legend: bool, default True

Adds Bokeh.models.LinearColorMapper based legend if True,

legend_position: str, default top_right

position of legend on the chart. Valid places are: right, left, bottom, top, top_right, top_left,

bottom_left, bottom_right

unselected_alpha: float [0, 1], default 0.2

if True, displays unselected data in the same color_palette but transparent(alpha=0.2)

Returns:

A cudashader heatmap (scatter object) of type:

cuxfilter.charts.datashader.custom_extensions.InteractiveDatashaderPoints

Example

from cuxfilter import layouts, themes, DataFrame
from cuxfilter.charts import heatmap
from cuxfilter.sampledata import unemployment_data

cux_df = DataFrame.from_dataframe(unemployment_data)

# this is the colormap from the original NYTimes plot
colors = ["#75968f", "#a5bab7", "#c9d9d3", "#e2e2e2", "#dfccce", "#ddb7b1", "#cc7878", "#933b41", "#550b1d"]

chart1 = heatmap(x='Year', y='Month', aggregate_col='rate',
                            color_palette=colors, point_size=10, unselected_alpha=0.2)


d = cux_df.dashboard([chart1], layout=layouts.single_feature, theme=themes.dark)
chart1.view(height=500)

Graph chart

datashader.graph(node_y='y', node_id='vertex', edge_source='source', edge_target='target', x_range=None, y_range=None, add_interaction=True, node_aggregate_col=None, edge_aggregate_col=None, node_aggregate_fn='count', edge_aggregate_fn='count', node_color_palette=None, edge_color_palette=['#000000'], node_point_size=15, node_point_shape='circle', node_pixel_shade_type='eq_hist', node_pixel_density=0.8, node_pixel_spread='dynspread', edge_render_type='direct', edge_transparency=0, curve_params={'curve_total_steps': 100, 'strokeWidth': 1}, tile_provider=None, title='', timeout=100, legend=True, legend_position='top_right', unselected_alpha=0.2)

Parameters:

node_x: str, default “x”

x-coordinate column name for the nodes cuDF dataframe

node_y: str, default “y”

y-coordinate column name for the nodes cuDF dataframe

node_id: str, default “vertex”

node_id/label column name for the nodes cuDF dataframe

edge_source: str, default “source”

edge_source column name for the edges cuDF dataframe

edge_target=”target”,

edge_target column name for the edges cuDF dataframe

x_range: tuple, default(nodes_gpu_dataframe[x].min(),

nodes_gpu_dataframe[x].max()) (min, max) x-dimensions of the geo-scatter plot to be displayed

y_range: tuple, default(nodes_gpu_dataframe[y].min(),

nodes_gpu_dataframe[y].max())

(min, max) x-dimensions of the geo-scatter plot to be displayed

add_interaction: {True, False}, default True

node_aggregate_col=str, default None,

column from the nodes gpu dataframe on which the mode_aggregate_fn will be run on

edge_aggregate_col=str, default None,

column from the edges gpu dataframe on which the mode_aggregate_fn will be run on

node_aggregate_fn={‘count’, ‘mean’, ‘max’, ‘min’}, default ‘count’

edge_aggregate_fn={‘count’, ‘mean’, ‘max’, ‘min’}, default ‘count’

node_color_palette=bokeh.palettes or list/tuple of hex_color_codes,

or list/tuple of color names, default bokeh.palettes.Virisdis10

edge_color_palette=bokeh.palettes or list/tuple of hex_color_codes,

or list/tuple of color names, default [“#000000”]

node_point_size: int, default 8

Point size in the scatter plot.

node_point_shape: str, default ‘circle’

Available options: circle, square, rect_vertical, rect_horizontal.

node_pixel_shade_type: str, default ‘eq_hist’

The “how” parameter in datashader.transfer_functions.shade() function. Available options: eq_hist, linear, log, cbrt

node_pixel_density: float, default 0.8

A tuning parameter in [0, 1], with higher values giving more dense scatter plot.

node_pixel_spread: str, default ‘dynspread’

dynspread: Spread pixels in an image dynamically based on the image density. spread: Spread pixels in an image.

edge_render_type: str, default ‘direct’

type of edge render. Available options are ‘direct’/’curved’ *Note: Curved edge rendering is an experimental feature and may throw out of memory errors

edge_transparency: float, default 0

value in range [0,1] to specify transparency level of edges, with 1 being completely transparent

curve_params: dict, default dict(strokeWidth=1, curve_total_steps=100)

control curvature and max_bundle_size if edge_render_type=’curved’

tile_provider: str, default None

Underlying map type.See https://holoviews.org/reference/elements/bokeh/Tiles.html

title: str,

chart title

timeout: int (milliseconds), default 100

Determines the timeout after which the callback will process new events without the previous one having reported completion. Increase for very long running callbacks and if zooming feels laggy.

legend: bool, default True

Adds Bokeh.models.LinearColorMapper based legend if True, Note: legend currently only works with pixel_shade_type=’linear’/’log’

legend_position: str, default top_right

position of legend on the chart. Valid places are: right, left, bottom, top, top_right, top_left,

bottom_left, bottom_right

unselected_alpha: float [0, 1], default 0.2

if True, displays unselected data in the same color_palette but transparent(alpha=0.2) (nodes only)

Returns:

A cudashader graph plot of type:

cuxfilter.charts.datashader.custom_extensions.InteractiveDatashaderGraph

Example

Loading BokehJS ...

import cuxfilter
import cudf

edges = cudf.DataFrame({
    'source': [0, 0, 0, 0, 1, 1, 1, 0, 1, 2, 1, 1, 2, 0, 0],
    'target': [1, 2, 3, 1, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 3]
})

nodes = cudf.DataFrame({
    'vertex': [0, 1, 2, 3],
    'x': [-3.3125157356262207,-1.8728941679000854, 0.9095478653907776, 1.9572150707244873],
    'y': [-1.6965408325195312, 2.470950126647949,-2.969928503036499,0.998791515827179]
})

cux_df = cuxfilter.DataFrame.load_graph((nodes, edges))

chart0 = cuxfilter.charts.datashader.graph(node_pixel_shade_type='linear', unselected_alpha=0.2)

d = cux_df.dashboard([chart0], layout=cuxfilter.layouts.double_feature)
chart0.view()