Mastering Donut Plot Data Visualization with Python: An AI/ML Expert‘s Guide

Donut plots, also known as ring charts or pie charts with a hole, are a visually engaging and informative way to represent proportions and compositions of categorical data. As artificial intelligence (AI) and machine learning (ML) continue to revolutionize data analysis, understanding how to effectively visualize results is a critical skill for practitioners. In this comprehensive guide, we‘ll dive deep into donut plot visualization using Python, with a focus on applications in AI and ML.

Why Donut Plots Matter in AI and ML

Effective data visualization is crucial in AI and ML projects for several reasons:

1. Communicating results: Donut plots provide a clear and intuitive way to present the proportions of different categories, making it easier to communicate insights to stakeholders and decision-makers.

2. Identifying patterns and anomalies: By visualizing data in a donut plot, AI/ML practitioners can quickly spot patterns, outliers, or imbalances that may require further investigation or data preprocessing.

3. Evaluating model performance: Donut plots can be used to visualize performance metrics for classification models, such as the distribution of predicted classes or the proportion of correct predictions for each class.

4. Analyzing feature importance: In feature selection or model interpretability, donut plots can illustrate the relative importance or contribution of different features to the model‘s predictions.

Implementing Donut Plots in Python

Python, with its rich ecosystem of data visualization libraries, provides a seamless way to create donut plots. The most popular library for this purpose is Matplotlib. Let‘s walk through the steps to create a donut plot using Matplotlib.

Step 1: Importing the necessary libraries

import matplotlib.pyplot as plt
import numpy as np

Step 2: Preparing the data

Suppose we have a dataset representing the customer segments of an e-commerce company:

data = {
    ‘Young Professionals‘: 4500,
    ‘College Students‘: 2500,
    ‘Retirees‘: 1500,
    ‘Working Parents‘: 3000
}

Step 3: Creating the donut plot

categories = list(data.keys())
sizes = list(data.values())

fig, ax = plt.subplots(figsize=(8, 8))
ax.pie(sizes, labels=categories, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85)

# Creating the donut hole
center_circle = plt.Circle((0, 0), 0.70, fc=‘white‘)
fig = plt.gcf()
fig.gca().add_artist(center_circle)

ax.axis(‘equal‘)
plt.tight_layout()
plt.show()

In this code snippet:

• We extract the category names and sizes from the data dictionary.
• We create a new figure and axes using plt.subplots() and set the figure size.
• We call ax.pie() to create the donut plot, specifying the sizes, labels, percentage format (autopct), starting angle, and the distance of the percentage labels from the center (pctdistance).
• To create the donut hole, we use plt.Circle() to draw a white circle at the center and add it to the plot using fig.gca().add_artist().
• We ensure the plot is circular with ax.axis(‘equal‘) and adjust the layout with plt.tight_layout().

Step 4: Customizing the donut plot

Matplotlib offers a wide range of customization options to enhance the appearance and readability of donut plots. Here are a few examples:

1. Exploding slices: To emphasize specific categories, you can slightly separate their slices from the donut using the explode parameter.

explode = [0.1, 0, 0, 0]  # Explode the first slice (Young Professionals)
ax.pie(sizes, labels=categories, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85, explode=explode)

2. Custom colors: You can assign specific colors to each category using the colors parameter.

