파레토 그림¶

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

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

# 어떤 공정에서 한 달간 기록된 불량 유형별 건수
defects = pd.Series({'긁힘': 112, '찌그러짐': 63, '정렬 불량': 41,
                     '변색': 18, '균열': 11, '기타': 7})

# 1단계: 큰 순으로 정렬한다. 파레토 그림에서 정렬은 선택이 아니라 필수다.
#         정렬하지 않으면 누적선이 계단처럼 들쭉날쭉해져 읽을 수 없다.
defects = defects.sort_values(ascending=False)

# 2단계: 누적 비율을 계산한다. cumsum()이 왼쪽부터 차례로 더해 준다.
cum = defects.cumsum() / defects.sum() * 100

fig, ax = plt.subplots(figsize=(9, 4))

# 왼쪽 축: 건수 막대
ax.bar(defects.index, defects.values, color='steelblue', width=0.6)
ax.set_ylabel("건수")
ax.set_xlabel("불량 유형")

# 오른쪽 축: 누적 비율 선. twinx()가 같은 x축을 공유하는 두 번째 y축을 만든다.
ax2 = ax.twinx()
ax2.plot(defects.index, cum.values, 'o-', color='crimson', lw=2)
ax2.axhline(80, color='gray', ls='--', lw=1)   # 80% 기준선
ax2.set_ylabel("누적 비율 (%)")
ax2.set_ylim(0, 105)

ax.set_title("파레토 그림: 불량 유형")
ax.spines['top'].set_visible(False)
ax2.spines['top'].set_visible(False)
plt.tight_layout()
plt.show()

print(cum.round(1))

# (1) 증분(= 각 범주의 몫)이 정말 비증가인가. 정렬했으므로 그래야 한다.
v = defects.values.astype(float)
T = v.sum()
c = np.cumsum(v) / T
inc = np.diff(np.concatenate([[0.0], c]))
print("\n증분  :", np.round(inc, 4))
print("비증가:", bool(np.all(np.diff(inc) <= 1e-12)))

# 80% 선을 처음 넘는 범주 수
k80 = int(np.searchsorted(c, 0.80)) + 1
print(f"80% 를 넘기는 데 필요한 범주 {k80} 개 / {len(v)} 개"
      f"  (= 상위 {k80/len(v):.0%}),  그때 누적 {c[k80-1]:.4f}")
print(f"상위 20% (= {0.2*len(v):.1f} 개 → 1 개) 의 몫 {c[0]:.4f}")

# 지니계수 — 작은 순으로 늘어놓고 쓴다
y = np.sort(v)
K = len(y)
i = np.arange(1, K + 1)
gini = 2 * np.sum(i * y) / (K * y.sum()) - (K + 1) / K
print(f"\nsum i*y = {np.sum(i * y):.0f},  지니계수 G = {gini:.4f}"
      f"  (상한 (K-1)/K = {(K-1)/K:.4f},  그 {gini/((K-1)/K):.0%})")

긁힘        44.4
찌그러짐      69.4
정렬 불량     85.7
변색        92.9
균열        97.2
기타       100.0
dtype: float64

증분  : [0.4444 0.25   0.1627 0.0714 0.0437 0.0278]
비증가: True
80% 를 넘기는 데 필요한 범주 3 개 / 6 개  (= 상위 50%),  그때 누적 0.8571
상위 20% (= 1.2 개 → 1 개) 의 몫 0.4444

sum i*y = 1234,  지니계수 G = 0.4656  (상한 (K-1)/K = 0.8333,  그 56%)

import numpy as np

rng = np.random.default_rng(0)

def top_share(v, frac=0.2):
    s = np.sort(np.asarray(v, float))[::-1]
    k = max(1, int(round(len(s) * frac)))
    return s[:k].sum() / s.sum()

print(f"{'분포':>16}{'상위 20% 비중':>15}{'80% 를 차지하는 상위 비율':>26}")
cases = {
    "균등": rng.uniform(1, 2, 2000),
    "정규(양수)": np.abs(rng.normal(100, 20, 2000)),
    "지수": rng.exponential(1, 2000),
    "로그정규(s=1)": rng.lognormal(0, 1, 2000),
    "로그정규(s=2)": rng.lognormal(0, 2, 2000),
    "파레토(a=1.16)": rng.pareto(1.16, 2000) + 1,
}
for name, v in cases.items():
    s = np.sort(v)[::-1]
    c = np.cumsum(s) / s.sum()
    k80 = int(np.searchsorted(c, 0.8)) + 1
    print(f"{name:>16}{top_share(v):>15.4f}{k80 / len(s):>26.4f}")

              분포      상위 20% 비중          80% 를 차지하는 상위 비율
              균등         0.2536                    0.7345
          정규(양수)         0.2570                    0.7360
              지수         0.5223                    0.4360
       로그정규(s=1)         0.5594                    0.4335
       로그정규(s=2)         0.8456                    0.1535
     파레토(a=1.16)         0.7491                    0.2875

