Log scale and symlog scale in Matplotlib - Deep Dive

Overview - Log scale and symlog scale

What is it?

Log scale and symlog scale are ways to display data on a graph where the axis values grow exponentially or cover both very small and very large numbers. A log scale shows values based on powers of a base number, like 10, making it easier to see patterns in data that spans many orders of magnitude. Symlog scale is a mix of linear and log scales, allowing negative and zero values to be shown alongside positive values on a log scale. These scales help visualize data that changes rapidly or has both small and large values.

Why it matters

Without log or symlog scales, graphs with very large or very small numbers can be hard to read because small values get squished and large values dominate. This makes it difficult to spot trends or compare data points. Log and symlog scales solve this by spreading out the data more evenly, revealing patterns and relationships that would otherwise be hidden. This is important in fields like science, finance, and engineering where data often spans wide ranges.

Where it fits

Before learning log and symlog scales, you should understand basic plotting and linear scales in graphs. After mastering these scales, you can explore advanced data visualization techniques like custom scales, interactive plots, and handling special data types in matplotlib.

Mental Model

Core Idea

Log and symlog scales transform axis values to better show data that changes exponentially or includes both positive and negative values across wide ranges.

Think of it like...

Imagine a map where distances are shown normally for nearby places but get compressed for faraway places to fit everything on one page. Log scale compresses large numbers while expanding small ones, and symlog scale lets you see places both east and west of a center point, like negative and positive values.

Linear scale: 1 ── 2 ── 3 ── 4 ── 5
Log scale:    1 ── 10 ── 100 ── 1000 ── 10000
Symlog scale: -1000 ── -10 ── 0 ── 10 ── 1000

Build-Up - 7 Steps

1

Foundation

Understanding linear scales

Concept: Linear scale shows data points spaced evenly based on their actual values.

In a linear scale, the distance between 1 and 2 is the same as between 4 and 5. This is the default way graphs display data. For example, plotting y = x on a graph with linear scale shows a straight line.

Result

Data points are spaced evenly, making it easy to see differences when values are close.

Understanding linear scale is essential because it is the baseline for all other scales and helps you see why log scales are needed for wide-ranging data.

2

Foundation

Basics of logarithms

Concept: Logarithms convert multiplication into addition, helping to handle large ranges of numbers.

A logarithm answers: 'To what power must we raise a base number to get another number?' For example, log base 10 of 1000 is 3 because 10^3 = 1000. This means large numbers can be represented by smaller, easier-to-handle values.

Result

You can represent very large or small numbers in a compact way.

Knowing logarithms is key to understanding how log scales compress data and why they reveal patterns hidden in linear scales.

3

Intermediate

Applying log scale in matplotlib

🤔Before reading on: do you think log scale can display zero or negative values? Commit to your answer.

Concept: Log scale transforms axis values by their logarithm, spreading out data that covers many orders of magnitude.

In matplotlib, you can set an axis to log scale using plt.xscale('log') or plt.yscale('log'). This changes the axis ticks to powers of the base (default 10). For example, plotting y = 10^x on a log scale shows a straight line.

Result

Graphs show exponential data clearly, but zero or negative values cause errors or are not shown.

Understanding that log scale cannot handle zero or negative values explains why some data needs alternative scales like symlog.

4

Intermediate

Introducing symlog scale

🤔Before reading on: do you think symlog scale treats small values linearly or logarithmically near zero? Commit to your answer.

Concept: Symlog scale combines linear and log scales to show both negative and positive values smoothly around zero.

Symlog scale uses a linear region around zero (controlled by a parameter called linthresh) and log scale outside that region. This lets you plot data with negative, zero, and positive values on the same axis. In matplotlib, use plt.xscale('symlog') or plt.yscale('symlog').

Result

Graphs can display data crossing zero without errors, showing both small and large values clearly.

Knowing symlog scale solves the limitation of log scale and expands your ability to visualize complex data.

5

Advanced

Customizing symlog parameters

🤔Before reading on: do you think changing linthresh affects only the linear region or the entire scale? Commit to your answer.

Concept: You can adjust the size of the linear region and the logarithmic base in symlog scale for better visualization.

In matplotlib, symlog scale accepts parameters like linthresh (linear threshold) and base (logarithm base). Increasing linthresh makes the linear region wider, showing more detail near zero. Changing base alters the spacing of log ticks. Example: plt.yscale('symlog', linthresh=0.1, base=2).

