Appendix E — Seaborn tutorial - No Bullshit Guide to Statistics

In this tutorial, we’ll learn about the seaborn library for data visualizations. We’ll start by explaining the plotting function interface that is common to all seaborn functions, then list all the seaborn functions thought examples. We’ll also describe the various options for customize plots’ the appearance, add adding annotations and labels.

Click the binder button or this link bit.ly/4twDwZu to play with the tutorial notebook interactively.

Notebook setup¶

Before we begin the tutorial, we we must take care of some preliminary tasks to prepare the notebook environment. Feel free to skip this commands

Installing seaborn and other libraries¶

We can install Python package pandas in the current environment using the %pip Jupyter magic command.

%pip install --quiet seaborn matplotlib pandas ministats

Note: you may need to restart the kernel to use updated packages.

import seaborn as sns
import matplotlib.pyplot as plt

Setting display options¶

Next, we run some commands to configure the display of figures and number formatting.

sns.set_theme(
    context="paper",
    style="whitegrid",
    palette="colorblind",
    rc={"font.family": "serif",
        "font.serif": ["Palatino", "DejaVu Serif", "serif"],
        "figure.figsize": (5, 1.7)},
)
%config InlineBackend.figure_format = 'retina'

# simple float __repr__
import numpy as np
np.set_printoptions(legacy='1.25')

Download datasets¶

import pandas as pd

The ministats package provides a helper function for downloading datasets. We’ll use this function now to make sure the datasets/ folder that accompanies this tutorial is present.

# download datasets/ directory if necessary
from ministats import ensure_datasets
ensure_datasets()

datasets/ directory present and ready.

With all these preliminaries in place, we can now get the pandas show started!

Loading datasets¶

healthexp = sns.load_dataset("healthexp")
healthexp
# pyg.walk(healthexp)

# TODO: show how to add per-datum labels

# dots = sns.load_dataset("dots")
# data = dots[(dots["choice"]=="T1") & (dots["align"]=="dots")]
# sns.lineplot(data=data, x="time", y="firing_rate")
# # data["align"].unique()

# attention = sns.load_dataset("attention", index_col=0)
# attention

Seaborn overview¶

The seaborn library is a powerful toolbox for generating statistical data visualizations. Seaborn makes it very easy to visualize data stored in pandas data frames. You can generate standard statistical plots like barplots, stripplots, scatterplots, using just a few lines of code. If you plan to pursue a career in a data-related field, learning a bit about seaborn is highly recommend.

Learning objectives¶

In this tutorial, I’m going to show you how to ...

Seaborn line plots¶

We’ll start by playing with the seaborn function for generating line plots sns.lineplot. We’ll use this function to learn the the syntax for mapping data to graph attributes, which is common to all seaborn plotting function.

Simple line plot¶

xs = np.linspace(-2, 2, 100)
ys = xs**2 
quadfun = pd.DataFrame({"x":xs, "y":ys})
sns.lineplot(data=quadfun, x="x", y="y", label="$f(x) = x^2$")

<Axes: xlabel='x', ylabel='y'>

Line plot with statistical calculations¶

wloss = pd.read_csv("datasets/wloss.csv")
wloss.sample(3)

sns.lineplot(data=wloss, x="week", y="weight")

<Axes: xlabel='week', ylabel='weight'>

Pandas datasets¶

import pandas as pd

The iris dataset¶

iris = sns.load_dataset("iris")
iris.head()

The tips dataset¶

tips = sns.load_dataset("tips")
tips.head()

The students dataset¶

students = pd.read_csv("datasets/students.csv",
                       index_col="student_ID")
students

sns.lineplot(data=students,
             x="effort",
             y="score")

<Axes: xlabel='effort', ylabel='score'>

Inventory of seaborn plotting functions¶

Strip plots¶

Use the function sns.stripplot

sns.stripplot(data=students, x="score");

plt.figure(figsize=(6,1))
sns.stripplot(data=students, x="score");

ALT. sns.swarmplot or sns.rugplot

Point plots¶

Use the function sns.pointplot

Scatter plots¶

Use the function sns.scatterplot

Line plot¶

Use the function sns.lineplot

Histograms¶

Use the function sns.histplot

Kernel density plots¶

Use the function sns.kdeplot

Box plots¶

Use the function sns.boxplot

