Seaborn-compatible API for interactive Vega-Lite plots via Altair.
29 |pip install seaborn_altair
31 | Works in Jupyter lab or Jupyter notebooks.
33 |import seaborn_altair as salt
35 | import seaborn as sns
36 | tips = sns.load_dataset("tips")
37 |
38 | # Use salt as you would sns
39 | salt.barplot(x="day", y="total_bill", data=tips)
40 |
This is only a proof of concept at this time. Only a subset of Seaborn plots (the ones with example links) are currently available with limited support.
44 |Idea from Jake VanderPlas. I know Python and Vega-Lite reasonably well, so decided to give it a shot.
97 |Contributions and suggestions welcome!
98 | 99 | 100 | -------------------------------------------------------------------------------- /docs/lvplot.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 25 | 26 | 27 |import seaborn as sns
28 | import numpy as np
29 | import altair as alt
30 | import pandas as pd
31 | import warnings
32 | from scipy import stats
33 |
34 | from seaborn.categorical import (
35 | _BarPlotter,
36 | _BoxPlotter,
37 | _LVPlotter,
38 | _PointPlotter,
39 | _StripPlotter,
40 | )
41 | from seaborn.palettes import color_palette
42 | from seaborn.external.six import string_types
43 |
44 | class _LVPlotterAltair(_LVPlotter):
45 |
46 | def _lvplot(self, box_data, positions,
47 | color=[255. / 256., 185. / 256., 0.],
48 | vert=True, widths=1, k_depth='proportion',
49 | ax=None, outlier_prop=None, scale='exponential',
50 | **kws):
51 |
52 | x = positions[0]
53 | box_data = np.asarray(box_data)
54 |
55 | # If we only have one data point, plot a line
56 | if len(box_data) == 1:
57 | kws.update({'color': self.gray, 'linestyle': '-'})
58 | ys = [box_data[0], box_data[0]]
59 | xs = [x - widths / 2, x + widths / 2]
60 | if vert:
61 | xx, yy = xs, ys
62 | else:
63 | xx, yy = ys, xs
64 | ax.plot(xx, yy, **kws)
65 | else:
66 | # Get the number of data points and calculate "depth" of
67 | # letter-value plot
68 | box_ends, k = self._lv_box_ends(box_data, k_depth=k_depth,
69 | outlier_prop=outlier_prop)
70 |
71 | # Anonymous functions for calculating the width and height
72 | # of the letter value boxes
73 | width = self._width_functions(scale)
74 |
75 | # Function to find height of boxes
76 | def height(b):
77 | return b[1] - b[0]
78 |
79 | # Functions to construct the letter value boxes
80 | def vert_perc_box(x, b, i, k, w):
81 | rect = Patches.Rectangle((x - widths*w / 2, b[0]),
82 | widths*w,
83 | height(b), fill=True)
84 | return rect
85 |
86 | def horz_perc_box(x, b, i, k, w):
87 | rect = Patches.Rectangle((b[0], x - widths*w / 2),
88 | height(b), widths*w,
89 | fill=True)
90 | return rect
91 |
92 | # Scale the width of the boxes so the biggest starts at 1
93 | w_area = np.array([width(height(b), i, k)
94 | for i, b in enumerate(box_ends)])
95 | w_area = w_area / np.max(w_area)
96 |
97 | # Calculate the medians
98 | y = np.median(box_data)
99 |
100 | # Calculate the outliers and plot
101 | outliers = self._lv_outliers(box_data, k)
102 |
103 | if vert:
104 | boxes = [vert_perc_box(x, b[0], i, k, b[1])
105 | for i, b in enumerate(zip(box_ends, w_area))]
106 |
107 | # Plot the medians
108 | ax.plot([x - widths / 2, x + widths / 2], [y, y],
109 | c='.15', alpha=.45, **kws)
110 |
111 | ax.scatter(np.repeat(x, len(outliers)), outliers,
112 | marker='d', c=mpl.colors.rgb2hex(color), **kws)
113 | else:
114 | boxes = [horz_perc_box(x, b[0], i, k, b[1])
115 | for i, b in enumerate(zip(box_ends, w_area))]
116 |
117 | # Plot the medians
118 | ax.plot([y, y], [x - widths / 2, x + widths / 2],
119 | c='.15', alpha=.45, **kws)
120 |
121 | ax.scatter(outliers, np.repeat(x, len(outliers)),
122 | marker='d', c=color, **kws)
123 |
124 | # Construct a color map from the input color
125 | rgb = [[1, 1, 1], list(color)]
126 | cmap = mpl.colors.LinearSegmentedColormap.from_list('new_map', rgb)
127 | collection = PatchCollection(boxes, cmap=cmap)
128 |
129 | # Set the color gradation
130 | collection.set_array(np.array(np.linspace(0, 1, len(boxes))))
131 |
132 | # Plot the boxes
133 | ax.add_collection(collection)
134 |
135 | def plot(self, ax, boxplot_kws):
136 | """Make the plot."""
137 | return self.draw_letter_value_plot(ax, boxplot_kws)
138 |
139 | import seaborn as sns
28 | import seaborn_altair.pyplot as palt
29 | tips = sns.load_dataset("tips")palt.hist('tip', data=tips, color="green")import seaborn as sns
28 | import seaborn_altair.pyplot as palt
29 | attend = sns.load_dataset("attention")palt.plot('solutions', 'score', color="green", data=attend[attend['subject'] == 1]).interactive()import seaborn as sns
28 | import seaborn_altair.pyplot as palt
29 | tips = sns.load_dataset("tips")palt.scatter('tip', 'total_bill', data=tips).interactive()%s
" % img)
73 |
74 | out.write(footer)
75 |
76 |
--------------------------------------------------------------------------------
/seaborn_altair/__init__.py:
--------------------------------------------------------------------------------
1 | from .axisgrid import *
2 | from .categorical import *
3 | from .regression import *
4 | from .relational import *
5 |
--------------------------------------------------------------------------------
/seaborn_altair/axisgrid.py:
--------------------------------------------------------------------------------
1 | import altair as alt
2 | from IPython.display import display
3 | import pandas as pd
4 |
5 | from .util import size_chart
6 |
7 | __all__ = ["FacetGrid"]
8 |
9 | class FacetGrid():
10 | """Subplot grid for plotting conditional relationships."""
11 |
12 | def __init__(self, data, row=None, col=None, hue=None, palette=None, height=3, aspect=1):
13 | self.hue = hue
14 | self.palette = palette
15 | self.height = height
16 | self.aspect = aspect
17 |
18 | self.chart = alt.Chart(data).mark_point()
19 |
20 | facets = {}
21 | if col is not None:
22 | facets['column'] = col
23 | if row is not None:
24 | facets['row'] = row
25 | if len(facets):
26 | self.chart = self.chart.facet(**facets)
27 |
28 | def _ipython_display_(self):
29 | display(self.chart)
30 |
31 | def map(self, func, *args, **kwargs):
32 | raise ValueError('FacetGrid.map is not implemented. Use map_dataframe instead.')
33 |
34 | def map_dataframe(self, func, *args, **kwargs):
35 | plot_kwargs = dict(
36 | color=self.hue,
37 | palette=self.palette, size=self.height,
38 | aspect=self.aspect, data=self.chart.data
39 | )
40 | plot_kwargs.update(kwargs)
41 |
42 | single = func(*args, **plot_kwargs)
43 |
44 | if isinstance(self.chart, alt.FacetChart):
45 | if isinstance(single, alt.FacetChart):
46 | raise ValueError("Cannot facet a FacetChart")
47 | self.chart.config = single.config
48 | single.config = alt.Undefined
49 | single.data = alt.Undefined
50 | self.chart.spec = single
51 | else:
52 | self.chart = single
53 |
54 | return self
55 |
--------------------------------------------------------------------------------
/seaborn_altair/categorical.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import altair as alt
3 | import pandas as pd
4 | from .util import infer_orient, size_chart, vega_color, vega_palette
5 | from .axisgrid import FacetGrid
6 |
7 | __all__ = ["boxplot", "catplot", "stripplot", "pointplot", "barplot", "countplot"]
8 |
9 | def _bar_encodings(x, y, xs, ys, hue, dodge, estimator):
10 | encodings = {
11 | ys: alt.Y(field=y, aggregate=estimator, type="quantitative", axis={"title": y}),
12 | "color": alt.Color(field=x ,type="nominal", legend=None)
13 | }
14 |
15 | if hue:
16 | legend = None if dodge else alt.Undefined
17 | encodings["color"] = alt.Color(field=hue ,type="nominal", legend=legend)
18 |
19 | xf = hue if hue and dodge else x
20 | encodings[xs] = alt.X(field=xf, type="nominal")
21 | return encodings
22 |
23 | def _bar_ci_encodings(x, y, xs, ys, hue, dodge, estimator):
24 | encodings = {
25 | ys: alt.Y(field=y, aggregate="ci0", type="quantitative"),
26 | "%s2" % ys: alt.Y(field=y, aggregate="ci1", type="quantitative")
27 | }
28 |
29 | xf = hue if hue and dodge else x
30 | encodings[xs] = alt.X(field=xf, type="nominal")
31 | return encodings
32 |
33 | def _point_encodings(x, y, xs, ys, hue, estimator):
34 | encodings = {
35 | ys: alt.Y(field=y, aggregate=estimator, type="quantitative"),
36 | "color": alt.Color(field="___" ,type="nominal", legend=None)
37 | }
38 |
39 | if hue:
40 | encodings["color"] = alt.Color(field=hue ,type="nominal")
41 |
42 | encodings[xs] = alt.X(field=x, type="nominal")
43 | return encodings
44 |
45 | def _point_ci_encodings(x, y, xs, ys, hue, estimator):
46 | encodings = {
47 | ys: alt.Y(field=y, aggregate="ci0", type="quantitative"),
48 | "%s2" % ys: alt.Y(field=y, aggregate="ci1", type="quantitative")
49 | }
50 |
51 | encodings[xs] = alt.X(field=x, type="nominal")
52 | return encodings
53 |
54 | def _validate_estimator(estimator, ci):
55 | if estimator in ["mean", np.mean]:
56 | estimator = "mean"
57 | if ci != 95 and ci is not None:
58 | raise ValueError("ci must be 95 for mean")
59 | elif estimator in ["median", np.median]:
60 | estimator = "median"
61 | if ci is not None:
62 | raise ValueError("ci not available for median")
63 | elif estimator in ["count", len]:
64 | estimator = "count"
65 | if ci is not None:
66 | raise ValueError("ci not available for median")
67 | else:
68 | raise ValueError("estimator must be mean or median")
69 | return estimator
70 |
71 | def barplot(
72 | x=None, y=None, hue=None, data=None,
73 | estimator=np.mean, ci=95, size=None, aspect=1,
74 | orient=None, color=None, palette=None, saturation=.75, dodge=True
75 | ):
76 | xs, ys = "x", "y"
77 | orient = infer_orient(data[x], data[y], orient)
78 | if orient == "h":
79 | x, y = y, x
80 | xs, ys = ys, xs
81 |
82 | estimator = _validate_estimator(estimator, ci)
83 |
84 | encodings = _bar_encodings(x, y, xs, ys, hue, dodge, estimator)
85 | chart = alt.Chart(data).mark_bar().encode(**encodings)
86 |
87 | if ci:
88 | ci_encodings = _bar_ci_encodings(x, y, xs, ys, hue, dodge, estimator)
89 | ci_layer = alt.Chart().mark_rule().encode(**ci_encodings)
90 | chart.data = alt.Undefined
91 | chart = alt.LayerChart(data=data, layer=[chart, ci_layer])
92 |
93 | if hue and dodge:
94 | facet_dir = "column" if orient == "v" else "row"
95 | chart = chart.facet(**{facet_dir: "%s:N" % x})
96 |
97 | size_chart(chart, size, aspect)
98 |
99 | pal = vega_palette(palette, color, saturation)
100 | return chart.configure_range(category=pal)
101 |
102 | def countplot(
103 | x=None, y=None, hue=None, data=None, size=None, aspect=1,
104 | orient=None, color=None, palette=None, saturation=.75, dodge=True
105 | ):
106 | estimator = len
107 | ci = None
108 |
109 | if x is None and y is not None:
110 | orient = "h"
111 | x = y
112 | elif y is None and x is not None:
113 | orient = "v"
114 | y = x
115 | elif x is not None and y is not None:
116 | raise TypeError("Cannot pass values for both `x` and `y`")
117 | else:
118 | raise TypeError("Must pass values for either `x` or `y`")
119 |
120 | return barplot(
121 | x, y, hue, data,
122 | estimator=estimator, ci=ci, size=size, aspect=aspect,
123 | orient=orient, color=color, palette=palette, saturation=saturation,
124 | dodge=dodge,
125 | )
126 |
127 | def pointplot(
128 | x=None, y=None, hue=None, data=None,
129 | estimator=np.mean, ci=95, join=True, size=None, aspect=1,
130 | orient=None, color=None, palette=None, saturation=.75
131 | ):
132 | xs, ys = "x", "y"
133 | orient = infer_orient(data[x], data[y], orient)
134 | if orient == "h":
135 | x, y = y, x
136 | xs, ys = ys, xs
137 |
138 | estimator = _validate_estimator(estimator, ci)
139 |
140 | encodings = _point_encodings(x, y, xs, ys, hue, estimator)
141 | chart = alt.Chart(data).mark_circle().encode(**encodings)
142 | layers = [chart]
143 |
144 | if join:
145 | layers.append(alt.Chart().mark_line().encode(**encodings))
146 |
147 | if ci:
148 | ci_encodings = _point_ci_encodings(x, y, xs, ys, hue, estimator)
149 | cfield = hue if hue else "___"
150 | ci_encodings["color"] = alt.Color(field=cfield, type="nominal", legend=None)
151 | layers.append(alt.Chart().mark_rule().encode(**ci_encodings))
152 |
153 | if len(layers) > 1:
154 | chart.data = alt.Undefined
155 | chart = alt.LayerChart(data=data, layer=layers)
156 |
157 | size_chart(chart, size, aspect)
158 |
159 | pal = vega_palette(palette, color, saturation)
160 | return chart.configure_range(category=pal)
161 |
162 |
163 | def stripplot(
164 | x=None, y=None, hue=None, data=None, size=None, aspect=1,
165 | dodge=False, orient=None, color=None, palette=None, saturation=.75
166 | ):
167 | xs, ys = "x", "y"
168 | if data is None:
169 | data = pd.DataFrame({"x": x})
170 | x = "x"
171 | if y:
172 | data["y"] = y
173 | y = "y"
174 |
175 | if y:
176 | orient = infer_orient(data[x], data[y], orient)
177 | else:
178 | orient = "v"
179 |
180 | if orient == "h":
181 | x, y = y, x
182 | xs, ys = ys, xs
183 |
184 | encodings = {}
185 |
186 | if y:
187 | encodings[ys] = alt.Y(field=y, type="quantitative")
188 | xf = hue if hue and dodge else x
189 | encodings[xs] = alt.X(field=xf, type="nominal")
190 | encodings["color"] = alt.Color(field=x ,type="nominal", legend=None)
191 | else:
192 | encodings[xs] = alt.X(field=x, type="quantitative")
193 |
194 | if hue:
195 | legend = None if dodge else alt.Undefined
196 | encodings["color"] = alt.Color(field=hue ,type="nominal", legend=legend)
197 |
198 | chart = alt.Chart(data).mark_tick().encode(**encodings)
199 |
200 | if hue and dodge:
201 | facet_dir = "column" if orient == "v" else "row"
202 | chart = chart.facet(**{facet_dir: "%s:N" % x})
203 |
204 | size_chart(chart, size, aspect)
205 |
206 | pal = vega_palette(palette, color, saturation)
207 | return chart.configure_range(category=pal)
208 |
209 | def boxplot(
210 | x=None, y=None, hue=None, data=None, size=None, aspect=1,
211 | orient=None, color=None, palette=None, saturation=.75, dodge=True
212 | ):
213 | xs, ys = "x", "y"
214 | if data is None:
215 | data = pd.DataFrame({"x": x})
216 | x = "x"
217 | if y:
218 | data["y"] = y
219 | y = "y"
220 |
221 | if x is None and y is None:
222 | # Make a box plot for each numeric column
223 | numeric_cols = [c for c in data if data[c].dtype in [np.float32, np.float64]]
224 | col = []
225 | val = []
226 | for c in numeric_cols:
227 | for v in data[c]:
228 | col.append(c)
229 | val.append(v)
230 |
231 | data = pd.DataFrame({"column": col, "value": val})
232 | x = "column"
233 | y = "value"
234 | if orient == "h":
235 | x, y = y, x
236 |
237 | if y:
238 | orient = infer_orient(data[x], data[y], orient)
239 | elif orient is None:
240 | orient = "h"
241 |
242 | if orient == "h":
243 | x, y = y, x
244 | xs, ys = ys, xs
245 |
246 | xf = hue if hue and dodge else x
247 |
248 | # Main bar
249 | encodings = {
250 | ys: alt.Y(field=y, aggregate="q1", type="quantitative", axis={"title": y}),
251 | "%s2" % ys: alt.Y(field=y, aggregate="q3", type="quantitative"),
252 | "color": alt.Color(field=x ,type="nominal", legend=None),
253 | xs: alt.X(field=xf, type="nominal")
254 | }
255 | if x is None:
256 | del encodings["color"]
257 | del encodings[xs]
258 | if hue:
259 | legend = None if dodge else alt.Undefined
260 | encodings["color"] = alt.Color(field=hue ,type="nominal", legend=legend)
261 | bar_layer = alt.Chart().mark_bar().encode(**encodings)
262 |
263 | # Min/max range line
264 | range_encodings = {
265 | ys: alt.Y(field=y, aggregate="min", type="quantitative"),
266 | "%s2" % ys: alt.Y(field=y, aggregate="max", type="quantitative"),
267 | xs: alt.X(field=xf, type="nominal")
268 | }
269 | if x is None:
270 | del range_encodings[xs]
271 | range_layer = alt.Chart().mark_rule().encode(**range_encodings)
272 |
273 | # Median line
274 | median_encodings = {
275 | ys: alt.Y(field=y, aggregate="median", type="quantitative"),
276 | xs: alt.X(field=xf, type="nominal")
277 | }
278 | if x is None:
279 | del median_encodings[xs]
280 | median_layer = alt.Chart().mark_tick(size=18, color="black").encode(**median_encodings)
281 |
282 | chart = alt.LayerChart(data=data, layer=[range_layer, bar_layer, median_layer])
283 |
284 | if hue and dodge:
285 | facet_dir = "column" if orient == "v" else "row"
286 | chart = chart.facet(**{facet_dir: "%s:N" % x})
287 |
288 | size_chart(chart, size, aspect)
289 |
290 | pal = vega_palette(palette, color, saturation)
291 | return chart.configure_range(category=pal)
292 |
293 | def catplot(
294 | x=None, y=None, hue=None, data=None, row=None, col=None,
295 | estimator=np.mean, ci=95, kind="point", height=None, aspect=1,
296 | orient=None, color=None, palette=None, facet_kws=None, **kwargs
297 | ):
298 |
299 | # Determine the plotting function
300 | try:
301 | plot_func = globals()[kind + "plot"]
302 | except KeyError:
303 | err = "Plot kind '{}' is not recognized".format(kind)
304 | raise ValueError(err)
305 |
306 | # Determine keyword arguments for the facets
307 | facet_kws = {} if facet_kws is None else facet_kws
308 | facet_kws.update(data=data, row=row, col=col, height=height, aspect=aspect)
309 |
310 | # Determine keyword arguments for the plotting function
311 | plot_kws = kwargs
312 | plot_kws.update(orient=orient, color=color, palette=palette)
313 |
314 | if kind in ["bar", "point"]:
315 | plot_kws.update(estimator=estimator, ci=ci)
316 |
317 | # Initialize the facets
318 | g = FacetGrid(**facet_kws)
319 |
320 | # Draw the plot onto the facets
321 | g.map_dataframe(plot_func, x, y, hue, **plot_kws)
322 |
323 | return g
324 |
--------------------------------------------------------------------------------
/seaborn_altair/pyplot.py:
--------------------------------------------------------------------------------
1 | import altair as alt
2 | import numpy as np
3 | import pandas as pd
4 | import warnings
5 |
6 | from .util import build_dataframe, dtype_to_vega_type, size_chart, vega_color, vega_palette
7 |
8 |
9 | def fill_between(x, y1, y2, color=None, style=None, data=None, palette=None, saturation=1, size=None, aspect=1):
10 | if data is None:
11 | xname = x.name if isinstance(x, pd.Series) else "x"
12 | data = pd.DataFrame({xname: x})
13 | x = xname
14 | if y1 is not None:
15 | y1name = y1.name if isinstance(y1, pd.Series) else "y1"
16 | data[y1name] = y1
17 | y1 = y1name
18 | if y2 is not None:
19 | y2name = y2.name if isinstance(y2, pd.Series) else "y2"
20 | data[y2name] = y2
21 | y2 = y2name
22 |
23 | encodings = {
24 | "x": alt.X(field=x, type=dtype_to_vega_type(data[x].dtype)),
25 | "y": alt.Y(field=y1, type="quantitative"),
26 | "y2": alt.Y(field=y2, type="quantitative"),
27 | }
28 | if color:
29 | if color in list(data.columns):
30 | encodings["color"] = alt.Color(field=color, type="nominal")
31 | else:
32 | encodings["color"] = alt.Color(value=vega_color(color))
33 |
34 | chart = alt.Chart(data).mark_area().encode(**encodings)
35 | size_chart(chart, size, aspect)
36 | pal = vega_palette(palette, None, saturation)
37 | return chart.configure_range(category=pal)
38 |
39 | def hist(x, color=None, data=None, palette=None, saturation=1, size=None, aspect=1):
40 | if data is None:
41 | data = pd.DataFrame({"x": x})
42 | x = "x"
43 |
44 | encodings = {
45 | "x": alt.X(bin=True, field=x, type="quantitative"),
46 | "y": alt.Y(aggregate="count", type="quantitative"),
47 | }
48 | if color:
49 | if color in list(data.columns):
50 | encodings["color"] = alt.Color(field=color)
51 | else:
52 | encodings["color"] = alt.Color(value=vega_color(color))
53 |
54 | chart = alt.Chart(data).mark_bar().encode(**encodings)
55 | size_chart(chart, size, aspect)
56 | pal = vega_palette(palette, None, saturation)
57 | return chart.configure_range(category=pal)
58 |
59 | def scatter(x, y, s=None, color=None, style=None, size_by=None, sizes=None, x_type="quantitative", color_type="nominal", size_type="quantitative", data=None, palette=None, saturation=1, size=None, aspect=1):
60 | if data is None:
61 | data, fields = build_dataframe({"x": x, "y": y})
62 | x, y = fields["x"], fields["y"]
63 |
64 | encodings = {
65 | "x": alt.X(field=x, type=x_type, axis={"title": x}),
66 | "y": alt.Y(field=y, type="quantitative", axis={"title": y}),
67 | }
68 | if color:
69 | if isinstance(color, alt.Color):
70 | encodings["color"] = color
71 | elif color in list(data.columns):
72 | encodings["color"] = alt.Color(field=color, type=color_type)
73 | else:
74 | encodings["color"] = alt.Color(value=vega_color(color))
75 | if style:
76 | if style in list(data.columns):
77 | encodings["shape"] = alt.Shape(field=style, type="nominal")
78 | else:
79 | encodings["shape"] = alt.Shape(value=style)
80 | if size_by:
81 | if size_by in list(data.columns):
82 | size_enc = dict(field=size_by, type=size_type)
83 | if sizes:
84 | size_enc["scale"] = dict(range=sizes)
85 | else:
86 | size_enc = dict(value=size_by)
87 | encodings["size"] = size_enc
88 |
89 | chart = alt.Chart(data).mark_point(filled=True).encode(**encodings)
90 | size_chart(chart, size, aspect)
91 | pal = vega_palette(palette, None, saturation, vega_type=color_type)
92 | if color_type == "nominal":
93 | chart = chart.configure_range(category=pal)
94 | else:
95 | chart = chart.configure_range(ramp=pal)
96 | return chart
97 |
98 | def plot(x, y, s=None, color=None, data=None, palette=None, saturation=1, size=None, aspect=1):
99 | if data is None:
100 | data, fields = build_dataframe({"x": x, "y": y})
101 | x, y = fields["x"], fields["y"]
102 |
103 | encodings = {
104 | "x": alt.X(field=x, type=dtype_to_vega_type(data[x].dtype)),
105 | "y": alt.Y(field=y, type="quantitative"),
106 | }
107 | if color:
108 | if color in list(data.columns):
109 | encodings["color"] = alt.Color(field=color, type="nominal")
110 | else:
111 | encodings["color"] = alt.Color(value=vega_color(color))
112 |
113 | chart = alt.Chart(data).mark_line().encode(**encodings)
114 | size_chart(chart, size, aspect)
115 | pal = vega_palette(palette, None, saturation)
116 | return chart.configure_range(category=pal)
117 |
--------------------------------------------------------------------------------
/seaborn_altair/regression.py:
--------------------------------------------------------------------------------
1 | import altair as alt
2 | import pandas as pd
3 | import seaborn as sns
4 | import six
5 | from .util import build_dataframe, size_chart, vega_palette
6 | from .pyplot import fill_between, plot, scatter as pscatter
7 |
8 | __all__ = ["regplot", "lmplot"]
9 |
10 | def regplot(
11 | x, y, data=None, x_estimator=None, x_bins=None, x_ci="ci",
12 | x_range=None, y_range=None, truncate=False,
13 | scatter=True, fit_reg=True, ci=95, n_boot=1000, units=None,
14 | order=1, logistic=False, lowess=False, robust=False, logx=False,
15 | color=None, scatter_kws={}, line_kws={}, ax=None,
16 | palette=None, height=None, aspect=1, color_scale=None
17 | ):
18 |
19 | if data is None:
20 | data, names = build_dataframe({"x": x, "y": y})
21 | x, y = names["x"], names["y"]
22 |
23 | if x_range is None:
24 | x_raw_range = (data[x].min(), data[x].max())
25 | x_pad = 0.05*(x_raw_range[1] - x_raw_range[0])
26 | x_range = (x_raw_range[0] - x_pad, x_raw_range[1] + x_pad)
27 |
28 | def plot_regression(data, color):
29 | p = sns.regression._RegressionPlotter(
30 | data[x], data[y], x_estimator=x_estimator, x_bins=x_bins, x_ci=x_ci,
31 | n_boot=n_boot, units=units, ci=ci, truncate=truncate,
32 | order=order, logistic=logistic, lowess=lowess, robust=robust, logx=logx
33 | )
34 |
35 | layers = []
36 | grid, yhat, err_bands = p.fit_regression(x_range=x_range)
37 | layers.append(plot(grid, yhat, color=color, **line_kws))
38 | if err_bands is not None:
39 | area = fill_between(grid, *err_bands, color=color)
40 | area.encoding.opacity = alt.value(0.15)
41 | layers.append(area)
42 | return layers
43 |
44 | def plot_scatter(data, color):
45 | p = sns.regression._RegressionPlotter(
46 | data[x], data[y], x_estimator=x_estimator, x_bins=x_bins, x_ci=x_ci,
47 | n_boot=n_boot, units=units, ci=ci, truncate=truncate,
48 | order=order, logistic=logistic, lowess=lowess, robust=robust, logx=logx
49 | )
50 |
51 | layers = []
52 | if p.x_estimator is None:
53 | layers.append(pscatter(x, y, data=data, color=color, **scatter_kws))
54 | else:
55 | xs, ys, cis = p.estimate_data
56 | if [ci for ci in cis if ci is not None]:
57 | for xval, cci in zip(xs, cis):
58 | ci_df = pd.DataFrame({x: [xval, xval], y: cci})
59 | layers.append(plot(x, y, data=ci_df))
60 | estimate_df = pd.DataFrame({x: xs, y: ys})
61 | layers.append(pscatter(x, y, data=estimate_df, color=color, **scatter_kws))
62 | return layers
63 |
64 | if color and color in list(data.columns):
65 | if color_scale is None:
66 | val = data[color].unique()
67 | pal = sns.color_palette(palette)
68 | color_scale = alt.Scale(domain=list(val), range=vega_palette(pal))
69 | else:
70 | val = color_scale.domain
71 |
72 | color_map = {}
73 | for i in range(len(color_scale.domain)):
74 | color_map[color_scale.domain[i]] = color_scale.range[i % len(color_scale.range)]
75 |
76 | layers = []
77 | if scatter:
78 | for v in data[color].unique():
79 | part = data.loc[data[color] == v]
80 | layers += plot_scatter(part, color_map[v])
81 |
82 | if fit_reg:
83 | for v in data[color].unique():
84 | part = data.loc[data[color] == v]
85 | layers += plot_regression(part, color_map[v])
86 | else:
87 | layers = []
88 | if scatter:
89 | layers += plot_scatter(data, color)
90 |
91 | if fit_reg:
92 | layers += plot_regression(data, color)
93 |
94 | for layer in layers:
95 | if isinstance(layer.mark, six.string_types):
96 | layer.mark = dict(type=layer.mark, clip=True)
97 | else:
98 | layer.mark.clip = True
99 | layer.encoding.x.scale=alt.Scale(domain=x_range, nice=False)
100 | if y_range is not None:
101 | layer.encoding.y.scale=alt.Scale(domain=y_range, nice=False)
102 | layer.config = alt.Undefined
103 |
104 | chart = alt.LayerChart(layer=layers)
105 | return chart
106 |
107 |
108 | def lmplot(
109 | x, y, data, hue=None, col=None, row=None, palette=None,
110 | x_estimator=None, x_bins=None, x_ci="ci",
111 | col_wrap=None, height=5, aspect=1,
112 | hue_order=None, col_order=None, row_order=None,
113 | scatter=True, fit_reg=True, ci=95, n_boot=1000, truncate=False,
114 | units=None, order=1, logistic=False, lowess=False, robust=False,
115 | logx=False, scatter_kws={}, line_kws={}
116 | ):
117 |
118 | x_raw_range = (data[x].min(), data[x].max())
119 | x_pad = 0.05*(x_raw_range[1] - x_raw_range[0])
120 | x_range = (x_raw_range[0] - x_pad, x_raw_range[1] + x_pad)
121 |
122 | y_raw_range = (data[y].min(), data[y].max())
123 | y_pad = 0.05*(y_raw_range[1] - y_raw_range[0])
124 | y_range = (y_raw_range[0] - y_pad, y_raw_range[1] + y_pad)
125 |
126 | def unique_with_order(a, order):
127 | b = list(order) if order else []
128 | for i in a.unique():
129 | if i not in b:
130 | b.append(i)
131 | return b
132 |
133 | cols = unique_with_order(data[col], col_order) if col else [1]
134 | rows = unique_with_order(data[row], row_order) if row else [1]
135 | hues = unique_with_order(data[hue], hue_order) if hue else [1]
136 |
137 | pal = sns.color_palette(palette)
138 | color_scale = alt.Scale(domain=list(hues), range=vega_palette(pal))
139 |
140 | charts = []
141 | for r in rows:
142 | row_part = data.loc[data[row] == r] if row else data
143 | chart_row = []
144 | for c in cols:
145 | part = row_part.loc[row_part[col] == c] if col else row_part
146 | chart = regplot(
147 | data=part, x=x, y=y, color=hue, palette=palette, x_range=x_range, y_range=y_range,
148 | x_estimator=x_estimator, x_bins=x_bins, x_ci=x_ci,
149 | scatter=scatter, fit_reg=fit_reg, ci=ci, n_boot=n_boot, units=units, truncate=truncate,
150 | order=order, logistic=logistic, lowess=lowess, robust=robust, logx=logx,
151 | scatter_kws=scatter_kws, line_kws=line_kws, color_scale=color_scale,
152 | )
153 | size_chart(chart, height, aspect)
154 | chart.title = ("%s = %s" % (row, r) if row else "") + (" | " if row and col else "") + ("%s = %s" % (col, c) if col else "")
155 | chart_row.append(chart)
156 | if col_wrap is not None and len(chart_row) >= col_wrap:
157 | charts.append(chart_row)
158 | chart_row = []
159 |
160 | if len(chart_row) > 0:
161 | charts.append(chart_row)
162 |
163 | if len(charts) > 1 or len(charts[0]) > 1:
164 | chart_rows = []
165 | for chart_row in charts:
166 | chart_rows.append(alt.hconcat(*chart_row))
167 | facets = alt.vconcat(*chart_rows)
168 | else:
169 | facets = charts[0][0]
170 |
171 | return facets
172 |
--------------------------------------------------------------------------------
/seaborn_altair/relational.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import pandas as pd
3 | from .pyplot import scatter
4 | from .util import build_dataframe, dtype_to_vega_type
5 |
6 | __all__ = ["scatterplot"]
7 |
8 | def scatterplot(
9 | x=None, y=None, hue=None, style=None, size=None, data=None,
10 | palette=None, sizes=[10, 80]
11 | ):
12 | if data is None:
13 | data, names = build_dataframe({"x": x, "y": y, "hue": hue, "style": style, "size": size})
14 | x, y, hue, style, size = names["x"], names["y"], names["hue"], names["style"], names["size"]
15 |
16 | if x is None and y is None:
17 | plot_data = data.copy()
18 | x = getattr(data.index, "name", "x")
19 | plot_data.loc[:, x] = data.index
20 | plot_data = pd.melt(plot_data, x, var_name="series", value_name="y")
21 | y = "y"
22 | hue = "series"
23 | style = "series"
24 | data = plot_data
25 |
26 | x_type = dtype_to_vega_type(data[x].dtype)
27 | params = dict(x=x, x_type=x_type, y=y, color=hue, style=style, size_by=size, sizes=sizes, palette=palette, data=data)
28 | if hue is not None:
29 | params['color_type'] = dtype_to_vega_type(data[hue].dtype)
30 | if size is not None:
31 | params['size_type'] = dtype_to_vega_type(data[size].dtype)
32 | return scatter(**params)
33 |
--------------------------------------------------------------------------------
/seaborn_altair/util.py:
--------------------------------------------------------------------------------
1 | import altair as alt
2 | from matplotlib.colors import to_rgba
3 | import numpy as np
4 | import pandas as pd
5 | import seaborn as sns
6 | import matplotlib as mpl
7 | import six
8 |
9 | def build_dataframe(fields):
10 | field_names = {}
11 | data = pd.DataFrame()
12 | for name, field in six.iteritems(fields):
13 | if field is not None:
14 | if isinstance(field, pd.Series):
15 | fname = field.name
16 | else:
17 | fname = name
18 | data[fname] = field
19 | field_names[name] = fname
20 | else:
21 | field_names[name] = None
22 | return data, field_names
23 |
24 | def dtype_to_vega_type(t):
25 | if t == np.dtype('datetime64[ns]'):
26 | return 'temporal'
27 | if t == np.float64 or t == np.int64:
28 | return 'quantitative'
29 | return 'nominal'
30 |
31 | def size_chart(chart, size, aspect):
32 | dpi = mpl.rcParams['figure.dpi']
33 | if size:
34 | if isinstance(chart, alt.FacetChart):
35 | chart = chart.spec
36 | chart.height = size*dpi
37 | chart.width = aspect*size*dpi
38 |
39 | def vega_color(color):
40 | if isinstance(color, six.string_types) and (color.startswith('rgb(') or color.startswith('rgba(')):
41 | return color
42 | c = to_rgba(color)
43 | return "rgba(%s,%s,%s,%s)" % (int(c[0]*255), int(c[1]*255), int(c[2]*255), c[3])
44 |
45 | def vega_palette(palette, color=None, saturation=1, vega_type="nominal"):
46 | if palette:
47 | if isinstance(palette, mpl.colors.Colormap):
48 | pal = palette.colors
49 | else:
50 | pal = sns.color_palette(palette)
51 | elif color:
52 | pal = [color]
53 | elif vega_type == "nominal":
54 | pal = sns.color_palette()
55 | else:
56 | pal = sns.cubehelix_palette(0, as_cmap=True).colors
57 |
58 | if saturation < 1:
59 | pal = sns.color_palette(pal, desat=saturation)
60 |
61 | pal = sns.color_palette(pal)
62 | return [vega_color(c) for c in pal]
63 |
64 | def vega_semantic_type(data):
65 | try:
66 | float_data = data.astype(np.float)
67 | values = np.unique(float_data.dropna())
68 | if np.array_equal(values, np.array([0., 1.])):
69 | return "nominal"
70 | return "quantitative"
71 | except (ValueError, TypeError):
72 | return "nominal"
73 |
74 | # From seaborn.categorical
75 | def infer_orient(x, y, orient=None):
76 | """Determine how the plot should be oriented based on the data."""
77 | orient = str(orient)
78 |
79 | def is_categorical(s):
80 | try:
81 | # Correct way, but does not exist in older Pandas
82 | try:
83 | return pd.api.types.is_categorical_dtype(s)
84 | except AttributeError:
85 | return pd.core.common.is_categorical_dtype(s) # pylint: disable=E1101
86 | except AttributeError:
87 | # Also works, but feels hackier
88 | return str(s.dtype) == "categorical"
89 |
90 | def is_not_numeric(s):
91 | try:
92 | np.asarray(s, dtype=np.float)
93 | except ValueError:
94 | return True
95 | return False
96 |
97 | no_numeric = "Neither the `x` nor `y` variable appears to be numeric."
98 |
99 | if orient.startswith("v"):
100 | return "v"
101 | elif orient.startswith("h"):
102 | return "h"
103 | elif x is None:
104 | return "v"
105 | elif y is None:
106 | return "h"
107 | elif is_categorical(y):
108 | if is_categorical(x):
109 | raise ValueError(no_numeric)
110 | else:
111 | return "h"
112 | elif is_not_numeric(y):
113 | if is_not_numeric(x):
114 | raise ValueError(no_numeric)
115 | else:
116 | return "h"
117 | else:
118 | return "v"
119 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | description-file = README.md
3 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | from distutils.core import setup
2 |
3 | setup(
4 | name='seaborn_altair',
5 | version='0.1.0',
6 | description='Seaborn-compatible API for interactive Vega-Lite plots via Altair',
7 | author='Kitware, Inc.',
8 | author_email='kitware@kitware.com',
9 | license='BSD (3-clause)',
10 | url='https://github.com/Kitware/seaborn_altair',
11 | packages=['seaborn_altair'],
12 | classifiers=[
13 | 'Development Status :: 3 - Alpha',
14 | 'Environment :: Web Environment',
15 | 'License :: OSI Approved :: BSD License',
16 | 'Operating System :: OS Independent',
17 | 'Programming Language :: Python',
18 | 'Programming Language :: Python :: 2',
19 | 'Programming Language :: Python :: 2.7'
20 | ],
21 | install_requires=[
22 | 'altair',
23 | 'seaborn'
24 | ]
25 | )
26 |
--------------------------------------------------------------------------------