executor.go

package main

import (
	"flag"
	"fmt"
	"github.com/yaricom/goESHyperNEAT/v2/eshyperneat"
	"github.com/yaricom/goESHyperNEAT/v2/examples/retina"
	"github.com/yaricom/goNEAT/v4/experiment"
	"github.com/yaricom/goNEAT/v4/neat"
	"github.com/yaricom/goNEAT/v4/neat/genetics"
	"log"
	"math/rand"
	"os"
	"os/signal"
	"syscall"
	"time"
)

// The experiment runner code
func main() {
	var outDirPath = flag.String("out", "./out", "The output directory to store results.")
	var contextPath = flag.String("context", "./data/retina/es_hyper.neat.yml", "The execution context configuration file.")
	var genomePath = flag.String("genome", "./data/retina/cppn_genome.yml", "The seed genome to start with.")
	var experimentName = flag.String("experiment", "retina", "The name of experiment to run. [retina, retina-parallel]")
	var maxWorkers = flag.Int("max-workers", 1, "Maximum number of workers to use for parallel experiments.")
	var speciesTarget = flag.Int("species_target", 15, "The target number of species to maintain.")
	var speciesCompatAdjustFreq = flag.Int("species_adjust_freq", 10, "The frequency of species compatibility threshold adjustments when trying to maintain their number.")

	var logLevel = flag.String("log-level", "", "The logger level to be used. Overrides the one set in configuration.")
	var trialsCount = flag.Int("trials", 0, "The number of trials for experiment. Overrides the one set in configuration.")
	var seed = flag.Int64("seed", -1, "The seed for the random number generator [-1 to use current Unix timestamp].")

	flag.Parse()

	// Seed the random-number generator with current time so that
	// the numbers will be different every time we run.
	if *seed < 0 {
		*seed = time.Now().UnixNano()
	}
	rand.Seed(*seed) //nolint:all

	// Load context configuration
	neatOptions, err := neat.ReadNeatOptionsFromFile(*contextPath)
	if err != nil {
		log.Fatal("Failed to load NEAT options: ", err)
	}

	// Load Genome
	log.Printf("Loading start genome for %s experiment\n", *experimentName)
	reader, err := genetics.NewGenomeReaderFromFile(*genomePath)
	if err != nil {
		log.Fatalf("Failed to open genome file, reason: '%s'", err)
	}
	startGenome, err := reader.Read()
	if err != nil {
		log.Fatalf("Failed to read start genome, reason: '%s'", err)
	}
	fmt.Println(startGenome)

	// Load Modular Retina environment

	// Check if output dir exists
	outDir := *outDirPath
	if _, err = os.Stat(outDir); err == nil {
		// backup it
		backUpDir := fmt.Sprintf("%s-%s", outDir, time.Now().Format("2006-01-02T15_04_05"))
		// clear it
		err = os.Rename(outDir, backUpDir)
		if err != nil {
			log.Fatal("Failed to do previous results backup: ", err)
		}
	}
	// create output dir
	err = os.MkdirAll(outDir, os.ModePerm)
	if err != nil {
		log.Fatal("Failed to create output directory: ", err)
	}

	// Override context configuration parameters with ones set from the command line
	if *trialsCount > 0 {
		neatOptions.NumRuns = *trialsCount
	}
	if len(*logLevel) > 0 {
		neat.LogLevel = neat.LoggerLevel(*logLevel)
	}
	if *maxWorkers < 1 {
		*maxWorkers = 1
	}

	// Create Experiment
	experimentContext := neatOptions.NeatContext()
	exp := experiment.Experiment{
		Id:       0,
		Trials:   make(experiment.Trials, neatOptions.NumRuns),
		RandSeed: *seed,
	}
	var generationEvaluator experiment.GenerationEvaluator
	var trialObserver experiment.TrialRunObserver
	switch *experimentName {
	case "retina":
		opts, err := eshyperneat.LoadYAMLConfigFile(*contextPath)
		if err != nil {
			log.Fatal("Failed to load ES-HyperNEAT options from config file: ", err)
		} else {
			experimentContext = eshyperneat.NewContext(experimentContext, opts)
		}
		if env, err := retina.NewRetinaEnvironment(retina.CreateRetinaDataset(), 4); err != nil {
			log.Fatalf("Failed to create retina environment, reason: %s", err)
		} else {
			generationEvaluator, trialObserver = retina.NewGenerationEvaluator(
				*outDirPath, env, *speciesTarget, *speciesCompatAdjustFreq)
		}
	case "retina-parallel":
		opts, err := eshyperneat.LoadYAMLConfigFile(*contextPath)
		if err != nil {
			log.Fatal("Failed to load ES-HyperNEAT options from config file: ", err)
		} else {
			experimentContext = eshyperneat.NewContext(experimentContext, opts)
		}
		if env, err := retina.NewRetinaEnvironment(retina.CreateRetinaDataset(), 4); err != nil {
			log.Fatalf("Failed to create retina environment, reason: %s", err)
		} else {
			generationEvaluator, trialObserver = retina.NewParallelGenerationEvaluator(
				*outDirPath, env, *speciesTarget, *speciesCompatAdjustFreq, *maxWorkers)
		}
	default:
		log.Fatalf("Unsupported experiment name requested: %s\n", *experimentName)
	}

	// prepare to execute
	errChan := make(chan error)
	fmt.Println("\nPress Ctrl+C to stop")
	ctx, cancel := signal.NotifyContext(experimentContext, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
	defer cancel()

	// run experiment in the separate GO routine
	go func() {
		errChan <- exp.Execute(ctx, startGenome, generationEvaluator, trialObserver)
	}()

	// Wait for experiment completion
	//
	err = <-errChan
	if err != nil {
		if ctx.Err() != nil {
			fmt.Println("\nExperiment interrupted by user")
			os.Exit(1)
		} else {
			log.Fatalf("Experiment execution failed: %s", err)
		}
	}

	// Print experiment results statistics
	//
	exp.PrintStatistics()

	// Save experiment data in native format
	//
	expResPath := fmt.Sprintf("%s/%s.dat", outDir, *experimentName)
	if expResFile, err := os.Create(expResPath); err != nil {
		log.Fatal("Failed to create file for experiment results", err)
	} else {
		if err = exp.Write(expResFile); err != nil {
			_ = expResFile.Close()
			log.Fatal("Failed to save experiment results", err)
		}
		if err = expResFile.Close(); err != nil {
			log.Fatal("Failed to close file for experiment results", err)
		}
	}

	// Save experiment data in Numpy NPZ format if requested
	//
	npzResPath := fmt.Sprintf("%s/%s.npz", outDir, *experimentName)
	if npzResFile, err := os.Create(npzResPath); err != nil {
		log.Fatalf("Failed to create file for experiment results: [%s], reason: %s", npzResPath, err)
	} else {
		if err = exp.WriteNPZ(npzResFile); err != nil {
			_ = npzResFile.Close()
			log.Fatal("Failed to save experiment results as NPZ file", err)
		}
		if err = npzResFile.Close(); err != nil {
			log.Fatalf("Failed to close file for experiment results: [%s], reason: %s", npzResPath, err)
		}
	}
}