4. Multiple vigilance parameters calculated in parallel

Using the class Art2aTask, multiple clusterings, e.g. with different vigilance parameters, can be run in parallel.

// Prepare your data as a 2D float array
// Each row represents a data vector
float[][] dataMatrix = {
        {0.1f, 0.2f, 0.3f},
        {0.2f, 0.1f, 0.4f},
        {0.9f, 0.8f, 0.7f},
        {0.8f, 0.9f, 0.6f},
        {0.15f, 0.25f, 0.35f},
        {0.85f, 0.75f, 0.65f},
        {0.05f, 0.15f, 0.25f},
        {0.95f, 0.85f, 0.75f},
        {0.12f, 0.22f, 0.32f},
        {0.88f, 0.78f, 0.68f}
};

// Configure clustering parameters
//Multiple vigilance parameters in interval [0,1]
float[] vigilances = {0.1f, 0.3f, 0.5f, 0.7f, 0.9f};
//Maximum number of clusters in interval [2, number of data row vectors of getDataMatrix]
int maximumNumberOfClusters = 10;
//default value
int maximumNumberOfEpochs = 10;
//default value
float convergenceThreshold = 0.99f;
//default value
float learningParameter = 0.01f;
//default value
float offsetForContrastEnhancement = 1.0f;
//default value
long randomSeed = 1L;

// Validate data matrix (same length in all rows, no empty rows, etc.)
if (Utils.isDataMatrixValid(dataMatrix)) {
    //*create list of Art2aTask instances to run in parallel below*
    LinkedList<Art2aTask> art2aTaskList = new LinkedList<>();
    PreprocessedArt2aData preprocessedArt2aData = Art2aKernel.getPreprocessedArt2aData(dataMatrix, offsetForContrastEnhancement);
    for (float vigilance : vigilances) {
        art2aTaskList.add(
                new Art2aTask(
                        preprocessedArt2aData,
                        vigilance,
                        maximumNumberOfClusters,
                        maximumNumberOfEpochs,
                        convergenceThreshold,
                        learningParameter,
                        randomSeed
                )
        );
    }
    //*run tasks in parallel*
    ExecutorService executorService = Executors.newFixedThreadPool(vigilances.length);
    List<Future<Art2aResult>> futureList = null;
    try {
        futureList = executorService.invokeAll(art2aTaskList);
    } catch (InterruptedException e) {
        System.out.println("test_ParallelClustering: InterruptedException occurred.");
    }
    executorService.shutdown();
    //collect results
    Art2aResult[] parallelResults = new Art2aResult[vigilances.length];
    int index = 0;
    for (Future<Art2aResult> future : futureList) {
        try {
            parallelResults[index++] = future.get();
        } catch (Exception e) {
            System.out.println("test_ParallelClustering: Exception occurred.");
            System.exit(1);
        }
    }
    // Compare results
    for (int i = 0; i < vigilances.length; i++) {
        System.out.println("Vigilance " + vigilances[i] +
                ": " + parallelResults[i].getNumberOfDetectedClusters() + " clusters");
    }
}

Output:

Vigilance 0.1: 2 clusters
Vigilance 0.3: 2 clusters
Vigilance 0.5: 2 clusters
Vigilance 0.7: 3 clusters
Vigilance 0.9: 5 clusters