Visualizing Intraday Stock Movements Using Heatmaps and Tree Maps

Overview

Understanding intraday market activity requires efficient visualization tools that highlight trends, correlations, and outliers within stock movements. Heatmaps and tree maps are powerful tools for this purpose:

• Heatmaps use color gradients to represent data intensities (e.g., price changes, volumes).
• Tree maps use hierarchical rectangular regions to show proportional metrics (e.g., market cap, sector performance).

This article explores:

1. The benefits of heatmaps and tree maps for analyzing intraday stock movements.
2. Practical use cases for visualizing stock activity.
3. Step-by-step Python implementations.

---

1. Benefits of Heatmaps and Tree Maps

1.1 Heatmaps

• Provide an intuitive view of price changes or volume intensities over time.
• Highlight patterns, such as recurring spikes or volatility during specific hours.

1.2 Tree Maps

• Display hierarchical data (e.g., sector-wise performance) proportionally in a single chart.
• Reveal market breadth by showing how many stocks are advancing versus declining.

---

2. Use Cases

2.1 Heatmaps

• Intraday Price Movement: Visualize hourly price changes for multiple stocks.
• Volume Spikes: Identify periods of high trading activity.

2.2 Tree Maps

• Sector-Wise Performance: Show sector contributions to overall market movement.
• Stock Returns Distribution: Display stocks’ daily returns within each sector.

---

3. Implementation

3.1 Heatmap of Intraday Stock Prices

Step 1: Import Libraries

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

---

Step 2: Simulate or Load Intraday Data

# Simulate intraday price data for 3 stocks (10-minute intervals)
np.random.seed(42)
time_intervals = pd.date_range("09:30", "16:00", freq="10min")
stocks = ["AAPL", "MSFT", "GOOG"]

# Create a DataFrame with random price changes
price_data = pd.DataFrame(
data=np.cumsum(np.random.randn(len(time_intervals), len(stocks)), axis=0),
index=time_intervals,
columns=stocks,
)

price_data = price_data.apply(lambda x: x + 100)  # Start prices around 100
print(price_data.head())

---

Step 3: Create a Heatmap

# Transpose data to use in heatmap
heatmap_data = price_data.T

# Plot heatmap
plt.figure(figsize=(10, 6))
sns.heatmap(
heatmap_data,
annot=False,
cmap="coolwarm",
xticklabels=False,
yticklabels=heatmap_data.index,
cbar_kws={"label": "Stock Price"},
)
plt.title("Intraday Stock Price Movements")
plt.xlabel("Time")
plt.ylabel("Stocks")
plt.show()

---

3.2 Tree Map of Sector-Wise Performance

Step 1: Simulate Stock Returns

# Simulate daily stock returns and sectors
stocks = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "NVDA"]
sectors = ["Technology", "Technology", "Technology", "Consumer", "Consumer", "Technology"]

returns = np.random.uniform(-0.05, 0.05, len(stocks))  # Random daily returns
market_cap = np.random.uniform(50, 500, len(stocks))  # Random market caps in $B

# Create DataFrame
sector_data = pd.DataFrame({
"Stock": stocks,
"Sector": sectors,
"Return": returns,
"MarketCap": market_cap
})
print(sector_data)

---

Step 2: Create a Tree Map

import squarify

# Aggregate data by sector
sector_aggregated = sector_data.groupby("Sector").agg({
"MarketCap": "sum",
"Return": "mean"
}).reset_index()

# Define color intensity based on sector return
colors = [plt.cm.coolwarm((x + 0.05) / 0.1) for x in sector_aggregated["Return"]]

# Create tree map
plt.figure(figsize=(12, 6))
squarify.plot(
sizes=sector_aggregated["MarketCap"],
label=sector_aggregated["Sector"],
color=colors,
alpha=0.8
)
plt.axis("off")
plt.title("Sector-Wise Market Performance")
plt.show()

---

4. Interpreting the Visualizations

Heatmap Insights

• Color Gradients: Darker shades indicate higher prices or volumes, revealing key activity periods.
• Patterns: Horizontal patterns show stable stocks; vertical patterns reveal synchronized movements across stocks.

Tree Map Insights

• Block Size: Indicates market cap; larger blocks dominate the market.
• Color: Green (positive return) and red (negative return) show sector performance at a glance.

---

5. Advanced Techniques

5.1 Interactive Heatmaps with Plotly

import plotly.express as px

# Interactive heatmap
fig = px.imshow(
heatmap_data,
labels={"x": "Time", "y": "Stocks", "color": "Stock Price"},
x=time_intervals.strftime("%H:%M"),
y=stocks,
color_continuous_scale="Viridis"
)
fig.update_layout(title="Intraday Stock Price Movements")
fig.show()

---

5.2 Dynamic Tree Maps with Plotly

import plotly.graph_objects as go

# Create interactive tree map
fig = go.Figure(go.Treemap(
labels=sector_aggregated["Sector"],
parents=[""] * len(sector_aggregated),
values=sector_aggregated["MarketCap"],
marker_colors=sector_aggregated["Return"],
marker_colorscale="RdYlGn",
textinfo="label+value+percent entry"
))
fig.update_layout(title="Interactive Sector-Wise Tree Map")
fig.show()

---

6. Limitations and Enhancements

Limitations

• Data Quality: Requires clean and granular intraday data.
• Scalability: Large datasets may slow down visualization rendering.
• Interactivity: Static charts lack detailed drill-down capabilities.

Enhancements

• Use real-time data feeds to update heatmaps dynamically.
• Drill-down functionality in tree maps for stock-level insights.
• Combine heatmaps and tree maps into dashboards using tools like Dash or Tableau.

---

7. Conclusion

Heatmaps and tree maps offer powerful ways to visualize and analyze intraday stock movements, making it easier to identify trends, correlations, and outliers. Whether you’re a day trader looking for actionable patterns or an analyst summarizing market performance, these techniques can provide valuable insights.

---

References

• Seaborn Documentation: https://seaborn.pydata.org/
• Plotly for Interactive Visualization: https://plotly.com/
• Squarify Library: https://github.com/laserson/squarify
• Investopedia: Intraday Trading Basics: https://www.investopedia.com/