Violin plots¶

Use the function sns.violinplot

Empirical Cumulative Distribution Function (ECDF) plot¶

Use the function sns.ecdfplot

Count plot¶

Use the function sns.countplot

titanic = sns.load_dataset("titanic")
sns.countplot(titanic, x="class", hue="sex")

<Axes: xlabel='class', ylabel='count'>

titanic

sns.barplot(data=titanic, x="class", hue="sex", y="survived", estimator=np.size);

titanic_counts = titanic["class"].value_counts().reset_index()
sns.barplot(data=titanic_counts, x="class",  y="count")

<Axes: xlabel='class', ylabel='count'>

Bar plots¶

Use the function sns.barplot

Plotting function graphs¶

def g(x):
    return 0.5 * x**2

import numpy as np
xs = np.linspace(0, 10, 1000)
gxs = g(xs)
sns.lineplot(x=xs, y=gxs, label="Graph of g(x)");

# # FIGURES ONLY
# from ministats.utils import savefigure
# ax = sns.lineplot(x=xs, y=gxs, label="Graph of g(x)");
# filename = "figures/tutorials/seaborn/graph_of_function_g_eq_halfx2.pdf"
# savefigure(ax, filename)

Linear model plots¶

Linear regression plot¶

sns.regplot(data=tips, x="total_bill", y="tip");

Residuals plot¶

sns.residplot(data=tips, x="total_bill", y="tip");

Linear model plots from scratch¶

Linear model plots using `statsmodels`¶

Plotting probability distributions¶

Line plots for continuous random variables¶

Stem plots for discrete random variables¶

Customizing plots¶

Anotomy of a figure¶


from matplotlib.ticker import MultipleLocator, FuncFormatter

np.random.seed(123)

X = np.linspace(0.5, 3.5, 100)
Y1 = 3+np.cos(X)
Y2 = 1+np.cos(1+X/0.75)/2
Y3 = np.random.uniform(Y1, Y2, len(X))

fig = plt.figure(figsize=(8, 8), facecolor="w")
ax = fig.add_subplot(1, 1, 1, aspect=1)


def minor_tick(x, pos):
    if not x % 1.0:
        return ""
    return "%.2f" % x

ax.xaxis.set_major_locator(MultipleLocator(1.000))
ax.xaxis.set_minor_locator(MultipleLocator(0.250))
ax.yaxis.set_major_locator(MultipleLocator(1.000))
ax.yaxis.set_minor_locator(MultipleLocator(0.250))
ax.xaxis.set_minor_formatter(FuncFormatter(minor_tick))

ax.set_xlim(0, 4)
ax.set_ylim(0, 4)

ax.tick_params(which='major', width=1.0)
ax.tick_params(which='major', length=10)
ax.tick_params(which='minor', width=1.0, labelsize=10)
ax.tick_params(which='minor', length=5, labelsize=10, labelcolor='0.25')

ax.grid(linestyle="--", linewidth=0.5, color='.25', zorder=-10)

ax.plot(X, Y1, c=(0.25, 0.25, 1.00), lw=2, label="Blue signal", zorder=10)
ax.plot(X, Y2, c=(1.00, 0.25, 0.25), lw=2, label="Red signal")
ax.scatter(X, Y3, c='w')

ax.set_title("Anatomy of a figure", fontsize=20)
ax.set_xlabel("X axis label")
ax.set_ylabel("Y axis label")

ax.legend(frameon=False)


def circle(x, y, radius=0.15):
    from matplotlib.patches import Circle
    from matplotlib.patheffects import withStroke
    circle = Circle((x, y), radius, clip_on=False, zorder=10, linewidth=1,
                    edgecolor='black', facecolor=(0, 0, 0, .0125),
                    path_effects=[withStroke(linewidth=5, foreground='w')])
    ax.add_artist(circle)


def text(x, y, text):
    ax.text(x, y, text, backgroundcolor="white",
            ha='center', va='top', weight='bold', color='blue')


# Minor tick
circle(0.50, -.05)
text(0.50, -0.25, "Minor tick label")

# Major tick
circle(4.00, 2.00)
text(4.00, 1.80, "Major tick")

# Minor tick
circle(0.25, 4.00)
text(0.25, 3.80, "Minor tick")

# Major tick label
circle(-0.05, 3.00)
text(-0.05, 2.80, "Major tick label")

