Seaborn Plot Overview

1. List various seaborn plots and describe any two in detail.

Seaborn provides various types of plots for data visualization. Some of the key plots are:

1. Scatter Plot (`scatterplot`)

2. Line Plot (`lineplot`)
3. Bar Plot (`barplot`)
4. Histogram (`histplot`)
5. Box Plot (`boxplot`)
6. Violin Plot (`violinplot`)
7. Pair Plot (`pairplot`)
8. Heatmap (`heatmap`)
9. Joint Plot (`jointplot`)
10. Strip Plot (`stripplot`)

Detailed Explanation of Two Plots:

1. Box Plot (`boxplot`)

A Box Plot (also called a box-and-whisker plot) is used to display the distribution of a dataset based on
five summary statistics:

Minimum
First Quartile (Q1)
Median (Q2)
Third Quartile (Q3)
Maximum

It helps in identifying outliers and understanding the spread and skewness of the data.
Example Code:

python

import seaborn as sns

import matplotlib.pyplot as plt

# Sample Data
data = sns.load_dataset("tips")

# Boxplot
sns.boxplot(x="day", y="total_bill", data=data)
plt.show()

This plot shows the distribution of `total_bill` across different days in the `tips` dataset.

2. Heatmap (`heatmap`)

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 1/32
A Heatmap is a graphical representation of data using colors to indicate values. It is commonly used to
visualize correlation matrices or missing values in a dataset.
Example Code:

python

import seaborn as sns

import matplotlib.pyplot as plt

# Sample Data
data = sns.load_dataset("flights").pivot("month", "year", "passengers")

# Heatmap
sns.heatmap(data, annot=True, cmap="coolwarm", fmt="d")
plt.show()

This heatmap displays passenger traffic over different years and months, with colors representing the
number of passengers.
Would you like examples of any other plots? 🚀

2. Explain how the hue, style, dashes, and marker parameters can be customized in a relational
line chart. Provide examples with Python code

Customizing `hue`, `style`, `dashes`, and `marker` in a Seaborn Relational Line Chart

Seaborn's `lineplot()` allows various customizations using parameters like hue, style, dashes, and
marker, which enhance visualization and make it easier to differentiate data categories.

1. `hue` Parameter

Used to differentiate data categories by color.

Each unique value in the specified column gets a different color.

2. `style` Parameter

Differentiates data categories by varying line styles or marker styles.

Works well with `hue` to add additional distinction.

3. `dashes` Parameter

Controls the dash pattern for lines.

Can be set to `True` (default, varies by category) or `False` (solid lines).
Can also take a dictionary specifying custom dash styles.

4. `marker` Parameter

Adds markers to data points in the line plot.

Can be customized using a dictionary or predefined marker styles.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 2/32
Example: Customizing `hue`, `style`, `dashes`, and `marker` in a Line Chart

python

import seaborn as sns

import matplotlib.pyplot as plt

# Sample Data
import pandas as pd
data = pd.DataFrame({
"day": list(range(1, 8)) * 2,
"sales": [10, 15, 20, 25, 30, 35, 40, 12, 18, 22, 28, 32, 38, 45],
"category": ["Product A"] * 7 + ["Product B"] * 7
})

# Creating the Line Plot with Customization

sns.lineplot(
data=data,
x="day",
y="sales",
hue="category", # Different colors for each category
style="category", # Different line styles for each category
dashes={"Product A": (2, 2), "Product B": ""}, # Custom dash patterns
markers=["o", "s"], # Custom markers for categories
markersize=8 # Size of markers
)

# Show the plot

plt.title("Sales Trend of Products Over a Week")
plt.xlabel("Day")
plt.ylabel("Sales")
plt.legend(title="Category")
plt.show()

Explanation of Customizations:

`hue="category"` → Product A and Product B are differentiated by color.

`style="category"` → Product A and B get different line styles.
`dashes={"Product A": (2,2), "Product B": ""}` → Product A has a dashed line, while Product B
has a solid line.
`markers=["o", "s"]` → Product A has circle (`o`) markers, Product B has square (`s`) markers.
`markersize=8` → Increases the size of markers for better visibility.

Output

This plot will display two product sales trends over a week, each with unique colors, markers, and line
styles.
Would you like further modifications or another example? 🚀

3. Discuss the impact of linewidth and palette on the aesthetics of a line chart. How can these
parameters be used effectively?

Impact of `linewidth` and `palette` on Line Chart Aesthetics

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 3/32
Seaborn provides several customization options to enhance the aesthetics of a line chart, including
`linewidth` and `palette`. These parameters play a crucial role in improving readability and visual
appeal.

1. `linewidth` (Thickness of the Line)

Impact:
A thicker line makes trends more prominent and easier to follow, especially when multiple
lines overlap.
A thinner line can be useful when displaying many categories to avoid clutter.
Using different line widths for emphasis can highlight important trends.
Effective Usage:
Use thicker lines for key trends and thinner lines for secondary trends.
Adjust line thickness based on the density of the data points.

2. `palette` (Color Scheme for Multiple Categories)

Impact:
The color scheme affects how distinct different lines appear in a multi-category plot.
A good palette improves data comprehension and avoids confusion.
Poor color choices (e.g., using too many similar shades) can reduce clarity.
Effective Usage:
Use contrasting colors when dealing with multiple categories.
Use sequential palettes for continuous data and categorical palettes for distinct groups.
Ensure colors are colorblind-friendly for accessibility.

Example: Customizing `linewidth` and `palette` in a Line Chart

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"day": list(range(1, 8)) * 2,
"sales": [10, 15, 20, 25, 30, 35, 40, 12, 18, 22, 28, 32, 38, 45],
"category": ["Product A"] * 7 + ["Product B"] * 7
})

# Customizing Line Plot with Linewidth & Palette

