精华内容
下载资源
问答
  • 编写函数Normalize,将复数归一化,即若复数为a+bi,归一化结果为a/sqrt(aa+bb) + ib/sqrt(aa+b*b) 。使用结构体指针类型作为函数参数可能是必要的。其中实部和虚部由键盘输入,输出为归一化结果,如果归一化结果的...

    编写函数Normalize,将复数归一化,即若复数为a+bi,归一化结果为a/sqrt(aa+bb) + ib/sqrt(aa+b*b) 。使用结构体指针类型作为函数参数可能是必要的。其中实部和虚部由键盘输入,输出为归一化结果,如果归一化结果的实部或虚部为小数的要求保留一位小数。

    样例输入:(格式说明:3 4 分别为以空格隔开的实数的实部和虚部)
    3 4
    样例输出:
    0.6+0.8i
    样例输入:
    2 5
    样例输出:
    0.4+0.9i

    sqrt运算直接加个include<math.h>头文件即可,其他的注意好细节

    #include<iostream>
    #include<iomanip>
    #include<math.h>
    using namespace std;
    double a,b;//表示实部和虚部 
    void Normalize();//将复数归一化
    int main()
    {
    	cin>>a>>b;
    	Normalize();
    	return 0;
    }
    //实部和虚部若为小数,要求保留一位小数
    void Normalize()
    {
    	double x,y;//表示归一化的实部和虚部
    	x=a/sqrt(a*a+b*b); 
    	y=b/sqrt(a*a+b*b);
    	cout<<fixed<<setprecision(1)<<x<<"+"<<fixed<<setprecision(1)<<y<<"i"<<endl;
    }
    
    展开全文
  • 本文作者:合肥工业大学 管理学院 钱洋 ... 未经本人允许禁止转载。 MathArrays的使用 归一化数组 import org.apache.commons.math3.random.SobolSequenceGenerator; import org.apache.commons.math3.util.MathArra...

    本文作者:合肥工业大学 管理学院 钱洋 email:1563178220@qq.com 内容可能有不到之处,欢迎交流。
    未经本人允许禁止转载

    MathArrays的使用

    归一化数组

    import org.apache.commons.math3.random.SobolSequenceGenerator;
    import org.apache.commons.math3.util.MathArrays;
    
    public class MathArraysTest {
    
    	public static void main(String[] args) {
    		SobolSequenceGenerator generator = new SobolSequenceGenerator(5);
    	    generator.skipTo(999999); 
    	    System.out.println("..............................");
    	    double[] vector = generator.nextVector();
    	    for (int i = 0; i < vector.length; i++) {
    	    	System.out.println(vector[i]);
    		}
    	    System.out.println(".............................");
    	    double[] normalizeVector = MathArrays.normalizeArray(vector,1.0);
    	    for (int i = 0; i < normalizeVector.length; i++) {
    			System.out.println(normalizeVector[i]);
    		}
    	}
    }
    

    程序执行结果为:

    在这里插入图片描述
    normalizeArray()方法用于将一组数,标准化到一个值。

    StatUtils类

    import org.apache.commons.math3.random.SobolSequenceGenerator;
    import org.apache.commons.math3.stat.StatUtils;
    
    public class StatUtilsTest {
    
    	public static void main(String[] args) {
    		SobolSequenceGenerator generator = new SobolSequenceGenerator(5);
    	    generator.skipTo(999999); 
    	    System.out.println("..............................");
    	    double[] vector = generator.nextVector();
    	    for (int i = 0; i < vector.length; i++) {
    	    	System.out.println(vector[i]);
    		}
    	    System.out.println(".............................");
    	    double[] normalizeVector = StatUtils.normalize(vector);
    	    for (int i = 0; i < normalizeVector.length; i++) {
    			System.out.println(normalizeVector[i]);
    		}
    	}
    }
    

    程序的输出结果为:
    在这里插入图片描述
    这个方法,与MathArrays类中的normalizeArray()方法还是存在差异的,该方法用于正太标准化。

    展开全文
  • 文章目录背景python中numpy生成随机数产生一组随机数产生二维随机数归一化随机数标准正太分布随机数多元正太分布随机数Java中math3产生各种随机数 背景 在编写机器学习算法时,经常需要对各类参数进行初始化,例如...

    本文作者:合肥工业大学 管理学院 钱洋 email:1563178220@qq.com 内容可能有不到之处,欢迎交流。
    未经本人允许禁止转载

    背景

    在编写机器学习算法时,经常需要对各类参数进行初始化,例如一些使用变分推断算法的模型。无论是在Java中,还是Python中,随机数生成器使用都非常重要。

    在Python中,我们可以使用numpy中的函数产生各类随机数。以下将先介绍numpy产生随机数的方式,之后介绍Java中Math3 如何产生用户想要的随机数。

    python中numpy生成随机数

    产生一组随机数

    import numpy as np
    a1 = np.random.sample(3)
    print(a1)
    

    程序输出结果为:

    [0.894403   0.75327423 0.0598    ]
    

    产生二维随机数

    import numpy as np
    a2 = np.random.random([3, 5])
    print(a2)
    

    程序输出结果为:

    [[0.74259942 0.14265614 0.39788471 0.24822603 0.70212864]
     [0.24499887 0.10752136 0.87938368 0.66949099 0.60077382]
     [0.93464286 0.12540026 0.23024034 0.01755745 0.1791168 ]]
    

    归一化随机数

    import numpy as np
    a2 = np.random.random([3, 5])
    a2 = a2 / a2.sum(1)[:, np.newaxis]  # normalize
    print(a2)
    

    程序输出结果为:

    [[0.20371704 0.13704266 0.07736116 0.07489164 0.50698749]
     [0.16472605 0.10869033 0.44036911 0.10437194 0.18184257]
     [0.12031567 0.04564694 0.0950007  0.33511749 0.40391919]]
    

    标准正太分布随机数

    import numpy as np
    c = np.random.normal(size=(3,4))
    print(c)
    

    程序输出结果为:

    [[-0.3369725  -1.05351817 -0.84444184  0.43715886]
     [-0.56812588  0.15303606  0.50248202  0.95384482]
     [-0.63582981  0.44559096 -1.91725906 -0.70182715]]
    

    多元正太分布随机数

    import numpy as np
    V = np.random.multivariate_normal(np.zeros(5), np.identity(5) * (5),size=3)
    print(V)
                                                   
    

    即均值为0,协方差为5的多元正太分布中,产生随机数,输出结果为:

    [[ 2.91755746 -1.67030031 -1.0542531   0.13214101 -2.03207468]
     [-1.86659205  0.14574427 -4.24525326 -3.91111677 -2.81316827]
     [-1.57533411  2.54300223 -0.69052118 -3.19566595  3.21427621]]
    

    Java中math3产生各种随机数

    Math3中的选择器有:
    在这里插入图片描述
    即:

    CorrelatedRandomVectorGenerator

    • CorrelatedRandomVectorGenerator:这个选择器用于从多元正太分布中抽取随机数,其中的方法包括:

    通过源码可以看到,CorrelatedRandomVectorGenerator中的构造方法有两个,分别是:

        /**
         * Builds a correlated random vector generator from its mean
         * vector and covariance matrix.
         *
         * @param mean Expected mean values for all components.
         * @param covariance Covariance matrix.
         * @param small Diagonal elements threshold under which  column are
         * considered to be dependent on previous ones and are discarded
         * @param generator underlying generator for uncorrelated normalized
         * components.
         * @throws org.apache.commons.math3.linear.NonPositiveDefiniteMatrixException
         * if the covariance matrix is not strictly positive definite.
         * @throws DimensionMismatchException if the mean and covariance
         * arrays dimensions do not match.
         */
        public CorrelatedRandomVectorGenerator(double[] mean,
                                               RealMatrix covariance, double small,
                                               NormalizedRandomGenerator generator) {
            int order = covariance.getRowDimension();
            if (mean.length != order) {
                throw new DimensionMismatchException(mean.length, order);
            }
            this.mean = mean.clone();
    
            final RectangularCholeskyDecomposition decomposition =
                new RectangularCholeskyDecomposition(covariance, small);
            root = decomposition.getRootMatrix();
    
            this.generator = generator;
            normalized = new double[decomposition.getRank()];
    
        }
    

    从这个构造方法中,可以看到其输入是均值数组,协方差矩阵,一个double类型的值,和实例化的NormalizedRandomGenerator。在后面会介绍这个构造方法的使用。
    另外一个构造方法是:

    /**
         * Builds a null mean random correlated vector generator from its
         * covariance matrix.
         *
         * @param covariance Covariance matrix.
         * @param small Diagonal elements threshold under which  column are
         * considered to be dependent on previous ones and are discarded.
         * @param generator Underlying generator for uncorrelated normalized
         * components.
         * @throws org.apache.commons.math3.linear.NonPositiveDefiniteMatrixException
         * if the covariance matrix is not strictly positive definite.
         */
        public CorrelatedRandomVectorGenerator(RealMatrix covariance, double small,
                                               NormalizedRandomGenerator generator) {
            int order = covariance.getRowDimension();
            mean = new double[order];
            for (int i = 0; i < order; ++i) {
                mean[i] = 0;
            }
    
            final RectangularCholeskyDecomposition decomposition =
                new RectangularCholeskyDecomposition(covariance, small);
            root = decomposition.getRootMatrix();
    
            this.generator = generator;
            normalized = new double[decomposition.getRank()];
    
        }
    

    使用多元正太分布,产生一组随机数,需要使用这里面的一个方法:

     /** Generate a correlated random vector.
         * @return a random vector as an array of double. The returned array
         * is created at each call, the caller can do what it wants with it.
         */
        public double[] nextVector() {
    
            // generate uncorrelated vector
            for (int i = 0; i < normalized.length; ++i) {
                normalized[i] = generator.nextNormalizedDouble();
            }
    
            // compute correlated vector
            double[] correlated = new double[mean.length];
            for (int i = 0; i < correlated.length; ++i) {
                correlated[i] = mean[i];
                for (int j = 0; j < root.getColumnDimension(); ++j) {
                    correlated[i] += root.getEntry(i, j) * normalized[j];
                }
            }
    
            return correlated;
    
        }
    

    使用案例

    下面以具体的案例讲解如何使用CorrelatedRandomVectorGenerator。

    import org.apache.commons.math3.linear.MatrixUtils;
    import org.apache.commons.math3.linear.RealMatrix;
    import org.apache.commons.math3.random.CorrelatedRandomVectorGenerator;
    import org.apache.commons.math3.random.GaussianRandomGenerator;
    import org.apache.commons.math3.random.JDKRandomGenerator;
    import org.apache.commons.math3.random.RandomGenerator;
    
    public class MultivariateGaussianGeneratorTest2 {
    
    	public static void main(String[] args) {
    		RandomGenerator rg = new JDKRandomGenerator();
    		rg.setSeed(17399225432l);  // 随机种子
    		GaussianRandomGenerator rawGenerator = new GaussianRandomGenerator(rg);
    		double[] mean = {1, 2, 5};
    		double[][] arrA = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};
    		RealMatrix matrixA = MatrixUtils.createRealMatrix(arrA); 
    		//生成协方差矩阵
    		RealMatrix covariance = matrixA.multiply (matrixA.transpose());
    		// 调用函数
    		CorrelatedRandomVectorGenerator generator = 
    		    new CorrelatedRandomVectorGenerator(mean, covariance, 1.0e-12 * covariance.getNorm(), rawGenerator);
    		double[] randomVector = generator.nextVector();
    		for(double d : randomVector){
    			System.out.println(d);
    		}
    	}
    }
    
    

    如上面程序所示,设置了均值数组,通过矩阵和矩阵的逆相乘得到协方差,以此作为输入产生一组来自多元正太分布的随机数。
    上面程序的输出结果为:

    Array2DRowRealMatrix{{14.0,26.0,32.0},{26.0,50.0,62.0},{32.0,62.0,77.0}}
    8.241122654913196
    15.481679575594983
    21.601958035935876
    

    GaussianRandomGenerator

    这个类,在上面的代码中已有使用。该类用于从标准正太分布中产生一个值。其中,该类的构造方法如下:

        /** Create a new generator.
         * @param generator underlying random generator to use
         */
        public GaussianRandomGenerator(final RandomGenerator generator) {
            this.generator = generator;
        }
    

    该类中产生,产生一个随机数的方法如下:

        /** Generate a random scalar with null mean and unit standard deviation.
         * @return a random scalar with null mean and unit standard deviation
         */
        public double nextNormalizedDouble() {
            return generator.nextGaussian();
        }
    

    使用案例

    下面以一个案例讲解其使用:

    import org.apache.commons.math3.random.GaussianRandomGenerator;
    import org.apache.commons.math3.random.JDKRandomGenerator;
    import org.apache.commons.math3.random.RandomGenerator;
    
    public class GaussianRandomTest {
    
    	public static void main(String[] args) {
    		RandomGenerator rg = new JDKRandomGenerator();
    //		rg.setSeed(17399225432l);  // 随机种子
    		GaussianRandomGenerator rawGenerator = new GaussianRandomGenerator(rg);
    		for (int i = 0; i < 10; i++) {
    			double g = rawGenerator.nextNormalizedDouble();
    			System.out.println(g);
    		}
    	}
    }
    

    执行该程序,会在控制台输出10个随机数,如下所示:
    在这里插入图片描述

    HaltonSequenceGenerator

    Halton sequences常用于 Monte Carlo估计中。其产生随机数的原理是以一个质数为基,例如2或者3等,然后开始在0-1之间进行划分。例如:

    ​1⁄2, ​1⁄4, ​3⁄4, ​1⁄8, ​5⁄8, ​3⁄8, ​7⁄8, ​1⁄16, ​9⁄16,...
    
    ​1⁄3, ​2⁄3, ​1⁄9, ​4⁄9, ​7⁄9, ​2⁄9, ​5⁄9, ​8⁄9, ​1⁄27,...
    

    在math3中,HaltonSequenceGenerator类中的构造方法有:

        /**
         * Construct a new Halton sequence generator for the given space dimension.
         *
         * @param dimension the space dimension
         * @throws OutOfRangeException if the space dimension is outside the allowed range of [1, 40]
         */
        public HaltonSequenceGenerator(final int dimension) throws OutOfRangeException {
            this(dimension, PRIMES, WEIGHTS);
        }
    

    即设置产生随机数的维度。
    另外,一个构造方法是:

    /**
         * Construct a new Halton sequence generator with the given base numbers and weights for each dimension.
         * The length of the bases array defines the space dimension and is required to be &gt; 0.
         *
         * @param dimension the space dimension
         * @param bases the base number for each dimension, entries should be (pairwise) prime, may not be null
         * @param weights the weights used during scrambling, may be null in which case no scrambling will be performed
         * @throws NullArgumentException if base is null
         * @throws OutOfRangeException if the space dimension is outside the range [1, len], where
         *   len refers to the length of the bases array
         * @throws DimensionMismatchException if weights is non-null and the length of the input arrays differ
         */
        public HaltonSequenceGenerator(final int dimension, final int[] bases, final int[] weights)
                throws NullArgumentException, OutOfRangeException, DimensionMismatchException {
    
            MathUtils.checkNotNull(bases);
    
            if (dimension < 1 || dimension > bases.length) {
                throw new OutOfRangeException(dimension, 1, PRIMES.length);
            }
    
            if (weights != null && weights.length != bases.length) {
                throw new DimensionMismatchException(weights.length, bases.length);
            }
    
            this.dimension = dimension;
            this.base = bases.clone();
            this.weight = weights == null ? null : weights.clone();
            count = 0;
        }
    

    即需要产生数据的维度,以及所使用的基(质素数组)以及权重。
    其中,在该类中,默认的基有:

        /** The first 40 primes. */
        private static final int[] PRIMES = new int[] {
            2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
            71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
            149, 151, 157, 163, 167, 173
        };
    

    默认的权重为:

      /** The optimal weights used for scrambling of the first 40 dimension. */
        private static final int[] WEIGHTS = new int[] {
            1, 2, 3, 3, 8, 11, 12, 14, 7, 18, 12, 13, 17, 18, 29, 14, 18, 43, 41,
            44, 40, 30, 47, 65, 71, 28, 40, 60, 79, 89, 56, 50, 52, 61, 108, 56,
            66, 63, 60, 66
        };
    

    如果需要产生一组随机数,需要调用该类中的两个方法:

     /** {@inheritDoc} */
        public double[] nextVector() {
            final double[] v = new double[dimension];
            for (int i = 0; i < dimension; i++) {
                int index = count;
                double f = 1.0 / base[i];
    
                int j = 0;
                while (index > 0) {
                    final int digit = scramble(i, j, base[i], index % base[i]);
                    v[i] += f * digit;
                    index /= base[i]; // floor( index / base )
                    f /= base[i];
                }
            }
            count++;
            return v;
        }
            /**
         * Skip to the i-th point in the Halton sequence.
         * <p>
         * This operation can be performed in O(1).
         *
         * @param index the index in the sequence to skip to
         * @return the i-th point in the Halton sequence
         * @throws NotPositiveException if index &lt; 0
         */
        public double[] skipTo(final int index) throws NotPositiveException {
            count = index;
            return nextVector();
        }
    
    

    使用案例

    下面将以具体的案例讲解HaltonSequenceGenerator的使用。

    import org.apache.commons.math3.random.HaltonSequenceGenerator;
    public class HaltonSequenceTest {
    
    	public static void main(String[] args) {
    		/*****第一种方式产生一组随机数*****/
    		HaltonSequenceGenerator randomVectorGenerator = new HaltonSequenceGenerator(3);
    		//设置
    		randomVectorGenerator.skipTo(999999); 
    		//产生一组随机数
    		double[] b = randomVectorGenerator.nextVector();
    		for (int i = 0; i < b.length; i++) {
    			System.out.println(b[i]);
    		}
    		/*****第二种方式产生一组随机数*****/
    		System.out.println(".......第二种构造方法产生随机数.........");
    		HaltonSequenceGenerator randomVectorGenerator1 = new HaltonSequenceGenerator(4, new int[] { 3, 5, 7,11, 13 }, null);
    		//设置
    		randomVectorGenerator1.skipTo(999999); 
    		//产生一组随机数
    		double[] b1 = randomVectorGenerator1.nextVector();
    		for (int i = 0; i < b1.length; i++) {
    			System.out.println(b1[i]);
    		}
    	}
    }
    
    

    执行该程序,输出结果为:
    在这里插入图片描述

    调整skipTo()方法中的数字,可以产生不同的随机数。

    JDKRandomGenerator

    JDKRandomGenerator类继承了java.util中的Random类,其使用方式较为简单。其构造方法主要有:

        /**
         * Create a new JDKRandomGenerator with a default seed.
         */
        public JDKRandomGenerator() {
            super();
        }
    
        /**
         * Create a new JDKRandomGenerator with the given seed.
         *
         * @param seed initial seed
         * @since 3.6
         */
        public JDKRandomGenerator(int seed) {
           
    

    另外,其还包括两个方法,用于设置随机数种子。

    该类可以调用Random类中的next, nextBoolean, nextBytes, nextDouble, nextFloat, nextGaussian, nextInt, nextInt, nextLong, setSeed方法。

    使用案例

    下面为使用案例:

    import org.apache.commons.math3.random.JDKRandomGenerator;
    import org.apache.commons.math3.random.RandomGenerator;
    
    public class JDKRandomTest {
    
    	public static void main(String[] args) {
    		RandomGenerator rg = new JDKRandomGenerator();
    		for (int i = 0; i < 2; i++) {
    			System.out.println("double:" + rg.nextDouble());
    			System.out.println("boolean:" + rg.nextBoolean());
    			System.out.println("float:"  + rg.nextFloat());
    			System.out.println("gaussian:" + rg.nextGaussian());
    			System.out.println("int:" + rg.nextInt());
    			System.out.println("long:" + rg.nextLong());
    		}
    		
    	}
    }
    

    执行该程序,输出结果为:
    在这里插入图片描述

    SobolSequenceGenerator

    SobolSequenceGenerator类的构造方法有两种,常使用第一种:

     /**
         * Construct a new Sobol sequence generator for the given space dimension.
         *
         * @param dimension the space dimension
         * @throws OutOfRangeException if the space dimension is outside the allowed range of [1, 1000]
         */
        public SobolSequenceGenerator(final int dimension) throws OutOfRangeException {
            if (dimension < 1 || dimension > MAX_DIMENSION) {
                throw new OutOfRangeException(dimension, 1, MAX_DIMENSION);
            }
    
            // initialize the other dimensions with direction numbers from a resource
            final InputStream is = getClass().getResourceAsStream(RESOURCE_NAME);
            if (is == null) {
                throw new MathInternalError();
            }
    
            this.dimension = dimension;
    
            // init data structures
            direction = new long[dimension][BITS + 1];
            x = new long[dimension];
    
            try {
                initFromStream(is);
            } catch (IOException e) {
                // the internal resource file could not be read -> should not happen
                throw new MathInternalError();
            } catch (MathParseException e) {
                // the internal resource file could not be parsed -> should not happen
                throw new MathInternalError();
            } finally {
                try {
                    is.close();
                } catch (IOException e) { // NOPMD
                    // ignore
                }
            }
        }
    
        /**
         * Construct a new Sobol sequence generator for the given space dimension with
         * direction vectors loaded from the given stream.
         * <p>
         * The expected format is identical to the files available from
         * <a href="http://web.maths.unsw.edu.au/~fkuo/sobol/">Stephen Joe and Frances Kuo</a>.
         * The first line will be ignored as it is assumed to contain only the column headers.
         * The columns are:
         * <ul>
         *  <li>d: the dimension</li>
         *  <li>s: the degree of the primitive polynomial</li>
         *  <li>a: the number representing the coefficients</li>
         *  <li>m: the list of initial direction numbers</li>
         * </ul>
         * Example:
         * <pre>
         * d       s       a       m_i
         * 2       1       0       1
         * 3       2       1       1 3
         * </pre>
         * <p>
         * The input stream <i>must</i> be an ASCII text containing one valid direction vector per line.
         *
         * @param dimension the space dimension
         * @param is the stream to read the direction vectors from
         * @throws NotStrictlyPositiveException if the space dimension is &lt; 1
         * @throws OutOfRangeException if the space dimension is outside the range [1, max], where
         *   max refers to the maximum dimension found in the input stream
         * @throws MathParseException if the content in the stream could not be parsed successfully
         * @throws IOException if an error occurs while reading from the input stream
         */
        public SobolSequenceGenerator(final int dimension, final InputStream is)
                throws NotStrictlyPositiveException, MathParseException, IOException {
    
            if (dimension < 1) {
                throw new NotStrictlyPositiveException(dimension);
            }
    
            this.dimension = dimension;
    
            // init data structures
            direction = new long[dimension][BITS + 1];
            x = new long[dimension];
    
            // initialize the other dimensions with direction numbers from the stream
            int lastDimension = initFromStream(is);
            if (lastDimension < dimension) {
                throw new OutOfRangeException(dimension, 1, lastDimension);
            }
        }
    

    使用该方法产生的随机数如下图所示:

    在这里插入图片描述

    使用案例

    以下为一个使用案例:

    import java.util.ArrayList;
    import java.util.List;
    import org.apache.commons.math3.linear.Array2DRowRealMatrix;
    import org.apache.commons.math3.linear.RealMatrix;
    import org.apache.commons.math3.random.SobolSequenceGenerator;
    
    public class SobolSequenceTest {
    
    	public static void main(String[] args) {
    		//产生一组随机数---测试案例
    		SobolSequenceGenerator generator = new SobolSequenceGenerator(5);
    	    generator.skipTo(999999); //这里必须使用,否则产生的全部是0
    	    System.out.println("..............................");
    	    double[] vector = generator.nextVector();
    	    for (int i = 0; i < vector.length; i++) {
    	    	System.out.println(vector[i]);
    		}
    	    System.out.println("...........SobolSequenceGenerator产生一组随机数.......");
    	    //产生多组随机数,并添加到矩阵中
    	    System.out.println(".............生成随机数矩阵...............");
    	    List<RealMatrix> points = new ArrayList<RealMatrix>();
    	    for (double i = 0; i < 3; i++) {
    	        double[] vector1 = generator.nextVector();
    	        RealMatrix pointMatrix = new Array2DRowRealMatrix(vector1);
    	        points.add(pointMatrix);
    	    }
    	    for (int i = 0; i < points.size(); i++) {
    			System.out.println(points.get(i));
    		}
    	}
    }
    

    程序的输出结果为:

    在这里插入图片描述

    UniformRandomGenerator

    从均匀分布中产生随机数。UniformRandomGenerator类实现了NormalizedRandomGenerator接口。UniformRandomGenerator类的构造方法为:

       /** Create a new generator.
         * @param generator underlying random generator to use
         */
        public UniformRandomGenerator(RandomGenerator generator) {
            this.generator = generator;
        }
    

    下面为其部分源码:

       /** Generate a random scalar with null mean and unit standard deviation.
         * <p>The number generated is uniformly distributed between -&sqrt;(3)
         * and +&sqrt;(3).</p>
         * @return a random scalar with null mean and unit standard deviation
         */
        public double nextNormalizedDouble() {
            return SQRT3 * (2 * generator.nextDouble() - 1.0);
        }
    
    

    从该源码中可以看到, nextNormalizedDouble()方法产生的随机数在 [-√3, +√3].之间,因为SQRT3 设置为√3,generator.nextDouble()产生的值范围是[0-1]。

    使用案例

    import org.apache.commons.math3.random.JDKRandomGenerator;
    import org.apache.commons.math3.random.RandomGenerator;
    import org.apache.commons.math3.random.UniformRandomGenerator;
    
    public class UniformRandomTest {
    
    	public static void main(String[] args) {
    		RandomGenerator rg = new JDKRandomGenerator();
    		rg.setSeed(10);
    		UniformRandomGenerator generator = new UniformRandomGenerator(rg);
    		double[] sample = new double[10];
    		for (int i = 0; i < sample.length; ++i) {
    			sample[i] = generator.nextNormalizedDouble();
    			System.out.println(sample[i]);
    		}
    	}
    }
    
    展开全文
  • 我们构造了大的<math> <msub> <mi> N </ mi> <mi> c </ mi> </ msub> </ math>为动力的近似手性<math> <mrow> <mi> S </ mi> <mi> U... 幅度与重新归一化比例无关。 将那些振幅与晶格数据拟合可允许t
  • pytorch基础学习3

    2020-10-29 21:54:38
    pytorch之批归一化一、注释学习二、部分参数 一、注释学习 对4D输入应用批处理归一化(带有额外通道维数的小批2D输入),如论文“`Batch Normalization: Accelerating Deep Network Training by Reducing Internal ...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    一、批归一化

    • 归一化定义
      不同的评价指标往往具有不同的量纲(例如:对于评价房价来说量纲指:面积、房价数、楼层等;对于预测某个人患病率来说量纲指:身高、体重等。)和量纲单位(例如:面积单位:平方米、平方厘米等;身高:米、厘米等),这样的情况会影响到数据分析的结果,为了消除指标之间量纲的影响,需要进行数据标准化处理,以解决数据指标之间的可比性。原始数据经过数据标准化处理后,各指标处于同一数量级,适合进行综合对比评价。
      2.批归一化的原因
    • 在现实生活中,一般的数据量都非常的大,此时若用算法进行处理,需要一次性加载进如此庞大的数据量,通常没有这么大的内存,无法实现。
      用所有数据量的均值和方差,容易造成过拟合,那么将数据分批载入训练模型中,其实就是对每批进行归一化,各批次的数据之间的均值与方差就一定的差别,这个差别一定程度上使得整个模型的训练变的更有鲁棒性,同样能够减少过拟合。

    二、BN到底解决了什么?

    一个标准的归一化步骤就是减均值除方差,那这种归一化操作有什么作用呢?我们观察下图,
    在这里插入图片描述
    a中左图是没有经过任何处理的输入数据,曲线是sigmoid函数,如果数据在梯度很小的区域,那么学习率就会很慢甚至陷入长时间的停滞。减均值除 方差后,数据就被移到中心区域如右图所示,对于大多数激活函数而言,这个区域的梯度都是最大的或者是有梯度的(比如ReLU),这可以看做是一种对抗梯度失的有效手段。对于一层如此,如果对于每一层数据都那么做的话,数据的分布总是在随着变化敏感的区域,相当于不用考虑数据分布变化了,这样训练起来更有效率。
    在这里插入图片描述
    对全局数据量使用归一化,本身就会对数据的分布产生破坏,另外在全局归一化后,处于中心区域的数据量将会减少很多,对于训练模型时,很多数据量将会产生梯度消失。使用批归一化就会如b图一般,对于每个批次的数据量即产生归一化的效果,又使得整个模型在训练过程中更多的数据量起到了相应的作用。

    三、pytorchBN注释

    对4D输入应用批处理归一化(带有额外通道维数的小批2D输入),如论文“`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”中所述。
    平均值和标准偏差是在小批量中按维度计算的,其中:math: ' \gamma '和:math: ' \beta '是大小为' C '的可学习参数向量(其中' C '是输入大小)。默认情况下,:math: ' \gamma '的元素设置为1,:math: ' \beta '的元素设置为0。标准偏差是通过有偏估计器计算的,相当于pytorch的方差‘torch.var’。
    同样在默认情况下,在训练期间,这一层将继续运行其计算的平均值和方差的估计值,然后在评估期间使用这些估计值进行归一化。运行估计值保持默认值:“momentum”为0.1。
    如果' track_running_stats '被设置为' ' False ' ',那么这一层就不会继续运行估计值,而在评估期间也会使用批处理统计信息。
    

    四、BN部分参数

    num_features: 来自期望输入的特征数,该期望输入的大小为’batch_size x num_features x height x width’。通常是对通道数进行归一化。
    eps: 为保证数值稳定性(分母不能趋近或取0),给分母加上的值。默认为1e-5。
    momentum: 动态均值和动态方差所使用的动量。默认为0.1。
    affine: 一个布尔值,当设为true,给该层添加可学习的仿射变换参数。

    Shape:

    输入:(N, C,H, W)
    输出:(N, C, H, W)(输入输出相同)


    展开全文
  • OpenGL学习之路3----画一个三角形

    千次阅读 2018-04-23 00:20:06
    归一化坐标 我们在屏幕上绘制图形的时候,是在一个归一化的空间里,即为下图 可以看到绘制窗口左下角坐标为(-1.0,-1.0)到右上角坐标为(1.0,1.0) 代码解释 opengl_math.h: #ifndef __OPENGL_MATH_H #...
  • DeepLabV3+ 基本原理及Pytorch版注解

    千次阅读 2020-05-30 17:29:57
    用到的sync_batchnorm.batchnorm比归一化包,pytorch版本的可以在https://github.com/acgtyrant/Synchronized-BatchNorm-PyTorch下载 B.在python2.7中,引用的队列是大写import Queue import math import torch...
  • 好久没进行了,看看吧,与DEMO7-2的区别,只看不同的地方,相机类型不同,归一化平面改为2*2/ar,视口为640*480,执行了背面消除,(就是判断面元向量与面元到视点向量的点乘,>0,则可见,否则,消除) 这一步是在...
  • OpenCV学习记录24

    2019-09-21 22:08:32
    一 学习内容 ...1.2 值域归一化(最大-最小归一化) 1.3 绘制线 二 代码调试 #include<opencv2/opencv.hpp> #include<iostream> #include<math.h> using namespace cv; using name...
  • opencv之直方图

    2017-02-17 23:10:59
    直方图的绘制主要用到calcHist()函数 计算,normal归一化直方图。 基本思路: ...3 用normalize()来进行直方图的归一化。 4 用inline 画出每个通道的直方图。#include #include #include<math.h>usin
  • 向量绕任意轴旋转

    2013-01-30 14:35:00
    此处旋转轴向量N必须为归一化后的向量,否则旋转后的向量将可能会出错 View Code 1 float c = (float)Math.Cos(theta); 2 float c1 =1.0f- (float)Math.Cos(theta); 3 float s = (float)Math.Sin(theta); ...
  • 我们用物质计算3d超对称Yang-Mills-Chern-Simons理论的维滕指数。 对于<math altimg =“ si2.gif” xmlns =“ ... 此外,在3D理论中,大量费米子环通过对Chern-Simons水平k的重新归一化来影响该指数。
  • 我们以高能级的三个中微子质量特征值作为输入参数,并通过考虑归一化群效应来计算低能中微子参数。 我们观察到,只有在输入质量特征值较大时,才能获得低能量中微子参数的正确输出值。<math altimg =“ si4.g
  • 针孔相机的投影过程(三维重建task1-2) ...(3归一化像平面坐标系到物理像平面坐标系; (4)物理像平面坐标系到图像坐标系。 #include <iostream> #include "math/vector.h" class Camera{ public:
  • 遥感生态指数(RSEI)——四个指数的计算

    万次阅读 多人点赞 2020-07-02 11:05:08
    ①首先,是绿度指数的计算,一般用归一化植被指数(NDVI) NDVI=(NIR-Red)/(NIR+Red) 在Bandmath工具中输入NDVI计算公式 (float(b4-b3))/(b4+b3) 其中,b3、b4分别是红波段和近红外波段 ②其次,是湿度计算...
  • OpenCV学习记录13

    2019-08-23 22:16:08
    3.灰度图像对比度调整——最大最小值归一化 二 代码调试 #include <opencv2/opencv.hpp> #include <iostream> #include <math.h> using namespace cv; int main() { Mat src; sr...
  • 准备:利用commons-math3 数学包封装的向量进行计算。 二.前提:输入参数为三点,两个向量共起点。 三.操作: 3.1)利用向量的相加构成的平行四边形法则来求角平分线,见图1.1、1.2  图1.1    图1.2 3.2)但是平行...
  • 常见激活函数的汇总

    2020-11-14 20:57:32
    相当于对数据进行归一化, 但是在实际应用过程中,他的导数在0-0.25之间,并且他在多级级联的时候会造成梯度的消失,因此在实际应用过程中很少应用。 并且逆运算为指数,在反向传播过程中耗时 tf.math.tanh(x) tf....
  • pycuda报错cuMemFree failed

    2019-05-11 15:48:02
    #归一化 template = template/sum return template def Gauss_filter(img,template_size,sigma): [rows,cols,channel] = img.shape border = int(template_size/2) template = ...
  • #归一化 template = template/sum return template def Gauss_filter(img,template_size,sigma): [rows,cols,channel] = img.shape border = int(template_size/2) template = ...
  • #数值归一 word = '#number' if word.isdigit() else word #去停用词 if len(word)>1 and word not in sw: seg.append(word) return seg def qlist_preprocessing(qlist): word_cnt = Counter() ...
  • # 加载数据集,从文件读取-->解码-->归一化--->拆分为输入和目标-->像素转为[-1,1]-->转变形状 def load_examples(input_dir): if input_dir is None or not os.path.exists(input_dir): raise Exception(...
  • //对结果进行归一化  cv::namedWindow("distance result", CV_WINDOW_NORMAL);  cv::imshow("distance result", distImg);  threshold(distImg, distImg, .4, 1...
  • Vector3归一化 Slerp PC 0.0465:0.15 0.076:0.12 0.02:0.001 0.1:0.14 0.014:0.001 0.10:0.11 Android 0.16:1.1 0.28:0.76 0.17:0.00035 0.43:0.5 0.21:0.02 0.3:0.06 iOS 0.04:0.145 0.055:0.11 0.017:0.05...
  • int InitBp(bp_nn *bp) { //初始bp网络 /*printf("请输入隐层节点数,最大数为100:\n"); scanf_s("%d", &(*bp).h); printf("请输入学习率:\n"); scanf_s("%lf", &(*bp).a); //(*bp).a为double型数据,...
  • //直方图归一化 cvNormalizeHist(Histogram,1); cvNormalizeHist(Histogram2,1); //计算当前帧与前一帧的直方图差 CompareHist = (float)cvCompareHist(Histogram,Histogram2,CV_COMP_CHISQR); ...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

math3归一化