# X Label
circle(1.80, -0.22)
text(1.80, -0.4, "X axis label")

# Y Label
circle(-0.20, 1.80)
text(-0.20, 1.6, "Y axis label")

# Title
circle(1.60, 4.10)
text(1.60, 3.9, "Title")

# Blue plot
circle(1.75, 2.80)
text(1.75, 2.60, "Line\n(line plot)")

# Red plot
circle(1.20, 0.60)
text(1.20, 0.40, "Line\n(line plot)")

# Scatter plot
circle(3.20, 1.75)
text(3.20, 1.55, "Markers\n(scatter plot)")

# Grid
circle(3.00, 3.00)
text(3.00, 2.80, "Grid")

# Legend
circle(3.70, 3.75)
text(3.70, 3.55, "Legend")

# Axes
circle(0.5, 0.5)
text(0.5, 0.3, "Axes")

# Figure
circle(-0.3, 0.65)
text(-0.3, 0.45, "Figure")

color = 'blue'
ax.annotate('Spines', xy=(4.0, 0.35), xycoords='data',
            xytext=(3.3, 0.5), textcoords='data',
            weight='bold', color=color,
            arrowprops=dict(arrowstyle='->',
                            connectionstyle="arc3",
                            color=color))

ax.annotate('', xy=(3.15, 0.0), xycoords='data',
            xytext=(3.45, 0.45), textcoords='data',
            weight='bold', color=color,
            arrowprops=dict(arrowstyle='->',
                            connectionstyle="arc3",
                            color=color))

ax.legend(loc="upper right")

Adding text annotations¶

healthexp = sns.load_dataset("healthexp")
healthexp_2020 = healthexp[healthexp["Year"]==2020]
ax = sns.scatterplot(data=healthexp_2020,
                     x="Spending_USD",
                     y="Life_Expectancy")
for _, row in healthexp_2020.iterrows():
    x_pos = row["Spending_USD"]
    y_pos = row["Life_Expectancy"] + 0.1
    ax.text(x_pos, y_pos, row["Country"], ha="center", va="bottom")

# ha supported values are 'center', 'right', 'left'
# va supported values are 'center', 'top', 'bottom',

sns.scatterplot(data=healthexp,
                x="Spending_USD",
                y="Life_Expectancy",
                hue="Country");

healthexp.groupby("Country")["Year"].last()

Country
Canada           2020
France           2020
Germany          2020
Great Britain    2020
Japan            2020
USA              2020
Name: Year, dtype: int64

Layout options¶

option	meaning	values / example	applies to
`color`	single colour override	`"k"`	sca, lin, his, kde, ecdf, str, swa, box, vio, poi, bar, cnt, reg, res
`orient`	vertical/horizontal	`"v"/"h"` or `"x"/"y"`	lin, str, swa, box, vio, poi, bar, cnt
`dodge`	separate hue groups	`True/False/"auto"`	his, str, swa, box, vio, poi, bar, cnt
`jitter`	random x spread	`True`, `0.2`	str
`width`	element width	`0.8`	box, vio, bar, cnt
`log_scale`	log axes	`True`, `10`, `(True, False)`	his, kde, ecdf, str, swa, box, vio, poi, bar, cnt

Matplotlib pass-through options¶

Seaborn plot functions will “forward” keywords arguments to the underlying matplotlib plotting function. This means we can sometimes use certain matplotlib options to change plot appearance.

option	meaning	values / example	applies to
`alpha`	transparency	`0.3`	sca, lin, his, kde, ecdf, str, swa, box, vio, poi, bar, cnt, reg, res, hea
`color`	single colour override	`"k"`	sca, lin, his, kde, ecdf, str, swa, box, vio, poi, bar, cnt, reg, res
`linewidth`	line/edge width	`1.5`	sca, lin, his, kde, ecdf, str, swa, box, vio, poi, bar, cnt, reg, res, hea
`linestyle/linestyles`	line style	`"-"`, `"--"`	lin, kde, ecdf, poi, reg
`marker`	marker style	`"o"`, `"."`, dict	sca, lin, str, swa, poi, reg, res
`s`	marker area	`s=30`	scatterplot, stripplot, swarmplot
`label`	legend label	`label="controls"`

Advanced seaborn topics¶

