https://github.com/smoren/genetic-search-ts
Multiprocessing genetic algorithm implementation library
https://github.com/smoren/genetic-search-ts
evolutionary-algorithms genetic-algorithm genetic-programming genetics heuristic-search-algorithms multiprocessing multiprocessing-library search-algorithm
Last synced: 7 months ago
JSON representation
Multiprocessing genetic algorithm implementation library
- Host: GitHub
- URL: https://github.com/smoren/genetic-search-ts
- Owner: Smoren
- License: mit
- Created: 2024-11-01T08:15:37.000Z (about 1 year ago)
- Default Branch: master
- Last Pushed: 2025-01-27T08:25:12.000Z (10 months ago)
- Last Synced: 2025-03-28T13:21:13.432Z (8 months ago)
- Topics: evolutionary-algorithms, genetic-algorithm, genetic-programming, genetics, heuristic-search-algorithms, multiprocessing, multiprocessing-library, search-algorithm
- Language: TypeScript
- Homepage:
- Size: 867 KB
- Stars: 9
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Multiprocessing Genetic Algorithm Implementation for TypeScript
[](https://www.npmjs.com/package/genetic-search)
[](https://www.npmjs.com/package/genetic-search)
[](https://coveralls.io/github/Smoren/genetic-search-ts?branch=master)
[](https://bundlephobia.com/result?p=genetic-search)
[](https://opensource.org/licenses/MIT)
Overview
--------
This project provides a TypeScript implementation of a genetic algorithm that can be used for optimization problems. The algorithm is designed to be highly customizable and can be used for a wide range of applications.
Features
--------
* **Multiprocessing support**: The algorithm can be run in parallel using multiple processes, making it suitable for large-scale optimization problems.
* **Deep customization**: The algorithm can be customized by providing custom implementations for various components:
* **base parameters** (population size, survival rate, crossover rate);
* **strategies** (population, phenome, fitness, sorting, selection, mutation, crossover, caching);
* **scheduler** for dynamic tuning of all the macro parameters.
* **Separation of phenome metrics and fitness calculation**: The algorithm separates the computation of phenomes
and fitness values, allowing normalization and other operations to be applied to the phenomes of all genomes prior
to evaluating the fitness function.
* **Type-safe**: The project uses TypeScript, which provides type safety and helps catch errors at compile-time.
Setup
-----
For single process (including browser apps) use:
```bash
npm i genetic-search
```
For multiprocessing in node environment use:
```bash
npm i genetic-search-multiprocess
```
Usage example
-------------
Let's get a max value of the parabola: `y = -(x-12)^2 - 3`.
```typescript
import type {
GeneticSearchConfig,
GeneticSearchStrategyConfig,
} from "genetic-search";
import {
GeneticSearch,
SimplePhenomeCache,
DescendingSortingStrategy,
RandomSelectionStrategy,
} from "genetic-search";
const config: GeneticSearchConfig = {
populationSize: 100,
survivalRate: 0.5,
crossoverRate: 0.5,
};
const strategies: GeneticSearchStrategyConfig = {
populate: new ParabolaPopulateStrategy(),
phenome: new ParabolaMultiprocessingPhenomeStrategy({
poolSize: 4,
task: async (data) => [-((data[0] - 12)**2) - 3],
onTaskResult: () => void 0,
}),
fitness: new ParabolaMaxValueFitnessStrategy(),
sorting: new DescendingSortingStrategy(),
selection: new RandomSelectionStrategy(2),
mutation: new ParabolaMutationStrategy(),
crossover: new ParabolaCrossoverStrategy(),
cache: new SimplePhenomeCache(),
}
const search = new GeneticSearch(config, strategies);
expect(search.partitions).toEqual([50, 25, 25]);
await search.fit({
generationsCount: 100,
beforeStep: () => void 0,
afterStep: () => void 0,
});
const bestGenome = search.bestGenome;
console.log('Best genome:', bestGenome);
```
Strategies implementation:
```typescript
import type {
BaseGenome,
BaseMutationStrategyConfig,
CrossoverStrategyInterface,
FitnessStrategyInterface,
GenerationFitnessColumn,
GenerationPhenomeMatrix,
IdGeneratorInterface,
PopulateStrategyInterface,
} from "genetic-search";
import type { MultiprocessingPhenomeStrategyConfig } from "genetic-search-multiprocess";
import { BaseMutationStrategy } from "genetic-search";
import { MultiprocessingPhenomeStrategyConfig } from "genetic-search-multiprocess";
export type ParabolaArgumentGenome = BaseGenome & {
id: number;
x: number;
}
export type ParabolaTaskConfig = [number];
export class ParabolaPopulateStrategy implements PopulateStrategyInterface {
populate(size: number, idGenerator: IdGeneratorInterface): ParabolaArgumentGenome[] {
const result: ParabolaArgumentGenome[] = [];
for (let i=0; i {
constructor() {
super({ probability: 1 });
}
mutate(genome: ParabolaArgumentGenome, newGenomeId: number): ParabolaArgumentGenome {
return { x: genome.x + Math.random() * 10 - 5, id: newGenomeId };
}
}
export class ParabolaCrossoverStrategy implements CrossoverStrategyInterface {
cross(parents: ParabolaArgumentGenome[], newGenomeId: number): ParabolaArgumentGenome {
const [lhs, rhs] = parents;
return { x: (lhs.x + rhs.x) / 2, id: newGenomeId };
}
}
export class ParabolaMultiprocessingPhenomeStrategy extends BaseMultiprocessingPhenomeStrategy, ParabolaTaskConfig> {
protected createTaskInput(genome: ParabolaArgumentGenome): ParabolaTaskConfig {
return [genome.x];
}
}
export class ParabolaMaxValueFitnessStrategy implements FitnessStrategyInterface {
score(results: GenerationPhenomeMatrix): GenerationFitnessColumn {
return results.map((result) => result[0]);
}
}
```
Api Reference
-------------
For detailed documentation and usage examples, please refer to:
* [Main API documentation](https://smoren.github.io/genetic-search-ts/)
* [Multiprocess API documentation](https://smoren.github.io/genetic-search-multiprocess-ts/)
Unit testing
------------
```bash
npm i
npm run test
```
License
-------
Genetic Search TS is licensed under the MIT License.