Result

You get more control over how data near zero and far from zero is displayed.

Understanding these parameters helps tailor plots to specific data shapes and improves clarity.

6

Advanced

Handling tick formatting on log and symlog

Concept: Ticks on log and symlog scales need special formatting to be readable and meaningful.

Matplotlib automatically formats ticks on log scales as powers of the base, but you can customize this with LogFormatter or SymmetricalLogLocator for symlog. Proper tick formatting helps users interpret the scale correctly and avoids confusion.

Result

Graphs have clear, understandable axis labels that match the scale type.

Knowing how to format ticks prevents misinterpretation of data and improves communication.

7

Expert

Limitations and numerical issues in symlog

🤔Before reading on: do you think symlog scale can perfectly represent all negative values without distortion? Commit to your answer.

Concept: Symlog scale approximates negative values near zero linearly but can introduce distortions and numerical instability for very small or very large values.

Because symlog blends linear and log scales, values close to zero are shown linearly, but very small negative values can be compressed or stretched unexpectedly. Also, floating-point precision limits can cause tick placement errors. Understanding these helps in choosing appropriate linthresh and data preprocessing.

Result

You avoid misleading graphs and know when symlog might not be the best choice.

Recognizing symlog's numerical limits prevents subtle bugs and misinterpretations in complex visualizations.

Under the Hood

Log scale transforms each axis value x into log_base(x), where base is usually 10. This means equal distances on the axis represent multiplication by the base. Symlog scale uses a piecewise function: linear transformation for values between -linthresh and +linthresh, and log transformation outside this range. This allows negative and zero values to be plotted by treating the linear region as a buffer zone around zero.

Why designed this way?

Log scale was designed to handle data spanning many orders of magnitude, common in science and engineering. However, it cannot handle zero or negative values, which are common in real data. Symlog was created to overcome this by combining linear and log scales, preserving the benefits of log scaling while allowing full range data visualization. Alternatives like logit or power scales exist but don't handle negative values as naturally.

Axis value x
  │
  ├─ if |x| ≤ linthresh: linear scale (x)
  └─ if |x| > linthresh: log scale (sign(x) * log_base(|x|))

Visualization:
  ┌─────────────┬─────────────┬─────────────┐
  │  Negative   │   Linear    │  Positive   │
  │  Log Scale  │  Region     │  Log Scale  │
  └─────────────┴─────────────┴─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can log scale display zero or negative values? Commit to yes or no.

Common Belief: Log scale can show zero and negative values just like linear scale.

Reality: Log scale cannot display zero or negative values because logarithm of zero or negative numbers is undefined.

Why it matters: Trying to plot zero or negative values on log scale causes errors or missing data, leading to incomplete or misleading graphs.

Quick: Does symlog scale treat all values logarithmically? Commit to yes or no.

Common Belief: Symlog scale applies logarithmic scaling to all values on the axis.

Reality: Symlog scale applies linear scaling near zero and logarithmic scaling only outside a threshold region.

Why it matters: Assuming full log scaling can cause confusion interpreting data near zero, where symlog behaves linearly.

Quick: Is changing the base in log scale just a cosmetic change? Commit to yes or no.

Common Belief: Changing the logarithm base only changes the labels but not the data representation.

Reality: Changing the base changes the spacing of ticks and the scale compression, affecting how data patterns appear.

Why it matters: Misunderstanding this can lead to incorrect interpretation of data relationships and trends.

Quick: Does symlog scale perfectly preserve distances for all values? Commit to yes or no.

Common Belief: Symlog scale preserves relative distances for all values like linear scale does.

Reality: Symlog scale distorts distances near zero due to the linear-log transition, which can mislead about small value differences.

Why it matters: Ignoring this can cause wrong conclusions about data variability near zero.

Expert Zone

1

Symlog scale's linear region size (linthresh) must be chosen carefully to balance detail near zero and log compression outside.

2

Tick placement on symlog axes can be tricky because standard log tick locators don't work well near zero, requiring custom locators.

3

Floating-point precision limits can cause subtle artifacts in log and symlog plots, especially with very large or very small numbers.

When NOT to use

Avoid log scale when data includes zero or negative values; use symlog or linear scale instead. Avoid symlog when data is strictly positive and you want pure log behavior. For probabilities or proportions, consider logit scale. For data without wide range, linear scale is simpler and clearer.

