산점도¶

import matplotlib.pyplot as plt
import numpy as np
from scipy import stats

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

np.random.seed(0)
num_samples = 10
x = stats.norm().rvs(size=num_samples)
noise = 0.7 * stats.norm().rvs(size=num_samples)
y = 1 + 2 * x + noise

fig, (ax_plot, ax_scatter) = plt.subplots(1, 2, figsize=(12, 3))

point_sizes = 100 * stats.norm().rvs(size=num_samples) ** 2
color_values = stats.uniform().rvs(size=num_samples)

# ax.plot: 마커 속성이 모든 점에 똑같이 적용된다.
#   markersize=10  모든 점의 크기가 10
#   mec/mfc/mew    테두리색(red) / 채움색(blue) / 테두리굵기(3)
ax_plot.plot(x, y, 'o', markersize=10, mec="red", mfc="blue", mew=3)
ax_plot.set_title("ax.plot\n마커 크기가 모두 같다")

# ax.scatter: 점마다 다른 값을 줄 수 있다.
#   s=배열  점마다 크기가 다르다  -> 세 번째 변수를 크기로 표현
#   c=배열  점마다 색이 다르다    -> 네 번째 변수를 색으로 표현
ax_scatter.scatter(x, y, s=point_sizes, c=color_values)
ax_scatter.set_title("ax.scatter\n마커 크기와 색이 점마다 다르다")

for ax in (ax_plot, ax_scatter):
    ax.set_xticks([])
    ax.set_yticks([])
    for spine in ['left', 'right', 'top', 'bottom']:
        ax.spines[spine].set_visible(False)

plt.show()

from matplotlib.transforms import Affine2D

# s 를 바꾸며 실제로 그려진 마커의 지름을 잰다.
probe_fig, probe_ax = plt.subplots(figsize=(4, 4))
S = np.array([25., 100., 225., 400.])
sc = probe_ax.scatter(np.arange(len(S)), np.zeros(len(S)), s=S)
probe_fig.canvas.draw()
path = sc.get_paths()[0]
print(f"{'s':>7}{'잰 지름 d':>11}{'d/sqrt(s)':>12}{'원 넓이 pi d^2/4':>17}{'/ s':>8}")
for s, m in zip(S, sc.get_transforms()):
    d = path.transformed(Affine2D(m)).get_extents().width
    print(f"{s:>7.0f}{d:>11.4f}{d/np.sqrt(s):>12.6f}"
          f"{np.pi*d*d/4:>17.4f}{np.pi*d*d/4/s:>8.4f}")
plt.close(probe_fig)

v = np.array([1., 2., 3., 4.])      # 나타내려는 값
print(f"\n값 {list(v.astype(int))} 을 보일 때")
print(f"  넓이에 비례시키면 (s = 100 v):  넓이 비 = {list(np.round(v/v[0],2))}"
      f"   <- 값의 비와 같다")
print(f"  반지름에 비례시키면 (s = 100 v^2): 넓이 비 = "
      f"{list(np.round((v/v[0])**2,2))}   <- 값의 비의 제곱")
print(f"  가장 큰 값은 {v[-1]/v[0]:.0f} 배인데 {((v[-1]/v[0])**2):.0f} 배로 보인다 "
      f"({100*((v[-1]/v[0])**2/(v[-1]/v[0]) - 1):.0f}% 과장)")

fig, (a1, a2) = plt.subplots(1, 2, figsize=(11, 2.6), sharey=True)
for ax, s, ttl in [(a1, 120 * v, "넓이에 비례 ($s \\propto v$) — 옳다"),
                   (a2, 120 * v ** 2, "반지름에 비례 ($s \\propto v^2$) — 과장된다")]:
    ax.scatter(np.arange(4), np.zeros(4), s=s, color="#1565C0")
    for i, vv in enumerate(v):
        ax.annotate(f"v = {vv:.0f}", (i, 0), xytext=(0, -38),
                    textcoords="offset points", ha="center", fontsize=10)
    ax.set_title(ttl, fontsize=11)
    ax.set_xlim(-0.6, 3.8)
    ax.set_ylim(-0.6, 0.6)
    ax.axis("off")
