How to Create a Regression Plot in Seaborn

Key Insights

Seaborn offers two main functions for regression plots: regplot() for single plots with fine-grained control, and lmplot() for multi-panel layouts with categorical grouping—choose based on whether you need faceting capabilities.
Regression plots combine scatter plots with fitted regression lines and confidence intervals, making them ideal for quickly visualizing relationships and identifying trends, outliers, or non-linear patterns in your data.
The order parameter enables polynomial regression fitting, while x_estimator aggregates discrete data points, allowing you to handle diverse data types beyond simple continuous variables.

Introduction to Seaborn Regression Plots

Regression plots are fundamental tools in exploratory data analysis, allowing you to visualize the relationship between two variables while simultaneously fitting a regression model. Seaborn provides two primary functions: regplot() and lmplot(). Understanding when to use each is crucial for efficient data visualization.

Use regplot() when you need a single regression plot with maximum control over the axes object. It’s perfect for integrating into existing matplotlib figures or creating custom subplot layouts. Choose lmplot() when you want to create multiple regression plots faceted by categorical variables. While lmplot() is built on top of regplot(), it returns a FacetGrid object rather than an axes object, making it less flexible for complex figure compositions but excellent for comparative analysis across groups.

The key difference: regplot() accepts data in various formats (arrays, series, or DataFrame columns), while lmplot() requires a DataFrame and uses column names for plotting. This makes lmplot() more convenient for grouped data but less flexible for custom data structures.

Basic Regression Plot Setup

First, ensure you have Seaborn installed. If not, install it using pip:

pip install seaborn pandas matplotlib

Here’s a basic regression plot using the built-in tips dataset:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Load sample dataset
tips = sns.load_dataset('tips')

# Create basic regression plot
plt.figure(figsize=(10, 6))
sns.regplot(x='total_bill', y='tip', data=tips)
plt.title('Relationship Between Total Bill and Tip Amount')
plt.xlabel('Total Bill ($)')
plt.ylabel('Tip ($)')
plt.tight_layout()
plt.show()

This creates a scatter plot with a fitted linear regression line and a 95% confidence interval shaded around it. The confidence interval shows the uncertainty in the regression estimate, widening where data is sparse.

Customizing the Regression Line

The regression line’s appearance and behavior can be extensively customized. The ci parameter controls the confidence interval size, while order enables polynomial regression for non-linear relationships.

# Create figure with multiple subplots
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Linear regression with no confidence interval
sns.regplot(x='total_bill', y='tip', data=tips, ci=None, 
            line_kws={'color': 'red', 'linewidth': 2}, ax=axes[0, 0])
axes[0, 0].set_title('No Confidence Interval')

# Linear regression with 99% confidence interval
sns.regplot(x='total_bill', y='tip', data=tips, ci=99, ax=axes[0, 1])
axes[0, 1].set_title('99% Confidence Interval')

# Second-order polynomial regression
sns.regplot(x='total_bill', y='tip', data=tips, order=2, 
            line_kws={'color': 'green'}, ax=axes[1, 0])
axes[1, 0].set_title('Polynomial Regression (order=2)')

# Third-order polynomial regression
sns.regplot(x='total_bill', y='tip', data=tips, order=3, 
            line_kws={'color': 'purple', 'linestyle': '--'}, ax=axes[1, 1])
axes[1, 1].set_title('Polynomial Regression (order=3)')

plt.tight_layout()
plt.show()

The line_kws parameter accepts any matplotlib line properties, giving you complete control over line color, width, style, and transparency. Be cautious with high-order polynomials—they can overfit and create misleading visualizations. Generally, stick to order 2 or 3 unless you have strong theoretical reasons for higher-order terms.

Scatter Plot Customization

The underlying scatter points can be customized using the scatter_kws parameter, which accepts matplotlib scatter plot arguments:

plt.figure(figsize=(12, 6))

# Customized scatter points
sns.regplot(x='total_bill', y='tip', data=tips,
            scatter_kws={'alpha': 0.5, 's': 80, 'color': 'darkblue', 
                        'edgecolor': 'black', 'linewidth': 0.5},
            line_kws={'color': 'red', 'linewidth': 2.5})

