상관행렬의 열지도¶

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

# 자료는 "Practical Statistics for Data Scientists" 저장소에서 바로 읽는다.
SP500 = ("https://raw.githubusercontent.com/gedeck/"
         "practical-statistics-for-data-scientists/8a6d3bb6468e979c861d4b37215e1413702dfdfa/data/")
sp500_sym = pd.read_csv(SP500 + 'sp500_sectors.csv')
sp500_px = pd.read_csv(SP500 + 'sp500_data.csv.gz', index_col=0)

# ETF 만 골라 2012년 7월 이후 구간을 쓴다.
etfs = sp500_px.loc[sp500_px.index > '2012-07-01',
                    sp500_sym[sp500_sym['sector'] == 'etf']['symbol']]

# 열이 종목, 행이 날짜이므로 corr() 이 종목 사이의 상관행렬을 준다.
corr_matrix = etfs.corr()

# vmin/vmax 를 -1 과 1 로 못박아야 색의 뜻이 그림마다 달라지지 않는다.
# 발산형 색지도라 0 이 가운데 색에 놓인다.
fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(corr_matrix,
            vmin=-1, vmax=1,
            cmap=sns.diverging_palette(20, 220, as_cmap=True),
            ax=ax,
            square=True,
            cbar_kws={'label': 'Correlation'})
ax.set_title('Correlation Heatmap: S&P 500 ETFs (2012-2015)')
plt.tight_layout()
plt.show()

# 색만 보고 넘어가지 않도록 수치를 찍는다.
p = corr_matrix.shape[0]
off = corr_matrix.values[np.triu_indices(p, 1)]
print(f"ETF {p} 종목, 거래일 {len(etfs)} 일 "
      f"({etfs.index.min()} ~ {etfs.index.max()}), 서로 다른 짝 {len(off)} 개")
print(f"상관 최소 {off.min():+.4f}  최대 {off.max():+.4f}  평균 {off.mean():+.4f}")
print(f"음수인 짝 = {(off < 0).sum()} 개")
from collections import Counter
cnt = Counter()
for i in range(p):
    for j in range(i + 1, p):
        if corr_matrix.values[i, j] < 0:
            cnt[corr_matrix.index[i]] += 1
            cnt[corr_matrix.columns[j]] += 1
print(f"음수 짝에 낀 횟수 = {dict(cnt.most_common())}")
print(f"유틸리티(XLU) 대 경기소비재(XLY) = {corr_matrix.loc['XLU', 'XLY']:+.4f}  "
      f"(방어 대 경기민감)")

rbar = off.mean()
print(f"\n등가중 포트폴리오 (수익률을 표준화해 분산을 1 로 맞춘 뒤)")
print(f"  공식 1/p + (1-1/p) rbar = {1/p + (1 - 1/p) * rbar:.6f}")
z = (etfs - etfs.mean()) / etfs.std()
print(f"  실제로 만들어 재면       = {z.mean(axis=1).var(ddof=1):.6f}")
print(f"  서로 독립이었다면 1/p    = {1/p:.6f}")
print(f"  표준편차 비: 실제 {np.sqrt(1/p + (1 - 1/p) * rbar):.4f}  "
      f"독립이었다면 {np.sqrt(1/p):.4f}")
print(f"  유효 독립 자산수 = {1 / (1/p + (1 - 1/p) * rbar):.2f} 개")

ETF 17 종목, 거래일 754 일 (2012-07-02 ~ 2015-07-01), 서로 다른 짝 136 개
상관 최소 -0.5471  최대 +0.9537  평균 +0.4063
음수인 짝 = 18 개
음수 짝에 낀 횟수 = {'VXX': 16, 'GLD': 3, 'XTL': 2, 'XLV': 2, 'XLI': 1, 'QQQ': 1, 'SPY': 1, 'DIA': 1, 'USO': 1, 'IWM': 1, 'XLE': 1, 'XLY': 1, 'XLU': 1, 'XLB': 1, 'XLP': 1, 'XLF': 1, 'XLK': 1}
유틸리티(XLU) 대 경기소비재(XLY) = +0.3668  (방어 대 경기민감)

등가중 포트폴리오 (수익률을 표준화해 분산을 1 로 맞춘 뒤)
  공식 1/p + (1-1/p) rbar = 0.441257
  실제로 만들어 재면       = 0.441257
  서로 독립이었다면 1/p    = 0.058824
  표준편차 비: 실제 0.6643  독립이었다면 0.2425
  유효 독립 자산수 = 2.27 개

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