plt.tight_layout()
plt.show()

      s     잰 지름 d   d/sqrt(s)    원 넓이 pi d^2/4     / s
     25     6.9444    1.388889          37.8761  1.5150
    100    13.8889    1.388889         151.5043  1.5150
    225    20.8333    1.388889         340.8846  1.5150
    400    27.7778    1.388889         606.0171  1.5150

값 [1, 2, 3, 4] 을 보일 때
  넓이에 비례시키면 (s = 100 v):  넓이 비 = [1.0, 2.0, 3.0, 4.0]   <- 값의 비와 같다
  반지름에 비례시키면 (s = 100 v^2): 넓이 비 = [1.0, 4.0, 9.0, 16.0]   <- 값의 비의 제곱
  가장 큰 값은 4 배인데 16 배로 보인다 (300% 과장)

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(0)
n = 20000
x = rng.normal(0, 1, n)
y = 0.7 * x + rng.normal(0, 0.7, n)

fig, axes = plt.subplots(1, 3, figsize=(13, 4))

# (1) 그냥 그리면 가운데가 다 뭉개진다
axes[0].scatter(x, y, s=6)
axes[0].set_title(f"산점도, n={n:,}\n(과밀)")

# (2) 투명도. alpha=0.03이면 점 하나가 3%만 진하다.
#     같은 자리에 33개쯤 겹쳐야 완전히 진해지므로 밀도가 진하기로 드러난다.
axes[1].scatter(x, y, s=6, alpha=0.03)
axes[1].set_title("산점도 + 투명도 alpha=0.03")

# (3) hexbin: 평면을 육각형으로 나누고 각 칸의 개수를 색으로 나타낸다.
#     mincnt=1 은 점이 하나도 없는 칸을 그리지 않는다는 뜻
hb = axes[2].hexbin(x, y, gridsize=40, cmap='Blues', mincnt=1)
axes[2].set_title("육각형 구간 그림")
plt.colorbar(hb, ax=axes[2], label='개수')

for ax in axes:
    ax.set_xlabel('x')
    ax.spines[['top', 'right']].set_visible(False)
axes[0].set_ylabel('y')

plt.tight_layout()
plt.show()

r_true = 0.7 / np.sqrt(0.7 ** 2 + 0.7 ** 2)
print(f"이론 상관 r = 0.7 / sqrt(0.7^2 + 0.7^2) = 1/sqrt(2) = {r_true:.6f}")
r0 = np.corrcoef(x, y)[0, 1]
print(f"표본 상관 r = {r0:.6f}   (몬테카를로 오차 ~ (1-r^2)/sqrt(n) = "
      f"{(1 - r_true ** 2) / np.sqrt(n):.6f})")

print("\n축을 바꾸어도 r 은 그대로인가")
cases = [("원자료", x, y), ("y 를 100 배", x, 100 * y),
         ("x 를 1/50 배 + 7", x / 50 + 7, y),
         ("둘 다 표준화", (x - x.mean()) / x.std(), (y - y.mean()) / y.std())]
for nm, xx, yy in cases:
    print(f"  {nm:<16} r = {np.corrcoef(xx, yy)[0, 1]:.12f}   "
          f"회귀기울기 b = {np.polyfit(xx, yy, 1)[0]:+.6f}")

print("\n몇 개의 점이 가려지는가 (figsize=(4.33, 4), dpi=170)")
for s in [6, 1]:
    fig, ax = plt.subplots(figsize=(4.33, 4), dpi=170)
    ax.scatter(x, y, s=s)
    fig.canvas.draw()
    px = ax.transData.transform(np.column_stack([x, y]))
    d = np.sqrt(s) * fig.dpi / 72                  # 마커 지름 (픽셀)
    uniq = len(np.unique(np.floor(px / d).astype(np.int64), axis=0))
    print(f"  s={s}: 마커 지름 {d:.2f} px,  마커 크기 격자의 서로 다른 칸 {uniq:,},  "
          f"덧칠되는 점 {n - uniq:,} ({100 * (n - uniq) / n:.1f}%)")
    plt.close(fig)

fig, (a1, a2) = plt.subplots(1, 2, figsize=(11, 3.6),
                             gridspec_kw={"width_ratios": [2.4, 1]})