sns.lineplot(
data=data,
x="day",
y="sales",
hue="category", # Different colors for each category
linewidth=3, # Set the line thickness
palette="coolwarm" # Custom color palette
)

# Titles and Labels

plt.title("Sales Trend of Products Over a Week", fontsize=14)
plt.xlabel("Day", fontsize=12)
plt.ylabel("Sales", fontsize=12)

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 4/32
 plt.legend(title="Category")

# Show the plot

plt.show()

How `linewidth` and `palette` Improve the Chart

✔ → Makes the lines bold and easy to distinguish.

✔
`linewidth=3`
→ Uses a color gradient for better distinction.
✔ Enhanced Readability → The chart is clearer, making trends easy to interpret.
`palette="coolwarm"`

Would you like to see an example with multiple line widths? 🚀

4. Compare estimator=None vs. estimator=mean in relational line charts. How does this affect
data representation?

Comparison: `estimator=None` vs. `estimator=mean` in Relational Line Charts

In Seaborn's `lineplot()`, the `estimator` parameter determines how multiple values for the same `x`
coordinate are aggregated.

1. `estimator=None`

Effect:
Displays raw data points without aggregation.
Multiple data points for the same `x` value are plotted individually.
Useful when you want to visualize all observations without averaging.
Best Used When:
You need to show every individual data point.
The dataset is small or has limited variations in `y` values.

2. `estimator=mean` (Default)

Effect:
Aggregates `y` values for each `x` and plots their mean.
Reduces clutter and smooths fluctuations.
Seaborn also shows confidence intervals (by default, a 95% confidence interval is plotted).
Best Used When:
You want a simplified trend rather than individual data points.
The dataset has multiple observations per `x` value, and an average is more meaningful.

Example: `estimator=None` vs. `estimator=mean`

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 5/32
 python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Generating Sample Data