plt.title('Customized Regression Plot', fontsize=14, fontweight='bold')
plt.xlabel('Total Bill ($)', fontsize=12)
plt.ylabel('Tip ($)', fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

The alpha parameter is particularly useful for dense datasets, as it reveals overlapping points. The s parameter controls point size, while edgecolor and linewidth add borders to points, improving visibility against the regression line.

Working with Different Data Types

Regression plots aren’t limited to continuous variables. Seaborn provides tools for handling discrete and categorical data through x_jitter, x_estimator, and x_bins.

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

# Discrete data with jitter
sns.regplot(x='size', y='total_bill', data=tips, 
            x_jitter=0.2, ax=axes[0])
axes[0].set_title('Discrete X with Jitter')
axes[0].set_xlabel('Party Size')

# Using x_estimator to show mean at each x value
sns.regplot(x='size', y='total_bill', data=tips, 
            x_estimator=np.mean, ax=axes[1])
axes[1].set_title('Using x_estimator (mean)')
axes[1].set_xlabel('Party Size')

# Binning continuous data
sns.regplot(x='total_bill', y='tip', data=tips, 
            x_bins=10, ax=axes[2])
axes[2].set_title('Binned Continuous Data')
axes[2].set_xlabel('Total Bill ($)')

plt.tight_layout()
plt.show()

The x_jitter parameter adds random noise to x-values, preventing overplotting when you have discrete or categorical variables. The x_estimator parameter aggregates y-values at each unique x-value using a specified function (mean, median, etc.), showing central tendency rather than individual points. This is invaluable when you have multiple observations at discrete x-values.

Multiple Regression Plots with lmplot()

When you need to compare relationships across categories, lmplot() shines. It creates a FacetGrid that automatically handles subplot creation and legend management:

# Single plot with hue for categories
sns.lmplot(x='total_bill', y='tip', hue='time', data=tips, 
           height=6, aspect=1.5, palette='Set1',
           scatter_kws={'alpha': 0.6, 's': 60})
plt.title('Tips by Time of Day')
plt.tight_layout()
plt.show()

# Faceted plots by columns
sns.lmplot(x='total_bill', y='tip', col='time', row='smoker', 
           data=tips, height=4, aspect=1.2,
           scatter_kws={'alpha': 0.5})
plt.tight_layout()
plt.show()

# Using hue with custom markers
sns.lmplot(x='total_bill', y='tip', hue='smoker', data=tips,
           markers=['o', 's'], palette='muted',
           height=6, aspect=1.5,
           scatter_kws={'s': 70, 'alpha': 0.7})
plt.tight_layout()
plt.show()

The hue parameter colors points and regression lines by category while keeping them on the same plot. The col and row parameters create separate subplots for each category level. The height and aspect parameters control figure dimensions—height sets the height of each facet in inches, while aspect is the ratio of width to height.

Practical Applications and Best Practices

Regression plots excel at revealing relationships, but they can mislead if used improperly. Here’s a complete real-world example demonstrating best practices:

import numpy as np

# Load and prepare data
diamonds = sns.load_dataset('diamonds')
# Sample for performance (full dataset is large)
diamonds_sample = diamonds.sample(n=1000, random_state=42)

# Create figure with multiple analyses
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# 1. Basic relationship with appropriate transformation
sns.regplot(x='carat', y='price', data=diamonds_sample, 
            scatter_kws={'alpha': 0.3, 's': 30}, ax=axes[0, 0])
axes[0, 0].set_title('Price vs Carat (Linear Scale)')
axes[0, 0].set_ylabel('Price ($)')

# 2. Log transformation for better fit
sns.regplot(x='carat', y='price', data=diamonds_sample,
            scatter_kws={'alpha': 0.3, 's': 30}, ax=axes[0, 1])
axes[0, 1].set_yscale('log')
axes[0, 1].set_title('Price vs Carat (Log Scale)')
axes[0, 1].set_ylabel('Price ($, log scale)')

# 3. Polynomial fit for non-linear relationship
sns.regplot(x='carat', y='price', data=diamonds_sample, order=2,
            scatter_kws={'alpha': 0.3, 's': 30, 'color': 'darkgreen'},
            line_kws={'color': 'red', 'linewidth': 2}, ax=axes[1, 0])
axes[1, 0].set_title('Polynomial Fit (order=2)')
axes[1, 0].set_ylabel('Price ($)')

# 4. Robust regression (less sensitive to outliers)
sns.regplot(x='carat', y='price', data=diamonds_sample, 
            robust=True, scatter_kws={'alpha': 0.3, 's': 30},
            line_kws={'color': 'purple'}, ax=axes[1, 1])
axes[1, 1].set_title('Robust Regression')
axes[1, 1].set_ylabel('Price ($)')

plt.tight_layout()
plt.show()

Key best practices:

Always examine residuals: A good regression plot should show randomly scattered points around the line. Patterns in residuals indicate model inadequacy.
Consider transformations: If your relationship is exponential or power-law, use log scales or transform your data before plotting.
Use robust regression for outliers: Set robust=True to use robust regression that’s less sensitive to outliers.
Don’t extrapolate blindly: The regression line extends beyond your data range, but predictions there are unreliable.
Sample large datasets: For datasets with millions of points, sample or use x_bins to avoid overplotting and improve performance.
Match plot type to question: Use regplot() for detailed single-variable analysis and lmplot() for comparing relationships across groups.

Regression plots are powerful tools for exploratory analysis, but remember they show correlation, not causation. Use them to generate hypotheses and identify patterns, then follow up with appropriate statistical tests and domain expertise to draw meaningful conclusions.