CSVEvolutionListener.java

package net.bmahe.genetics4j.extras.evolutionlisteners;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;
import org.apache.commons.lang3.Validate;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.immutables.value.Value;

import net.bmahe.genetics4j.core.Genotype;
import net.bmahe.genetics4j.core.evolutionlisteners.EvolutionListener;

/**
 * Evolution Listener which writes the output of each generation to a CSV file
 *
 * @author bruno
 *
 * @param <T> Fitness type
 * @param <U> Data type written to the CSV
 */
@Value.Immutable
public abstract class CSVEvolutionListener<T extends Comparable<T>, U> implements EvolutionListener<T> {
	final static public Logger logger = LogManager.getLogger(CSVEvolutionListener.class);

	public static final boolean DEFAULT_AUTO_FLUSH = true;

	private CSVPrinter csvPrinter;

	protected CSVPrinter openPrinter() {

		final List<String> headers = columnExtractors().stream()
				.map(ce -> ce.header())
				.collect(Collectors.toUnmodifiableList());

		try {
			return CSVFormat.DEFAULT.withAutoFlush(autoFlush())
					.withHeader(headers.toArray(new String[headers.size()]))
					.print(Path.of(filename()), StandardCharsets.UTF_8);
		} catch (IOException e) {
			logger.error("Could not open {}", filename(), e);
			throw new RuntimeException("Could not open file " + filename(), e);
		}

	}

	/**
	 * Whether or not the CSV writer has auto flush enabled. Defaults to
	 * {@value #DEFAULT_AUTO_FLUSH}
	 *
	 * @return
	 */
	@Value.Default
	public boolean autoFlush() {
		return DEFAULT_AUTO_FLUSH;
	}

	/**
	 * User defined function to provide some additional information when computing
	 * the value to write. Defaults to null
	 *
	 * @return
	 */
	@Value.Default
	public GenerationFunction<T, U> evolutionContextSupplier() {
		return (generation, population, fitness, isDone) -> null;
	}

	/**
	 * How many generations to skip between each writes. Defaults to writing every
	 * generations
	 *
	 * @return
	 */
	@Value.Default
	public int skipN() {
		return 0;
	}

	/**
	 * Users can supply an optional set of filters to control which individuals get
	 * written and in which order. Default to have no impact.
	 *
	 * @return
	 */
	@Value.Default
	public Function<Stream<EvolutionStep<T, U>>, Stream<EvolutionStep<T, U>>> filter() {
		return (stream) -> stream;
	}

	/**
	 * Destination file name for the CSV file
	 *
	 * @return
	 */
	@Value.Parameter
	public abstract String filename();

	/**
	 * List of Column Extractors. They specify how and what to write from each
	 * individual at a given generation
	 *
	 * @return
	 */
	@Value.Parameter
	public abstract List<ColumnExtractor<T, U>> columnExtractors();

	@Override
	public void onEvolution(final long generation, final List<Genotype> population, final List<T> fitness,
			final boolean isDone) {
		Validate.isTrue(generation >= 0);
		Validate.notNull(population);
		Validate.notNull(fitness);
		Validate.isTrue(population.size() > 0);
		Validate.isTrue(population.size() == fitness.size());

		if (isDone == false && skipN() > 0 && generation % skipN() != 0) {
			return;
		}

		if (csvPrinter == null) {
			csvPrinter = openPrinter();
		}

		final Optional<U> context = Optional
				.ofNullable(evolutionContextSupplier().apply(generation, population, fitness, isDone));

		final var rawIndividualStream = IntStream.range(0, population.size())
				.boxed()
				.map(individualIndex -> EvolutionStep.of(context,
						generation,
						individualIndex,
						population.get(individualIndex),
						fitness.get(individualIndex),
						isDone));

		final var filteredStream = filter().apply(rawIndividualStream);

		filteredStream.forEach(evolutionStep -> {
			final List<Object> columnValues = columnExtractors().stream()
					.map(ce -> ce.columnExtractorFunction())
					.map(cef -> cef.apply(evolutionStep))
					.collect(Collectors.toUnmodifiableList());

			try {
				csvPrinter.printRecord(columnValues);
			} catch (IOException e1) {
				logger.error("Could not write values: {}", columnValues, e1);
				throw new RuntimeException("Could not write values: " + columnValues, e1);
			}
		});

		if (isDone && csvPrinter != null) {
			try {
				csvPrinter.close(true);
			} catch (IOException e) {
				logger.error("Could not close CSV printer for filename {}", filename(), e);
				throw new RuntimeException("Could not close CSV printer for filename " + filename(), e);
			}
		}
	}