np.random.seed(42)
data = pd.DataFrame({
"day": np.tile(np.arange(1, 8), 5), # Repeat days 5 times
"sales": np.random.randint(10, 50, 35), # Random sales values
"category": np.repeat(["Product A", "Product B"], 35 // 2) # Two categories
})

# Creating Subplots for Comparison

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Plot with estimator=None (Raw Data Points)

sns.lineplot(data=data, x="day", y="sales", hue="category", estimator=None, ax=axes[0])
axes[0].set_title("estimator=None (Raw Data)")

# Plot with estimator=mean (Aggregated Data)

sns.lineplot(data=data, x="day", y="sales", hue="category", estimator="mean", ax=axes[1])
axes[1].set_title("estimator=mean (Averaged Data)")

plt.show()

Key Observations:

Parameter Behavior
`estimator=None` Plots all raw data points. Lines may look jagged due to variations.

`estimator=mean` Averages values at each `x` point. Produces a smoother trend line.

✅ Use when you want to see every data point and detect outliers.
✅ Use
`estimator=None`
`estimator=mean` when you want a clear trend line without excessive fluctuations.

Would you like an example with another `estimator` like `median`? 🚀

5. What is the function of errorbar=sd in a line chart? How does it help in visualizing data
uncertainty? Provide an example.

Function of `errorbar="sd"` in a Line Chart

The `errorbar` parameter in Seaborn's `lineplot()` controls the display of error bars, which represent
the variability or uncertainty in the data.

When `errorbar="sd"` is used:

It displays the standard deviation (SD) around the mean for each `x` value.
The shaded region around the line represents how much the data varies at each `x` point.
A wider shaded area indicates higher variability (more uncertainty).
A narrower shaded area means more consistency in the data.

Example: Using `errorbar="sd"` to Visualize Data Uncertainty

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 6/32
 python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Generating Sample Data

np.random.seed(42)
data = pd.DataFrame({
"day": np.tile(np.arange(1, 8), 5), # Repeat days 5 times
"sales": np.random.randint(10, 50, 35), # Random sales values
"category": np.repeat(["Product A", "Product B"], 35 // 2) # Two categories
}) [18, 17]
# Creating the Line Plot with error bars (standard deviation)
sns.lineplot(
data=data,
x="day",
y="sales",
hue="category",
errorbar="sd" # Show standard deviation as error bars
)

# Titles and Labels

plt.title("Sales Trend with Standard Deviation Error Bars")
plt.xlabel("Day")
plt.ylabel("Sales")
plt.legend(title="Category")

# Show the plot

plt.show()

How `errorbar="sd"` Helps in Data Visualization

✅ Shows Variability → The shaded region helps identify fluctuations in sales.

✅ Indicates Data Uncertainty → A wider region means more variation; a narrower region means
more consistency.
✅ Enhances Interpretation → Helps decide whether observed trends are reliable or if there's high
variation.

Comparison with Other Error Bars

`errorbar` Option Meaning

`"sd"` Shows standard deviation (spread of data).

`"se"` Shows standard error (uncertainty in mean estimation).

`None` No error bars displayed.

Would you like an example comparing `"sd"` vs `"se"`? 🚀

6. Describe the role of col, row, and sort in structuring relational line charts. How do these
parameters improve visualization?

Role of `col`, `row`, and `sort` in Structuring Relational Line Charts

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 7/32
Seaborn's `relplot()` function allows advanced structuring of relational plots using `col`, `row`, and
`sort` parameters. These parameters help organize and display complex datasets more effectively.

1. `col` (Column-Wise Subplots)

Function: Splits the dataset into multiple plots arranged in columns based on a categorical
variable.
Use Case: Useful for comparing trends across categories side by side.
Example: If sales data is available for multiple regions, using `col="region"` creates a separate
column for each region.

2. `row` (Row-Wise Subplots)

Function: Creates row-wise subplots, where each row represents a different category.
Use Case: Ideal when there are too many categories for a column-wise arrangement.
Example: If a dataset contains monthly sales data for different products, `row="product"`
separates each product’s trend into its own row.

3. `sort` (Sorting X-Axis Values)

Function: Determines whether x-axis values should be sorted before plotting.
Use Case: Ensures correct order of data points, preventing incorrect trend representation.
Example: If dates in a time-series dataset are unordered, using `sort=True` ensures proper
sequential plotting.

Example: Using `col`, `row`, and `sort` in a Relational Line Chart

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Generating Sample Data

np.random.seed(42)
data = pd.DataFrame({
"day": np.tile(np.arange(1, 8), 6), # 7 Days repeated for each category
"sales": np.random.randint(10, 50, 42), # Random sales values
"region": np.repeat(["North", "South"], 21), # Two regions
"category": np.tile(["Electronics", "Clothing", "Groceries"], 14) # Three categories
})

# Relational Line Plot with col, row, and sort

sns.relplot(
data=data,
x="day",
y="sales",
hue="category", # Different colors for categories
col="region", # Separate plots for each region (Column-wise)
row="category", # Separate plots for each product category (Row-wise)
kind="line",
sort=True # Ensure x-values are sorted correctly
)

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 8/32
 plt.show()

How These Parameters Improve Visualization

Parameter Effect
`col` Makes comparisons between categories clearer by arranging them in separate columns.

`row` Helps avoid overcrowding by displaying categories in separate rows.

`sort` Ensures data points are plotted in the correct order, avoiding misleading trends.

✅ & `row` → Useful for categorical breakdowns of trends.

✅
`col`
`sort=True` → Ensures chronological correctness for time-series data.

Would you like an example with a different dataset, such as stock prices or weather trends? 🚀

simple and easy example get me becuse i write the example in exam

Here’s a simple and easy example that you can write in your exam to explain `col`, `row`, and `sort`
in relational line charts.

Example: Using `col`, `row`, and `sort` in a Line Chart

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Creating a small dataset

data = pd.DataFrame({
"day": [1, 2, 3, 1, 2, 3, 1, 2, 3],
"sales": [10, 15, 20, 8, 12, 18, 5, 10, 15],
"region": ["North", "North", "North", "South", "South", "South", "East", "East", "East"],
"category": ["A", "A", "A", "B", "B", "B", "C", "C", "C"]
})

# Plotting a relational line chart

sns.relplot(
data=data,
x="day",
y="sales",
hue="category", # Different colors for categories
col="region", # Separate plots for each region (Column-wise)
kind="line",
sort=True # Ensure x-values are sorted correctly
)

plt.show()

How This Example Works

`col="region"` → Creates separate plots for North, South, and East regions.
`hue="category"` → Uses different colors for categories A, B, and C.
Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 9/32
 `sort=True` → Ensures the `day` values are plotted in the correct order.

✅ Simple to understand
✅ Easy to write in exams
✅ Clearly shows the effect of `col` and `sort`

Would you like me to simplify it even more? 🚀

7. How do hue, col, row, style, and marker enhance the readability of a relational scatter chart?
Provide Python examples.

How `hue`, `col`, `row`, `style`, and `marker` Enhance Readability in a Relational
Scatter Chart

Seaborn’s `scatterplot()` and `relplot(kind="scatter")` allow customization with hue, col, row, style,
and marker, improving data clarity and readability.

Parameter Function Effect

`hue` Changes color based on a category. Helps distinguish groups.

`col` Creates subplots in columns. Separates categories visually.

`row` Creates subplots in rows. Avoids clutter for multiple categories.

`style` Changes shape of markers. Differentiates categories without colors.

`marker` Customizes marker symbols. Makes data points more visible.

Example: Scatter Plot with `hue`, `col`, `row`, `style`, and `marker`

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Creating a small dataset

data = pd.DataFrame({
"sales": [100, 200, 150, 180, 300, 250, 400, 350, 500],
"profit": [20, 40, 30, 35, 60, 50, 80, 70, 100],
"region": ["North", "North", "North", "South", "South", "South", "East", "East", "East"],
"category": ["Electronics", "Clothing", "Groceries", "Electronics", "Clothing", "Groceries", "El
})

# Scatter plot using relplot

sns.relplot(
data=data,
x="sales",
y="profit",
hue="category", # Different colors for each category
col="region", # Separate plots for each region (Column-wise)
style="category", # Different marker styles for each category
kind="scatter"
)

plt.show()

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 10/32
How These Parameters Improve Readability

✅ → Colors differentiate Electronics, Clothing, and Groceries.

✅
`hue="category"`
→ Creates separate scatter plots for North, South, and East.
✅
`col="region"`
→ Uses different marker shapes for better visibility.
✅ Prevents clutter → Easier to analyze data trends per region.
`style="category"`

Want a simpler version for your exam?

Let me know! 🚀

simple ans sort exaple

How `hue`, `col`, `row`, `style`, and `marker` Improve Readability in a Scatter Chart

Parameter Function
`hue` Uses different colors for categories.

`col` Creates separate plots in columns for each category.

`row` Creates separate plots in rows for each category.

`style` Changes marker style based on category.

`marker` Customizes marker shapes for better visibility.

Simple Example:

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample data
data = pd.DataFrame({
"sales": [100, 200, 300, 150, 250, 350],
"profit": [20, 40, 60, 30, 50, 70],
"region": ["North", "North", "South", "South", "East", "East"],
"category": ["A", "B", "A", "B", "A", "B"]
})

# Scatter plot
sns.relplot(
data=data,
x="sales",
y="profit",
hue="category", # Different colors
col="region", # Separate plots for each region
style="category", # Different marker styles
kind="scatter"
)

plt.show()

Why This Example is Useful?

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 11/32
✅ Simple to understand
✅ Easy to write in an exam
✅ Clearly shows the effect of `hue`, `col`, and `style`
Let me know if you need an even shorter version! 🚀

8. What is the significance of size and sizes in a scatter plot? How can varying marker sizes convey
additional information?
9. Describe different ways to visualize distributions using plots such as histograms, KDE plots, and
box plots. Provide examples.

8. Significance of `size` and `sizes` in a Scatter Plot

In Seaborn, the `size` and `sizes` parameters help represent additional numerical information by
varying the marker sizes in a scatter plot.

Parameter Function
`size` Changes marker size based on a numerical column.
`sizes` Defines the range (min & max) of marker sizes.

Example: Using `size` and `sizes` in a Scatter Plot

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"sales": [100, 200, 300, 400, 500],
"profit": [20, 40, 60, 80, 100],
"customers": [10, 50, 80, 30, 90] # Number of customers
})

# Scatter plot with size variation

sns.scatterplot(
data=data,
x="sales",
y="profit",
size="customers", # Marker size represents customers
sizes=(20, 200), # Min & max marker sizes
legend=True
)

plt.show()

How Varying Marker Sizes Convey Information?

✅ Larger markers = Higher values (e.g., more customers).

✅ Smaller markers = Lower values (e.g., fewer customers).
✅ Helps compare data points easily.
9. Ways to Visualize Distributions
Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 12/32
There are several ways to visualize data distributions:

Plot Type Function

Histogram Shows data distribution using bars.

KDE (Kernel Density Estimation) Plot Smooth curve representing the distribution.
Box Plot Shows median, quartiles, and outliers.

Example: Histogram, KDE Plot, and Box Plot

python

import seaborn as sns

import matplotlib.pyplot as plt

# Sample Data
data = [10, 20, 20, 30, 30, 30, 40, 50, 60, 70, 80]

# Histogram
sns.histplot(data, bins=5, kde=True) # kde=True adds a KDE curve
plt.show()

# KDE Plot
sns.kdeplot(data, shade=True)
plt.show()

# Box Plot
sns.boxplot(y=data)
plt.show()

Comparison of Plots

✅ Histogram → Best for showing frequency.

✅ KDE Plot → Best for smooth distribution curves.
✅ Box Plot → Best for identifying outliers and median values.
Would you like a simpler version for your exam? 🚀

10. Explain how regression plots are used for predictive analysis. What are the key parameters that
influence regression visualization?
11. Discuss the different types of categorical plots available in Seaborn. How do they help in
understanding categorical data?

10. Regression Plots for Predictive Analysis

Regression plots in Seaborn (`sns.regplot()`, `sns.lmplot()`) help visualize relationships between two
numerical variables and make predictions by fitting a regression line.

Key Parameters in Regression Visualization

Parameter Function
`ci` Confidence interval (default 95%).
`order` Polynomial order for non-linear trends.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 13/32
 Parameter Function
`scatter_kws` Customizes scatter points (e.g., size, color).
`line_kws` Customizes regression line (e.g., color, width).

Simple Example of a Regression Plot

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"experience": [1, 2, 3, 4, 5, 6, 7, 8],
"salary": [30, 35, 40, 50, 55, 60, 70, 80]
})