Production Patterns

In real-world data science, log scale is used for plotting distributions like income or population where values span many orders. Symlog is common in scientific data with measurements around zero, such as sensor readings or financial returns. Professionals customize linthresh and base parameters and combine these scales with interactive zooming for detailed analysis.

Connections

Exponential growth

Log scale is the inverse transformation of exponential growth.

Understanding log scale helps interpret exponential processes by turning multiplicative growth into additive linear trends.

Signal processing

Symlog scale relates to how signals with positive and negative amplitudes are analyzed.

Knowing symlog scale aids in visualizing signals that cross zero, common in audio and sensor data.

Human perception of sound (decibels)

Decibel scale is a logarithmic scale similar to log scale in plotting data.

Recognizing log scale's similarity to decibel perception helps understand why log scales match human senses for loudness.

Common Pitfalls

#1 Trying to plot zero or negative values on a log scale axis.

Wrong approach:

plt.yscale('log')
plt.plot([1, 0, -1, 10], [10, 20, 30, 40])

Correct approach:

plt.yscale('symlog')
plt.plot([1, 0, -1, 10], [10, 20, 30, 40])

Root cause:

Misunderstanding that log scale cannot handle zero or negative values causes runtime errors or missing data.

#2 Using default linthresh in symlog without adjusting for data range.

Wrong approach:

plt.yscale('symlog')
plt.plot(data_with_small_values)

Correct approach:

plt.yscale('symlog', linthresh=0.01)
plt.plot(data_with_small_values)

Root cause:

Not tuning linthresh leads to poor visualization near zero, hiding important small value details.

#3 Assuming changing log base only changes labels, not data representation.

Wrong approach:

plt.xscale('log', base=2)
# Treats data same as base 10

Correct approach:

plt.xscale('log', base=2)
# Recognizes different tick spacing and scale compression

Root cause:

Ignoring that base affects scale spacing causes misinterpretation of data patterns.

Key Takeaways

Log scale transforms data to show multiplicative relationships clearly but cannot handle zero or negative values.

Symlog scale combines linear and log scales to visualize data with negative, zero, and positive values smoothly.

Choosing parameters like linthresh and base in symlog scale is crucial for clear and accurate data visualization.

Proper tick formatting and understanding scale limitations prevent misinterpretation and errors in plots.

Log and symlog scales are essential tools for exploring data spanning wide ranges or crossing zero in many real-world fields.

Practice

1. What is the main difference between a log scale and a symlog scale in matplotlib?

easy

A. Log scale only works for positive values, while symlog can handle negative and zero values.

B. Log scale can handle negative values, but symlog cannot.

C. Symlog scale is only for categorical data, log scale is for numerical data.

D. Log scale and symlog scale are exactly the same.

Solution

1. Step 1: Understand log scale limitations

   Log scale transforms data using logarithms and only supports positive values because logarithm of zero or negative numbers is undefined.

2. Step 2: Understand symlog scale features

   Symlog scale combines linear and logarithmic scales to handle negative, zero, and positive values by using a linear region around zero.

3. Final Answer:

   Log scale only works for positive values, while symlog can handle negative and zero values. -> Option A

4. Quick Check:

   Log scale positive only, symlog includes negatives [OK]

Hint: Log scale = positive only; symlog = includes negatives and zero [OK]

Common Mistakes:

• Thinking log scale supports zero or negative values
• Confusing symlog with linear scale
• Assuming symlog is only for positive values

2. Which of the following is the correct way to set the y-axis to a symlog scale in matplotlib?

easy

A. ax.set_scale('symlog')

B. ax.set_yscale('logarithm')

C. ax.set_yscale('symlog')

D. ax.set_scale('log')

Solution

1. Step 1: Recall matplotlib scale setting methods

   Matplotlib uses ax.set_xscale() or ax.set_yscale() to set axis scales.

2. Step 2: Identify correct scale name and method

   To set y-axis to symlog, use ax.set_yscale('symlog'). Other options are either incorrect method names or scale names.

3. Final Answer:

   ax.set_yscale('symlog') -> Option C

4. Quick Check:

   Use set_yscale with 'symlog' string [OK]

Hint: Use ax.set_yscale('symlog') to set y-axis symlog scale [OK]

Common Mistakes:

