regressionprior.java

一个自然语言处理的Java开源工具包。LingPipe目前已有很丰富的功能

            }
        }
    }

    static final double sqrt2 = Math.sqrt(2.0);
    static final double log2Sqrt2Over2 = com.aliasi.util.Math.log2(sqrt2/2.0);
    static final double log2Sqrt2Pi
        = com.aliasi.util.Math.log2(Math.sqrt(2.0 * Math.PI));
    static final double log21OverPi = -com.aliasi.util.Math.log2(Math.PI);

    static class LaplaceRegressionPrior
        extends ArrayRegressionPrior
        implements Serializable {

        LaplaceRegressionPrior(double[] priorVariances) {
            super(priorVariances);
        }
        public double gradient(double beta, int dimension) {
            if (beta == 0.0) return 0.0;
            if (beta > 0)
                return Math.sqrt(2.0/mValues[dimension]);
            return -Math.sqrt(2.0/mValues[dimension]);
        }
        public double log2Prior(double beta, int dimension) {
            return log2Sqrt2Over2
                - 0.5 * com.aliasi.util.Math.log2(mValues[dimension])
                - sqrt2 * Math.abs(beta) / Math.sqrt(mValues[dimension]);
        }
        public String toString() {
            return toString("LaplaceRegressionPrior","Variance");
        }
        private Object writeReplace() {
            return new Serializer(this);
        }
        private static class Serializer extends AbstractExternalizable {
            final LaplaceRegressionPrior mPrior;
            public Serializer(LaplaceRegressionPrior prior) {
                mPrior = prior;
            }
            public Serializer() {
                this(null);
            }
            public void writeExternal(ObjectOutput out) throws IOException {
                out.writeInt(mPrior.mValues.length);
                for (int i = 0; i < mPrior.mValues.length; ++i)
                    out.writeDouble(mPrior.mValues[i]);
            }
            public Object read(ObjectInput in)
                throws IOException, ClassNotFoundException {

                int numDimensions = in.readInt();
                double[] priorVariances = new double[numDimensions];
                for (int i = 0; i < numDimensions; ++i)
                    priorVariances[i] = in.readDouble();
                return new LaplaceRegressionPrior(priorVariances);
            }
        }
    }

    static class CauchyRegressionPrior
        extends ArrayRegressionPrior
        implements Serializable {

        CauchyRegressionPrior(double[] priorSquaredScales) {
            super(priorSquaredScales);
        }
        public double gradient(double beta, int dimension) {
            return 2.0 * beta / (beta * beta + mValues[dimension]);
        }
        public double log2Prior(double beta, int dimension) {
            return log21OverPi
                + 0.5 * com.aliasi.util.Math.log2(mValues[dimension])
                - com.aliasi.util.Math.log2(beta * beta + mValues[dimension]
                                            * mValues[dimension]);
        }
        public String toString() {
            return toString("CauchyRegressionPrior","Scale");
        }
        private Object writeReplace() {
            return new Serializer(this);
        }
        private static class Serializer extends AbstractExternalizable {
            final CauchyRegressionPrior mPrior;
            public Serializer(CauchyRegressionPrior prior) {
                mPrior = prior;
            }
            public Serializer() {
                this(null);
            }
            public void writeExternal(ObjectOutput out) throws IOException {
                out.writeInt(mPrior.mValues.length);
                for (int i = 0; i < mPrior.mValues.length; ++i)
                    out.writeDouble(mPrior.mValues[i]);
            }
            public Object read(ObjectInput in)
                throws IOException, ClassNotFoundException {

                int numDimensions = in.readInt();
                double[] priorScales = new double[numDimensions];
                for (int i = 0; i < numDimensions; ++i)
                    priorScales[i] = in.readDouble();
                return new CauchyRegressionPrior(priorScales);
            }
        }
    }


    static abstract class VariableRegressionPrior extends RegressionPrior {
        final double mPriorVariance;
        final boolean mNoninformativeIntercept;
        VariableRegressionPrior(double priorVariance,
                                boolean noninformativeIntercept) {
            mPriorVariance = priorVariance;
            mNoninformativeIntercept = noninformativeIntercept;
        }
        public String toString(String priorName, String paramName) {
            return priorName + "(" + paramName + "=" + mPriorVariance
                + ", noninformativeIntercept=" + mNoninformativeIntercept + ")";
        }
    }

    static class VariableGaussianRegressionPrior
        extends VariableRegressionPrior
        implements Serializable {
        VariableGaussianRegressionPrior(double priorVariance,
                                        boolean noninformativeIntercept) {
            super(priorVariance,noninformativeIntercept);
        }
        public double gradient(double beta, int dimension) {
            return (dimension == 0 && mNoninformativeIntercept)
                ? 0.0
                : beta / mPriorVariance;
        }
        public double log2Prior(double beta, int dimension) {
            if (dimension == 0 && mNoninformativeIntercept)
                return 0.0;  // log(1)=0.0
            return -log2Sqrt2Pi
                - 0.5 * com.aliasi.util.Math.log2(mPriorVariance)
                - beta * beta / (2.0 * mPriorVariance);

        }
        public String toString() {
            return toString("GaussianRegressionPrior","Variance");
        }
        private Object writeReplace() {
            return new Serializer(this);
        }
        private static class Serializer extends AbstractExternalizable {
            final VariableGaussianRegressionPrior mPrior;
            public Serializer(VariableGaussianRegressionPrior prior) {
                mPrior = prior;
            }
            public Serializer() {
                this(null);
            }
            public void writeExternal(ObjectOutput out) throws IOException {
                out.writeDouble(mPrior.mPriorVariance);
                out.writeBoolean(mPrior.mNoninformativeIntercept);
            }
            public Object read(ObjectInput in)
                throws IOException, ClassNotFoundException {

                double priorVariance = in.readDouble();
                boolean noninformativeIntercept = in.readBoolean();
                return new VariableGaussianRegressionPrior(priorVariance,
                                                           noninformativeIntercept);
            }
        }
    }

    static class VariableLaplaceRegressionPrior
        extends VariableRegressionPrior
        implements Serializable {

        final double mPositiveGradient;
        final double mNegativeGradient;
        final double mPriorIntercept;
        final double mPriorCoefficient;
        VariableLaplaceRegressionPrior(double priorVariance,
                                       boolean noninformativeIntercept) {
            super(priorVariance,noninformativeIntercept);
            mPositiveGradient = Math.sqrt(2.0/priorVariance);
            mNegativeGradient = -mPositiveGradient;
            mPriorIntercept
                = log2Sqrt2Over2 - 0.5
                * com.aliasi.util.Math.log2(priorVariance);
            mPriorCoefficient = -sqrt2 / Math.sqrt(priorVariance);
        }
        public double gradient(double beta, int dimension) {
            return (dimension == 0 && mNoninformativeIntercept || beta == 0.0)
                ? 0.0
                : (beta > 0
                   ? mPositiveGradient
                   : mNegativeGradient );
        }
        public double log2Prior(double beta, int dimension) {
            if (dimension == 0 && mNoninformativeIntercept)
                return 0.0;
            return mPriorIntercept + mPriorCoefficient * Math.abs(beta);

            // return log2Sqrt2Over2
            // - 0.5 * com.aliasi.util.Math.log2(mPriorVariance)
            // - sqrt2 * Math.abs(beta) / Math.sqrt(mPriorVariance);
        }
        public String toString() {
            return toString("LaplaceRegressionPrior","Variance");
        }
        private Object writeReplace() {
            return new Serializer(this);
        }
        private static class Serializer extends AbstractExternalizable {
            final VariableLaplaceRegressionPrior mPrior;
            public Serializer(VariableLaplaceRegressionPrior prior) {
                mPrior = prior;
            }
            public Serializer() {
                this(null);
            }
            public void writeExternal(ObjectOutput out) throws IOException {
                out.writeDouble(mPrior.mPriorVariance);
                out.writeBoolean(mPrior.mNoninformativeIntercept);
            }
            public Object read(ObjectInput in)
                throws IOException, ClassNotFoundException {

                double priorVariance = in.readDouble();
                boolean noninformativeIntercept = in.readBoolean();
                return new VariableLaplaceRegressionPrior(priorVariance,
                                                          noninformativeIntercept);
            }
        }
    }

    static class VariableCauchyRegressionPrior
        extends VariableRegressionPrior {
        VariableCauchyRegressionPrior(double priorVariance,
                                      boolean noninformativeIntercept) {
            super(priorVariance,noninformativeIntercept);
        }
        public double gradient(double beta, int dimension) {
            return (dimension == 0 && mNoninformativeIntercept)
                ? 0
                : 2.0 * beta / (beta * beta + mPriorVariance);
        }
        public double log2Prior(double beta, int dimension) {
            if (dimension == 0 && mNoninformativeIntercept)
                return 0.0;
            return log21OverPi
                + 0.5 * com.aliasi.util.Math.log2(mPriorVariance)
                - com.aliasi.util.Math.log2(beta * beta + mPriorVariance);
        }
        public String toString() {
            return toString("CauchyRegressionPrior","Scale");
        }
        private static class Serializer extends AbstractExternalizable {
            final VariableCauchyRegressionPrior mPrior;
            public Serializer(VariableCauchyRegressionPrior prior) {
                mPrior = prior;
            }
            public Serializer() {
                this(null);
            }
            public void writeExternal(ObjectOutput out) throws IOException {
                out.writeDouble(mPrior.mPriorVariance);
                out.writeBoolean(mPrior.mNoninformativeIntercept);
            }
            public Object read(ObjectInput in)
                throws IOException, ClassNotFoundException {

                double priorScale = in.readDouble();
                boolean noninformativeIntercept = in.readBoolean();
                return new VariableCauchyRegressionPrior(priorScale,
                                                         noninformativeIntercept);
            }
        }
    }



}