# Regression plot
sns.regplot(x="experience", y="salary", data=data, ci=90, line_kws={"color": "red"})
plt.show()

How Regression Plots Help in Prediction?

✅ Shows trends between variables.

✅ Helps forecast future values (e.g., salary prediction).
✅ Confidence intervals indicate reliability.
11. Types of Categorical Plots in Seaborn

Categorical plots analyze relationships where at least one variable is categorical.

Plot Type Function

Bar Plot (`sns.barplot`) Shows mean values with error bars.
Count Plot (`sns.countplot`) Counts occurrences of categories.
Box Plot (`sns.boxplot`) Shows distribution, median, and outliers.

Violin Plot (`sns.violinplot`) Combines box plot & KDE for distribution.
Strip Plot (`sns.stripplot`) Shows individual data points.

Simple Example: Comparing Bar, Count, and Box Plots

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"category": ["A", "A", "B", "B", "C", "C", "A", "B", "C"],
"sales": [10, 20, 15, 25, 30, 35, 12, 22, 28]
})

# Bar Plot (Mean Sales per Category)

sns.barplot(x="category", y="sales", data=data)
plt.show()

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 14/32
 # Count Plot (Frequency of Each Category)
sns.countplot(x="category", data=data)
plt.show()

# Box Plot (Distribution of Sales)

sns.boxplot(x="category", y="sales", data=data)
plt.show()

How Categorical Plots Help?

✅ Bar Plot → Compare category averages.

✅ Count Plot → See category distribution.
✅ Box Plot → Identify median, quartiles, and outliers.
Would you like a shorter version for exams? 🚀

12. How can multiple plots be combined in a single visualization using matplotlib and seaborn?
Provide examples.
13. Compare the use of facet grids (col and row) in both line and scatter plots. When should they be
used?

12. Combining Multiple Plots in a Single Visualization

Using Matplotlib and Seaborn, multiple plots can be combined using:

Method Description
`plt.subplot()` / `plt.subplots()` Create multiple plots in one figure.

`sns.FacetGrid()` Creates multiple plots for different categories.

`sns.pairplot()` Creates multiple scatter plots for numerical variables.

Example: Using `plt.subplots()` to Combine Multiple Plots

python

import matplotlib.pyplot as plt

import seaborn as sns
import pandas as pd

# Sample Data
data = pd.DataFrame({
"category": ["A", "A", "B", "B", "C", "C", "A", "B", "C"],
"sales": [10, 20, 15, 25, 30, 35, 12, 22, 28]
})

# Create a figure with 1 row, 2 columns

fig, axes = plt.subplots(1, 2, figsize=(10, 5))

# Bar Plot on the first subplot

sns.barplot(x="category", y="sales", data=data, ax=axes[0])
axes[0].set_title("Bar Plot")