# 앞과 같은 자료다.
# 자료는 "Practical Statistics for Data Scientists" 저장소에서 바로 읽는다.
SP500 = ("https://raw.githubusercontent.com/gedeck/"
         "practical-statistics-for-data-scientists/8a6d3bb6468e979c861d4b37215e1413702dfdfa/data/")
sp500_sym = pd.read_csv(SP500 + 'sp500_sectors.csv')
sp500_px = pd.read_csv(SP500 + 'sp500_data.csv.gz', index_col=0)
etfs = sp500_px.loc[sp500_px.index > '2012-07-01',
                    sp500_sym[sp500_sym['sector'] == 'etf']['symbol']]

corr_matrix = etfs.corr()

fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(corr_matrix,
            vmin=-1, vmax=1,
            cmap=sns.diverging_palette(20, 220, as_cmap=True),
            annot=True,  # 칸마다 숫자를 적는다
            fmt='.2f',   # 소수점 두 자리
            ax=ax,
            square=True,
            cbar_kws={'label': 'Correlation'},
            cbar=False)  # 숫자를 적었으므로 색막대는 없어도 된다
ax.set_title('Annotated Correlation Heatmap: S&P 500 ETFs')
plt.tight_layout()
plt.show()

print(f"{'짝':>10s} {'r':>8s} {'sqrt((1+r)/2)':>15s} {'표준편차 감소':>13s}")
for a, b in [('SPY', 'DIA'), ('QQQ', 'XLK'), ('SPY', 'QQQ'),
             ('SPY', 'GLD'), ('SPY', 'VXX')]:
    r = corr_matrix.loc[a, b]
    ratio = np.sqrt((1 + r) / 2)
    print(f"{a + '-' + b:>10s} {r:+8.4f} {ratio:15.4f} {1 - ratio:12.1%}")

gld = [c for c in corr_matrix.columns if c not in ('GLD', 'VXX', 'USO')]
g = corr_matrix.loc['GLD', gld]
print(f"\nGLD 대 주식형 {len(gld)} 종목: 최소 {g.min():+.4f}  최대 {g.max():+.4f}  "
      f"평균 {g.mean():+.4f}  음수 {int((g < 0).sum())} 개")
v = corr_matrix.loc['VXX', gld]
print(f"VXX 대 주식형 {len(gld)} 종목: 최소 {v.min():+.4f}  최대 {v.max():+.4f}  "
      f"평균 {v.mean():+.4f}  음수 {int((v < 0).sum())} 개")
print(f"\n칸 수 {corr_matrix.shape[0]}x{corr_matrix.shape[1]} = {corr_matrix.size} 개")

         짝        r   sqrt((1+r)/2)       표준편차 감소
   SPY-DIA  +0.9537          0.9884         1.2%
   QQQ-XLK  +0.9451          0.9862         1.4%
   SPY-QQQ  +0.9090          0.9770         2.3%
   SPY-GLD  +0.0787          0.7344        26.6%
   SPY-VXX  -0.5471          0.4759        52.4%

GLD 대 주식형 14 종목: 최소 -0.0422  최대 +0.1886  평균 +0.0635  음수 2 개
VXX 대 주식형 14 종목: 최소 -0.5471  최대 -0.2057  평균 -0.4354  음수 14 개

칸 수 17x17 = 289 개

VXX | GLD USO XTL XLU | XLE XLP XLV XLB IWM XLF QQQ XLK XLY XLI SPY DIA

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from scipy.cluster.hierarchy import dendrogram, linkage
from scipy.spatial.distance import squareform

# 상관이 비슷한 종목끼리 이웃하도록 순서를 다시 매긴다. 1 - r 을 거리로
# 삼으면 상관이 높을수록 가까운 것이 되어 군집화에 바로 쓸 수 있다.
corr_matrix = etfs.corr()
linkage_matrix = linkage(1 - corr_matrix, method='ward')

fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(corr_matrix,
            cmap=sns.diverging_palette(20, 220, as_cmap=True),
            vmin=-1, vmax=1,
            ax=ax,
            square=True)
ax.set_title('Clustered Correlation Heatmap')
plt.tight_layout()
plt.show()