	public static class Builder<T extends Comparable<T>, U> extends ImmutableCSVEvolutionListener.Builder<T, U> {
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> of(String filename,
			List<ColumnExtractor<T, U>> columnExtractors) {
		return ImmutableCSVEvolutionListener.of(filename, (Iterable<? extends ColumnExtractor<T, U>>) columnExtractors);
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> of(String filename,
			Iterable<? extends ColumnExtractor<T, U>> columnExtractors) {
		return ImmutableCSVEvolutionListener.of(filename, columnExtractors);
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> of(final String filename,
			final GenerationFunction<T, U> evolutionContextSupplier,
			final Iterable<? extends ColumnExtractor<T, U>> columnExtractors) {
		var csvEvolutionListenerBuilder = new CSVEvolutionListener.Builder<T, U>();

		csvEvolutionListenerBuilder.filename(filename)
				.evolutionContextSupplier(evolutionContextSupplier)
				.addAllColumnExtractors(columnExtractors);

		return csvEvolutionListenerBuilder.build();
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> of(final String filename,
			final GenerationFunction<T, U> evolutionContextSupplier,
			final Iterable<? extends ColumnExtractor<T, U>> columnExtractors, final int skipN) {
		var csvEvolutionListenerBuilder = new CSVEvolutionListener.Builder<T, U>();

		csvEvolutionListenerBuilder.filename(filename)
				.evolutionContextSupplier(evolutionContextSupplier)
				.addAllColumnExtractors(columnExtractors)
				.skipN(skipN);

		return csvEvolutionListenerBuilder.build();
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> ofTopN(final String filename,
			final GenerationFunction<T, U> evolutionContextSupplier,
			final Iterable<? extends ColumnExtractor<T, U>> columnExtractors, final Comparator<T> comparator,
			final int topN) {
		var csvEvolutionListenerBuilder = new CSVEvolutionListener.Builder<T, U>();

		csvEvolutionListenerBuilder.filename(filename)
				.evolutionContextSupplier(evolutionContextSupplier)
				.addAllColumnExtractors(columnExtractors)
				.filter(stream -> stream.sorted((a, b) -> comparator.reversed().compare(a.fitness(), b.fitness()))
						.limit(topN));

		return csvEvolutionListenerBuilder.build();
	}

	public static <T extends Comparable<T>, U> CSVEvolutionListener<T, U> ofTopN(final String filename,
			final GenerationFunction<T, U> evolutionContextSupplier,
			final Iterable<? extends ColumnExtractor<T, U>> columnExtractors, final int topN) {
		var csvEvolutionListenerBuilder = new CSVEvolutionListener.Builder<T, U>();

		csvEvolutionListenerBuilder.filename(filename)
				.evolutionContextSupplier(evolutionContextSupplier)
				.addAllColumnExtractors(columnExtractors)
				.filter(stream -> stream.sorted(Comparator.comparing(EvolutionStep::fitness)).limit(topN));

		return csvEvolutionListenerBuilder.build();
	}
}




























































Active mutators

CONDITIONALS_BOUNDARY
CONSTRUCTOR_CALLS
EMPTY_RETURNS
EXPERIMENTAL_ARGUMENT_PROPAGATION
EXPERIMENTAL_BIG_DECIMAL
EXPERIMENTAL_BIG_INTEGER
EXPERIMENTAL_MEMBER_VARIABLE
EXPERIMENTAL_NAKED_RECEIVER
EXPERIMENTAL_REMOVE_SWITCH_MUTATOR_[0-99]
EXPERIMENTAL_SWITCH
FALSE_RETURNS
INCREMENTS
INLINE_CONSTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NON_VOID_METHOD_CALLS
NULL_RETURNS
PRIMITIVE_RETURNS
REMOVE_CONDITIONALS_EQUAL_ELSE
REMOVE_CONDITIONALS_EQUAL_IF
REMOVE_CONDITIONALS_ORDER_ELSE
REMOVE_CONDITIONALS_ORDER_IF
REMOVE_INCREMENTS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

Report generated by PIT 1.20.2

1		package net.bmahe.genetics4j.extras.evolutionlisteners;
2
3		import java.io.IOException;
4		import java.nio.charset.StandardCharsets;
5		import java.nio.file.Path;
6		import java.util.Comparator;
7		import java.util.List;
8		import java.util.Optional;
9		import java.util.function.Function;
10		import java.util.stream.Collectors;
11		import java.util.stream.IntStream;
12		import java.util.stream.Stream;
13
14		import org.apache.commons.csv.CSVFormat;
15		import org.apache.commons.csv.CSVPrinter;
16		import org.apache.commons.lang3.Validate;
17		import org.apache.logging.log4j.LogManager;
18		import org.apache.logging.log4j.Logger;
19		import org.immutables.value.Value;
20
21		import net.bmahe.genetics4j.core.Genotype;
22		import net.bmahe.genetics4j.core.evolutionlisteners.EvolutionListener;
23
24		/**
25		* Evolution Listener which writes the output of each generation to a CSV file
26		*
27		* @author bruno
28		*
29		* @param <T> Fitness type
30		* @param <U> Data type written to the CSV
31		*/
32		@Value.Immutable
33		public abstract class CSVEvolutionListener<T extends Comparable<T>, U> implements EvolutionListener<T> {
34		final static public Logger logger = LogManager.getLogger(CSVEvolutionListener.class);
35
36		public static final boolean DEFAULT_AUTO_FLUSH = true;
37
38		private CSVPrinter csvPrinter;
39
40		protected CSVPrinter openPrinter() {

CSVEvolutionListener.java

Mutations

Active mutators

Tests examined