import numpy as np
import matplotlib.pyplot as plt

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

labels = ["결제 오류", "배송 지연", "상품 불량", "회원가입 문제", "환불 요청", "기타"]
counts = np.array([340, 210, 95, 60, 45, 30], float)

order = np.argsort(-counts)
print(f"{'유형':>14}{'건수':>7}{'비율':>9}{'누적 비율':>11}")
cum = 0.0
for i in order:
    cum += counts[i] / counts.sum()
    print(f"{labels[i]:>14}{counts[i]:>7.0f}{counts[i]/counts.sum():>9.3f}{cum:>11.3f}")

# "기타"를 크기와 무관하게 맨 끝으로
idx = [i for i in np.argsort(-counts) if labels[i] != "기타"] + [labels.index("기타")]
c = np.cumsum(counts[idx]) / counts.sum()

fig, ax = plt.subplots(figsize=(8, 4))
ax.bar(range(len(idx)), counts[idx], color="steelblue")
ax.set_xticks(range(len(idx)))
ax.set_xticklabels([labels[i] for i in idx], rotation=20, ha="right")
ax.set_ylabel("건수")
ax2 = ax.twinx()
ax2.plot(range(len(idx)), c * 100, "o-", color="darkorange")
ax2.axhline(80, color="gray", ls="--", lw=1)
ax2.set_ylabel("누적 비율 (%)"); ax2.set_ylim(0, 105)
fig.tight_layout()
plt.show()

k80 = int(np.searchsorted(c, 0.8)) + 1
print(f"\n상위 {k80}개 유형이 전체의 {c[k80-1]:.1%} 를 차지한다")

            유형     건수       비율      누적 비율
         결제 오류    340    0.436      0.436
         배송 지연    210    0.269      0.705
         상품 불량     95    0.122      0.827
       회원가입 문제     60    0.077      0.904
         환불 요청     45    0.058      0.962
            기타     30    0.038      1.000

상위 3개 유형이 전체의 82.7% 를 차지한다

import numpy as np

a = np.array([50, 45, 40, 35, 30], float)      # 고른 자료
b = np.array([160, 20, 10, 8, 2], float)       # 치우친 자료

for name, v in [("고른 자료", a), ("치우친 자료", b)]:
    s = np.sort(v)[::-1]
    c = np.cumsum(s) / s.sum()
    slopes = np.diff(np.concatenate([[0], c]))
    print(f"{name}: 누적 {np.round(c, 3)}")
    print(f"  구간별 기울기 {np.round(slopes, 3)}")
    print(f"  첫 기울기 / 마지막 기울기 = {slopes[0]/slopes[-1]:.1f}\n")

고른 자료: 누적 [0.25  0.475 0.675 0.85  1.   ]
  구간별 기울기 [0.25  0.225 0.2   0.175 0.15 ]
  첫 기울기 / 마지막 기울기 = 1.7

치우친 자료: 누적 [0.8  0.9  0.95 0.99 1.  ]
  구간별 기울기 [0.8  0.1  0.05 0.04 0.01]
  첫 기울기 / 마지막 기울기 = 80.0

import numpy as np

months = ["1월", "2월", "3월", "4월", "5월", "6월",
          "7월", "8월", "9월", "10월", "11월", "12월"]
sales = np.array([80, 75, 85, 90, 95, 110, 130, 125, 100, 92, 88, 140], float)

print("원래 순서 (계절성이 보인다)")
print(f"  {dict(zip(months, sales.astype(int)))}")
print(f"  여름(6~8월) 평균 {sales[5:8].mean():.1f}, 겨울(12~2월) 평균 "
      f"{np.mean([sales[11], sales[0], sales[1]]):.1f}")

order = np.argsort(-sales)
print("\n크기 순 정렬 (계절성이 사라진다)")
print(f"  {[months[i] for i in order]}")
c = np.cumsum(sales[order]) / sales.sum()
print(f"  상위 20%(2~3개월)가 {c[2]:.1%} 를 차지 — 그래서 어쩌라는 것인가?")

원래 순서 (계절성이 보인다)
  {'1월': 80, '2월': 75, '3월': 85, '4월': 90, '5월': 95, '6월': 110, '7월': 130, '8월': 125, '9월': 100, '10월': 92, '11월': 88, '12월': 140}
  여름(6~8월) 평균 121.7, 겨울(12~2월) 평균 98.3

크기 순 정렬 (계절성이 사라진다)
  ['12월', '7월', '8월', '6월', '9월', '5월', '10월', '4월', '11월', '3월', '1월', '2월']
  상위 20%(2~3개월)가 32.6% 를 차지 — 그래서 어쩌라는 것인가?