# Box Plot on the second subplot

sns.boxplot(x="category", y="sales", data=data, ax=axes[1])
axes[1].set_title("Box Plot")

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 15/32
 plt.tight_layout()
plt.show()

✅ Why Use This?

Helps compare different plots in one figure.
Saves space and improves readability.

13. Comparing Facet Grids (`col` and `row`) in Line & Scatter Plots

Facet Grids allow plotting multiple subplots based on categorical variables.

Feature Line Plot Scatter Plot

Creates separate line charts for each Creates separate scatter plots for each
`col`
category. category.
`row` Stacks charts vertically. Stacks scatter plots for comparison.

When to
Comparing trends across categories. Comparing distributions across categories.
Use?

Example: Facet Grid in a Line Plot

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"month": [1, 2, 3, 1, 2, 3, 1, 2, 3],
"sales": [100, 200, 250, 90, 180, 240, 80, 170, 230],
"region": ["North", "North", "North", "South", "South", "South", "East", "East", "East"]
})

# Facet Grid for Line Plot

sns.relplot(data=data, x="month", y="sales", hue="region", col="region", kind="line")

plt.show()

Example: Facet Grid in a Scatter Plot

python

# Scatter Plot with Facet Grid

sns.relplot(data=data, x="month", y="sales", hue="region", col="region", kind="scatter")

plt.show()

✅ Why Use Facet Grids?

Line Plots: Compare trends across categories.
Scatter Plots: Compare data distribution across groups.
`col` vs. `row`: Helps structure data neatly for easy analysis.

Would you like a simpler version for quick writing in exams? 🚀

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 16/32
 14. Explain how orient affects visualization in line and scatter charts. When should it be used?
15. Write a Seaborn code to create a relational line plot using the fmri dataset, where:
timepoint is plotted on the x-axis and signal on the y-axis, the plot includes standard deviation (sd)
as an error bar.

14. Effect of `orient` in Line and Scatter Charts

The `orient` parameter in Seaborn controls whether the data is plotted horizontally (`h`) or vertically
(`v`).

When to Use `orient`?

Scenario Best Orient Value

Vertical Plot (default) Use when the x-axis is categorical.

Horizontal Plot (`orient="h"`) Use when the y-axis is categorical.

Example: Using `orient` in a Scatter Plot

python

import seaborn as sns

import matplotlib.pyplot as plt
import pandas as pd

# Sample Data
data = pd.DataFrame({
"category": ["A", "B", "C", "A", "B", "C"],
"value": [10, 20, 15, 25, 30, 35]
})

# Vertical Scatter Plot (Default)

sns.stripplot(x="category", y="value", data=data)
plt.title("Vertical Strip Plot")
plt.show()

# Horizontal Scatter Plot using orient="h"

sns.stripplot(x="value", y="category", data=data, orient="h")
plt.title("Horizontal Strip Plot")
plt.show()

✅ Why Use `orient`?

Improves readability when category labels are long.

Useful when comparing multiple distributions side by side.

15. Creating a Relational Line Plot using the `fmri` Dataset

Seaborn has a built-in `fmri` dataset, which tracks brain activity (signal) over time (timepoint).

Code to Plot `timepoint` vs `signal` with `sd` as an Error Bar

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 17/32
 python

import seaborn as sns

import matplotlib.pyplot as plt

# Load the fmri dataset

fmri = sns.load_dataset("fmri")

# Create a line plot with standard deviation as the error bar

sns.relplot(
data=fmri, x="timepoint", y="signal", kind="line", errorbar="sd"
)

plt.title("FMRI Signal over Time with Standard Deviation")

plt.show()

✅ How Does `errorbar="sd"` Help?

Shows variation in the data.

Helps understand data uncertainty.
Useful for scientific and statistical analysis.

Would you like me to simplify it further for quick exam writing? 🚀

Uploaded image
16. Write seaborn code for following graph: (ANS: sns.displot(tips, x="size", bins=[1, 2, 3, 4, 5, 6, 7]))
17. What does bins control in histplot()?

16. Seaborn Code for the Given Graph

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load the tips dataset

tips = sns.load_dataset("tips")

# Create the histogram

sns.displot(tips, x="size", bins=[1, 2, 3, 4, 5, 6, 7])

plt.show()

17. What Does `bins` Control in `histplot()`?

The `bins` parameter controls the number and range of bins used to group data in a histogram.
It defines how the data is divided into intervals for visualization.
Fewer bins → broader intervals (less detail).
More bins → narrower intervals (more detail).

Example: Different `bins` Values

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 18/32
 python

# Default bins
sns.histplot(tips, x="size")
plt.show()

# Custom bins (more detailed)

sns.histplot(tips, x="size", bins=10)
plt.show()

✅ Key Takeaway:
Using the right number of bins helps in better data interpretation without making the plot too noisy
or too simplified.

18. How does changing the bw_adjust parameter in kdeplot() affect the smoothness of the curve?
19. What happens when you add cumulative=True in ecdfplot()?

18. Effect of `bw_adjust` in `kdeplot()`

The `bw_adjust` (Bandwidth Adjustment) parameter in `sns.kdeplot()` controls the smoothness of the
KDE (Kernel Density Estimation) curve.

Impact of `bw_adjust` Values

Smaller `bw_adjust` (e.g., `bw_adjust=0.5`) → Less smoothing, more detailed curve (may appear
noisy).
Larger `bw_adjust` (e.g., `bw_adjust=2`) → More smoothing, less detail (curve is too generalized).

Example: Changing `bw_adjust` in `kdeplot()`

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load the tips dataset

tips = sns.load_dataset("tips")

# Plot KDE with different bw_adjust values

