num4regana 0.0.3-java → 0.0.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b63549f4e9c8d1779a21f7247bae8c034c4066e9907b53c76281c84c18c114
-  data.tar.gz: 19bd91c1939a3055b03a5bf35b516e09f31360cdeb227baab648c5277f843de9
+  metadata.gz: a35c59c0d504b97992d42739340fb1370e5fd80fc547987bb4d0a138f628b284
+  data.tar.gz: fec825eed34dd9c230fed6065accc753e3539bd5af5bb9b8a697c1a3752c06c6
 SHA512:
-  metadata.gz: ed0417b5fd2374d6ce4b3253484f532c40675fdf920e0bd7f10ec65e1c14ff7d1cf8be8fc748d9c68fe173613e67c4bcfa97235c43dbd4a9a65533a7a5fa38f1
-  data.tar.gz: a630e9d0ea9b931542b439617f9b28b38f1b0ac6e857ae95538cb04da60407af0882bf2654ec444abcbe150109c5e40bfcaf372d8514f5f621eb9af23cdb13fc
+  metadata.gz: 10a7cbe03f96c05fc5995b696e6946fbc222d6b5a6b0f8b487cd5c50dfccca9d931d9312d5ab3589473b2589f6887885a142e6fcb467aa526499fb6812248368
+  data.tar.gz: 97009fb18fcb77dd771b6290eea892092710bf49d647e451cb720d94f2ead2a07826657b139e9842fc14d8c6b3aa3ac3fd938819bea090faa403bfe43384fb8e

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## [0.0.5] - 2024-09-27
+
+### add
+- add Bayesian models
+- add Hierarchical Bayesian models
+
+## [0.0.4] - 2024-09-13
+
+### add
+- add function of getAIC
+
 ## [0.0.3] - 2024-09-05
 
 ### add

data/ext/num4regana/AbstractGLM.java

@@ -0,0 +1,63 @@
+import java.util.Arrays;
+
+abstract class AbstractGLM {
+    private final double eta = 0.005;
+    abstract double regression(double[] b, double[] xi);
+    abstract double linkFunc(double q);
+    // 勾配降下法
+    protected double[] grand_metod(double[] yi, double[] b, double[][] xij) {
+        // 交差エントロピー計算
+        double[] ei = calcE(yi, b, xij);
+
+        // パラメータ更新
+        for(int i = 0; i < ei.length; i++) {
+            b[i] -= eta * ei[i];
+        }
+        return b;
+    }
+    // AIC
+    protected double calcAIC(double[] b, double[][] xij) {
+        // 尤度計算
+        double maxL = calcLogL(b,xij); 
+        int k = 1 + xij[0].length;
+
+        return -2 * (maxL - k);
+    }
+    // 交差エントロピー計算
+    private double[] calcE(double[] yi, double[] b, double[][] xij) {
+        double[] xi = new double[b.length];
+        double[] ei = new double[b.length];
+
+        Arrays.fill(ei, 0.0);
+        for(int i = 0; i < yi.length; i++) {
+            xi[0] = 1.0;
+            System.arraycopy(xij[i], 0, xi, 1, xij[0].length);
+
+            double q = regression(b, xi);
+            double p = linkFunc(q);
+
+            for(int j = 0; j < xi.length; j++) {                
+                ei[j] += (p - yi[i]) * xi[j];
+            }
+        }
+
+        return ei;
+    }
+    // 対数尤度計算(パラメータ)
+    private double calcLogL(double[] b, double[][] xij) {
+        double l = 0.0;
+        double[] xi = new double[b.length];
+
+        for(int i = 0; i < xij.length; i++) {
+            xi[0] = 1.0;
+            System.arraycopy(xij[i], 0, xi, 1, xij[0].length);
+
+            double q = regression(b, xi);
+            double p = linkFunc(q);
+
+            l += Math.log(p);
+        }
+        return l;
+    }   
+}
+

data/ext/num4regana/AbstractGLMM.java

