Blog

#!/usr/bin/env python3
"""파일마다 (크기, 바이트 엔트로피, gzip 압축 후 크기)를 측정해 CSV로 남긴다."""
import gzip, math, random, sys
from collections import Counter
from pathlib import Path

DIRS = ["/usr/bin", "/usr/lib/x86_64-linux-gnu", "/usr/share/doc",
        "/usr/share/man", "/usr/share/icons", "/usr/include"]

def entropy(data: bytes) -> float:
    counts = Counter(data)
    n = len(data)
    return -sum((c / n) * math.log2(c / n) for c in counts.values())

def collect(limit_per_dir=60, min_size=4096, max_size=2_000_000):
    random.seed(42)
    rows = []
    for d in DIRS:
        files = [p for p in Path(d).rglob("*") if p.is_file() and not p.is_symlink()]
        random.shuffle(files)
        taken = 0
        for p in files:
            if taken >= limit_per_dir:
                break
            try:
                data = p.read_bytes()
            except OSError:
                continue
            if not (min_size <= len(data) <= max_size):
                continue
            gz = len(gzip.compress(data, 9))
            rows.append((p.suffix.lower() or "(none)", len(data), entropy(data), gz))
            taken += 1
    return rows

if __name__ == "__main__":
    rows = collect()
    with open("files.csv", "w") as f:
        f.write("ext,size,entropy,gz_size\n")
        for ext, size, ent, gz in rows:
            f.write(f"{ext},{size},{ent:.4f},{gz}\n")
    print(f"수집한 파일: {len(rows)}개 -> files.csv")

#!/usr/bin/env python3
"""같은 문제를 (1) 손으로 짠 규칙 (2) 데이터로 학습한 직선 으로 각각 풀어 비교한다."""
import csv
import numpy as np

TEXT_EXT = {".h", ".html", ".txt", ".pl", ".pm", ".svg", ".1", ".0", ".openbsd"}

rows = list(csv.DictReader(open("files.csv")))
ext     = np.array([r["ext"] for r in rows])
size    = np.array([int(r["size"]) for r in rows], dtype=float)
entropy = np.array([float(r["entropy"]) for r in rows])
ratio   = np.array([int(r["gz_size"]) for r in rows]) / size   # 예측 대상

rng = np.random.default_rng(0)
idx = rng.permutation(len(rows))
n_train = int(len(rows) * 0.7)
tr, te = idx[:n_train], idx[n_train:]

def mae(pred, true):
    return float(np.mean(np.abs(pred - true)))

# (1) 사람이 짠 규칙: 확장자가 텍스트류면 잘 줄고, 아니면 안 줄 것이다
def rule(ext_arr):
    return np.where(np.isin(ext_arr, list(TEXT_EXT)), 0.30, 0.90)

# (2) 학습: ratio ≈ w*entropy + b 의 w, b를 데이터에서 찾는다 (최소제곱)
X_tr = np.column_stack([entropy[tr], np.ones(len(tr))])
w, b = np.linalg.lstsq(X_tr, ratio[tr], rcond=None)[0]

print(f"학습 데이터 {len(tr)}개 / 평가 데이터 {len(te)}개")
print(f"찾아낸 파라미터: ratio = {w:.4f} * entropy + {b:.4f}")
print()
print(f"{'방법':<28}{'평가 MAE':>10}")
print("-" * 38)
print(f"{'항상 평균값으로 예측':<24}{mae(np.full(len(te), ratio[tr].mean()), ratio[te]):>12.4f}")
print(f"{'손으로 짠 확장자 규칙':<24}{mae(rule(ext[te]), ratio[te]):>12.4f}")
print(f"{'학습한 직선 (entropy)':<24}{mae(w * entropy[te] + b, ratio[te]):>12.4f}")

#!/usr/bin/env python3
"""'학습'이 무엇인지 확인한다: 손실을 가장 작게 만드는 파라미터를 찾는 일이다."""
import csv
import numpy as np

rows    = list(csv.DictReader(open("files.csv")))
size    = np.array([int(r["size"]) for r in rows], dtype=float)
entropy = np.array([float(r["entropy"]) for r in rows])
ratio   = np.array([int(r["gz_size"]) for r in rows]) / size

def loss(w, b):                      # 평균제곱오차(MSE)
    return float(np.mean((w * entropy + b - ratio) ** 2))

# 방법 1: 파라미터 공간을 무작위로 뒤진다
rng = np.random.default_rng(0)
best = min(((loss(w, b), w, b) for w, b in rng.uniform(-2, 2, size=(200_000, 2))))
print(f"무작위 탐색 20만 회 : w={best[1]:+.4f} b={best[2]:+.4f}  MSE={best[0]:.6f}")

# 방법 2: 최소제곱의 닫힌 해로 한 번에 구한다
X = np.column_stack([entropy, np.ones(len(rows))])
w, b = np.linalg.lstsq(X, ratio, rcond=None)[0]
print(f"최소제곱 닫힌 해     : w={w:+.4f} b={b:+.4f}  MSE={loss(w, b):.6f}")

#!/usr/bin/env python3
"""학습 데이터에 없던 종류를 만나면 어떻게 되는지 본다."""
import csv
import numpy as np

rows    = list(csv.DictReader(open("files.csv")))
ext     = np.array([r["ext"] for r in rows])
size    = np.array([int(r["size"]) for r in rows], dtype=float)
entropy = np.array([float(r["entropy"]) for r in rows])
ratio   = np.array([int(r["gz_size"]) for r in rows]) / size

def fit(mask):
    X = np.column_stack([entropy[mask], np.ones(mask.sum())])
    return np.linalg.lstsq(X, ratio[mask], rcond=None)[0]

def mae(w, b, mask):
    return float(np.mean(np.abs(w * entropy[mask] + b - ratio[mask])))

gz  = ext == ".gz"          # 이미 압축된 파일 (더 줄지 않는다)
all_ = np.ones(len(rows), dtype=bool)

for name, train_mask in [("전체(.gz 포함)", all_), (".gz 제외", ~gz)]:
    w, b = fit(train_mask)
    lo, hi = entropy[train_mask].min(), entropy[train_mask].max()
    pred = w * entropy[gz] + b
    print(f"[{name}] 학습 entropy {lo:.2f}~{hi:.2f} | "
          f"ratio = {w:+.4f}*entropy {b:+.4f}")
    print(f"    .gz(entropy {entropy[gz].min():.2f}~{entropy[gz].max():.2f}) "
          f"예측 {pred.min():.3f}~{pred.max():.3f} / 실제 평균 {ratio[gz].mean():.3f} "
          f"| MAE {mae(w, b, gz):.4f}")