sns.kdeplot(tips["total_bill"], bw_adjust=0.5, label="bw_adjust=0.5")
sns.kdeplot(tips["total_bill"], bw_adjust=1, label="bw_adjust=1 (default)")
sns.kdeplot(tips["total_bill"], bw_adjust=2, label="bw_adjust=2")

plt.legend()
plt.title("Effect of bw_adjust on KDE Plot")
plt.show()

✅ Key Takeaway:
Low `bw_adjust` → More detailed but might be too wavy.
High `bw_adjust` → Smoother but may lose finer details.

19. Effect of `cumulative=True` in `ecdfplot()`

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 19/32
The `cumulative=True` parameter in `sns.ecdfplot()` converts the Empirical Cumulative Distribution
Function (ECDF) plot into a cumulative graph.

What Happens?

The plot shows the proportion of data points that are less than or equal to a given value.
Instead of a density curve, it gradually increases from 0 to 1.
Useful for understanding percentiles and data distribution.

Example: Using `cumulative=True` in `ecdfplot()`

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load the tips dataset

tips = sns.load_dataset("tips")

# ECDF plot with and without cumulative=True

sns.ecdfplot(tips["total_bill"], label="ECDF (default)")
sns.ecdfplot(tips["total_bill"], cumulative=True, label="Cumulative ECDF")

plt.legend()
plt.title("Effect of cumulative=True in ECDF Plot")
plt.show()

✅ Key Takeaway:
Without `cumulative=True` → Standard ECDF (shows individual points).
With `cumulative=True` → Displays increasing proportion, useful for percentiles.

Would you like a quick summary to remember for exams? 🚀

20. How can you overlay a kdeplot() on a histplot()?

21. What does the shade parameter do in kdeplot()? 22. How does marginal_kws modify the
marginal plots in jointplot()?
23. What effect does diag_kind="kde" have in pairplot()?

20. Overlaying `kdeplot()` on `histplot()`

To overlay a KDE plot on a histogram, use `sns.histplot()` with `kde=True` or use `sns.kdeplot()`
separately.

Example: Using `kde=True` in `histplot()`

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load dataset

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 20/32
 tips = sns.load_dataset("tips")

# Overlay KDE on Histogram

sns.histplot(tips["total_bill"], kde=True, bins=20)

plt.title("Histogram with KDE Overlay")

plt.show()

Example: Using `histplot()` and `kdeplot()` separately

python

sns.histplot(tips["total_bill"], bins=20, color="blue", alpha=0.5)

sns.kdeplot(tips["total_bill"], color="red", linewidth=2)

plt.title("Overlay KDE on Histogram")

plt.show()

✅ Key Takeaway:
`kde=True`inside `histplot()` is a quick way.
For more customization, use `kdeplot()` separately.

21. Effect of `shade` in `kdeplot()`

The `shade` parameter (before Seaborn v0.11) or `fill=True` (newer versions) fills the area under the
KDE curve.

Example: Using `fill=True` (newer versions)

python

sns.kdeplot(tips["total_bill"], fill=True, color="blue")

plt.title("KDE Plot with Shaded Area")
plt.show()

✅ Key Takeaway:
Before v0.11 → Use `shade=True`.
After v0.11 → Use `fill=True`.
It improves visibility and highlights density areas.

22. Effect of `marginal_kws` in `jointplot()`

The `marginal_kws` parameter customizes the marginal plots in `sns.jointplot()`. It modifies settings
like `color`, `bins`, or `fill`.

Example: Using `marginal_kws` in `jointplot()`

python

sns.jointplot(data=tips, x="total_bill", y="tip", kind="scatter",

marginal_kws={"bins": 30, "fill": True, "color": "blue"})

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 21/32
 plt.show()

✅ Key Takeaway:
`marginal_kws` customizes the histogram/KDE plots on the margins.
Useful for controlling appearance and details.

23. Effect of `diag_kind="kde"` in `pairplot()`

In `sns.pairplot()`, the `diag_kind="kde"` changes the diagonal plots to KDE plots instead of
histograms.

Example: Using `diag_kind="kde"`

python

sns.pairplot(tips, diag_kind="kde")
plt.show()

✅ Key Takeaway:
By default → Diagonal plots show histograms.
With `diag_kind="kde"` → Uses KDE plots for smoother distribution visualization.

Would you like a quick revision sheet for your exam? 📚🚀

24. How does kind="reg" in jointplot() change the visualization?

25. What does corner=True do in pairplot()?
26. How can you use rugplot() to add small tick marks below a KDE plot?

24. Effect of `kind="reg"` in `jointplot()`

When you set `kind="reg"` in `sns.jointplot()`, it adds a regression line to the scatter plot to show the
trend between two variables.

Example: Using `kind="reg"` in `jointplot()`

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load dataset
tips = sns.load_dataset("tips")

# Create a regression jointplot

sns.jointplot(data=tips, x="total_bill", y="tip", kind="reg")

plt.show()

✅ Key Takeaway:
Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 22/32
 Adds a regression line along with a confidence interval.
Useful for predictive analysis and understanding correlations.

25. Effect of `corner=True` in `pairplot()`

When `corner=True` in `sns.pairplot()`, it removes the upper diagonal plots, keeping only the lower
diagonal and diagonal plots.

Example: Using `corner=True` in `pairplot()`

python

sns.pairplot(tips, corner=True)
plt.show()

✅ Key Takeaway:
Reduces redundancy by removing duplicate scatter plots.
Useful for large datasets to improve clarity.

26. Using `rugplot()` with `kdeplot()`

A `rugplot()` adds small tick marks along the x-axis (or y-axis) to show individual data points.

Example: Overlaying `rugplot()` on `kdeplot()`

python

sns.kdeplot(tips["total_bill"], fill=True, color="blue")

sns.rugplot(tips["total_bill"], color="red", height=0.1) # Small ticks at bottom

plt.title("KDE Plot with Rugplot")

plt.show()