@@ -0,0 +1,127 @@
+import java.util.Arrays;
+import org.apache.commons.math3.distribution.BetaDistribution;
+import org.apache.commons.math3.distribution.NormalDistribution;
+
+abstract class AbstractGLMM {
+    private NormalDistribution nDist = new NormalDistribution(0,1);
+    abstract double regression(double[] b, double[] xi, double r);
+    abstract double linkFunc(double q);
+    // mcmc法
+    // （メトロポリス法,ギブスサンプリング）
+    protected double[] mcmcGS(double[] yi, double[] b, double[][] xij) {
+        BetaDistribution beDist = new BetaDistribution(50, 50);
+        BetaDistribution beDist2 = new BetaDistribution(1, 1);  // 確率用
+        double[] newB = new double[b.length];
+        double oldL = 0.0;
+        double newL = 0.0;
+
+        for(int i = 0; i < b.length; i++) {
+            newB = Arrays.copyOf(b, b.length);
+            oldL = calcLx(b,xij);
+            newB[i] = beDist.sample();
+            newL = calcLx(newB,xij);
+
+            double r = newL / oldL;
+            if (r > 1.0) {
+                b[i] = newB[i];
+            }
+            else {
+                double r2 = beDist2.sample();
+
+                if (r2 < (1.0 - r)) {
+                    b[i] = newB[i];
+                }
+            }            
+        }
+        return b;
+    }
+    // BIC
+    protected double calcBIC(double[] b, double[][] xij) {
+        // 尤度計算
+        double maxL = calcLogLx(b,xij);
+        int k = 1 + xij[0].length;
+        int n = xij.length;
+
+        return -2 * maxL + k * Math.log(n);
+    }
+    // EMアルゴリズム
+    protected double[] mcmcEM(double[] yi, double[] b, double[][] xij) {
+        double[] newB = new double[b.length];
+
+        double[] bE = calcEStep(yi, b);
+        double[] bM = calcMStep(yi, bE, xij);
+
+        for(int i = 0; i < newB.length; i++) {
+            newB[i] = b[i] + bM[i];
+        }
+        return newB;
+    }
+    /* ------------------------------------------------------------------ */
+    // 尤度計算(パラメータ)
+    private double calcLx(double[] b, double[][] xij) {
+        double l = 1.0;
+        double[] xi = new double[b.length];
+
+        for(int i = 0; i < xij.length; i++) {
+            xi[0] = 1.0;
+            System.arraycopy(xij[i], 0, xi, 1, xij[0].length);
+            double q = regression(b, xi, nDist.sample());
+            double p = linkFunc(q);
+
+            l *= p;
+        }
+        return l;
+    }   
+    // 対数尤度計算(パラメータ)
+    private double calcLogLx(double[] b, double[][] xij) {
+        double l = 0.0;
+        double[] xi = new double[b.length];
+
+        for(int i = 0; i < xij.length; i++) {
+            xi[0] = 1.0;
+            System.arraycopy(xij[i], 0, xi, 1, xij[0].length);
+            double q = regression(b, xi, nDist.sample());
+            double p = linkFunc(q);
+
+            l += Math.log(p);
+        }
+        return l;
+    }
+    // E-Step
+    //  (自己エントロピー)
+    private double[] calcEStep(double[] yi, double[] b) {
+        double[] bh = new double[b.length];
+
+        Arrays.fill(bh, 0.0);
+        for(int j = 0; j < b.length; j++) {
+            for(int i = 0; i < yi.length; i++) {
+                double p = linkFunc(yi[i]);
+
+                bh[j] += p * Math.log(p);
+            }
+            bh[j] *= -1;
+        }
+        return bh;
+    }
+    // M-Step
+    //  (KLダイバージェンス)
+    private double[] calcMStep(double[] yi, double[] b, double[][] xij) {
+        double[] xi = new double[b.length];
+        double[] ei = new double[b.length];
+
+        Arrays.fill(ei, 0.0);
+        for(int j = 0; j < b.length; j++) {
+            for(int i = 0; i < xij.length; i++) {
+                xi[0] = 1.0;
+                System.arraycopy(xij[i], 0, xi, 1, xij[0].length);
+
+                double q = linkFunc(yi[i]);
+                double p = linkFunc(regression(b, xi, 0));
+
+                ei[j] += q * (Math.log(q) - Math.log(p)) * xi[j];
+            }   
+        }
+        return ei;
+    }   
+}
+

data/ext/num4regana/LogitBayesRegAna.java

