Exploring Data Visualization in Altair: An Interesting Alternative to Seaborn

Data visualization is an essential tool for artificial intelligence (AI) and machine learning (ML) practitioners. Whether you‘re exploring a new dataset, debugging a model, or presenting results to stakeholders, being able to create clear and compelling visualizations is a key skill.

In the Python ecosystem, there are many popular open-source libraries for data visualization, including Matplotlib, Seaborn, Plotly, and Bokeh. However, in recent years, a newer library called Altair has been gaining traction as an interesting alternative, particularly among data scientists working on AI/ML projects.

In this post, we‘ll take a deep dive into Altair from the perspective of an AI/ML expert. We‘ll explore why Altair‘s declarative API and tight integration with the Vega and Vega-Lite libraries make it well-suited for ML workflows. We‘ll also walk through detailed code examples of how to create interactive and layered charts in Altair for common AI/ML use cases.

By the end of this post, you‘ll have a solid understanding of Altair‘s capabilities and how it compares to other popular visualization libraries like Seaborn. Whether you‘re a seasoned ML practitioner or just getting started with data visualization in Python, I think you‘ll find Altair to be a powerful and intuitive tool to have in your toolkit.

What is Altair?

Altair is a statistical data visualization library for Python that allows you to create a wide range of charts and plots using a declarative API. Rather than specifying how to draw the individual components of a chart step-by-step (known as an imperative approach), you simply declare the mappings between data columns and visual properties, and Altair takes care of the rest.

Under the hood, Altair is powered by the Vega and Vega-Lite libraries. Vega is a low-level visualization grammar that provides a JSON syntax for specifying charts. Vega-Lite is a higher-level grammar built on top of Vega that allows you to create common chart types with fewer lines of code.

Altair acts as a Python interface for Vega and Vega-Lite. It provides a clean and concise API for generating Vega-Lite JSON specifications, which are then rendered as interactive charts in the browser. This declarative approach allows you to focus on the data mappings and encoding rules, rather than worrying about implementation details.

One of the key advantages of Altair‘s declarative API is that it allows you to quickly iterate and experiment with different chart types and encodings. This is particularly useful in AI/ML workflows, where you often need to explore datasets and visualize results from multiple angles. With Altair, you can easily swap out data fields, change the mark type, or add interactive features without having to completely rewrite your code each time.

Installing and Using Altair

To get started with Altair, you‘ll need to install it using pip:

pip install altair vega_datasets

Note that we‘re also installing the vega_datasets package, which provides a collection of example datasets that we‘ll use throughout this post.

Once installed, you can import Altair in your Python scripts or Jupyter notebooks:

import altair as alt

To create a chart in Altair, you typically start by loading your data into a Pandas DataFrame. You can then create a chart object by calling the alt.Chart() function and chaining together a series of methods that specify the data mappings and visual properties of the chart.

For example, here‘s how you can create a simple scatter plot in Altair:

from vega_datasets import data

source = data.cars()

alt.Chart(source).mark_point().encode(
    x=‘Horsepower‘,
    y=‘Miles_per_Gallon‘,
    color=‘Origin‘
)

In this example, we first load the "cars" dataset using the vega_datasets package. We then create a chart object by calling alt.Chart() and passing in the data source.

Next, we specify that we want to create a scatter plot by calling the mark_point() method. Finally, we define the data mappings for the x-axis, y-axis, and color encoding using the encode() method.

When we run this code in a Jupyter notebook, Altair renders the chart as an interactive Vega-Lite plot:

The plot shows the relationship between a car‘s horsepower and its fuel efficiency in miles per gallon. The points are color-coded by the car‘s country of origin, and hovering over each point displays a tooltip with the exact values.

Why Altair for AI/ML Workflows?

So what makes Altair particularly well-suited for AI and ML workflows compared to other visualization libraries like Seaborn? Here are a few key advantages:

1. Declarative API: Altair‘s declarative API is a natural fit for the type of exploratory data analysis and rapid experimentation that is common in ML projects. With Altair, you can quickly iterate on different chart types and encodings without getting bogged down in verbose imperative code.

2. Layered and interactive charts: Altair makes it easy to create layered charts that combine multiple data views (e.g. points and lines) and add interactive features like tooltips and selection. This is useful for visualizing complex ML results, such as the output of a clustering algorithm or the decision boundary of a classifier.

3. Customization with Vega-Lite: Because Altair is built on top of Vega-Lite, you have access to a wide range of customization options for fine-tuning the appearance of your charts. Vega-Lite also supports more advanced chart types like geoplots and density heatmaps that are useful for visualizing geographic or high-dimensional ML data.

4. Integration with scientific computing stack: Altair integrates well with the rest of the Python scientific computing stack, including libraries like NumPy, Pandas, and scikit-learn. This makes it easy to incorporate Altair charts into your existing ML workflows without having to switch contexts or convert data formats.

To illustrate these advantages, let‘s walk through a few more detailed examples of using Altair for common AI/ML visualization tasks.

Visualizing Model Performance with Altair

One common task in ML projects is to evaluate and compare the performance of different models on a given dataset. Altair makes it easy to create interactive charts that allow you to quickly assess model performance across different metrics and hyperparameters.