✅ Key Takeaway:
`rugplot()` shows data density by displaying tick marks.
Helps to visualize exact data points along with KDE.

Would you like me to summarize everything for your quick exam revision? 🚀📚

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 23/32
 27. Write line of code for following graph (Hint: dataset is Penguines)

(Ans: sns.displot(penguins, x="flipper_length_mm", hue="species", multiple="stack"))

28. How can you display multiple KDE plots in displot() for different categories?

28. Displaying Multiple KDE Plots in `displot()` for Different Categories

You can use the `hue` parameter in `sns.displot()` to show multiple KDE plots for different categories.

Example: Multiple KDE Plots for Different Species in the Penguins Dataset

python

import seaborn as sns

import matplotlib.pyplot as plt

# Load dataset
penguins = sns.load_dataset("penguins")

# Create KDE plots for different species

sns.displot(penguins, x="flipper_length_mm", hue="species", kind="kde")

plt.show()

✅ Key Points:
`hue="species"`→ Separates KDE plots by species.
`kind="kde"` → Uses KDE instead of a histogram.
This helps compare distributions of `flipper_length_mm` for each species.

Would you like a side-by-side KDE and histogram visualization for better comparison? 🚀

27. Write line of code for following graph (Hint: dataset is Penguines)

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 24/32
 (Ans: sns.displot(penguins, x="flipper_length_mm", hue="species", multiple="stack"))

Yes! The correct line of code for the given graph is:

python

sns.displot(penguins, x="flipper_length_mm", hue="species", multiple="stack")

✅ Explanation:
`x="flipper_length_mm"`→ Sets the x-axis to flipper length.
`hue="species"` → Colors the histogram by penguin species.
`multiple="stack"` → Stacks the bars to show total distribution across species.

This effectively visualizes how flipper length varies across species. 🚀

29. What does stat="probability" do in histplot()?

30. How can you set specific x-axis and y-axis limits in histplot()?
31. How can you increase spacing between subplots in pairplot()?

29. What does `stat="probability"` do in `histplot()`?

✅ Answer:
Setting `stat="probability"` in `sns.histplot()` normalizes the histogram so that the sum of all bar
heights equals 1. Each bar height represents the relative frequency (probability) instead of the raw
count.
🔹 Example:
python

sns.histplot(data=penguins, x="flipper_length_mm", stat="probability")

30. How can you set specific x-axis and y-axis limits in `histplot()`?

✅ Answer:
You can use `plt.xlim()` and `plt.ylim()` to define custom axis limits.
🔹 Example:
python

sns.histplot(data=penguins, x="flipper_length_mm")
plt.xlim(170, 230) # Set x-axis range
plt.ylim(0, 100) # Set y-axis range
plt.show()

31. How can you increase spacing between subplots in `pairplot()`?

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 25/32
✅ Answer:
You can use the `corner=True` parameter to reduce redundant plots or adjust spacing using
`plt.subplots_adjust()`.

🔹 Example:
python

g = sns.pairplot(penguins, hue="species")
g.fig.subplots_adjust(wspace=0.5, hspace=0.5) # Increase spacing
plt.show()

This ensures better visibility by reducing overlap between subplots. 🚀

32. How can you use histplot() to create a normalized histogram? Demonstrate with stat="density"
and stat="probability".
33. How can you customize pairplot() by changing marker styles, line thickness, and adding
correlation coefficients? Show a code example.
34. Demonstrate how you can use hue in pairplot() to visualize category-based distributions.

32. How can you use `histplot()` to create a normalized histogram?

✅ Answer:
A normalized histogram represents data as a probability density instead of raw counts. You can achieve
this using `stat="density"` or `stat="probability"` in `sns.histplot()`.
🔹 Example with `stat="density"`

The area under the histogram sums to 1 (useful for probability density functions).

python

import seaborn as sns

import matplotlib.pyplot as plt

sns.histplot(data=penguins, x="flipper_length_mm", stat="density", bins=20)

plt.show()

🔹 Example with `stat="probability"`

The sum of all bar heights equals 1.

python

sns.histplot(data=penguins, x="flipper_length_mm", stat="probability", bins=20)

plt.show()

33. How can you customize `pairplot()` by changing marker styles, line thickness,
and adding correlation coefficients?

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 26/32
✅ Answer:
You can customize `pairplot()` using parameters like `markers`, `plot_kws`, and custom correlation
annotations.
🔹 Example:
python

import seaborn as sns

import matplotlib.pyplot as plt
import numpy as np

# Load dataset
penguins = sns.load_dataset("penguins")

# Function to add correlation coefficients

def corr_coeff(x, y, **kwargs):
r = np.corrcoef(x, y)[0, 1]
plt.gca().annotate(f'ρ = {r:.2f}', xy=(0.5, 0.5), xycoords='axes fraction',
ha='center', va='center', fontsize=12, fontweight='bold')

# Create pairplot with customization

g = sns.pairplot(penguins, hue="species", markers=["o", "s", "D"],
plot_kws={"s": 60, "linewidth": 1.5})

# Add correlation coefficients on the upper triangle

g.map_upper(corr_coeff)
plt.show()

🔹 Customizations used:
`markers` → Different marker styles for each category.
`plot_kws={"s": 60, "linewidth": 1.5}` → Adjusts scatter plot marker size and thickness.
`g.map_upper(corr_coeff)` → Adds correlation coefficients in the upper triangle.

34. How can you use `hue` in `pairplot()` to visualize category-based distributions?

✅ Answer:
The `hue` parameter allows coloring based on categorical values, making it easier to compare
distributions across categories.

🔹 Example:
python

sns.pairplot(penguins, hue="species", diag_kind="kde", markers=["o", "s", "D"])

plt.show()

