Java Code Examples for org.nd4j.linalg.factory.Nd4j#getRandom()

public A3CThreadDiscrete(MDP<OBSERVATION, Integer, DiscreteSpace> mdp, IAsyncGlobal<IActorCritic> asyncGlobal,
                         A3CLearningConfiguration a3cc, int deviceNum, TrainingListenerList listeners,
                         int threadNumber) {
    super(asyncGlobal, mdp, listeners, threadNumber, deviceNum);
    this.configuration = a3cc;
    this.asyncGlobal = asyncGlobal;
    this.threadNumber = threadNumber;

    Long seed = configuration.getSeed();
    rnd = Nd4j.getRandom();
    if (seed != null) {
        rnd.setSeed(seed + threadNumber);
    }

    setUpdateAlgorithm(buildUpdateAlgorithm());
}
 

/**
 *
 * @param random        Object to use (or null for deterministic)
 * @param mode          Contour retrieval mode
 * @param method        Contour approximation method
 * @param blurWidth     Width of blurring kernel size
 * @param blurHeight    Height of blurring kernel size
 * @param lowerThresh   Lower threshold for either Canny or Threshold
 * @param upperThresh   Upper threshold for either Canny or Threshold
 * @param isCanny       Whether the edge detector is Canny or Threshold
 */
public LargestBlobCropTransform(Random random, int mode, int method, int blurWidth, int blurHeight, int lowerThresh,
                int upperThresh, boolean isCanny) {
    super(random);
    this.rng = Nd4j.getRandom();
    this.mode = mode;
    this.method = method;
    this.blurWidth = blurWidth;
    this.blurHeight = blurHeight;
    this.lowerThresh = lowerThresh;
    this.upperThresh = upperThresh;
    this.isCanny = isCanny;
    this.converter = new OpenCVFrameConverter.ToMat();
}
 

public A3CDiscrete(MDP<OBSERVATION, Integer, DiscreteSpace> mdp, IActorCritic iActorCritic, A3CLearningConfiguration conf) {
    this.iActorCritic = iActorCritic;
    this.mdp = mdp;
    this.configuration = conf;
    asyncGlobal = new AsyncGlobal<>(iActorCritic, conf);

    Long seed = conf.getSeed();
    Random rnd = Nd4j.getRandom();
    if (seed != null) {
        rnd.setSeed(seed);
    }

    policy = new ACPolicy<>(iActorCritic, rnd);
}
 

@Test
public void testMultithreading2() throws Exception {

    final AtomicInteger cnt = new AtomicInteger(0);
    final CopyOnWriteArrayList<INDArray> list = new CopyOnWriteArrayList<>();

    Thread[] threads = new Thread[10];
    for (int x = 0; x < threads.length; x++) {
        list.add(null);
    }

    for (int x = 0; x < threads.length; x++) {
        threads[x] = new Thread(new Runnable() {
            @Override
            public void run() {
                Random rnd = Nd4j.getRandom();
                rnd.setSeed(119);
                INDArray array = Nd4j.getExecutioner().exec(new UniformDistribution(Nd4j.createUninitialized(25)));

                Nd4j.getExecutioner().commit();

                list.set(cnt.getAndIncrement(), array);
            }
        });
        threads[x].start();
    }

    for (int x = 0; x < threads.length; x++) {
        threads[x].join();

        assertNotEquals(null, list.get(x));

        if (x > 0) {
            assertEquals(list.get(0), list.get(x));
        }
    }
}
 

@Test
public void testMultithreading1() throws Exception {

    final AtomicInteger cnt = new AtomicInteger(0);
    final CopyOnWriteArrayList<float[]> list = new CopyOnWriteArrayList<>();

    Thread[] threads = new Thread[10];
    for (int x = 0; x < threads.length; x++) {
        list.add(null);
    }

    for (int x = 0; x < threads.length; x++) {
        threads[x] = new Thread(new Runnable() {
            @Override
            public void run() {
                Random rnd = Nd4j.getRandom();
                rnd.setSeed(119);
                float[] array = new float[10];

                for (int e = 0; e < array.length; e++) {
                    array[e] = rnd.nextFloat();
                }
                list.set(cnt.getAndIncrement(), array);
            }
        });
        threads[x].start();
    }

    // we want all threads finished before comparing arrays
    for (int x = 0; x < threads.length; x++)
        threads[x].join();

    for (int x = 0; x < threads.length; x++) {
        assertNotEquals(null, list.get(x));

        if (x > 0) {
            assertArrayEquals(list.get(0), list.get(x), 1e-5f);
        }
    }
}
 

public RandomCropTransform(Random random, long seed, int height, int width) {
    super(random);
    this.outputHeight = height;
    this.outputWidth = width;
    this.rng = Nd4j.getRandom();
    this.rng.setSeed(seed);
    this.converter = new OpenCVFrameConverter.ToMat();
}
 

public RandomProjection(double eps){
    this(eps, Nd4j.getRandom());
}
 

public OrthogonalDistribution(double gain) {
    this.gain = gain;
    this.random = Nd4j.getRandom();
}
 

public RandomProjection(int components){
    this(components, Nd4j.getRandom());
}
 

public BaseDistribution() {
    this(Nd4j.getRandom());
}
 

public ConstantDistribution(double value) {
    this.value = value;
    this.random = Nd4j.getRandom();
}
 

public CartpoleEnvironment() {
    this(Nd4j.getRandom());
}
 

public LogNormalDistribution(INDArray mean, double std) {
    this.means = mean;
    this.standardDeviation = std;
    this.random = Nd4j.getRandom();
}
 

public TruncatedNormalDistribution(INDArray mean, double std) {
    this.means = mean;
    this.standardDeviation = std;
    this.random = Nd4j.getRandom();
}
 

public DiscreteSpace(int size) {
    this(size, Nd4j.getRandom());
}
 

public ACPolicy(IActorCritic actorCritic) {
    this(actorCritic, Nd4j.getRandom());
}
 

public RandomProjection(int components){
    this(components, Nd4j.getRandom());
}
 

public NormalDistribution(INDArray mean, double std) {
    this.means = mean;
    this.standardDeviation = std;
    this.random = Nd4j.getRandom();
}
 

/**
 * Create a uniform real distribution using the given lower and upper
 * bounds.
 *
 * @param lower Lower bound of this distribution (inclusive).
 * @param upper Upper bound of this distribution (exclusive).
 * @throws NumberIsTooLargeException if {@code lower >= upper}.
 */
public UniformDistribution(double lower, double upper) throws NumberIsTooLargeException {
    this(Nd4j.getRandom(), lower, upper);
}
 

/**
 * Create a normal distribution using the given mean, standard deviation and
 * inverse cumulative distribution accuracy.
 *
 * @param mean               Mean for this distribution.
 * @param sd                 Standard deviation for this distribution.
 * @param inverseCumAccuracy Inverse cumulative probability accuracy.
 * @throws NotStrictlyPositiveException if {@code sd <= 0}.
 * @since 2.1
 */
public TruncatedNormalDistribution(double mean, double sd, double inverseCumAccuracy) throws NotStrictlyPositiveException {
    this(Nd4j.getRandom(), mean, sd, inverseCumAccuracy);
}