RecurrentParityBenchmarkCLI

package net.bmahe.genetics4j.samples.neat;

import java.io.File;
import java.io.PrintWriter;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;

import net.bmahe.genetics4j.core.Genotype;
import net.bmahe.genetics4j.core.spec.EvolutionResult;
import net.bmahe.genetics4j.neat.Connection;
import net.bmahe.genetics4j.neat.chromosomes.NeatChromosome;

@Command(name = "RecurrentParityBenchmarkCLI",
		mixinStandardHelpOptions = true,
		version = "0.1",
		description = "Run benchmark for different hyperparameter values")
public class RecurrentParityBenchmarkCLI implements Callable<Integer> {
	private static final Logger logger = LogManager.getLogger(RecurrentParityBenchmarkCLI.class);

	private double randomWeightsProb = 0.05;
	private double switchMutationProb = 0.005;
	private double addNodeProb = 0.01;
	private double deleteNodeProb = 0.005;
	private double addConnectionProb = 0.01;

	// Node
	@Option(names = "--start-add-node", description = "Start of the range for addition of nodes")
	private double startAddNodeProb = 0.005;

	@Option(names = "--end-add-node", description = "End of the range for addition of nodes")
	private double endAddNodeProb = 0.05;

	@Option(names = "--count-add-node", description = "How many steps to try")
	private int countAddNodeProb = 1;

	@Option(names = "--start-delete-node", description = "Start of the range for deletion of nodes")
	private double startDeleteNodeProb = 0.005;

	@Option(names = "--end-delete-node", description = "End of the range for deletion of nodes")
	private double endDeleteNodeProb = 0.05;

	@Option(names = "--count-delete-node", description = "How many steps to try")
	private int countDeleteNodeProb = 1;

	// Connection
	@Option(names = "--start-add-connection", description = "Start of the range for addition of connections")
	private double startAddConnectionProb = 0.005;

	@Option(names = "--end-add-connection", description = "End of the range for addition of connections")
	private double endAddConnectionProb = 0.05;

	@Option(names = "--count-add-connection", description = "How many steps to try")
	private int countAddConnectionProb = 1;

	@Option(names = "--start-delete-connection", description = "Start of the range for deletion of connections")
	private double startDeleteConnectionProb = 0.005;

	@Option(names = "--end-delete-connection", description = "End of the range for deletion of connections")
	private double endDeleteConnectionProb = 0.05;

	@Option(names = "--count-delete-connection", description = "How many steps to try")
	private int countDeleteConnectionProb = 1;

	// Global
	@Option(names = "--count", description = "How many steps to try")
	private int countExecs = 1;

	@Option(names = { "-f", "--file" },
			paramLabel = "FILE",
			description = "Destination filename for generated csv data",
			defaultValue = "recurrent_parity_benchmark.csv")
	private String destinationFilename;

	public static void main(String... args) {
		int exitCode = new CommandLine(new RecurrentParityBenchmarkCLI()).execute(args);
		System.exit(exitCode);
	}

	@Override
	public Integer call() throws Exception {
		final RecurrentParityExample recurrentParityExample = new RecurrentParityExample();

		final File csvOutputFile = new File(destinationFilename);
		try (PrintWriter printWriter = new PrintWriter(csvOutputFile)) {

			printWriter.println(
					String.join(
							",",
							"delete_connection",
							"add_connection",
							"delete_node",
							"add_node",
							"duration_ns",
							"best_fitness",
							"generation",
							"num_connections",
							"num_connections_enabled",
							"num_connections_disabled",
							"num_nodes"));

			final double deleteConnectionStep = (endDeleteConnectionProb - startDeleteConnectionProb)
					/ countDeleteConnectionProb;
			for (double deleteConnectionProb = startDeleteConnectionProb; deleteConnectionProb < endDeleteConnectionProb; deleteConnectionProb += deleteConnectionStep) {
				logger.info("delete connection probability: {}", deleteConnectionProb);

				final double addConnectionStep = (endAddConnectionProb - startAddConnectionProb) / countAddConnectionProb;
				for (double addConnectionProb = startAddConnectionProb; addConnectionProb < endAddConnectionProb; addConnectionProb += addConnectionStep) {
					logger.info("\t add connection probability: {}", addConnectionProb);

					final double deleteNodeStep = (endDeleteNodeProb - startDeleteNodeProb) / countDeleteNodeProb;
					for (double deleteNodeProb = startDeleteNodeProb; deleteNodeProb < endDeleteNodeProb; deleteNodeProb += deleteNodeStep) {
						logger.info("\t\t delete Node probability: {}", deleteNodeProb);

						final double addNodeStep = (endAddNodeProb - startAddNodeProb) / countAddNodeProb;
						for (double addNodeProb = startAddNodeProb; addNodeProb < endAddNodeProb; addNodeProb += addNodeStep) {
							logger.info("\t\t\t add Node probability: {}", addNodeProb);

							for (int i = 0; i < countExecs; i++) {
								final long startTimeNs = System.nanoTime();
								final EvolutionResult<Float> evolutionResult = recurrentParityExample.run(
										randomWeightsProb,
										switchMutationProb,
										addNodeProb,
										deleteNodeProb,
										addConnectionProb,
										deleteConnectionProb);
								final long endTimeNs = System.nanoTime();
								final long durationNs = endTimeNs - startTimeNs;

								final Float bestFitness = evolutionResult.bestFitness();
								final long generation = evolutionResult.generation();

								final Genotype genotype = evolutionResult.bestGenotype();
								final NeatChromosome chromosome = genotype.getChromosome(0, NeatChromosome.class);
								final List<Connection> connections = chromosome.getConnections();

								final long numEnabledConnections = connections.stream().filter(Connection::isEnabled).count();
								final long numDisabledConnections = connections.size() - numEnabledConnections;

								final Set<Integer> uniqueNodes = connections.stream()
										.flatMap(connection -> Stream.of(connection.fromNodeIndex(), connection.toNodeIndex()))
										.collect(Collectors.toSet());

								final String csvRow = String.format(
										"%f,%f,%f,%f,%d,%f,%d,%d,%d,%d,%d",
										deleteConnectionProb,
										addConnectionProb,
										deleteNodeProb,
										addNodeProb,
										durationNs,
										bestFitness,
										generation,
										connections.size(),
										numEnabledConnections,
										numDisabledConnections,
										uniqueNodes.size());
								printWriter.println(csvRow);
								printWriter.flush();
							}
						}
					}

				}
			}

		}
		return 0;
	}

}