• Using ax.set_scale instead of ax.set_yscale
• Using wrong scale name like 'logarithm'
• Trying to set scale on x-axis when y-axis is intended

3. What will be the output of the following code snippet?

import matplotlib.pyplot as plt
import numpy as np

x = np.array([-100, -10, -1, 0, 1, 10, 100])
y = x

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_xscale('symlog', linthresh=1)
plt.show()

medium

A. A plot with x-axis on a linear scale only.

B. A plot with x-axis showing only positive values on a logarithmic scale, negative values ignored.

C. A runtime error because negative values cannot be plotted on log scale.

D. A plot with x-axis showing a linear scale near zero and logarithmic scale away from zero, including negative values.

Solution

1. Step 1: Understand symlog scale behavior

   Symlog scale allows negative and zero values by using a linear region around zero defined by linthresh.

2. Step 2: Analyze code and data

   The x values include negative, zero, and positive numbers. Setting x-axis to symlog with linthresh=1 means values between -1 and 1 are linear, outside are logarithmic.

3. Final Answer:

   A plot with x-axis showing a linear scale near zero and logarithmic scale away from zero, including negative values. -> Option D

4. Quick Check:

   Symlog handles negatives with linear region near zero [OK]

Hint: Symlog mixes linear near zero and log away, including negatives [OK]

Common Mistakes:

• Expecting error due to negative values on log scale
• Thinking symlog is fully logarithmic without linear region
• Assuming negative values are ignored or cause crash

4. The following code throws a ValueError: "Data has no positive values, and therefore can not be log-scaled." How can you fix it?

import matplotlib.pyplot as plt
import numpy as np

x = np.array([-10, -5, -1, 0])
y = np.arange(4)

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_xscale('log')
plt.show()

medium

A. Change ax.set_xscale('log') to ax.set_xscale('symlog').

B. Remove negative values from x before plotting.

C. Change y-axis scale instead of x-axis scale.

D. Use ax.set_xscale('linear') instead.

Solution

1. Step 1: Identify cause of error

   Log scale requires positive values only. The x array has negative and zero values, causing the error.

2. Step 2: Apply symlog scale to handle negatives

   Symlog scale supports negative and zero values by combining linear and log scales, so changing to symlog fixes the error.

3. Final Answer:

   Change ax.set_xscale('log') to ax.set_xscale('symlog'). -> Option A

4. Quick Check:

   Use symlog for negative values on log scale [OK]

Hint: Use symlog scale to plot negative or zero values on log axis [OK]

Common Mistakes:

• Trying to plot negative values on log scale directly
• Removing data instead of changing scale
• Changing unrelated axis scale

5. You have a dataset with values ranging from -1000 to 1000, including zero. You want to plot it using matplotlib so that the axis shows a logarithmic scale for large values but remains linear near zero to avoid distortion. Which approach is best?

hard

A. Use ax.set_xscale('log') and filter out negative and zero values.

B. Use ax.set_xscale('symlog', linthresh=10) to combine linear and log scales.

C. Use ax.set_xscale('linear') because log scales cannot handle negatives.

D. Use ax.set_xscale('log') with linthresh=10 parameter.

Solution

1. Step 1: Understand data range and requirements

   Data includes negative, zero, and positive values from -1000 to 1000. We want log scale for large values but linear near zero to avoid distortion.

2. Step 2: Choose appropriate scale and parameters

   Log scale cannot handle negatives or zero. Symlog scale supports negatives and zero by mixing linear region near zero (controlled by linthresh) and log scale outside.

3. Step 3: Evaluate options

   Use ax.set_xscale('symlog', linthresh=10) to combine linear and log scales. uses symlog with linthresh=10, which fits the requirement. Use ax.set_xscale('log') and filter out negative and zero values. filters data, losing information. Use ax.set_xscale('linear') because log scales cannot handle negatives. uses linear scale only, losing log benefits. Use ax.set_xscale('log') with linthresh=10 parameter. is invalid because log scale does not accept linthresh.

4. Final Answer:

   Use ax.set_xscale('symlog', linthresh=10) to combine linear and log scales. -> Option B

5. Quick Check:

   Symlog with linthresh mixes linear near zero and log away [OK]

Hint: Use symlog with linthresh to mix linear near zero and log away [OK]

Common Mistakes:

• Trying to use log scale with negative values
• Filtering out negative values instead of using symlog
• Using linear scale only losing log benefits
• Using invalid parameters with log scale