for ax, yy, ttl in [(a1, y, "납작한 축, $y$ 그대로"),
                    (a2, 100 * y, "길쭉한 축, $y$ 를 100 배")]:
    ax.scatter(x, yy, s=4, alpha=0.05, color="#1565C0")
    b, c = np.polyfit(x, yy, 1)
    xs = np.array([x.min(), x.max()])
    ax.plot(xs, b * xs + c, color="#D32F2F", lw=1.8)
    ax.set_title(f"{ttl}\n$r$ = {np.corrcoef(x, yy)[0,1]:.6f},  기울기 = {b:.3f}",
                 fontsize=10)
    ax.set_xlabel("$x$")
    ax.spines[["top", "right"]].set_visible(False)
a1.set_ylabel("$y$")
plt.tight_layout()
plt.show()

이론 상관 r = 0.7 / sqrt(0.7^2 + 0.7^2) = 1/sqrt(2) = 0.707107
표본 상관 r = 0.704212   (몬테카를로 오차 ~ (1-r^2)/sqrt(n) = 0.003536)

축을 바꾸어도 r 은 그대로인가
  원자료              r = 0.704211695820   회귀기울기 b = +0.702388
  y 를 100 배        r = 0.704211695820   회귀기울기 b = +70.238787
  x 를 1/50 배 + 7   r = 0.704211695820   회귀기울기 b = +35.119393
  둘 다 표준화          r = 0.704211695820   회귀기울기 b = +0.704212

몇 개의 점이 가려지는가 (figsize=(4.33, 4), dpi=170)
  s=6: 마커 지름 5.78 px,  마커 크기 격자의 서로 다른 칸 2,195,  덧칠되는 점 17,805 (89.0%)
  s=1: 마커 지름 2.36 px,  마커 크기 격자의 서로 다른 칸 7,558,  덧칠되는 점 12,442 (62.2%)

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(0)

# 1~5의 정수 평점 300쌍
xs = rng.integers(1, 6, 300)
ys = rng.integers(1, 6, 300)

fig, (a, b) = plt.subplots(1, 2, figsize=(12, 4))

# 그냥 그리면 300개가 25개 자리에 완전히 포개진다
a.scatter(xs, ys, s=20)
a.set_title("이산 자료 — 점이 정확히 포개진다")
a.set_xlabel("평점 x")
a.set_ylabel("평점 y")

# 지터: 각 점을 ±0.2 범위에서 무작위로 민다.
# 값을 바꾸는 것이므로 그림 설명에 반드시 밝혀야 한다.
b.scatter(xs + rng.uniform(-.2, .2, 300),
          ys + rng.uniform(-.2, .2, 300), s=20, alpha=.5)
b.set_title("지터와 투명도를 준 뒤")
b.set_xlabel("평점 x")

for ax in (a, b):
    ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

N, K = 300, 25
print(f"관측 {N} 개,  가능한 자리 {K} 개")
occ = len(set(zip(xs.tolist(), ys.tolist())))
E = K * (1 - (1 - 1/K) ** N)
print(f"차 있는 자리: 실제 {occ},  기댓값 K(1-(1-1/K)^n) = {E:.6f}")
print(f"  (1-1/25)^300 = {(1-1/K)**N:.3e}  -> 빈 자리가 있을 확률이 사실상 0")
print(f"가려지는 점 = {N} - {occ} = {N-occ}  ({100*(N-occ)/N:.1f}%)")

cnt = np.zeros((5, 5), int)
for a, b in zip(xs, ys):
    cnt[a-1, b-1] += 1
print(f"한 자리의 도수: 최소 {cnt.min()}, 최대 {cnt.max()}, 평균 {cnt.mean():.1f}")
print("도수표 (행 = 평점 x, 열 = 평점 y):")
for i in range(5):
    print("   " + " ".join(f"{c:3d}" for c in cnt[i]))

print(f"\n{'n':>6}{'기대 차 있는 자리':>18}{'가려지는 비율':>14}")
for n2 in [10, 25, 50, 100, 300, 1000]:
    e = K * (1 - (1 - 1/K) ** n2)
    print(f"{n2:>6}{e:>18.2f}{100*(1-e/n2):>13.1f}%")

fig, (p1, p2, p3) = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)
p1.scatter(xs, ys, s=20, color="#1565C0")
p1.set_title(f"그대로 — 점 300개가 자국 {occ}개", fontsize=11)
p1.set_ylabel("평점 y")
p2.scatter(xs + rng.uniform(-.2, .2, N), ys + rng.uniform(-.2, .2, N),
           s=20, alpha=.5, color="#1565C0")
