llamda.ga.hsevo package

Submodules

llamda.ga.hsevo.evolution module

llamda.ga.hsevo.hsevo module

class llamda.ga.hsevo.hsevo.HSEvo(config, problem, evaluator, llm_client, output_dir)

Bases: GeneticAlgorithm[HSEvoConfig, Problem]

Parameters:

• config (HSEvoConfig)

• problem (Problem)

• evaluator (Evaluator)

• llm_client (BaseClient)

• output_dir (str)

cal_usage_LLM(lst_prompt, lst_completion, encoding_name='cl100k_base')

Returns the number of tokens in a text string.

Parameters:

• lst_prompt (list[list[dict]])

• lst_completion (list[str])

• encoding_name (str)

Return type:

None

comprehensive_reflection()

Return type:

None

create_new_harmony(harmony_memory, bounds)

Parameters:

• harmony_memory (ndarray)

• bounds (list[list[int]])

Return type:

ndarray

create_population_hs(str_code, parameter_ranges, harmony_memory, try_hs_idx=None)

Parameters:

• str_code (str)

• parameter_ranges (list[int])

• harmony_memory (ndarray)

• try_hs_idx (int | None)

Return type:

list[HSEvoIndividual] | None

crossover(population)

Parameters:

population (list[HSEvoIndividual])

Return type:

list[HSEvoIndividual]

evolve()

Return type:

tuple[str, str]

find_best_obj(population_hs)

Parameters:

population_hs (list[HSEvoIndividual])

Return type:

int

flash_reflection(population)

Parameters:

population (list[HSEvoIndividual])

Return type:

None

harmony_search()

Return type:

HSEvoIndividual | None

init_population()

Return type:

None

initialize_harmony_memory(bounds)

Parameters:

bounds (list[list[int]])

Return type:

ndarray

mutate()

Elitist-based mutation. We only mutate the best individual to generate n_pop new individuals.

Return type:

list[HSEvoIndividual]

random_select(population)

Random selection, select individuals with equal probability.

Parameters:

population (list[HSEvoIndividual])

Return type:

list[HSEvoIndividual]

response_to_individual(response, name, messages=None)

Convert response to individual

Parameters:

• response (str)

• name (str)

• messages (list[str] | None)

Return type:

HSEvoIndividual

responses_to_population(responses, try_hs_idx=None)

Convert responses to population. Applied to the initial population.

Parameters:

• responses (list[str])

• try_hs_idx (int | None)

Return type:

list[HSEvoIndividual]

save_log_population(population, logHS=False)

Parameters:

• population (list[HSEvoIndividual])

• logHS (bool)

Return type:

None

sel_individual_hs()

Return type:

str

update_harmony_memory(population_hs, harmony_memory, new_harmony, func_block, parameter_ranges, try_hs_idx)

Parameters:

• population_hs (list[HSEvoIndividual])

• harmony_memory (ndarray)

• new_harmony (ndarray)

• func_block (str)

• parameter_ranges (list[int])

• try_hs_idx (int)

Return type:

tuple[list[HSEvoIndividual], ndarray]

update_iter()

Update after each iteration

Return type:

None

class llamda.ga.hsevo.hsevo.HSEvoConfig(max_fe: int = 450, pop_size: int = 10, init_pop_size: int = 30, mutation_rate: float = 0.5, hm_size: int = 5, hmcr: float = 0.7, par: float = 0.5, bandwidth: float = 0.2, max_iter: int = 5)

Bases: object

Parameters:

• max_fe (int)

• pop_size (int)

• init_pop_size (int)

• mutation_rate (float)

• hm_size (int)

• hmcr (float)

• par (float)

• bandwidth (float)

• max_iter (int)

bandwidth: float = 0.2

hm_size: int = 5

hmcr: float = 0.7

init_pop_size: int = 30

max_fe: int = 450

max_iter: int = 5

mutation_rate: float = 0.5

par: float = 0.5

pop_size: int = 10

class llamda.ga.hsevo.hsevo.HSEvoIndividual(name: str | None = None, code: str | None = None, exec_success: bool | None = None, obj: float | None = None, traceback_msg: str | None = None, tryHS: bool = False)

Bases: Individual

Parameters:

• name (str | None)

• code (str | None)

• exec_success (bool | None)

• obj (float | None)

• traceback_msg (str | None)

• tryHS (bool)

tryHS: bool = False

llamda.ga.hsevo.hsevo.extract_to_hs(input_string)

Parameters:

input_string (str)

Return type:

tuple[dict | None, str | None]

llamda.ga.hsevo.hsevo.format_messages(pre_messages)

Parameters:

pre_messages (dict)

Return type:

list[dict]

Module contents