# 그려진 축의 순서를 자료의 순서와 맞대어 본다.
drawn = [t.get_text() for t in ax.get_xticklabels()]
print("그려진 축 순서 =", drawn)
print("corr_matrix 열 =", list(corr_matrix.columns))
print("둘이 같은가 :", drawn == list(corr_matrix.columns))
print("linkage_matrix 를 쓴 곳이 있는가 : 없음 — 계산만 하고 버렸다")

# 블록 구조를 재는 잣대: 축에서 이웃한 두 종목의 평균 상관
nb = lambda o: np.mean([corr_matrix.values[o[i], o[i + 1]] for i in range(len(o) - 1)])
p = len(corr_matrix)
base = list(range(p))
leaves_bad = dendrogram(linkage_matrix, no_plot=True)['leaves']

# 올바른 방법: 1-r 을 압축 거리벡터로 넘긴다
D = 1 - corr_matrix.values
np.fill_diagonal(D, 0.0)
leaves_ok = dendrogram(linkage(squareform(D, checks=False), method='average'),
                       no_plot=True)['leaves']

print(f"\n{'순서':>26s} {'이웃 평균 r':>11s}")
for lab, o in [("원래 (그림에 쓰인 것)", base),
               ("linkage(1-corr) 의 잎", leaves_bad),
               ("압축 거리 + average", leaves_ok)]:
    print(f"{lab:>26s} {nb(o):11.4f}")
print(f"{'참고: 모든 짝의 평균 r':>26s} "
      f"{corr_matrix.values[np.triu_indices(p, 1)].mean():11.4f}")
print("\n압축 거리 + average 순서:")
print(" ", [corr_matrix.columns[i] for i in leaves_ok])

그려진 축 순서 = ['XLI', 'QQQ', 'SPY', 'DIA', 'GLD', 'VXX', 'USO', 'IWM', 'XLE', 'XLY', 'XLU', 'XLB', 'XTL', 'XLV', 'XLP', 'XLF', 'XLK']
corr_matrix 열 = ['XLI', 'QQQ', 'SPY', 'DIA', 'GLD', 'VXX', 'USO', 'IWM', 'XLE', 'XLY', 'XLU', 'XLB', 'XTL', 'XLV', 'XLP', 'XLF', 'XLK']
둘이 같은가 : True
linkage_matrix 를 쓴 곳이 있는가 : 없음 — 계산만 하고 버렸다

                        순서     이웃 평균 r
             원래 (그림에 쓰인 것)      0.4527
       linkage(1-corr) 의 잎      0.5013
           압축 거리 + average      0.5555
            참고: 모든 짝의 평균 r      0.4063

압축 거리 + average 순서:
  ['VXX', 'GLD', 'USO', 'XTL', 'XLU', 'XLE', 'XLP', 'XLV', 'XLB', 'IWM', 'XLF', 'QQQ', 'XLK', 'XLY', 'XLI', 'SPY', 'DIA']

# 종목이 많으면 열지도가 읽히지 않는다. 업종 펀드만 열 개로 좁힌다.
sector_etfs = ['XLI', 'QQQ', 'XLE', 'XLY', 'XLU', 'XLB', 'XLV', 'XLP', 'XLF', 'XLK']
subset_corr = corr_matrix.loc[sector_etfs, sector_etfs]

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(subset_corr, annot=True, fmt='.2f', ax=ax, square=True)
ax.set_title('Sector ETF Correlations')
plt.tight_layout()
plt.show()

# 색막대가 어디에서 어디까지인지 그림에서 직접 꺼내 본다.
qm = ax.collections[0]
lo, hi = qm.get_clim()
print(f"색막대 범위: vmin = {lo:.4f},  vmax = {hi:.4f}   (못박지 않아 자료에 맞춰졌다)")
print(f"색지도 = {qm.cmap.name}  (발산형이 아니라 순차형이라 0 이 가운데가 아니다)")
print(f"\n{'r':>6s} {'보기 1 에서의 색 위치':>20s} {'보기 4 에서의 색 위치':>20s}")
for r in (0.34, 0.38, 0.53, 0.95):
    print(f"{r:6.2f} {(r + 1) / 2:20.3f} {(r - lo) / (hi - lo):20.3f}")