p2.set_title("지터 + 투명도 — 뭉치의 크기가 도수", fontsize=11)
gx, gy = np.meshgrid(np.arange(1, 6), np.arange(1, 6), indexing="ij")
p3.scatter(gx.ravel(), gy.ravel(), s=12 * cnt.ravel(), color="#E65100")
for i in range(5):
    for j in range(5):
        p3.annotate(f"{cnt[i, j]}", (i + 1, j + 1), xytext=(0, 14),
                    textcoords="offset points", ha="center", fontsize=8)
p3.set_title("거품 산점도 — 넓이가 도수 (자료를 바꾸지 않는다)", fontsize=11)
for ax in (p1, p2, p3):
    ax.set_xlabel("평점 x")
    ax.set_xlim(0.3, 5.7)
    ax.set_ylim(0.3, 5.9)
    ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

관측 300 개,  가능한 자리 25 개
차 있는 자리: 실제 25,  기댓값 K(1-(1-1/K)^n) = 24.999880
  (1-1/25)^300 = 4.801e-06  -> 빈 자리가 있을 확률이 사실상 0
가려지는 점 = 300 - 25 = 275  (91.7%)
한 자리의 도수: 최소 6, 최대 18, 평균 12.0
도수표 (행 = 평점 x, 열 = 평점 y):
     8  14  12  12  11
    14   6  13   6  11
    13   9  13  13  11
     9  13  10  16  11
    17   9  18  13  18

     n        기대 차 있는 자리       가려지는 비율
    10              8.38         16.2%
    25             15.99         36.0%
    50             21.75         56.5%
   100             24.58         75.4%
   300             25.00         91.7%
  1000             25.00         97.5%

import numpy as np

rng = np.random.default_rng(0)
d = rng.choice([1, 2, 3, 4, 5], 4000)

print("지터 폭에 따른 정보 손실 (원래 정수값을 반올림으로 되찾을 수 있는가)")
for j in (0.1, 0.3, 0.45, 0.6, 1.0):
    jittered = d + rng.uniform(-j, j, len(d))
    print(f"  ±{j:>4}: 복원 정확도 {np.mean(np.round(jittered) == d):.4f}   "
          f"인접 범주와 겹침 {'있음' if j > 0.5 else '없음'}")

지터 폭에 따른 정보 손실 (원래 정수값을 반올림으로 되찾을 수 있는가)
  ± 0.1: 복원 정확도 1.0000   인접 범주와 겹침 없음
  ± 0.3: 복원 정확도 1.0000   인접 범주와 겹침 없음
  ±0.45: 복원 정확도 1.0000   인접 범주와 겹침 없음
  ± 0.6: 복원 정확도 0.8350   인접 범주와 겹침 있음
  ± 1.0: 복원 정확도 0.5062   인접 범주와 겹침 있음

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(3)
x = np.linspace(0, 30, 300)
y = np.sin(x / 1.2) * 0.5 + 0.08 * x + rng.normal(0, 0.08, len(x))

fig, axes = plt.subplots(3, 1, figsize=(9, 7))
# set_aspect(r) 은 "y 한 눈금이 x 한 눈금의 r 배 길이"라는 뜻이다.
# 따라서 자료의 기울기 s 는 화면에서 r*s 로 보인다.
for ax, ratio, title in [(axes[0], 0.1, "너무 납작하다 — 진동이 보이지 않는다"),
                         (axes[1], 1.37, "45도로 눕혔다 — 진동과 추세가 함께 보인다"),
                         (axes[2], 12.0, "너무 높다 — 선분이 수직에 가까워 구별이 안 된다")]:
    ax.plot(x, y, lw=0.9)
    ax.set_aspect(ratio)
    ax.set_title(title, fontsize=9)
fig.tight_layout()
plt.show()

slopes = np.abs(np.diff(y) / np.diff(x))
print(f"국소 기울기의 중앙값 {np.median(slopes):.4f}")
# 화면 기울기가 1(=45도)이 되려면 r * s = 1, 즉 r = 1/s 여야 한다.
print(f"기울기 중앙값을 45도로 만드는 가로세로 비율 ≈ {1 / np.median(slopes):.4f}")

국소 기울기의 중앙값 0.7276
기울기 중앙값을 45도로 만드는 가로세로 비율 ≈ 1.3743

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(4)
n = 1500
x = rng.lognormal(0, 1.4, n)
y = 3 * x ** 0.8 * rng.lognormal(0, 0.35, n)

