계단함수¶

import pandas as pd

# "Practical Statistics for Data Scientists" 저장소의 자료. 탭으로 구분되어 있다.
url = ("https://raw.githubusercontent.com/gedeck/"
       "practical-statistics-for-data-scientists/8a6d3bb6468e979c861d4b37215e1413702dfdfa/data/house_sales.csv")
house = pd.read_csv(url, sep='\t')

print(f"{len(house)}건, 열 {house.shape[1]}개")
print(house[['AdjSalePrice', 'SqFtTotLiving', 'YrBuilt']].describe().round(1).to_string())

22687건, 열 22개
       AdjSalePrice  SqFtTotLiving  YrBuilt
count       22687.0        22687.0  22687.0
mean       565233.3         2080.2   1971.2
std        385402.9          913.7     30.3
min          3368.0          370.0   1900.0
25%        360563.0         1420.0   1950.0
50%        471315.0         1910.0   1977.0
75%        649411.0         2540.0   2000.0
max      11644855.0        10740.0   2015.0

import numpy as np

age = 2024 - house['YrBuilt'].values
print("YrBuilt 사분위수 =", np.percentile(house['YrBuilt'], [25, 50, 75]))
print("나이    사분위수 =", np.percentile(age, [25, 50, 75]))

knots = [0, 20, 40, 60, 80, 150]
cut = pd.cut(age, bins=knots, include_lowest=True)
tab = pd.DataFrame({'건수': pd.Series(cut).value_counts().sort_index()})
tab['이름폭'] = [20, 20, 20, 20, 70]
tab['실제폭'] = [20, 20, 20, 20, age.max() - 80]
tab['한 해당'] = (tab['건수'] / tab['실제폭']).round(1)
print(tab.to_string())
print(f"나이의 최댓값 = {age.max()},  마지막 절단점 = {knots[-1]}")

YrBuilt 사분위수 = [1950. 1977. 2000.]
나이    사분위수 = [24. 47. 74.]
                  건수  이름폭  실제폭   한 해당
(-0.001, 20.0]  4170   20   20  208.5
(20.0, 40.0]    5558   20   20  277.9
(40.0, 60.0]    4212   20   20  210.6
(60.0, 80.0]    4259   20   20  213.0
(80.0, 150.0]   4488   70   44  102.0
나이의 최댓값 = 124,  마지막 절단점 = 150

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

age = 2024 - house['YrBuilt'].values
price = house['AdjSalePrice'].values
df = pd.DataFrame({'age': age, 'price': price})

# 계단함수는 연속변수를 구간으로 잘라 구간마다 상수를 맞추는 것이다.
# 가장 거친 비선형 모형이지만 해석이 쉽다는 장점이 있다.
knots = [0, 20, 40, 60, 80, 150]
df['age_bin'] = pd.cut(df['age'], bins=knots, include_lowest=True)

# 구간마다 가변수 하나씩을 만든다.
df_dummies = pd.get_dummies(df['age_bin'], drop_first=False)

X_step = df_dummies.values
step_model = LinearRegression()
step_model.fit(X_step, df['price'])

# 절편 없이 적합하면 각 계수가 곧 그 구간의 평균이 된다.
step_model_nc = LinearRegression(fit_intercept=False).fit(X_step, df['price'])
for interval, coef in zip(df_dummies.columns, step_model_nc.coef_):
    print(f"{str(interval):<18} 평균 가격 = {coef:>10,.0f}")
print(f"R^2 = {r2_score(df['price'], step_model.predict(X_step)):.4f}")

(-0.001, 20.0]     평균 가격 =    642,643
(20.0, 40.0]       평균 가격 =    621,917
(40.0, 60.0]       평균 가격 =    490,326
(60.0, 80.0]       평균 가격 =    482,741
(80.0, 150.0]      평균 가격 =    571,694
R^2 = 0.0283

grp = df.groupby('age_bin', observed=True)['price'].agg(['count', 'mean'])
ybar = df['price'].mean()
SSB = (grp['count'] * (grp['mean'] - ybar) ** 2).sum()
SST = ((df['price'] - ybar) ** 2).sum()
print(f"구간간 제곱합 SSB = {SSB:.6e}")
print(f"전체   제곱합 SST = {SST:.6e}")
print(f"손으로 구한 R^2 = SSB/SST = {SSB / SST:.8f}")

