Submission parameters · Vilvik docs

Vilvik's optimization runs are described by a set of parameters that the form (and the API) accepts. Today, all submissions are configured for the genetic algorithm. This page lists every parameter we support, what it controls, and the section in PyGAD's documentation where you can read more.

About the library. Vilvik runs the genetic algorithm on top of an extended version of the open-source PyGAD library. The descriptions below are short and user-facing. For full parameter semantics, defaults, valid combinations, edge cases. PyGAD's documentation is the authoritative reference.

Every field on the new-submission form has an i icon next to it that opens the same description shown here.

1. Mandatory¶

You must supply each of these.

Number of generations. How many iterations the algorithm runs to evolve solutions. Larger numbers explore more thoroughly at the cost of longer runs.
Fitness function. The Python function that evaluates how good a candidate solution is. Vilvik calls it on every solution; the higher the value it returns, the better. The libraries you can import inside fitness_func are listed in Libraries you can import.
Number of parents. How many candidates from each generation are selected as parents for the next one.
Number of genes. The number of variables in each candidate solution. Each gene corresponds to one knob the algorithm tunes.
Number of chromosomes. The total population size (how many candidates exist per generation).
Fitness batch size. How many candidates the algorithm evaluates in one batch when calling your fitness function. Tune this to amortize per-call overhead.

See Initialization and Fitness function in PyGAD documentation for full semantics.

2. Initial population¶

These control how the first generation of candidates is built.

Initial population range start. Lower bound for randomly generated genes in the first population.
Initial population range end. Upper bound for randomly generated genes in the first population.
Initial population. A user-supplied starting population. When set, replaces the random initialization above.
Gene data type. The data type of each gene (integer, float, …). Set this to match your problem domain.

See Initial population in PyGAD documentation for full semantics.

3. Parent selection¶

How parents are chosen from the current population to produce the next generation.

Parent selection type. The selection strategy (roulette wheel, stochastic universal sampling, tournament, …).
Number of parents to keep. How many parents survive unchanged into the next generation.
Number of elitism to keep. How many of the very best solutions are preserved untouched into the next generation.

See Parent selection in PyGAD documentation for full semantics.

4. Crossover and mutation¶

How parents are combined and how their children are perturbed.

Crossover type. The strategy for combining genes from two parents (single-point, two-point, uniform, …).
Crossover probability. The chance that crossover is applied to any given pair of parents.
Mutation type. The mutation strategy (random, swap, …).
Percentage of genes to mutate. The fraction of each candidate's genes that are subject to mutation.
Mutation by replacement. Whether mutation replaces the gene with a fresh value or modifies the existing one.
Mutation probability. The chance that mutation is applied to a candidate.
Number of genes to mutate. A fixed count of genes to mutate, when you want to drive mutation by count rather than percentage.
Random mutation range start. Lower bound for values introduced by random mutation.
Random mutation range end. Upper bound for values introduced by random mutation.

See Crossover and mutation in PyGAD documentation for full semantics.

5. Callbacks¶

Optional Python functions that run at specific points during the search. Your code runs in a secure environment.

on_start. Runs once when the algorithm starts.
on_fitness. Runs after fitness is computed for the current generation.
on_parents. Runs after parents are selected.
on_crossover. Runs after crossover.
on_mutation. Runs after mutation.
on_generation. Runs at the end of each generation, useful for logging progress.
on_stop. Runs once when the algorithm stops.

The form offers ready-made templates for common callbacks. Open the Callback Function Templates modal next to the field to pick one and adapt it. See Creating a submission for the template workflow.

See Callbacks in PyGAD documentation for full semantics.

6. Miscellaneous¶

Everything else.

Gene space. The allowed values for each gene. Use this to constrain the search to specific intervals or discrete sets.
Save best solutions. Keep a record of the best solution per generation (more storage; useful for analysis).
Save all solutions. Keep every solution from every generation (much more storage; usually only for research).
Allow duplicate genes. Whether two genes in the same candidate can hold the same value.
Stop criteria. Stop the algorithm early when a target fitness is reached or another condition is met.
Random seed. Set a seed for reproducibility. The same seed plus the same parameters gives you the same sequence of candidates.

See Misc parameters in PyGAD documentation for full semantics.

Tier-based caps on GA parameters¶

A number of parameters have caps that depend on your subscription tier. The numbers below are read live from the database, so they always reflect what is currently set; admins can adjust them, and per-account overrides apply on top of these defaults.

Number of generations. Free up to 100; Premium up to 10000.
Number of genes. Free up to 10; Premium up to 1000.
Population size (number of chromosomes). Free up to 200; Premium up to 2000.
Number of parents mating. Free up to 200; Premium up to 2000.
K-tournament size. Only applied when parent selection is set to one of the tournament strategies. Free up to 50; Premium up to 200.
Number of genes to mutate. Free up to 200; Premium up to 2000.
Parallel workers. Parsed from parallel_processing. Free up to 2; Premium up to 16.
Total fitness evaluations per run. Composite cap on num_generations × sol_per_pop. Free up to 200000; Premium up to 2000000. This cap catches the case where each individual parameter is under its own limit yet the product is huge.
Initial population, gene space, and callback code sizes. Each text field has its own byte cap. The full comparison is on Plans and tiers.
Save full history. save_solutions=True keeps every solution from every generation; this is memory-heavy and is reserved for higher tiers. save_best_solutions=True keeps only the best per generation and is allowed everywhere by default.

The complete live comparison across every tier is on Plans and tiers.

Docs