Seaborn figure-level functions (FacetGrid objects)¶

students = pd.read_csv("datasets/students.csv")


fig, axs = plt.subplots(2, 1, sharex=True)

# prepare data
dstudents = students[students["curriculum"]=="debate"]
lstudents = students[students["curriculum"]=="lecture"]

# select colors to use for the two groups
blue, yellow  = sns.color_palette()[0], sns.color_palette()[1]

# plot histograms
bins = [50, 60, 70, 80, 90, 100]
sns.histplot(data=dstudents, x="score", color=blue, ax=axs[0], bins=bins)
sns.histplot(data=lstudents, x="score", color=yellow, ax=axs[1], bins=bins)

# add labels
axs[0].legend(labels=["debate"])
axs[1].legend(labels=["lecture"]);

Alternatively, we can use sns.displot with curriculum as the row option to produce a similar plot.

sns.displot(data=students, x='score', row='curriculum',
            hue='curriculum', alpha=0.8, bins=bins,
            aspect=3.3, height=2);

Data visualization tips¶

Exercises¶

Line plot of countrypops dataset: https://posit-dev.github.io/great-tables/reference/data.countrypops.html

Links¶

Here are some links to learning resources for seaborn and data visualization techniques.

Official docs¶

[ Seaborn documentation website ]
https://seaborn.pydata.org/
https://seaborn.pydata.org/introduction.html

[ Seaborn tutorials featuring lots of useful plot examples ]
https://seaborn.pydata.org/tutorial.html

[ Gallery of data visualizations produced using seaborn ] https://seaborn.pydata.org/examples/index.html

Tutorials¶

[ Seaborn tutorial for beginners ]
https://www.datacamp.com/community/tutorials/seaborn-python-tutorial

[ The ultimate Python seaborn tutorial ]
https://elitedatascience.com/python-seaborn-tutorial

[ Seaborn Tutorial ]
https://www.geeksforgeeks.org/python-seaborn-tutorial/

Video tutorials¶

[ Intro to seaborn by Kimberly Fessel (excellent!) ]
https://www.youtube.com/playlist?list=PLtPIclEQf-3cG31dxSMZ8KTcDG7zYng1j
see also notebooks from the videos.

[ Seaborn Tutorial 2021 by Derek Banas ]
https://www.youtube.com/watch?v=6GUZXDef2U0

[ Data Visualisation with seaborn Crash Course by Valentine Mwangi ]
https://www.youtube.com/watch?v=zafPvR4MmBA
See also the colab notebook for the course.

Other plotting libraries:¶

altair https://github.com/vega/altair
plotnine [1,2,3,4]
PyGwalker https://github.com/Kanaries/pygwalker

CUT MATERIAL¶

%pip install -q pygwalker

Note: you may need to restart the kernel to use updated packages.

import pygwalker as pyg

exercise = sns.load_dataset("exercise", index_col=0)
exercise.head()
# pyg.walk(exercise)

sns.catplot(
    data=exercise, x="time", y="pulse", hue="kind", col="diet",
    capsize=.2, palette="YlGnBu_d", errorbar="se",
    kind="point", height=6, aspect=.75,
)

<seaborn.axisgrid.FacetGrid at 0x1151d2f30>

seaice = sns.load_dataset("seaice")
seaice
# pyg.walk(healthexp)

FMRI¶

fmri = sns.load_dataset("fmri")
fmri.head()
# fmri.shape
# fmri["subject"].value_counts()


# Plot the responses for different events and regions
sns.lineplot(data=fmri, x="timepoint", y="signal",
             hue="region", style="event");

tips = sns.load_dataset("tips")
print(tips.shape)
tips.head()

(244, 7)

The Dow Jones dataset¶

dowjones = sns.load_dataset("dowjones")
dowjones["Year"] = dowjones["Date"].dt.year
sns.lineplot(data=dowjones, x="Year", y="Price", estimator="mean", errorbar=("sd",1))

<Axes: xlabel='Year', ylabel='Price'>

plt.figure(figsize=(5,3))
ax = sns.pointplot(data=titanic, x="class", y="survived", hue="sex",
                   markers=["^", "o"], linestyles=["-", "--"])

# sns.despine(top=True)

# [attr for attr in dir(sns) if attr.endswith("plot")]

Appendix E — Seaborn tutorial