print(f"x 의 범위 {x.min():.4f} ~ {x.max():.1f}")
print(f"x 의 90% 가 {np.percentile(x, 90):.2f} 이하에 있다"
      f"  → 선형 축에서는 화면의 {np.percentile(x, 90) / x.max() * 100:.1f}% 안에 뭉친다")

fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))
axes[0].scatter(x, y, s=8, alpha=0.4)
axes[0].set_title("선형 축 — 왼쪽 아래 구석에 뭉친다", fontsize=10)
axes[1].scatter(x, y, s=8, alpha=0.4)
axes[1].set_xscale("log"); axes[1].set_yscale("log")
axes[1].set_title("양로그 축 — 관계가 직선으로 펴진다", fontsize=10)
# 로그 축의 기본 눈금표는 $10^{-2}$ 꼴의 수식이라 한글 글꼴에서 음수 기호가
# 깨진다. 눈금을 평범한 숫자로 찍으면 그 문제도 없고 읽기도 쉽다.
plain = mticker.FuncFormatter(lambda v, _: f"{v:g}")
axes[1].xaxis.set_major_formatter(plain)
axes[1].yaxis.set_major_formatter(plain)
for ax in axes:
    ax.set_xlabel("x"); ax.set_ylabel("y")
fig.tight_layout()
plt.show()

slope = np.polyfit(np.log(x), np.log(y), 1)[0]
print(f"\n양로그 기울기 {slope:.4f}   (참 지수 0.8)")

x 의 범위 0.0034 ~ 106.6
x 의 90% 가 6.38 이하에 있다  → 선형 축에서는 화면의 6.0% 안에 뭉친다

양로그 기울기 0.8035   (참 지수 0.8)

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(6)
n = 200
x = np.sort(rng.uniform(0, 10, n))
y = 2 + 0.3 * x + rng.normal(0, 1.2, n)         # 참 관계는 직선이다

def loess(x, y, xq, frac):
    """국소 선형 평활 (단순 구현)"""
    k = max(3, int(frac * len(x)))
    out = np.empty(len(xq))
    for i, q in enumerate(xq):
        idx = np.argsort(np.abs(x - q))[:k]
        d = np.abs(x[idx] - q)
        w = (1 - (d / (d.max() + 1e-12)) ** 3) ** 3
        b = np.polyfit(x[idx], y[idx], 1, w=np.sqrt(w))
        out[i] = np.polyval(b, q)
    return out

xq = np.linspace(0.3, 9.7, 200)
fig, axes = plt.subplots(1, 3, figsize=(13, 4), sharey=True)
for ax, frac in zip(axes, (0.08, 0.3, 0.9)):
    ax.scatter(x, y, s=10, alpha=0.4)
    ax.plot(xq, loess(x, y, xq, frac), color="red", lw=2)
    ax.plot(xq, 2 + 0.3 * xq, color="green", ls="--", lw=1.5)
    ax.set_title(f"span = {frac}", fontsize=10)
axes[0].set_ylabel("y")
fig.tight_layout()
plt.show()

for frac in (0.08, 0.3, 0.9):
    fit = loess(x, y, xq, frac)
    print(f"span {frac}: 참 직선과의 최대 이탈 {np.max(np.abs(fit - (2 + 0.3 * xq))):.4f}")

span 0.08: 참 직선과의 최대 이탈 0.9939
span 0.3: 참 직선과의 최대 이탈 0.4274
span 0.9: 참 직선과의 최대 이탈 0.1247

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

rng = np.random.default_rng(7)
n = 3000

A = rng.multivariate_normal([0, 0], [[1, 0.7], [0.7, 1]], n)

c2 = 0.8
c, v, w = np.sqrt(c2), 1 - c2, 0.7 - c2
half = n // 2
B = np.vstack([rng.multivariate_normal([-c, -c], [[v, w], [w, v]], half),
               rng.multivariate_normal([c, c], [[v, w], [w, v]], n - half)])

print(f"{'자료':>12}{'상관':>10}{'x 평균':>10}{'x 표준편차':>12}{'x 초과첨도':>12}")
for label, d in [("A 정규", A), ("B 두 덩어리", B)]:
    print(f"{label:>12}{np.corrcoef(d.T)[0, 1]:>+10.4f}{d[:, 0].mean():>+10.3f}"
          f"{d[:, 0].std():>12.4f}{stats.kurtosis(d[:, 0]):>+12.4f}")