p = len(corr_matrix)
full = corr_matrix.values[np.triu_indices(p, 1)]
sub = subset_corr.values[np.triu_indices(len(sector_etfs), 1)]
print(f"\n짝 {len(full)} -> {len(sub)},  사라진 짝 {len(full) - len(sub)} 개")
print(f"빠진 종목 = {[c for c in corr_matrix.columns if c not in sector_etfs]}")
print(f"음수 짝: 전체 {int((full < 0).sum())} 개  ->  부분집합 {int((sub < 0).sum())} 개")
print(f"부분집합 상관 최소 {sub.min():+.4f}  최대 {sub.max():+.4f}  평균 {sub.mean():+.4f}")
rb = sub.mean()
q = len(sector_etfs)
print(f"부분집합 등가중 분산 = 1/q + (1-1/q) rbar = {1/q + (1 - 1/q) * rb:.4f}  "
      f"(유효 독립 자산수 {1 / (1/q + (1 - 1/q) * rb):.2f} 개)")

색막대 범위: vmin = 0.3379,  vmax = 1.0000   (못박지 않아 자료에 맞춰졌다)
색지도 = rocket  (발산형이 아니라 순차형이라 0 이 가운데가 아니다)

     r        보기 1 에서의 색 위치        보기 4 에서의 색 위치
  0.34                0.670                0.003
  0.38                0.690                0.064
  0.53                0.765                0.290
  0.95                0.975                0.924

짝 136 -> 45,  사라진 짝 91 개
빠진 종목 = ['SPY', 'DIA', 'GLD', 'VXX', 'USO', 'IWM', 'XTL']
음수 짝: 전체 18 개  ->  부분집합 0 개
부분집합 상관 최소 +0.3379  최대 +0.9451  평균 +0.6230
부분집합 등가중 분산 = 1/q + (1-1/q) rbar = 0.6607  (유효 독립 자산수 1.51 개)

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

corr_matrix = etfs.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(corr_matrix,
            cmap='gray',  # 인쇄를 염두에 둔 회색조. 다만 부호를 읽기 어려워진다.
            vmin=-1, vmax=1,
            ax=ax,
            square=True,
            cbar_kws={'label': 'Correlation'})
ax.set_title('Correlation Heatmap (Grayscale)')
plt.tight_layout()
plt.show()

p = len(corr_matrix)
off = corr_matrix.values[np.triu_indices(p, 1)]

# 회색조 명도는 vmin=-1, vmax=1 이므로 g = (r+1)/2 로 선형이다.
g = (off + 1) / 2
print(f"r = -1 -> 명도 0.000 (검정),  r = 0 -> 명도 0.500 (중간회색),  "
      f"r = +1 -> 명도 1.000 (흰색)")
print(f"실제 짝 {len(off)} 개의 명도: 최소 {g.min():.3f}  최대 {g.max():.3f}")
qs = np.percentile(off, [25, 50, 75])
print(f"r 의 사분위 {qs[0]:+.3f} {qs[1]:+.3f} {qs[2]:+.3f}  ->  "
      f"명도 {(qs[0]+1)/2:.3f} {(qs[1]+1)/2:.3f} {(qs[2]+1)/2:.3f}")
print(f"명도 0.80 이상 (r >= 0.60) 인 짝 = {(g >= 0.80).sum()} / {len(off)}")
print(f"그 짝들의 명도 폭 = {g[g >= 0.80].max() - g[g >= 0.80].min():.3f}  "
      f"(쓸 수 있는 폭 1.000 가운데)")
print(f"\n부호가 헷갈리는 구간: |r| < 0.1 인 짝 = {(np.abs(off) < 0.1).sum()} 개, "
      f"명도 {(g[np.abs(off) < 0.1]).min():.3f} ~ {(g[np.abs(off) < 0.1]).max():.3f}")

r = -1 -> 명도 0.000 (검정),  r = 0 -> 명도 0.500 (중간회색),  r = +1 -> 명도 1.000 (흰색)
실제 짝 136 개의 명도: 최소 0.226  최대 0.977
r 의 사분위 +0.184 +0.459 +0.747  ->  명도 0.592 0.729 0.874
명도 0.80 이상 (r >= 0.60) 인 짝 = 56 / 136
그 짝들의 명도 폭 = 0.177  (쓸 수 있는 폭 1.000 가운데)

부호가 헷갈리는 구간: |r| < 0.1 인 짝 = 12 개, 명도 0.479 ~ 0.539