pred_int = step_model.predict(X_step)
pred_nc = step_model_nc.predict(X_step)
pred_mean = df['age_bin'].map(grp['mean']).values.astype(float)
for name, p in [("절편 포함 (쪽의 값)", pred_int), ("절편 없이", pred_nc),
                ("구간평균 직접", pred_mean)]:
    print(f"{name:<20} R^2 = {r2_score(df['price'], p):.8f}")
print(f"절편 포함 적합값 vs 구간평균: 최대 차이 {np.abs(pred_int - pred_mean).max():,.0f}")
print(f"절편 없이 적합값 vs 구간평균: 최대 차이 {np.abs(pred_nc - pred_mean).max():.2e}")
print(f"절편 포함 계수의 최대 절대값 = 10^{np.log10(np.abs(step_model.coef_).max()):.1f}")

구간간 제곱합 SSB = 9.564938e+13
전체   제곱합 SST = 3.369673e+15
손으로 구한 R^2 = SSB/SST = 0.02838536
절편 포함 (쪽의 값)         R^2 = 0.02833211
절편 없이                R^2 = 0.02838536
구간평균 직접              R^2 = 0.02838536
절편 포함 적합값 vs 구간평균: 최대 차이 4,365
절편 없이 적합값 vs 구간평균: 최대 차이 4.81e-08
절편 포함 계수의 최대 절대값 = 10^16.3

# 구간을 몇 개로 나눌지가 이 방법의 유일한 조절값이다. 늘리면 R^2 는
# 반드시 오르지만 구간마다 자료가 줄어 추정이 불안해진다.
# qcut 은 개수가 고르게 들어가도록 분위수로 자른다.
results = []
for n_bins in [3, 4, 5, 6, 8, 10]:
    df['bin_temp'] = pd.qcut(df['age'], q=n_bins, duplicates='drop')
    X_temp = pd.get_dummies(df['bin_temp'], drop_first=False).values
    model = LinearRegression().fit(X_temp, df['price'])
    pred = model.predict(X_temp)
    r2 = r2_score(df['price'], pred)
    rmse = np.sqrt(mean_squared_error(df['price'], pred))
    results.append({'n_bins': n_bins, 'R2': r2, 'RMSE': rmse})

print(pd.DataFrame(results).round(4).to_string(index=False))

 n_bins     R2        RMSE
      3 0.0226 381016.7261
      4 0.0239 380754.8087
      5 0.0286 379852.0395
      6 0.0327 379038.4143
      8 0.0332 378949.6438
     10 0.0334 378904.4326

rows, prev = [], None
for q in range(3, 13):
    X = pd.get_dummies(pd.qcut(df['age'], q=q, duplicates='drop'),
                       drop_first=False).values
    r2 = r2_score(df['price'],
                  LinearRegression(fit_intercept=False).fit(X, df['price']).predict(X))
    rows.append({'q': q, '구간': X.shape[1], 'R2': round(r2, 6),
                 '앞보다': '-' if prev is None else ('내려감' if r2 < prev else '올라감')})
    prev = r2
print(pd.DataFrame(rows).to_string(index=False))

def qcut_edges(q):
    """qcut 이 실제로 쓴 내부 절단점."""
    cats = pd.qcut(df['age'], q=q, duplicates='drop').cat.categories
    return sorted(set(cats.right.values[:-1]))

print()
for small, big in [(3, 6), (4, 8), (5, 10), (6, 8), (7, 8)]:
    es, eb = qcut_edges(small), qcut_edges(big)
    print(f"q={small:2d} -> q={big:2d}:  {big} 가 {small} 의 배수 {str(big % small == 0):<5} "
          f"절단점 포함 {set(es) <= set(eb)}")

 q  구간       R2 앞보다
 3   3 0.022651   -
 4   4 0.024003 올라감
 5   5 0.028654 올라감
 6   6 0.032741 올라감
 7   7 0.034249 올라감
 8   8 0.033282 내려감
 9   9 0.030280 내려감
10  10 0.033404 올라감
11  11 0.036551 올라감
12  12 0.035454 내려감