import numpy as np
from scipy import stats

rng = np.random.default_rng(1)
labels = ["A", "B", "C", "D", "E"]
counts = np.array([48, 42, 38, 35, 32], float)      # 서로 비슷하다
n = counts.sum()

print(f"{'범주':>5}{'건수':>7}{'비율':>9}{'95% 윌슨 구간':>22}")
for l, k in zip(labels, counts):
    p = k / n
    z = 1.96
    d = 1 + z * z / n
    c = (p + z * z / (2 * n)) / d
    h = z / d * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
    print(f"{l:>5}{k:>7.0f}{p:>9.4f}   [{c-h:.4f}, {c+h:.4f}]")

print("\n부트스트랩으로 순위의 안정성 확인")
B = 10_000
ranks = np.empty((B, len(labels)))
for b in range(B):
    resampled = rng.multinomial(int(n), counts / n)
    ranks[b] = stats.rankdata(-resampled)
for i, l in enumerate(labels):
    print(f"  {l}: 1위 확률 {np.mean(ranks[:, i] == 1):.3f}   "
          f"순위 90% 구간 [{np.quantile(ranks[:, i], 0.05):.0f}, "
          f"{np.quantile(ranks[:, i], 0.95):.0f}]")

   범주     건수       비율             95% 윌슨 구간
    A     48   0.2462   [0.1910, 0.3111]
    B     42   0.2154   [0.1635, 0.2783]
    C     38   0.1949   [0.1454, 0.2561]
    D     35   0.1795   [0.1320, 0.2394]
    E     32   0.1641   [0.1187, 0.2225]

부트스트랩으로 순위의 안정성 확인
  A: 1위 확률 0.641   순위 90% 구간 [1, 3]
  B: 1위 확률 0.203   순위 90% 구간 [1, 4]
  C: 1위 확률 0.070   순위 90% 구간 [1, 5]
  D: 1위 확률 0.027   순위 90% 구간 [2, 5]
  E: 1위 확률 0.008   순위 90% 구간 [2, 5]

import numpy as np

labels = ["결제 오류", "배송 지연", "상품 불량", "회원가입 문제", "환불 요청"]
counts = np.array([340, 210, 95, 60, 45], float)          # 건수
unit_cost = np.array([2, 8, 45, 1, 30], float)            # 건당 처리 비용(만원)
unit_time = np.array([5, 20, 90, 3, 40], float)           # 건당 처리 시간(분)

for name, w in [("건수", counts),
                ("총 비용", counts * unit_cost),
                ("총 시간", counts * unit_time)]:
    order = np.argsort(-w)
    c = np.cumsum(w[order]) / w.sum()
    top = [labels[i] for i in order[:3]]
    print(f"{name:>8} 기준 상위 3개: {top}   상위 3개가 {c[2]:.1%}")

      건수 기준 상위 3개: ['결제 오류', '배송 지연', '상품 불량']   상위 3개가 86.0%
    총 비용 기준 상위 3개: ['상품 불량', '배송 지연', '환불 요청']   상위 3개가 90.8%
    총 시간 기준 상위 3개: ['상품 불량', '배송 지연', '환불 요청']   상위 3개가 88.6%

import numpy as np

labels = ["A", "B", "C", "D", "E"]
before = np.array([340, 210, 95, 60, 45], float)
after = np.array([120, 205, 92, 58, 44], float)      # A 에만 개선 조치

for name, v in [("개선 전", before), ("개선 후", after)]:
    order = np.argsort(-v)
    c = np.cumsum(v[order]) / v.sum()
    print(f"{name}: 총 {v.sum():.0f}건, 순위 {[labels[i] for i in order]}, "
          f"상위 2개가 {c[1]:.1%}")

print(f"\nA 는 {before[0]:.0f} → {after[0]:.0f} 로 {1 - after[0]/before[0]:.1%} 감소")
print(f"전체는 {before.sum():.0f} → {after.sum():.0f} 로 "
      f"{1 - after.sum()/before.sum():.1%} 감소")
print(f"그런데 B 의 '비중'은 {before[1]/before.sum():.3f} → "
      f"{after[1]/after.sum():.3f} 로 올랐다 (건수는 거의 그대로)")

개선 전: 총 750건, 순위 ['A', 'B', 'C', 'D', 'E'], 상위 2개가 73.3%
개선 후: 총 519건, 순위 ['B', 'A', 'C', 'D', 'E'], 상위 2개가 62.6%

A 는 340 → 120 로 64.7% 감소
전체는 750 → 519 로 30.8% 감소
그런데 B 의 '비중'은 0.280 → 0.395 로 올랐다 (건수는 거의 그대로)