🔹 Explanation:
`hue="species"` → Colors data points by species.
`diag_kind="kde"` → Uses KDE plots on the diagonal instead of histograms.
`markers=["o", "s", "D"]` → Different markers for each category.

This makes it easy to compare feature relationships across different species. 🚀

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 27/32
 35. What is the default kind in catplot() for categorical scatterplots?
36. How does stripplot() represent data points?
37. What is the key difference between stripplot() and swarmplot()?
38. How can you control jittering in stripplot()?

35. What is the default `kind` in `catplot()` for categorical scatterplots?

✅ Answer:
The default `kind` in `sns.catplot()` is "strip", which corresponds to `stripplot()`.

python

sns.catplot(data=penguins, x="species", y="flipper_length_mm")

This is equivalent to:

python

sns.catplot(data=penguins, x="species", y="flipper_length_mm", kind="strip")

36. How does `stripplot()` represent data points?

✅ Answer:
`stripplot()` displays individual data points along a categorical axis as jittered dots.
It helps visualize data distribution and density for each category.

🔹 Example:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True)

37. What is the key difference between `stripplot()` and `swarmplot()`?

✅ Answer:
Feature `stripplot()` `swarmplot()`
Data Point Arrangement Uses random jittering Uses non-overlapping adjustment
Overlapping Yes, points can overlap No, points are adjusted to avoid overlap

Suitability Large datasets Small datasets

Visualization Style Dots spread randomly Dots arranged compactly

🔹 Example:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True) # May have overlappin

sns.swarmplot(data=penguins, x="species", y="flipper_length_mm") # Adjusts to avoid overlap

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 28/32
38. How can you control jittering in `stripplot()`?

✅ Answer:
Jittering adds random noise to spread overlapping points.
You can control it using the `jitter` parameter:
🔹 Example:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=0.2) # Adjust jitter amount

`jitter=True`→ Default, auto-adjusts jitter.

`jitter=0.1` → Less spread (tighter points).
`jitter=0.5` → More spread (widely spaced points).

📌 Tip: If too many points overlap, consider using `swarmplot()` instead! 🚀

39. Why might swarmplot() be better than stripplot() in some cases?

40. How does the dodge parameter in swarmplot() affect categorical grouping?
41. What happens when hue is added to stripplot()?

39. Why might `swarmplot()` be better than `stripplot()` in some cases?

✅ Answer:
avoids overlapping points by adjusting their positions, making it easier to interpret
`swarmplot()`
densely packed data.
📌 Advantages of `swarmplot()` over `stripplot()`:

Better clarity → Points do not overlap.

Easier comparison → Data distributions are more distinct.
More structured layout → Maintains relative density information.

🔹 Example Comparison:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True) # May cause overlap

sns.swarmplot(data=penguins, x="species", y="flipper_length_mm") # Avoids overlap

40. How does the `dodge` parameter in `swarmplot()` affect categorical grouping?

✅ Answer:
`dodge=True` separates points within the same category when using `hue`, making
subcategories more distinguishable.
If `dodge=False` (default), all subcategories in `hue` overlap within the same category.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 29/32
🔹 Example:
python

sns.swarmplot(data=penguins, x="species", y="flipper_length_mm", hue="sex", dodge=True)

✅ → Separates male and female penguins within each species.

❌
`dodge=True`
`dodge=False` → Overlapping points for both sexes.

41. What happens when `hue` is added to `stripplot()`?

✅ Answer:
Adding `hue` in `stripplot()` colors data points by category, helping differentiate subgroups.
If `dodge=True`, it separates hue-based groups along the categorical axis.

🔹 Example:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", hue="sex", dodge=True)

Effects:

🎨 Different colors → Distinguish and penguins.

🔄 Grouping effect → Subcategories are either overlapping (
`male` `female`
`dodge=False`) or separated
(`dodge=True`).

42. How can you reduce overlapping points in stripplot()?

43. How does swarmplot() adjust points to avoid overlap?
44. What does alpha control in stripplot() and swarmplot()?

42. How can you reduce overlapping points in `stripplot()`?

✅ Answer:
To reduce overlapping points in `stripplot()`, you can use the following techniques:

1. Enable Jittering (`jitter=True`)

Adds a small random displacement along the x-axis to spread out overlapping points.
Can also specify a float value (e.g., `jitter=0.2`) to control the spread.

python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True)

2. Reduce Marker Size (`size` parameter)

Smaller markers reduce crowding.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 30/32
 python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True, size=4)

3. Increase Transparency (`alpha` parameter)

Makes overlapping points more visible.

python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", jitter=True, alpha=0.6)

43. How does `swarmplot()` adjust points to avoid overlap?

✅ Answer:
`swarmplot()` automatically adjusts point positions along the x-axis to prevent overlapping, while
preserving the original data distribution.
🔹 Mechanism:
Uses a packing algorithm to arrange points horizontally.
Points are stacked when needed but never overlap.
Ensures data density is accurately represented without distortion.

🔹 Example:
python

sns.swarmplot(data=penguins, x="species", y="flipper_length_mm")

Outcome:
✅ No overlapping, unlike `stripplot()`.
✅ Maintains relative density while ensuring visibility.

44. What does `alpha` control in `stripplot()` and `swarmplot()`?

✅ Answer:
The `alpha` parameter controls the transparency of the markers.
Lower `alpha` (e.g., `alpha=0.3`) → More transparent points, useful for dense data to reduce
clutter.
Higher `alpha` (e.g., `alpha=1.0`) → Fully opaque points.

🔹 Example:
python

sns.stripplot(data=penguins, x="species", y="flipper_length_mm", alpha=0.5)

sns.swarmplot(data=penguins, x="species", y="flipper_length_mm", alpha=0.7)

Effect:

✅ Helps visualize overlapping points better.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 31/32
 ✅ Makes densely packed plots more readable.
ChatGPT can make mistakes. Check important info.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 32/32