q= 3 -> q= 6:  6 가 3 의 배수 True  절단점 포함 True
q= 4 -> q= 8:  8 가 4 의 배수 True  절단점 포함 True
q= 5 -> q=10:  10 가 5 의 배수 True  절단점 포함 True
q= 6 -> q= 8:  8 가 6 의 배수 False 절단점 포함 False
q= 7 -> q= 8:  8 가 7 의 배수 False 절단점 포함 False

# 견줄 기준선 둘. 직선과 3차 다항식이다.
linear_model = LinearRegression()
linear_model.fit(df[['age']].values, df['price'])

X_poly = np.column_stack([df['age'] ** i for i in range(1, 4)])
poly_model = LinearRegression().fit(X_poly, df['price'])

slope_hand = np.cov(df['age'], df['price'], ddof=1)[0, 1] / np.var(df['age'], ddof=1)
r = np.corrcoef(df['age'], df['price'])[0, 1]
pred_lin = linear_model.predict(df[['age']].values)
print(f"기울기: sklearn {linear_model.coef_[0]:.4f}   손계산 {slope_hand:.4f}")
print(f"R^2: sklearn {r2_score(df['price'], pred_lin):.6f}   상관계수^2 {r ** 2:.6f}   (r = {r:.4f})")

pred_poly = poly_model.predict(X_poly)
print(f"3차 다항 설계행렬의 조건수 = "
      f"{np.linalg.cond(np.column_stack([np.ones(len(X_poly)), X_poly])):.3e}")

for name, pred, p in [("직선      ", pred_lin, 2),
                      ("3차 다항  ", pred_poly, 4),
                      ("계단 5구간", step_model_nc.predict(X_step), 5)]:
    print(f"{name}  모수 {p}개   R^2 = {r2_score(df['price'], pred):.6f}   "
          f"RMSE = {np.sqrt(mean_squared_error(df['price'], pred)):>9,.0f}")

기울기: sklearn -1044.2267   손계산 -1044.2267
R^2: sklearn 0.006746   상관계수^2 0.006746   (r = -0.0821)
3차 다항 설계행렬의 조건수 = 3.864e+06
직선        모수 2개   R^2 = 0.006746   RMSE =   384,092
3차 다항    모수 4개   R^2 = 0.029196   RMSE =   379,727
계단 5구간  모수 5개   R^2 = 0.028385   RMSE =   379,885

# 분위수로 나눈 구간 — 구간마다 개수가 고르다
df['q_bin'] = pd.qcut(df['age'], q=5)
q_means = df.groupby('q_bin')['price'].agg(['mean', 'count'])

# 폭이 같은 구간 — 구간마다 개수가 들쭉날쭉하다
df['w_bin'] = pd.cut(df['age'], bins=5)
w_means = df.groupby('w_bin')['price'].agg(['mean', 'count'])

bin_edges = [0, 20, 40, 60, 80, 150]
bin_indices = np.digitize(df['age'], bin_edges)
# 가변수 행렬을 만든다
K = len(bin_edges) - 1
X_digit = np.zeros((len(df), K))
for k in range(K):
    X_digit[:, k] = (bin_indices == k + 1).astype(float)
model_digit = LinearRegression().fit(X_digit, df['price'])

from sklearn.linear_model import LogisticRegression

# "비싼" 주택을 중앙값 위로 정의한다.
df = pd.DataFrame({'age': 2024 - house['YrBuilt'].values,
                   'price': house['AdjSalePrice'].values})
df['expensive'] = (df['price'] > df['price'].median()).astype(int)

# 연속형 설명변수
logit_cont = LogisticRegression().fit(df[['age']], df['expensive'])
acc_cont = logit_cont.score(df[['age']], df['expensive'])

# 계단함수 설명변수
X_class = pd.get_dummies(pd.cut(df['age'], bins=5), drop_first=True).values
logit_step = LogisticRegression().fit(X_class, df['expensive'])
acc_step = logit_step.score(X_class, df['expensive'])

print(f"연속형 정확도: {acc_cont:.4f}")
print(f"계단함수 정확도: {acc_step:.4f}")

연속형 정확도: 0.5614
계단함수 정확도: 0.5818