Create Logistic.py

Logistic.py

@@ -0,0 +1,120 @@
+import numpy as np
+import pandas as pd
+from scipy.stats import norm
+
+# モデルで使う関数定義
+def logit(x):
+    p = 1 / (1 + np.exp(-x))
+    dp = p * (1 - p)
+    return p, dp
+
+def probit(x):
+    p = norm.cdf(x)
+    dp = norm.pdf(x)
+    return p, dp
+
+def bhood(func, param, y, z):
+    xb = np.dot(z, param)
+    p, dp = func(xb)
+    p = np.clip(p, 1e-8, 1 - 1e-8)  # log(0)防止
+    lhood = np.sum(y * np.log(p) + (1 - y) * np.log(1 - p))
+    grad = np.dot(z.T, y - p)
+    hess = -np.dot(z.T * dp.flatten(), z)
+    return lhood, grad, hess
+
+# メインクラス
+class BinaryLogit:
+    def __init__(self, mode="logit", tol=1e-4):
+        self.mode = mode
+        self.tol = tol
+        self.coef = None
+        self.se = None
+        self.t = None
+        self.APE = None
+        self.PEA = None
+        self.p = None
+        self.likelihood = None
+        self.n = None
+        self.k = None
+
+    def _get_func(self):
+        if self.mode == "logit":
+            return logit
+        elif self.mode == "probit":
+            return probit
+        else:
+            raise NotImplementedError(f"Unknown mode: {self.mode}")
+
+    def _get_z_y(self, x, y=None):
+        # Pandas から NumPy に変換
+        if isinstance(x, pd.DataFrame):
+            x_array = x.values
+            x_names = ["const"] + x.columns.tolist()
+        else:
+            x_array = np.asarray(x)
+            x_names = ["const"] + [f"x{i}" for i in range(x_array.shape[1])]
+
+        self.n, self.k = x_array.shape
+        const = np.ones((self.n, 1))
+        z = np.hstack([const, x_array])
+        self.x_names = x_names
+
+        if y is None:
+            return z
+
+        if isinstance(y, (pd.Series, pd.DataFrame)):
+            y_array = np.asarray(y).flatten()
+            self.y_name = y.name if hasattr(y, 'name') else "y"
+        else:
+            y_array = np.asarray(y).flatten()
+            self.y_name = "y"
+
+        return z, y_array
+
+    def fit(self, x, y):
+        z, y = self._get_z_y(x, y)
+        func = self._get_func()
+
+        param = np.zeros(z.shape[1])
+        f = bhood(func, param, y, z)
+        r = np.max(np.abs(f[1]))
+
+        while r > self.tol:
+            param = param - np.dot(np.linalg.inv(f[2]), f[1])
+            f = bhood(func, param, y, z)
+            r = np.max(np.abs(f[1]))
+
+        self.coef = param
+        self.intercept_ = param[0]
+        self.coef_ = param[1:]
+        self.likelihood = f[0]
+        self.se = np.sqrt(np.diag(np.linalg.inv(-f[2])))
+        self.t = self.coef / self.se
+        self.p = (1 - norm.cdf(np.abs(self.t))) * 2
+
+        u = func(np.dot(z, param.reshape(-1, 1)))
+        self.APE = np.mean(u[1]) * param
+        u = func(np.dot(np.mean(z, axis=0), param))
+        self.PEA = u[1] * param
+        return self
+
+    def predict(self, x):
+        if isinstance(x, pd.DataFrame):
+            x_array = x.values
+        else:
+            x_array = np.asarray(x)
+
+        if x_array.shape[1] != self.k:
+            raise ValueError(f"Expected {self.k} features, got {x_array.shape[1]}")
+
+        const = np.ones((x_array.shape[0], 1))
+        z = np.hstack([const, x_array])
+        func = self._get_func()
+        return func(np.dot(z, self.coef))[0]
+
+    def summary(self):
+        col_names = ["coef", "se", "t", "p", "PEA", "APE"]
+        df = pd.DataFrame(np.c_[self.coef, self.se, self.t, self.p, self.PEA, self.APE],
+                          index=self.x_names,
+                          columns=col_names)
+        return df