For example, suppose we have trained a set of binary classification models on the classic iris dataset and want to visualize their performance using precision-recall curves. We can create a layered Altair chart that shows the curves for each model, along with an interactive legend that allows us to toggle the visibility of each curve:

import altair as alt
from vega_datasets import data
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_recall_curve
from sklearn.svm import SVC

# Load the iris dataset 
iris = data.iris()

# Split into features and target
X = iris[[‘sepalLength‘, ‘sepalWidth‘, ‘petalLength‘, ‘petalWidth‘]]
y = iris[‘species‘]

# Split into train and test sets  
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Train models with different kernels
models = {
    ‘Linear SVC‘: SVC(kernel=‘linear‘, probability=True),
    ‘RBF SVC‘: SVC(kernel=‘rbf‘, probability=True),    
    ‘Poly SVC‘: SVC(kernel=‘poly‘, probability=True),
}

for name, model in models.items():
    model.fit(X_train, y_train)

# Compute precision-recall curves
precision, recall = {}, {}
for name, model in models.items():  
    y_score = model.predict_proba(X_test)[:, 1]
    precision[name], recall[name], _ = precision_recall_curve(y_test, y_score, pos_label=‘versicolor‘)

# Create Altair chart
source = pd.DataFrame({
    ‘recall‘: [x for y in recall.values() for x in y],
    ‘precision‘: [x for y in precision.values() for x in y],
    ‘model‘: [name for name in precision.keys() for x in recall[name]]
})

alt.Chart(source).mark_line().encode(
    x=‘recall‘,
    y=‘precision‘, 
    color=‘model‘
).properties(
    title=‘Precision-Recall Curves by Model‘,
    width=500,
    height=400
).interactive()

This code first loads the iris dataset and splits it into training and test sets. It then trains three SVC models with different kernel functions (linear, RBF, polynomial) and computes the precision-recall curves for each model on the test set.

Finally, it creates an Altair chart with the precision-recall curves for each model. The chart uses a line mark to represent each curve, with the recall on the x-axis and precision on the y-axis. The color encoding is used to distinguish the curves by model type.

The resulting chart is interactive, allowing you to pan, zoom, and hover over each curve to view its values:

From this chart, we can see that the linear SVC model performs best on this dataset, with a higher precision at most recall levels compared to the other kernels.

Visualizing Geographic Data with Altair

Another common use case for data visualization in AI/ML is to plot geographic data, such as the locations of sensors or the distribution of customer transactions. Altair supports creating map-based visualizations using the geoshape mark type and lookup data transform.

For example, suppose we have a dataset of UFO sightings by state and want to create a choropleth map showing the relative frequency of sightings. We can use Altair to load a TopoJSON file of US state boundaries, merge it with our frequency data, and create a color-encoded map:

import altair as alt
from vega_datasets import data

states = alt.topo_feature(data.us_10m.url, ‘states‘)

source = pd.DataFrame({
    ‘state‘: [‘CA‘, ‘WA‘, ‘NY‘, ‘TX‘, ‘FL‘],
    ‘sightings‘: [100, 50, 75, 20, 90]   
})

alt.Chart(states).mark_geoshape().encode(
    color=‘sightings:Q‘
).transform_lookup(
    lookup=‘id‘,
    from_=alt.LookupData(source, ‘state‘, [‘sightings‘])
).properties(
    width=500,
    height=300
).project(
    type=‘albersUsa‘
)

This code first loads the US state boundaries from a TopoJSON file using the alt.topo_feature() function. It then creates a DataFrame with the frequency of UFO sightings by state.

Next, it defines an Altair chart with a geoshape mark type, which is used to represent geographic regions. The color encoding is set to the sightings column, which will color-code each state by the number of sightings.

The transform_lookup() function is used to merge the state boundaries with the frequency data based on the state name. Finally, the project() method is used to set the map projection to Albers USA.

The resulting chart is a interactive choropleth map of UFO sightings by state:

From this map, we can quickly identify the states with the highest frequency of UFO sightings, such as California and Florida.

Conclusion

In conclusion, Altair is a powerful and expressive data visualization library that offers many advantages for AI/ML workflows in Python. Its declarative API, built-in interactivity, and tight integration with the Vega-Lite library make it well-suited for rapid exploration and iteration on complex datasets.

While Seaborn and other imperative plotting libraries are still useful for certain tasks, I believe that Altair‘s approach represents the future of data visualization in Python. By shifting to a declarative, grammar-based paradigm, Altair allows you to create more expressive and interactive visualizations with less code.

As an AI/ML practitioner, being able to quickly prototype and share compelling data visualizations is a key skill. Whether you‘re exploring a new dataset, debugging a model, or presenting results to stakeholders, Altair can help you communicate your insights more effectively.

Of course, Altair is not without its limitations. Its declarative API can take some getting used to if you‘re coming from an imperative plotting background. And for certain advanced use cases, you may still need to drop down to Vega-Lite or even Vega for full customization.

But overall, I believe that Altair hits a sweet spot for most common AI/ML visualization tasks. It provides a clean and concise API for quickly generating interactive charts, while still offering enough flexibility to handle more complex use cases.

If you‘re an AI/ML practitioner looking to up your data visualization game in Python, I highly recommend giving Altair a try. With its expressive API and beautiful output, it just might become your new favorite tool for exploring and communicating insights from your data.