colors = [‘#ff9999‘, ‘#66b3ff‘, ‘#99ff99‘, ‘#ffcc99‘]
ax.pie(sizes, labels=categories, colors=colors, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85)

3. Adding a title and legend: Provide context and improve readability by adding a title and legend to the plot.

ax.set_title("Customer Segments")
ax.legend(labels=categories, loc=‘best‘)

4. Displaying actual values: If preferred, you can show the actual values instead of percentages on the donut slices by creating a custom autopct function.

def make_autopct(sizes):
    def my_autopct(pct):
        total = sum(sizes)
        val = int(round(pct*total/100.0))
        return ‘{v:d}‘.format(v=val)
    return my_autopct

ax.pie(sizes, labels=categories, autopct=make_autopct(sizes), startangle=90, pctdistance=0.85)

Advanced Donut Plot Techniques

Beyond the basic implementation, there are advanced techniques to enhance donut plots and adapt them to specific AI/ML use cases:

1. Sub-level categories: You can create a multi-level donut plot to represent hierarchical data by plotting concentric rings, each representing a level of the hierarchy.

2. Non-circular shapes: While donut plots are typically circular, you can experiment with other shapes like squares or polygons to create visually distinct plots.

3. Combining with other plot types: Donut plots can be combined with other visualizations, such as bar charts or line plots, to provide additional context or show trends over time.

Accessibility Considerations

When creating donut plots, it‘s important to consider accessibility for users with visual impairments. Here are some best practices:

1. Color choice: Ensure sufficient contrast between the colors used for different categories. Use color palettes that are distinguishable by people with color blindness.

2. Label readability: Make sure the labels and percentages are clearly visible and readable. Use an appropriate font size and style.

3. Alternative text: Provide alternative text descriptions for donut plots when used in web-based or exported formats to ensure accessibility for screen reader users.

Real-World Examples in AI and ML

Donut plots find numerous applications in AI and ML projects. Here are a few examples:

1. Classification model evaluation: Visualize the distribution of predicted classes versus actual classes to assess the performance of a classification model.

import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

# Assuming y_true and y_pred are the true and predicted class labels
cm = confusion_matrix(y_true, y_pred)
class_labels = [‘Class A‘, ‘Class B‘, ‘Class C‘]

fig, ax = plt.subplots(figsize=(8, 8))
ax.pie(cm.flatten(), labels=class_labels, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85)

center_circle = plt.Circle((0, 0), 0.70, fc=‘white‘)
fig = plt.gcf()
fig.gca().add_artist(center_circle)

ax.axis(‘equal‘)
ax.set_title("Classification Model Evaluation")
plt.tight_layout()
plt.show()

2. Feature importance visualization: Illustrate the relative importance of features in a machine learning model using a donut plot.

import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier

# Assuming X is the feature matrix and y is the target variable
model = RandomForestClassifier()
model.fit(X, y)

importances = model.feature_importances_
feature_labels = [‘Feature 1‘, ‘Feature 2‘, ‘Feature 3‘, ‘Feature 4‘]

fig, ax = plt.subplots(figsize=(8, 8))
ax.pie(importances, labels=feature_labels, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85)

center_circle = plt.Circle((0, 0), 0.70, fc=‘white‘)
fig = plt.gcf()
fig.gca().add_artist(center_circle)

ax.axis(‘equal‘)
ax.set_title("Feature Importance")
plt.tight_layout()
plt.show()

3. Customer segmentation: Analyze the composition of customer segments based on demographic or behavioral attributes.

import matplotlib.pyplot as plt

data = {
    ‘Young Professionals‘: 4500,
    ‘College Students‘: 2500,
    ‘Retirees‘: 1500,
    ‘Working Parents‘: 3000
}

categories = list(data.keys())
sizes = list(data.values())

fig, ax = plt.subplots(figsize=(8, 8))
ax.pie(sizes, labels=categories, autopct=‘%1.1f%%‘, startangle=90, pctdistance=0.85)

center_circle = plt.Circle((0, 0), 0.70, fc=‘white‘)
fig = plt.gcf()
fig.gca().add_artist(center_circle)

ax.axis(‘equal‘)
ax.set_title("Customer Segments")
plt.tight_layout()
plt.show()

Conclusion

Donut plots are a powerful and visually appealing tool for representing proportions and compositions of categorical data in AI and ML projects. By leveraging Python‘s Matplotlib library, you can easily create and customize donut plots to effectively communicate insights, evaluate model performance, and analyze feature importance.

When creating donut plots, consider best practices such as choosing appropriate colors, ensuring label readability, and providing alternative text for accessibility. Additionally, explore advanced techniques like sub-level categories, non-circular shapes, and combining donut plots with other visualizations to create more comprehensive and informative representations of your data.

By mastering donut plot visualization in Python, you can enhance your data storytelling skills and effectively communicate complex AI and ML concepts to both technical and non-technical audiences. Embrace the power of donut plots in your projects and unlock new insights from your data!