Examples with DenseLocalOnHeapVector org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector used on opensource projects

Example 6 with DenseLocalOnHeapVector

use of org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector in project ignite by apache.

the class LocalModelsTest method importExportSVMBinaryClassificationModelTest.

/**
 */
@Test
public void importExportSVMBinaryClassificationModelTest() throws IOException {
    executeModelTest(mdlFilePath -> {
        SVMLinearBinaryClassificationModel mdl = new SVMLinearBinaryClassificationModel(new DenseLocalOnHeapVector(new double[] { 1, 2 }), 3);
        Exporter<SVMLinearBinaryClassificationModel, String> exporter = new FileExporter<>();
        mdl.saveModel(exporter, mdlFilePath);
        SVMLinearBinaryClassificationModel load = exporter.load(mdlFilePath);
        Assert.assertNotNull(load);
        Assert.assertEquals("", mdl, load);
        return null;
    });
}

Example 7 with DenseLocalOnHeapVector

use of org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector in project ignite by apache.

the class FuzzyCMeansDistributedClustererTest method testTwoDimensionsLittleData.

/**
 * Test that algorithm gives correct results on a small sample - 4 centers on the plane.
 */
public void testTwoDimensionsLittleData() {
    IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
    FuzzyCMeansDistributedClusterer clusterer = new FuzzyCMeansDistributedClusterer(new EuclideanDistance(), 2, BaseFuzzyCMeansClusterer.StopCondition.STABLE_MEMBERSHIPS, 0.01, 500, null, 2, 50);
    double[][] points = new double[][] { { -10, -10 }, { -9, -11 }, { -10, -9 }, { -11, -9 }, { 10, 10 }, { 9, 11 }, { 10, 9 }, { 11, 9 }, { -10, 10 }, { -9, 11 }, { -10, 9 }, { -11, 9 }, { 10, -10 }, { 9, -11 }, { 10, -9 }, { 11, -9 } };
    SparseDistributedMatrix pntMatrix = new SparseDistributedMatrix(16, 2, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
    for (int i = 0; i < 16; i++) pntMatrix.setRow(i, points[i]);
    FuzzyCMeansModel mdl = clusterer.cluster(pntMatrix, 4);
    Vector[] centers = mdl.centers();
    Arrays.sort(centers, Comparator.comparing(vector -> Math.atan2(vector.get(1), vector.get(0))));
    DistanceMeasure measure = mdl.distanceMeasure();
    assertEquals(0, measure.compute(centers[0], new DenseLocalOnHeapVector(new double[] { -10, -10 })), 1);
    assertEquals(0, measure.compute(centers[1], new DenseLocalOnHeapVector(new double[] { 10, -10 })), 1);
    assertEquals(0, measure.compute(centers[2], new DenseLocalOnHeapVector(new double[] { 10, 10 })), 1);
    assertEquals(0, measure.compute(centers[3], new DenseLocalOnHeapVector(new double[] { -10, 10 })), 1);
    pntMatrix.destroy();
}

Example 8 with DenseLocalOnHeapVector

use of org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector in project ignite by apache.

the class FuzzyCMeansDistributedClustererTest method performRandomTest.

/**
 * Test given clusterer on points placed randomly around vertexes of a regular polygon.
 *
 * @param distributedClusterer Tested clusterer.
 * @param seed Seed for the random numbers generator.
 */
private void performRandomTest(FuzzyCMeansDistributedClusterer distributedClusterer, long seed) {
    final int minNumCenters = 2;
    final int maxNumCenters = 5;
    final double maxRadius = 1000;
    final int maxPoints = 1000;
    final int minPoints = 300;
    Random random = new Random(seed);
    int numCenters = random.nextInt(maxNumCenters - minNumCenters) + minNumCenters;
    double[][] centers = new double[numCenters][2];
    for (int i = 0; i < numCenters; i++) {
        double angle = Math.PI * 2.0 * i / numCenters;
        centers[i][0] = Math.cos(angle) * maxRadius;
        centers[i][1] = Math.sin(angle) * maxRadius;
    }
    int numPoints = minPoints + random.nextInt(maxPoints - minPoints);
    double[][] points = new double[numPoints][2];
    for (int i = 0; i < numPoints; i++) {
        int center = random.nextInt(numCenters);
        double randomDouble = random.nextDouble();
        double radius = randomDouble * randomDouble * maxRadius / 10;
        double angle = random.nextDouble() * Math.PI * 2.0;
        points[i][0] = centers[center][0] + Math.cos(angle) * radius;
        points[i][1] = centers[center][1] + Math.sin(angle) * radius;
    }
    SparseDistributedMatrix pntMatrix = new SparseDistributedMatrix(numPoints, 2, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
    for (int i = 0; i < numPoints; i++) pntMatrix.setRow(i, points[i]);
    FuzzyCMeansModel mdl = distributedClusterer.cluster(pntMatrix, numCenters);
    Vector[] computedCenters = mdl.centers();
    DistanceMeasure measure = mdl.distanceMeasure();
    int cntr = numCenters;
    for (int i = 0; i < numCenters; i++) {
        for (int j = 0; j < numCenters; j++) {
            if (measure.compute(computedCenters[i], new DenseLocalOnHeapVector(centers[j])) < 100) {
                cntr--;
                break;
            }
        }
    }
    assertEquals(0, cntr);
    pntMatrix.destroy();
}

Example 9 with DenseLocalOnHeapVector

use of org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector in project ignite by apache.

the class KMeansDistributedClustererTestSingleNode method testClusterizationOnDatasetWithObviousStructure.

/**
 */
public void testClusterizationOnDatasetWithObviousStructure() throws IOException {
    IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
    int ptsCnt = 10000;
    int squareSideLen = 10000;
    Random rnd = new Random(123456L);
    // Let centers be in the vertices of square.
    Map<Integer, Vector> centers = new HashMap<>();
    centers.put(100, new DenseLocalOnHeapVector(new double[] { 0.0, 0.0 }));
    centers.put(900, new DenseLocalOnHeapVector(new double[] { squareSideLen, 0.0 }));
    centers.put(3000, new DenseLocalOnHeapVector(new double[] { 0.0, squareSideLen }));
    centers.put(6000, new DenseLocalOnHeapVector(new double[] { squareSideLen, squareSideLen }));
    int centersCnt = centers.size();
    SparseDistributedMatrix points = new SparseDistributedMatrix(ptsCnt, 2, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
    List<Integer> permutation = IntStream.range(0, ptsCnt).boxed().collect(Collectors.toList());
    Collections.shuffle(permutation, rnd);
    Vector[] mc = new Vector[centersCnt];
    Arrays.fill(mc, VectorUtils.zeroes(2));
    int centIdx = 0;
    int totalCnt = 0;
    List<Vector> massCenters = new ArrayList<>();
    for (Integer count : centers.keySet()) {
        for (int i = 0; i < count; i++) {
            Vector pnt = new DenseLocalOnHeapVector(2).assign(centers.get(count));
            // Perturbate point on random value.
            pnt.map(val -> val + rnd.nextDouble() * squareSideLen / 100);
            mc[centIdx] = mc[centIdx].plus(pnt);
            points.assignRow(permutation.get(totalCnt), pnt);
            totalCnt++;
        }
        massCenters.add(mc[centIdx].times(1 / (double) count));
        centIdx++;
    }
    EuclideanDistance dist = new EuclideanDistance();
    OrderedNodesComparator comp = new OrderedNodesComparator(centers.values().toArray(new Vector[] {}), dist);
    massCenters.sort(comp);
    KMeansDistributedClusterer clusterer = new KMeansDistributedClusterer(dist, 3, 100, 1L);
    KMeansModel mdl = clusterer.cluster(points, 4);
    Vector[] resCenters = mdl.centers();
    Arrays.sort(resCenters, comp);
    checkIsInEpsilonNeighbourhood(resCenters, massCenters.toArray(new Vector[] {}), 30.0);
    points.destroy();
}

Example 10 with DenseLocalOnHeapVector

use of org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector in project ignite by apache.

the class IgniteLUDecompositionBenchmark method runLUDecomposition.

/**
 * Based on LUDecompositionTest.
 */
private void runLUDecomposition() {
    Matrix testMatrix = new DenseLocalOnHeapMatrix(new DataChanger.Scale().mutate(new double[][] { { 2.0d, 1.0d, 1.0d, 0.0d }, { 4.0d, 3.0d, 3.0d, 1.0d }, { 8.0d, 7.0d, 9.0d, 5.0d }, { 6.0d, 7.0d, 9.0d, 8.0d } }));
    LUDecomposition dec1 = new LUDecomposition(new PivotedMatrixView(testMatrix));
    dec1.solve(new DenseLocalOnHeapVector(testMatrix.rowSize()));
    dec1.destroy();
    LUDecomposition dec2 = new LUDecomposition(new PivotedMatrixView(testMatrix));
    dec2.solve(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()));
    dec2.destroy();
    LUDecomposition dec3 = new LUDecomposition(testMatrix);
    dec3.getL();
    dec3.getU();
    dec3.getP();
    dec3.getPivot();
    dec3.destroy();
}