@@ -0,0 +1,85 @@
+import java.util.Map;
+import java.util.Arrays;
+import org.apache.commons.math3.distribution.BetaDistribution;
+
+public class LogitBayesRegAna extends AbstractGLMM {
+    private final int NUM = 1000;
+    private final int TIM = 3;
+    private static LogitBayesRegAna regana = new LogitBayesRegAna();
+    public static LogitBayesRegAna getInstance() {
+        return regana;
+    }
+    public LineReg nonLineRegAna(double[] yi, double xij[][]) {
+        double[] b = initB(xij[0].length);
+
+        for  (int i = 0; i < NUM; i++) {
+            b = mcmcGS(yi, b, xij);
+        }
+
+        return new LineReg(b);
+    }
+    public double getBIC(Map<String, Object> regCoe, double[][] xij) {
+        double[] b = new double[1 + xij[0].length];
+
+        b[0] = (double)regCoe.get("intercept");
+        System.arraycopy(regCoe.get("slope"), 0, b, 1, xij[0].length);
+        return calcBIC(b, xij);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+        BetaDistribution beDist = new BetaDistribution(50, 50);
+
+        for(int i = 0; i < b.length; i++) {
+            b[i] = beDist.sample();
+        }
+        return b;
+    }
+    private double[] calcMeanBy(double[] yi, double[] b) {
+        double[] meanB = new double[b.length];
+
+        Arrays.fill(meanB, 0.0);
+        for(int i = 0; i < meanB.length; i++) {
+            for(int j = 0; j < yi.length; j++) {
+                meanB[i] += yi[j] * b[i];
+            }
+        }
+        return meanB;
+    }
+    // q = b0 + b1 * x0
+    double regression(double[] b, double[] xi, double r) {
+        double ret = 0.0;
+
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret;
+    }
+    // p = 1 / (1 + exp( -q))
+    double linkFunc(double q) {
+        return 1.0 / (1.0 + Math.exp(-1.0 * q));
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    /*********************************/
+    /* class define                  */
+    /*********************************/
+    public class LineReg {
+        private double a   = 0.0;
+        private double[] b = null;
+        public LineReg(double[] b) {
+            this.a = b[0];
+            this.b = new double[b.length - 1];
+            for (int i = 0; i < this.b.length; i++) {
+                this.b[i] = b[i + 1];
+            }
+        }
+        public double getIntercept() {
+            return a;
+        }
+        public double[] getSlope() {
+            return b;
+        }
+    }
+}
+

data/ext/num4regana/LogitRegAna.java

@@ -1,12 +1,45 @@
-public class LogitRegAna {
+import java.util.Arrays;
+import java.util.Map;
+
+public class LogitRegAna extends AbstractGLM {
+    private final int NUM = 1000;
     private static LogitRegAna regana = new LogitRegAna();
     public static LogitRegAna getInstance() {
         return regana;
     }
     public LineReg nonLineRegAna(double[] yi, double xij[][]) {
-        NonLineRegAna line = new NonLineRegAna();
+        double[] b = initB(xij[0].length);
+         
+        for  (int i = 0; i < NUM; i++) {
+            b = grand_metod(yi, b, xij);
+        }
+        return new LineReg(b);
+    }
+    public double getAIC(Map<String, Object> regCoe, double[][] xij) {
+        double[] b = new double[1 + xij[0].length];
 
-        return line.nonLineRegAna(yi, xij);
+        b[0] = (double)regCoe.get("intercept");
+        System.arraycopy(regCoe.get("slope"), 0, b, 1, xij[0].length);
+        return calcAIC(b, xij);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+         
+        Arrays.fill(b, 0.0);
+        return b;
+    }
+    // q = b0 + b1 * x0
+    double regression(double[] b, double[] xi) {
+        double ret = 0.0;
+
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret;
+    }
+    // p = 1 / (1 + exp( -q))
+    double linkFunc(double q) {
+        return 1.0 / (1.0 + Math.exp(-1.0 * q));
     }
     /*********************************/
     /* interface define              */
@@ -31,52 +64,5 @@ public class LogitRegAna {
             return b;
         }
     }
-    private class NonLineRegAna {
-        private final double eta = 0.001;
-        private final int num = 10000;
-        public LineReg nonLineRegAna(double[] yi, double[][] xij) {
-            double[] b = new double[1 + xij[0].length];
-            
-            for(int i = 0; i < b.length; i++) {
-                b[i] = 0.0;
-            }
-            for  (int i = 0; i < num; i++) {
-                b = grand_metod(yi, b, xij);
-            }
-            return new LineReg(b);
-        }
-        // q = b0 + b1 * x0
-        private double rereion(double[] b, double[] xi) {
-            double ret = b[0];
-
-            for(int i = 0; i < xi.length; i++) {
-                ret += b[i + 1] * xi[i];
-            }
-            return ret;
-        }
-        // p = 1 / (1 + exp( -q))
-        private double sigmoid(double q) {
-            return 1.0 / (1.0 + Math.exp(-1.0 * q));
-        }
-        private double[] grand_metod(double[] yi, double[] b, double[][] xij) {
-            double e0 = 0.0;
-            double[] en = new double[xij[0].length];
-
-            for(int i = 0; i < yi.length; i++) {
-                double q = rereion(b, xij[i]);
-                double p = sigmoid(q);
-
-                e0 += (yi[i] - p);
-                for(int j = 0; j < en.length; j++) {                
-                    en[j] += (yi[i] - p) * xij[i][j];
-                }
-            }
-            b[0] = b[0] + eta * e0;
-            for(int j = 0; j < en.length; j++) {
-                b[1 + j] += eta * en[j];
-            }
-            return b;
-        }
-    }
 }
 

data/ext/num4regana/PoissonBayesRegAna.java

@@ -0,0 +1,74 @@
+import java.util.Arrays;
+import java.util.Map;
+import org.apache.commons.math3.distribution.BetaDistribution;
+
+public class PoissonBayesRegAna extends AbstractGLMM {
+    private final int NUM = 1000;
+    private final int TIM = 3;
+    private static PoissonBayesRegAna regana = new PoissonBayesRegAna();
+    public static PoissonBayesRegAna getInstance() {
+        return regana;
+    }
+    public LineReg nonLineRegAna(double[] yi, double xij[][]) {
+        double[] b = initB(xij[0].length);
+
+        for  (int i = 0; i < NUM; i++) {
+            b = mcmcGS(yi, b, xij);
+        }
+        return new LineReg(b);
+    }
+    public double getBIC(Map<String, Object> regCoe, double[][] xij) {
+        double[] b = new double[1 + xij[0].length];
+
+        b[0] = (double)regCoe.get("intercept");
+        System.arraycopy(regCoe.get("slope"), 0, b, 1, xij[0].length);
+        return calcBIC(b, xij);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+        BetaDistribution beDist = new BetaDistribution(50, 50);
+
+        for(int i = 0; i < b.length; i++) {
+            b[i] = beDist.sample();
+        }
+        return b;
+    }
+    // q = b0 + b1 * x0
+    double regression(double[] b, double[] xi, double r) {
+        double ret = 0.0;
+
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret;
+    }
+    // p = exp(q)
+    double linkFunc(double q) {
+        return Math.exp(q);
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    /*********************************/
+    /* class define                  */
+    /*********************************/
+    public class LineReg {
+        private double a   = 0.0;
+        private double[] b = null;
+        public LineReg(double[] b) {
+            this.a = b[0];
+            this.b = new double[b.length - 1];
+            for (int i = 0; i < this.b.length; i++) {
+                this.b[i] = b[i + 1];
+            }
+        }
+        public double getIntercept() {
+            return a;
+        }
+        public double[] getSlope() {
+            return b;
+        }
+    }
+    
+}
+

data/ext/num4regana/PoissonHierBayesRegAna.java

@@ -0,0 +1,65 @@
+import java.util.Arrays;
+import java.util.Map;
+import org.apache.commons.math3.distribution.BetaDistribution;
+
+public class PoissonHierBayesRegAna extends AbstractGLMM {
+    private final int NUM = 1000;
+    private static PoissonHierBayesRegAna regana = new PoissonHierBayesRegAna();
+    public static PoissonHierBayesRegAna getInstance() {
+        return regana;
+    }
+    public LineReg nonLineRegAna(double[] yi, double xij[][]) {
+        double[] b = initB(xij[0].length);
+
+        for  (int i = 0; i < NUM; i++) {
+            b = mcmcGS(yi, b, xij);
+        }
+        return new LineReg(b);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+        BetaDistribution beDist = new BetaDistribution(50, 50);
+
+        for(int i = 0; i < b.length; i++) {
+            b[i] = beDist.sample();
+        }
+        return b;
+    }
+    // q = b0 + b1 * x0 + r
+    // (ランダム切片モデル)
+    double regression(double[] b, double[] xi, double r) {
+        double ret = 0.0;
+
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret + r;
+    }
+    // p = exp(q)
+    double linkFunc(double q) {
+        return Math.exp(q);
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    /*********************************/
+    /* class define                  */
+    /*********************************/
+    public class LineReg {
+        private double a   = 0.0;
+        private double[] b = null;
+        public LineReg(double[] b) {
+            this.a = b[0];
+            this.b = new double[b.length - 1];
+            for (int i = 0; i < this.b.length; i++) {
+                this.b[i] = b[i + 1];
+            }
+        }
+        public double getIntercept() {
+            return a;
+        }
+        public double[] getSlope() {
+            return b;
+        }
+    }
+}

data/ext/num4regana/PoissonRegAna.java

@@ -1,12 +1,45 @@
-public class PoissonRegAna {
+import java.util.Arrays;
+import java.util.Map;
+
+public class PoissonRegAna extends AbstractGLM {
+    private final int NUM = 1000;
     private static PoissonRegAna regana = new PoissonRegAna();
     public static PoissonRegAna getInstance() {
         return regana;
     }
     public LineReg nonLineRegAna(double[] yi, double[][] xij) {
-        NonLineRegAna line = new NonLineRegAna();
+        double[] b = initB(xij[0].length);
+
+        for  (int i = 0; i < NUM; i++) {
+            b = grand_metod(yi, b, xij);
+        }
+        return new LineReg(b);
+    }
+    public double getAIC(Map<String, Object> regCoe, double[][] xij) {
+        double[] b = new double[1 + xij[0].length];
+
+        b[0] = (double)regCoe.get("intercept");
+        System.arraycopy(regCoe.get("slope"), 0, b, 1, xij[0].length);
+        return calcAIC(b, xij);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+         
+        Arrays.fill(b, 0.0);
+        return b;
+    }
+    // q = b0 + b1 * x0
+    double regression(double[] b, double[] xi) {
+        double ret = 0.0;
 
-        return line.nonLineRegAna(yi, xij);
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret;
+    }
+    // p = exp(q)
+    double linkFunc(double q) {
+        return Math.exp(q);
     }
     /*********************************/
     /* interface define              */
@@ -31,52 +64,5 @@ public class PoissonRegAna {
             return b;
         }
     }
-    private class NonLineRegAna {
-        private final double eta = 0.005;
-        private final int num = 1000;
-        public LineReg nonLineRegAna(double[] yi, double[][] xij) {
-            double[] b = new double[1 + xij[0].length];
-            
-            for(int i = 0; i < b.length; i++) {
-                b[i] = 0.0;
-            }
-            for  (int i = 0; i < num; i++) {
-                b = grand_metod(yi, b, xij);
-            }
-
-            return new LineReg(b);
-        }
-        // q = b0 + b1 * x0
-        private double rereion(double[] b, double[] xi) {
-            double ret = b[0];
-
-            for(int i = 0; i < xi.length; i++) {
-                ret += b[i + 1] * xi[i];
-            }
-            return ret;
-        }
-        private double linkFunc(double q) {
-            return Math.exp(q);
-        }
-        private double[] grand_metod(double[] yi, double[] b, double[][] xij) {
-            double e0 = 0.0;
-            double[] en = new double[xij[0].length];
-
-            for(int i = 0; i < yi.length; i++) {
-                double q = rereion(b, xij[i]);
-                double p = linkFunc(q);
-
-                e0 += (yi[i] - p);
-                for(int j = 0; j < en.length; j++) {                
-                    en[j] += (yi[i] - p) * xij[i][j];
-                }
-            }
-            b[0] += eta * e0;
-            for(int j = 0; j < en.length; j++) {
-                b[1 + j] += eta * en[j];
-            }
-            return b;
-        }
-    }
 }
 

data/ext/num4regana/ProBitRegAna.java

@@ -0,0 +1,71 @@
+import java.util.Arrays;
+import org.apache.commons.math3.distribution.NormalDistribution;
+import java.util.Map;
+
+public class ProBitRegAna extends AbstractGLM {
+    private final int NUM = 1000;
+    private static ProBitRegAna regana = new ProBitRegAna();
+    private NormalDistribution ndist = new NormalDistribution(0, 1);
+    
+    public static ProBitRegAna getInstance() {
+        return regana;
+    }
+    public LineReg nonLineRegAna(double[] yi, double[][] xij) {
+        double[] b = initB(xij[0].length);
+         
+        for  (int i = 0; i < NUM; i++) {
+            b = grand_metod(yi, b, xij);
+        }
+        return new LineReg(b);
+    }
+    public double getAIC(Map<String, Object> regCoe, double[][] xij) {
+        double[] b = new double[1 + xij[0].length];
+
+        b[0] = (double)regCoe.get("intercept");
+        System.arraycopy(regCoe.get("slope"), 0, b, 1, xij[0].length);
+        return calcAIC(b, xij);
+    }
+    private double[] initB(int xsie) {
+        double[] b = new double[1 + xsie];
+         
+        Arrays.fill(b, 0.0);
+        return b;
+    }
+    // q = b0 + b1 * x0
+    double regression(double[] b, double[] xi) {
+        double ret = 0.0;
+
+        for(int i = 0; i < xi.length; i++) {
+            ret += b[i] * xi[i];
+        }
+        return ret;
+    }
+    // 
+    double linkFunc(double q) {
+        return ndist.cumulativeProbability(q);
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    /*********************************/
+    /* class define                  */
+    /*********************************/
+    public class LineReg {
+        private double a   = 0.0;
+        private double[] b = null;
+        public LineReg(double[] b) {
+            this.a = b[0];
+            this.b = new double[b.length - 1];
+            for (int i = 0; i < this.b.length; i++) {
+                this.b[i] = b[i + 1];
+            }
+        }
+        public double getIntercept() {
+            return a;
+        }
+        public double[] getSlope() {
+            return b;
+        }
+    }
+}
+

data/lib/num4glmmregana.rb

@@ -0,0 +1,180 @@
+require 'java'
+require 'num4regana.jar'
+require 'commons-math3-3.6.1.jar'
+
+java_import 'LogitBayesRegAna'
+java_import 'PoissonBayesRegAna'
+java_import 'java.util.HashMap'
+
+# 一般化線形混合モデル
+#  (Apache commoms math3使用)
+module Num4GLMMRegAnaLib
+    # (2項)ベイズロジスティック回帰分析
+    class LogitBayesRegAnaLib
+        def initialize
+            @multana = LogitBayesRegAna.getInstance()
+        end
+        # (2項)ベイズロジスティック回帰分析
+        #
+        # @overload non_line_reg_ana(yi, xij)
+        #   @param [Array] yi yの値(double[])
+        #   @param [Array] xij xの値(double[][])
+        #   @return [Hash] (intercept:定数項 slope:回帰係数)
+        # @example
+        #   glsyi = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        #   glsxij = [
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
+        #   ]
+        #   regana = Num4GLMMRegAnaLib::LogitBayesRegAnaLib.new
+        #   regana.non_line_reg_ana(glsyi, glsxij)
+        #   => 
+        #     {  
+        #        :intercept=>0.5742886218005325,      # 定数項
+        #                                             # 回帰係数
+        #        :slope=>[0.5517212822536828, 0.5748054561700319]
+        #     }
+        def non_line_reg_ana(yi, xij)
+            multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
+            retRb = {
+                "intercept":  multRet.getIntercept(), # 定数項
+                "slope":      multRet.getSlope().to_a,     # 回帰係数
+            }
+            return retRb
+        end
+        # BIC
+        #
+        # @overload get_bic(regcoe, xij)
+        #   @param [Hash] regcoe 回帰係数(intercept:定数項 slope:回帰係数)
+        #   @param [Array] xij xの値(double[][])
+        #   @return double AIC値
+        # @example
+        #   reg = {
+        #        :intercept=>  -6.2313,    # 定数項
+        #        :slope=>      [2.5995, 0.1652],     # 回帰係数
+        #   }
+        #   xij = [
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
+        #   ]
+        #   regana = Num4GLMMRegAnaLib::LogitBayesRegAnaLib.new
+        #   regana.get_bic(reg, xij)
+        #   => 159.386
+        def get_bic(regcoe, xij)
+            o = HashMap.new
+            o["intercept"] = regcoe[:intercept]
+            o["slope"]     = regcoe[:slope].to_java(Java::double)
+            @multana.getBIC(o, xij.to_java(Java::double[]))
+        end
+    end
+    # ベイズポアソン回帰分析
+    class PoissonBayesRegAnaLib
+        def initialize
+            @multana = PoissonBayesRegAna.getInstance()
+        end
+        # ベイズポアソン回帰分析
+        #
+        # @overload non_line_reg_ana(yi, xij)
+        #   @param [Array] yi yの値(double[])
+        #   @param [Array] xij xの値(double[][])
+        #   @return [Hash] (intercept:定数項 slope:回帰係数)
+        # @example
+        #   glsyi = [4, 10, 7, 14]
+        #   glsxij = [
+        #       [1],
+        #       [2],
+        #       [3],
+        #       [4],
+        #   ]
+        #   regana = Num4GLMMRegAnaLib::PoissonBayesRegAnaLib.new
+        #   regana.non_line_reg_ana(glsyi, glsxij)
+        #   => 
+        #     {
+        #        :intercept=>0.4341885635221602, # 定数項
+        #        :slope=>[0.5703137378188881]    # 回帰係数
+        #     }
+        def non_line_reg_ana(yi, xij)
+            multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
+            retRb = {
+                "intercept":  multRet.getIntercept(), # 定数項
+                "slope":      multRet.getSlope().to_a,     # 回帰係数
+            }
+            return retRb
+        end
+        # BIC
+        #
+        # @overload get_bic(regcoe, xij)
+        #   @param [Hash] regcoe 回帰係数(intercept:定数項 slope:回帰係数)
+        #   @param [Array] xij xの値(double[][])
+        #   @return double AIC値
+        # @example
+        #   reg = {
+        #        :intercept=>0.4341885635221602, # 定数項
+        #        :slope=>[0.5703137378188881]    # 回帰係数
+        #   }
+        #   xij = [
+        #       [1],
+        #       [2],
+        #       [3],
+        #       [4],
+        #   ]
+        #   regana = Num4GLMMRegAnaLib::BayesPoissonRegAnaLib.new
+        #   regana.get_bic(reg, xij)
+        #   => -13.157
+        def get_bic(regcoe, xij)
+            o = HashMap.new
+            o["intercept"] = regcoe[:intercept]
+            o["slope"]     = regcoe[:slope].to_java(Java::double)
+            @multana.getBIC(o, xij.to_java(Java::double[]))
+        end
+    end
+end
+

data/lib/num4glmregana.rb

@@ -4,6 +4,8 @@ require 'commons-math3-3.6.1.jar'
 
 java_import 'LogitRegAna'
 java_import 'PoissonRegAna'
+java_import 'ProBitRegAna'
+java_import 'java.util.HashMap'
 
 # 一般化線形回帰分析
 #  (Apache commoms math3使用)
@@ -20,35 +22,41 @@ module Num4GLMRegAnaLib
         #   @param [Array] xij xの値(double[][])
         #   @return [Hash] (intercept:定数項 slope:回帰係数)
         # @example
-        #   glsyi = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        #   glsyi = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
         #   glsxij = [
-        #       [95],
-        #       [90],
-        #       [85],
-        #       [80],
-        #       [80],
-        #       [75],
-        #       [70],
-        #       [70],
-        #       [65],
-        #       [50],
-        #       [60],
-        #       [55],
-        #       [45],
-        #       [65],
-        #       [40],
-        #       [35],
-        #       [55],
-        #       [50],
-        #       [50],
-        #       [45],
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
         #   ]
         #   regana = Num4RegAnaLib::LogitRegAnaLib.new
         #   regana.non_line_reg_ana(glsyi, glsxij)
         #   => 
         #     {
-        #       "intercept":  -17.81,    # 定数項
-        #       "slope":      [0.16],    # 回帰係数
+        #        "intercept":  -6.2313,              # 定数項
+        #        "slope":      [2.5995, 0.1652],     # 回帰係数
         #     }
         def non_line_reg_ana(yi, xij)
             multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
@@ -58,6 +66,54 @@ module Num4GLMRegAnaLib
             }
             return retRb
         end
+        # AIC
+        #
+        # @overload get_aic(regcoe, xij)
+        #   @param [Hash] regcoe 回帰係数(intercept:定数項 slope:回帰係数)
+        #   @param [Array] xij xの値(double[][])
+        #   @return double AIC値
+        # @example
+        #   reg = {
+        #        :intercept=>  -6.2313,    # 定数項
+        #        :slope=>      [2.5995, 0.1652],     # 回帰係数
+        #   }
+        #   xij = [
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
+        #   ]
+        #   regana = Num4RegAnaLib::LogitRegAnaLib.new
+        #   regana.get_aic(reg, xij)
+        #   => 155.612
+        def get_aic(regcoe, xij)
+            o = HashMap.new
+            o["intercept"] = regcoe[:intercept]
+            o["slope"]     = regcoe[:slope].to_java(Java::double)
+            @multana.getAIC(o, xij.to_java(Java::double[]))
+        end
     end
     # ポアソン回帰分析
     class PoissonRegAnaLib
@@ -85,6 +141,89 @@ module Num4GLMRegAnaLib
         #        "intercept":  1.3138,    # 定数項
         #        "slope":      [0.3173],  # 回帰係数
         #     }
+        def non_line_reg_ana(yi, xij)
+            multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
+            retRb = {
+                "intercept":  multRet.getIntercept(), # 定数項
+                "slope":     multRet.getSlope().to_a,     # 回帰係数
+            }
+            return retRb
+        end
+        # AIC
+        #
+        # @overload get_aic(regcoe, xij)
+        #   @param [Hash] regcoe 回帰係数(intercept:定数項 slope:回帰係数)
+        #   @param [Array] xij xの値(double[][])
+        #   @return double AIC値
+        # @example
+        #   reg = {
+        #        :intercept => 1.3138,    # 定数項
+        #        :slope    =>  [0.3173],  # 回帰係数
+        #   }
+        #   xij = [
+        #       [1],
+        #       [2],
+        #       [3],
+        #       [4],
+        #   ]
+        #   regana = Num4RegAnaLib::PoissonRegAnaLib.new
+        #   regana.get_aic(reg, xij)
+        #   => -12.856
+        def get_aic(regcoe, xij)
+            o = HashMap.new
+            o["intercept"] = regcoe[:intercept]
+            o["slope"]     = regcoe[:slope].to_java(Java::double)
+            @multana.getAIC(o, xij.to_java(Java::double[]))
+        end
+    end
+    # プロビット回帰分析
+    class ProBitRegAnaLib
+        def initialize
+            @multana = ProBitRegAna.getInstance()
+        end
+        # プロビット回帰分析
+        #
+        # @overload non_line_reg_ana(yi, xij)
+        #   @param [Array] yi yの値(double[])
+        #   @param [Array] xij xの値(double[][])
+        #   @return [Hash] (intercept:定数項 slope:回帰係数)
+        # @example
+        #   glsyi = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        #   glsxij = [
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
+        #   ]
+        #   regana = Num4RegAnaLib::ProBitRegAnaLib.new
+        #   regana.non_line_reg_ana(glsyi, glsxij)
+        #   => 
+        #     {
+        #        "intercept":  -5.0497,    # 定数項
+        #        "slope":      [2.2379, 0.2973],     # 回帰係数
+        #     }
         def non_line_reg_ana(yi, xij)
             multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
             retRb = {
@@ -93,6 +232,54 @@ module Num4GLMRegAnaLib
             }
             return retRb
         end
+        # AIC
+        #
+        # @overload get_aic(regcoe, xij)
+        #   @param [Hash] regcoe 回帰係数(intercept:定数項 slope:回帰係数)
+        #   @param [Array] xij xの値(double[][])
+        #   @return double AIC値
+        # @example
+        #   reg = {
+        #        :intercept=>  -5.0497,    # 定数項
+        #        :slope=>      [2.2379, 0.2973],     # 回帰係数
+        #   }
+        #   xij = [
+        #        [1, 24],
+        #        [1, 18],
+        #        [0, 15],
+        #        [1, 16],
+        #        [0, 10],
+        #        [1, 26],
+        #        [1, 2],
+        #        [0, 24],
+        #        [1, 18],
+        #        [1, 22],
+        #        [1, 3],
+        #        [1, 6],
+        #        [0, 15],
+        #        [0, 12],
+        #        [1, 6],
+        #        [0, 6],
+        #        [1, 12],
+        #        [0, 12],
+        #        [1, 18],
+        #        [1, 3],
+        #        [1, 8],
+        #        [0, 9],
+        #        [0, 12],
+        #        [0, 6],
+        #        [0, 8],
+        #        [1, 12],
+        #   ]
+        #   regana = Num4RegAnaLib::ProBitRegAnaLib.new
+        #   regana.get_aic(reg, xij)
+        #   => 119.674
+        def get_aic(regcoe, xij)
+            o = HashMap.new
+            o["intercept"] = regcoe[:intercept]
+            o["slope"]     = regcoe[:slope].to_java(Java::double)
+            @multana.getAIC(o, xij.to_java(Java::double[]))
+        end
     end
 end
 

data/lib/num4hbmregana.rb

@@ -0,0 +1,44 @@
+require 'java'
+require 'num4regana.jar'
+require 'commons-math3-3.6.1.jar'
+
+java_import 'PoissonHierBayesRegAna'
+# 階層ベイズモデル
+module Num4HBMRegAnaLib
+    # 階層ベイズポアソン回帰分析
+    class PoissonHierBayesRegAnaLib
+        def initialize
+            @multana = PoissonHierBayesRegAna.getInstance()
+        end
+        # ポアソン回帰分析
+        #
+        # @overload non_line_reg_ana(yi, xij)
+        #   @param [Array] yi yの値(double[])
+        #   @param [Array] xij xの値(double[][])
+        #   @return [Hash] (intercept:定数項 slope:回帰係数)
+        # @example
+        #   glsyi = [4, 10, 7, 14]
+        #   glsxij = [
+        #       [1],
+        #       [2],
+        #       [3],
+        #       [4],
+        #   ]
+        #   regana = Num4RegAnaLib::HierBayesPoissonRegAnaLib.new
+        #   regana.non_line_reg_ana(glsyi, glsxij)
+        #   => 
+        #     {
+        #        "intercept":  0.477366,    # 定数項
+        #        "slope":      [0.538545],  # 回帰係数
+        #     }
+        def non_line_reg_ana(yi, xij)
+            multRet = @multana.nonLineRegAna(yi.to_java(Java::double), xij.to_java(Java::double[]))
+            retRb = {
+                "intercept":  multRet.getIntercept(), # 定数項
+                "slope":      multRet.getSlope().to_a,     # 回帰係数
+            }
+            return retRb
+        end
+    end
+end
+

data/lib/num4regana.rb

@@ -1,9 +1,14 @@
 require_relative('num4lineregana')
 require_relative('num4glmregana')
+require_relative('num4glmmregana')
+require_relative('num4hbmregana')
 
+# 回帰分析
 module Num4RegAnaLib
     include Num4LineRegAnaLib
     include Num4GLMRegAnaLib
+    include Num4GLMMRegAnaLib
+    include Num4HBMRegAnaLib
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4regana
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: java
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-05 00:00:00.000000000 Z
+date: 2024-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -61,12 +61,20 @@ files:
 - Gemfile
 - LICENSE
 - Rakefile
+- ext/num4regana/AbstractGLM.java
+- ext/num4regana/AbstractGLMM.java
+- ext/num4regana/LogitBayesRegAna.java
 - ext/num4regana/LogitRegAna.java
 - ext/num4regana/MultRegAna.java
+- ext/num4regana/PoissonBayesRegAna.java
+- ext/num4regana/PoissonHierBayesRegAna.java
 - ext/num4regana/PoissonRegAna.java
+- ext/num4regana/ProBitRegAna.java
 - ext/num4regana/SmplRegAna.java
 - lib/commons-math3-3.6.1.jar
+- lib/num4glmmregana.rb
 - lib/num4glmregana.rb
+- lib/num4hbmregana.rb
 - lib/num4lineregana.rb
 - lib/num4regana.rb
 homepage: http://github.com/siranovel/num4regana