fig, axes = plt.subplots(1, 2, figsize=(11, 5), sharex=True, sharey=True)
for ax, (label, d) in zip(axes, [("A 정규", A), ("B 두 덩어리", B)]):
    ax.scatter(d[:, 0], d[:, 1], s=6, alpha=0.25)
    ax.set_title(f"{label}   r = {np.corrcoef(d.T)[0, 1]:.3f}", fontsize=10)
    ax.set_xlabel("x"); ax.set_ylabel("y")
fig.tight_layout()
plt.show()

          자료        상관      x 평균      x 표준편차      x 초과첨도
        A 정규   +0.6954    +0.008      1.0065     -0.0772
     B 두 덩어리   +0.6940    +0.010      1.0086     -1.2763

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

values = np.array([1, 2, 4, 8, 16], float)

print("값을 넓이에 비례시켰을 때")
print(f"{'값':>6}{'반지름 비':>12}{'넓이 비':>10}{'지각되는 크기 비':>18}")
for v in values:
    r = np.sqrt(v / values[0])
    print(f"{v:>6.0f}{r:>12.3f}{v / values[0]:>10.1f}{(v / values[0]) ** 0.7:>18.2f}")

fig, axes = plt.subplots(1, 2, figsize=(11, 3.5))
x = np.arange(len(values))
axes[0].scatter(x, np.zeros_like(x), s=values / values[0] * 120)
axes[0].set_title("넓이에 비례 — 16배 차이가 7배로 보인다", fontsize=9)
axes[1].bar(x, values)
axes[1].set_title("막대 길이 — 16배가 16배로 보인다", fontsize=9)
for ax in axes:
    ax.set_xticks(x); ax.set_xticklabels([f"{int(v)}" for v in values])
axes[0].set_yticks([])
fig.tight_layout()
plt.show()

값을 넓이에 비례시켰을 때
     값       반지름 비      넓이 비         지각되는 크기 비
     1       1.000       1.0              1.00
     2       1.414       2.0              1.62
     4       2.000       4.0              2.64
     8       2.828       8.0              4.29
    16       4.000      16.0              6.96

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(0)
K, n = 4, 120
group = np.repeat(np.arange(K), n)
offset = np.array([0., 3., 6., 9.])
x = rng.normal(offset[group], 0.8)
y = -0.8 * (x - offset[group]) + 2.0 * offset[group] / 3 + rng.normal(0, 0.5, len(x))

print(f"전체 상관 {np.corrcoef(x, y)[0, 1]:+.4f}   "
      f"전체 기울기 {np.polyfit(x, y, 1)[0]:+.4f}")
for k in range(K):
    m = group == k
    print(f"  집단 {k}: 상관 {np.corrcoef(x[m], y[m])[0, 1]:+.4f}   "
          f"기울기 {np.polyfit(x[m], y[m], 1)[0]:+.4f}")

fig, axes = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True)
axes[0].scatter(x, y, s=10, alpha=0.5, color="gray")
xs = np.linspace(x.min(), x.max(), 50)
axes[0].plot(xs, np.polyval(np.polyfit(x, y, 1), xs), color="red", lw=2)
axes[0].set_title("집단을 모르면 — 양의 관계로 보인다", fontsize=10)
for k in range(K):
    m = group == k
    axes[1].scatter(x[m], y[m], s=10, alpha=0.6, label=f"집단 {k}")
    xk = np.linspace(x[m].min(), x[m].max(), 30)
    axes[1].plot(xk, np.polyval(np.polyfit(x[m], y[m], 1), xk), lw=2)
axes[1].set_title("집단별로 보면 — 모두 음의 관계", fontsize=10)
axes[1].legend(fontsize=8)
for ax in axes:
    ax.set_xlabel("x"); ax.set_ylabel("y")
fig.tight_layout()
plt.show()

전체 상관 +0.8508   전체 기울기 +0.5860
  집단 0: 상관 -0.8030   기울기 -0.8002
  집단 1: 상관 -0.8200   기울기 -0.8412
  집단 2: 상관 -0.8238   기울기 -0.8351
  집단 3: 상관 -0.8058   기울기 -0.6931