def test(): population_size = 10 my_registers = read_registries() initial_population = [] #establishing a population with non-negative fitness for i in range(0, population_size): myInd = Individual() while myInd.fitness <= 0: myInd.randomize(my_registers) Genetic.fitness(myInd) initial_population.append(myInd) #print_all_gen(initial_population) #print("----------------") print( "\n/////////////////////////////////////////////GENERATION: {}".format( 0)) new_gen = Genetic.breed(initial_population, my_registers) for i in range(1, 50): print("\n/////////////////////////////////////////////GENERATION: {}". format(i)) new_gen = Genetic.breed(new_gen, my_registers)
def main(): population_size = 10 my_registers = read_registries() initial_population = [] #establishing a population with non-negative fitness for i in range(0, population_size): myInd = Individual() while myInd.fitness <= 0: myInd.randomize(my_registers) Genetic.fitness(myInd) initial_population.append(myInd) new_gen = Genetic.breed(initial_population, my_registers) #evaluating till we get top == 100 top_fitness = 0 try: while top_fitness < 100: if top_fitness != 0: new_gen = Genetic.breed(new_gen, my_registers) for item in new_gen: if item.fitness > top_fitness: top_fitness = item.fitness #print("{} broke to: {}".format(item, top_fitness)) print_all_gen(new_gen) except KeyboardInterrupt: print_all_gen(new_gen)
class TestIndividual(TestCase): p = random.randint(2, 10) G = get_graph('../data/SJC1.dat') i1 = Individual(p, G) i2 = Individual(p, G) def testMutation(self): i3 = mutate(self.i1, self.G) intersection = self.i1.chromosome.intersection(i3.chromosome) self.assertEqual(len(i3.chromosome), self.p) self.assertEqual(len(intersection), self.p - 1) self.assertNotEqual(self.i1, i3) def testCrossover(self): (i3, i4) = crossover(self.i1, self.i2) union1 = self.i1.chromosome.union(self.i2.chromosome) union2 = i3.chromosome.union(i4.chromosome) self.assertEqual(union1, union2) self.assertEqual(len(i3.chromosome), self.p) self.assertEqual(len(i4.chromosome), self.p) def testCrossoverSameIndividuals(self): (i3, i4) = crossover(self.i1, self.i1) self.assertEqual(i3, self.i1) self.assertEqual(i4, None) def testCrossoverDiffIndividuals(self): (i3, i4) = crossover(self.i1, self.i2, c=3) self.assertNotEqual(i3, i4) union1 = self.i1.chromosome.union(self.i2.chromosome) union2 = i3.chromosome.union(i4.chromosome) self.assertEqual(union1, union2) self.assertEqual(len(i3.chromosome), self.p) self.assertEqual(len(i4.chromosome), self.p)
def __ramped_half_and_half(self, population_size, max_depth, funcs, terms): """Creates a population with Ramped half-and-half initialization Arguments: population_size {int} -- Size of the population. max_depth {int} -- Max depth of a tree contained in an individual funcs {[object]} -- List of functions to be used in individual creation terms {[string]} -- List of terminals to be used in individual creation Returns: [Individual] -- List of individual, i.e., the population. """ pop = [] group = (population_size / (max_depth - 1)) full = True for i in range(2, max_depth + 1): for j in range(int(group)): pop.append( Individual(self.__gen_rnd_expr(funcs, terms, i, full))) full = not full for i in range(population_size % (max_depth - 1)): pop.append( Individual(self.__gen_rnd_expr(funcs, terms, max_depth, full))) return pop
def mate(a: Individual, b: Individual): if random.random() < .9: min_len = (min(len(a.dna), len(b.dna))) cross_point = random.randrange(1, min_len) acopy = [] bcopy = [] for x in a.dna: acopy.append(x) for x in b.dna: bcopy.append(x) new_a_dna = acopy[:cross_point] + bcopy[cross_point:] new_b_dna = bcopy[:cross_point] + acopy[cross_point:] for x in range(0, min_len): if random.random() < .5: new_a_dna[x] = new_a_dna[x][0], int( round((new_a_dna[x][1] + new_a_dna[x][1] + new_b_dna[x][1]) / 3)) return Individual(new_a_dna), Individual(new_b_dna) else: return a, b
def orderOneCrossover(self, amountOfCrossovers, regionLength): previousPairs = [] for i in range(0, amountOfCrossovers): space1 = randint(0, len(self.individuals) - 1) space2 = randint(0, len(self.individuals) - 1) while (str(space1) + str(space2) in previousPairs or space1 == space2): space1 = randint(0, len(self.individuals) - 1) space2 = randint(0, len(self.individuals) - 1) previousPairs.append(str(space1) + str(space2)) P1 = self.individuals[space1] P2 = self.individuals[space2] childRep = '' loc = randint(0, len(P1.representation) - 1) region = P1.representation[loc:loc + regionLength] right = '' left = '' for c in P2.representation[loc + regionLength:]: if (c not in region): right = right + c for c in P2.representation[:loc + regionLength]: if (c not in region): left = left + c childRep = left + region + right mInd = Individual() mInd.setRepresentation(childRep) self.individuals.append(mInd)
def crossover(self): new_generation = [self.fittest()] for index in range(len(self.individuals) - 1): rnd = random.random() if rnd <= Population.cp: child = crossovers.aox(self.individuals[index].chromosome, self.individuals[index + 1].chromosome) new_generation.append(Individual(child)) else: if rnd <= 0.5: new_generation.append(self.individuals[index]) else: new_generation.append(self.individuals[index + 1]) rnd = random.random() # crossover du dernier et premier if rnd <= Population.cp: child = crossovers.aox(self.individuals[-1].chromosome, self.individuals[0].chromosome) new_generation.append(Individual(child)) else: if rnd <= 0.5: new_generation.append(self.individuals[-1]) else: new_generation.append(self.individuals[0]) self.individuals = new_generation
def f(parents): # Don't modify parents individuals = [parent.copy() for parent in parents] np.random.shuffle(individuals) intermediate_pool = [] while len(intermediate_pool) < len(individuals): i = len(intermediate_pool) if np.random.uniform() < p_m: p = mutate_program(individuals[i].program.copy()) intermediate_pool.append( Individual(program=p.copy(), max_depth=p.max_depth)) else: # Wrap around if at end a_index = i b_index = i + 1 if i != len(individuals) - 1 else 0 p_a, p_b = crossover_program( individuals[a_index].program.copy(), individuals[b_index].program.copy()) intermediate_pool.append( Individual(program=p_a.copy(), max_depth=p_a.max_depth)) intermediate_pool.append( Individual(program=p_b.copy(), max_depth=p_b.max_depth)) return intermediate_pool
def oneChildCrossover(p1, p2, crossfuncs, crossparams): """ Crossover all the chromosomes in the two individuals. The crossover function for each pair of corresponding chromosomes is the the corresponding element in crossfuncs, called with the corresponding tuple in crossparams. Note that it is assumed that each crossover function in crossfuncs returns one child chromosome pre: isinstance(p1, Individual) isinstance(p2, Individual) len(p1) == len(p2) len(p1) == len(crossfuncs) len(crossfuncs) == len(crossparams) post: __old__.p1 is p1 __old__.p2 is p2 __old__.p1 == p1 __old__.p2 == p2 len(__return__) == 1 isinstance(__return__, Individual) len(__return__)==len(p1) all(len(c)==len(p1[i]) for i,c in enumerate(__return__.chromosomes)) all(len(c)==len(p1[i]) for i,c in enumerate(__return__.chromosomes)) """ answer = Individual([]) for i, (crossfunc, crossparams) in enumerate(zip(crossfuncs, crossparams)): answer.append(crossfunc(p1[i], p2[i], *crossparams)) return answer
def init_pop(self): self.individuals = [] for _ in range(0, self.nindiv): individual = Individual(self.size_indiv, self.mutation_rate) individual.init_chromosome() self.individuals.append(individual)
def genPop(N, chromGenfuncs, chromGenParams): """ Return a population (list) of N unique individuals. Each individual has len(chromgGenFuncs) chromosomes. For each individual, chromosome_i is generated by calling chromGenFuncs_i(chromeGenParams_i) pre: N >= 0 isinstance(chromGenfuncs, list) isinstance(chromGenParams, list) len(chromGenfuncs) == len(chromGenParams) post: isinstance(__return__, list) len(__return__) == N forall(__return__, lambda indiv: __return__.count(indiv) == 1) post[chromGenfuncs, chromGenParams]: __old__.chromGenfuncs == chromGenfuncs __old__.chromGenParams == chromGenParams """ answer = set() chromGens = zip(chromGenfuncs, chromGenParams) while len(answer) < N: indiv = Individual([]) for genfunc, genparams in chromGens: indiv.append(genfunc(*genparams)) answer.add(indiv) return list(answer)
def crossover(population): #assumes individuals are shuffled new_pop = [] for i in range(0, population.size >> 1): individual1 = population.individuals[i] individual2 = population.individuals[population.size - i - 1] if (random.uniform() < population.parameters['p.crossover']): type = population.parameters['crossover.type'] \ if (population.parameters['crossover.type'] \ != 'permutation.all.operators') else \ np.random.choice(GeneticOperators.keys) children = GeneticOperators.permutation_crossover_individuals(\ individual1,individual2,type) \ if(population.parameters['type']=='permutation') else \ GeneticOperators.crossover_individuals(\ individual1,individual2) else: children = [\ Individual(individual1.genotype,\ np.array(individual1.phenotype)),\ Individual(individual2.genotype,\ np.array(individual2.phenotype))] new_pop = new_pop + children return \ Population(population.environment, population.parameters,new_pop)
class TestIndividual(TestCase): def setUp(self) -> None: self.items = [] for i in range(5): item = Item(random.randint(1, 10), random.randint(0, 75)) self.items.append(item) weight = 0 for i in range(5): weight += self.items[i].weight print(weight) max_weight = round(weight / 2) self.ind = Individual(self.items, max_weight) def test_generate_genotype(self): self.ind.generate_genotype() self.assertEqual(len(self.ind.genotype), len(self.items)) def test_correct_genotype(self): self.ind.generate_genotype() self.ind.correct_genotype() self.assertLessEqual(self.ind.weight_used, self.ind.max_weight) def test_breeding(self): ind2 = Individual(self.items, self.ind.max_weight) ind3 = ind2 self.ind.generate_genotype() ind2.generate_genotype() self.ind.correct_genotype() ind2.correct_genotype() ind3.breeding(self.ind, ind2) self.assertLessEqual(ind3.weight_used, ind3.max_weight)
def __init__(self, probability_handler, max_individual_size = 10): self.probability_handler = probability_handler self.max_individual_size = max_individual_size self.population = [] self.values_handler = Values_Handler(probability_handler) self.individual = Individual(self.probability_handler.max_feature_number, self.max_individual_size, self.values_handler) self.mh = Mutation_Handler(self.probability_handler, self.values_handler)
def __init__(self, populationSize): self.individuals = [] for i in range(populationSize): i = Individual() i.generateIndividual() self.individuals.append(i)
def __init__(self, num_pops): self.num_pops = num_pops self.pops = [] for i in range(num_pops): indi = Individual() indi.initialize() self.pops.append(indi)
def onePoint(self, parents, n, gene_size, crate): """ One point crossover [imagine] parent1: [0, 1, 1] => crossover => child: [1(p1), 0(p2), 0(p2)] parent2: [1, 1, 0] [example] Crossover.Onepoint(list.parents, 5) => [crossover the parents for individuals size] :param list[Individual] parents: Selected parents :param int n: Size of individuals :param int gene_size: Size of gene :param int crate: Probability of crossover :returns: Children :rtype: list[Individual] """ children = [] idx = [i for i in range(gene_size)] for i in range(n): child = Individual() parent1, parent2 = npr.choice(parents, 2, replace=False) gene1 = copy.copy(parent1.getGene()) gene2 = parent2.getGene() point = npr.choice(idx, 1)[0] if (crate > npr.random()): gene1[point:] = gene2[point:] child.setGene(gene1) children.append(child) return (children)
def execute(self): Individual.nMachines = self.nMachines Individual.nTasks = self.nTasks Individual.tasks = file_manager.load_tasks(self.filename, self.nTasks, self.nMachines) Individual.crossoverMask = Individual.generate_crossover_mask(self.nTasks) makespanPopulation = Population.generate(self.populationSize, Individual.tasks) for i in range(self.maxIterations): currentMakespan = makespanPopulation.makespan_sum() # SELECTION parents = makespanPopulation.select_parents(self.crossoverFactor) # CROSSOVER childs = [] childs = Individual.crossover_two_point(parents, i+1, currentMakespan) # MUTATION for child in childs: child.apply_mutation_simple(self.mutationFactor, currentMakespan) makespanPopulation.insert_individual(child) # INSERTION newPopulationIndividuals = makespanPopulation.update_population(self.elitismFactor) # LOGGING if(i % 100 == 0): self.save_log_information(i, makespanPopulation) return makespanPopulation.best_individual(), self.logs_generations, self.logs_average, self.logs_makespan, self.logs_flowtime
def randomPoints(self, parents, n, gene_size, crate): """ Random points crossover [imagine] parent1: [0, 1, 1, 1] => crossover => child: [1(p2), 1(p1), 1(p1), 1(p2)] parent2: [1, 1, 0, 1] [example] Crossover.Twopoints(list.parents) => [crossover the parents for individuals size] :param list[Individual] parents: Selected parents :param int n: Size of individuals :param int gene_size: Size of gene :param int crate: Probability of crossover :returns: Children :rtype: list[Individual] """ children = [] idx = [i for i in range(gene_size)] n_random = npr.randint(1, gene_size + 1) for i in range(n): child = Individual() parent1, parent2 = npr.choice(parents, 2, replace=False) gene1 = copy.copy(parent1.getGene()) gene2 = parent2.getGene() points = npr.choice(idx, n_random, replace=False) if (crate > npr.random()): for j in points: gene1[j] = gene2[j] child.setGene(gene1) children.append(child) return (children)
def mutation(childs, pmut, fit, center, limit, mutation_f): mutation_list = list(filter(lambda individual: np.random.rand() < pmut, childs[:int(len(childs) * pmut)])) for i, individual in enumerate(mutation_list): mutated = mutation_f(Individual.getQ(individual[0]), limit) sol = newton.newton(mutated, a_par, b_par, c_par) mutation_list[i] = (Individual(mutated, sol), fit(center, sol)) return mutation_list
def createPopulation(self, functions, constants, n_ind, n_gene, n_register): self.p = [] for i in range(n_ind): ind = Individual(functions, constants, n_register) ind.createGene(random.randint(1, n_gene)) self.p.append(ind)
def ox_crossover(individual1,individual2): n,i,f,i_central,i_sides= PermutationCrossover.mapping_sections(\ individual1,individual2) p1_central = set(individual1.phenotype[i_central]) p2_central = set(individual2.phenotype[i_central]) centrals = p1_central.union(p2_central) rest_1 = list(filter(lambda x:x[1] not in centrals, \ enumerate(individual1.phenotype))) rest_2 = list(filter(lambda x:x[1] not in centrals, \ enumerate(individual2.phenotype))) rest_1 = np.array([x[1] for x in \ list(filter(lambda x:x[0]>=f,rest_1))+\ (list(filter(lambda x:x[0]<i,rest_1)))]) rest_2 = np.array([x[1] for x in \ list(filter(lambda x:x[0]>=f,rest_2))+\ (list(filter(lambda x:x[0]<i,rest_2)))]) head_1 = np.array(list(filter(lambda x:x not in p2_central,\ individual1.phenotype[i_central]))) head_2 = np.array(list(filter(lambda x:x not in p1_central,\ individual2.phenotype[i_central]))) child1 = PermutationCrossover.build_child(\ head_1,individual2.phenotype[i_central],rest_1) child2= PermutationCrossover.build_child(\ head_2,individual1.phenotype[i_central],rest_2) return [Individual(phenotype=child1),Individual(phenotype=child2)]
def simulated_annealing(self): currentResult = self.initialize() currentValue = Individual(self.graph, currentResult) bestValue = Individual(self.graph, currentResult) for i in range(1, self.nIterations): j = self.invert(currentResult) newValue = Individual(self.graph, currentResult) if newValue.fitness < currentValue.fitness: currentValue = Individual(self.graph, newValue.code) else: p = 1.0 / i**0.5 q = random.uniform(0, 1) if p > q: currentValue = Individual(self.graph, newValue.code) else: self.restore(j, currentResult) if newValue.fitness < bestValue.fitness: bestValue = Individual(self.graph, newValue.code) if bestValue.fitness == 0: break bestValue.getSubgraphs() return bestValue
def update_velocity(self, neighbour): """ Updates the particle's velocity and moves it by one iteration self.velocity = (w_inertia * v) + (w_mem * (histpos - pos) + (wg * (neihg - pos))) self.pos = self.pos + self.vel returns amount of change in velocity """ self.p['Neighbour'] = neighbour.p['Coordinate'] # Switch to update velocity def updatev(row): if ((row['Neighbour'] - row['Coordinate']) == 0): ret = ( (self.w_inertia * row['Velocity']) + (self.w_memory * (row['HBest'] - row['Coordinate'])) + self.__generateCoord({ 'min': 0.00001, 'max': 0.0001 }) ) # Add a pinch of randomness to make sure that velocities are different elif (row['HBest'] - row['Coordinate']) == 0: ret = ((self.w_inertia * row['Velocity']) + (self.w_memory) + (self.w_neigh * (row['Neighbour'] - row['Coordinate']))) elif row['Velocity'] == 0: ret = ((self.w_inertia) + (self.w_memory * (row['HBest'] - row['Coordinate'])) + (self.w_neigh * (row['Neighbour'] - row['Coordinate']))) else: ret = ((self.w_inertia * row['Velocity']) + (self.w_memory * (row['HBest'] - row['Coordinate'])) + (self.w_neigh * (row['Neighbour'] - row['Coordinate']))) return ret def move(row): return row['Coordinate'] + row['Velocity'] previous_vel = self.p['Velocity'] self.p['Velocity'] = self.p.apply(updatev, axis=1) self.__clampV() self.p['Coordinate'] = self.p.apply(move, axis=1) self.__clampPos() # Update fitness self.current_fit = self.ff.fitness( Individual.factory("Coordinate", self.n_thresholds, self.p)) # Reset particle while its fitness is not valid while (self.current_fit.value == 0): self.__reset() # Replace your historical best if you've defeated it hfit = self.ff.fitness( Individual.factory("HBest", self.n_thresholds, self.p)) if (hfit.value < self.current_fit.value): hfit = self.current_fit self.p['HBest'] = self.p['Coordinate'] self.iteration += 1 diff_in_v = self.p['Velocity'] - previous_vel return diff_in_v
def reproduction(self): self.generationCount += 1 # do for every individual in a population for i in range(self.capacity): # crossover event parent1, parent2 = self.selection() child = parent1 # evenly split "DNA" between two parents for j in range(floor(self.length / 2) - 1): child[j * 2] = parent2[j * 2] # mutation event final = Individual(self.mutation(child, self.mutRate), self.length, self.phrase) # replace currently highest fitness individual if final.getFitness() > self.currentHigh: self.bestMatch = final.getName() # insert individual into new population self.nextPop.append(final) self.pop = self.nextPop # set next gen population to current population self.currentHigh = max(self.nextPop) return "Generation count: " + str(self.generationCount)
def crossover_population(self, population): new_population = Population(population.size, population.dataset, population.chromosome_size) cut_index = int(random() * population.chromosome_size) for i in range(population.size): parent1 = population.get_fittest(i) parent2 = Individual(population.chromosome_size, population.dataset) offspring = parent1 if i > self.elitism_count and self.crossover_rate > random( ) and i >= cut_index: for j in range(parent2.chromosome_size): adiconado = False while not adiconado: if not self.isContained(parent2.chromosome[j], offspring): offspring.chromosome[j] = parent2.chromosome[j] adiconado = True else: parent2 = Individual(population.chromosome_size, population.dataset) new_population.individuals[i] = offspring return new_population
def make_next_generation(population, pizza): mating_pool = population[:int(c_par * P)] next_generation = [] for _ in range(int(c_rec * P) // 2): A, B = random.sample(mating_pool, 2) C, D = A.recombine(B, pizza) next_generation += [C, D] next_generation += mating_pool for _ in range(int(c_mut * P)): # A = random.choice(next_generation) A = mating_pool[0] B = A.copy() levels = random.choice([1, 2, 3]) B.mutate(pizza, levels) next_generation.append(B) for _ in range(int(c_ran * P)): A = Individual({}, slices, n_col, n_row, L, H) A.fill_layout(pizza) next_generation.append(A) next_generation.sort(key=lambda x: x.efficiency(), reverse=True) return next_generation
def __init__(self, initial_pop, layer_types, layer_shapes, conv_layer_types=None, population=None): self.pop_size = initial_pop self.layer_types = layer_types self.layer_shapes = layer_shapes self.conv_layer_types = conv_layer_types if population is not None: self.population = population # If not enough members, create random ones if initial_pop < len(population): while initial_pop < len(population): self.population.append( Individual(layer_types, layer_shapes, conv_layer_types)) else: self.pop_size = len(population) self.fitness = zip(np.zeros(self.pop_size), range(self.pop_size)) else: self.fitness = zip(np.zeros(initial_pop), range(initial_pop)) self.population = [] for i in range(initial_pop): self.population.append( Individual(layer_types, layer_shapes, conv_layer_types))
def recombination(parent1, parent2): child1 = Individual(chromosome=np.append(parent1[:crossPoint], parent2[crossPoint:]), ) child2 = Individual(chromosome=np.append(parent2[:crossPoint], parent1[crossPoint:]), ) return [child1, child2]
def gen_n_individuals(n, samples): individuals = list() while len(individuals) < n: # avoid full empty weights candidate = None while True: lw = np.random.choice([0, 1], 1) pw_len = random.randint(1, 10) pw = np.array( [Population.is_set(x + 1, pw_len) for x in range(10)]) prw_len = random.randint(1, 10) prw = np.array( [Population.is_set(x + 1, prw_len) for x in range(10)]) params = SVRParams() candidate = Individual(samples=samples, linear_weight=lw, prev_weights=pw, prev_residual_weights=prw, params=params) if candidate.hash() > 0: break individuals.append(candidate) return individuals
def __init__(self, size, initialize=False): self.individuals = [] if initialize: for i in range(0, size): individual = Individual() individual.generate_individual() self.individuals.append(individual)
def test_fight(self): ind1 = Individual("01101110") ind2 = Individual("00111000") fight1 = ind2.fight(ind1) self.assertEqual(ind1.fitness, 1) self.assertEqual(ind2.fitness, 0) fight2 = ind1.fight(ind2) self.assertEqual(fight1, False) self.assertEqual(fight2, False)
def crossover_pt(self, individual_1, individual_2): crossover_individual = Individual() uniform_rate = uniform(3, 7) * .1 crossover_point = int(uniform_rate * len(crossover_individual.genes)) crossover_individual.genes = individual_1.genes[0:crossover_point] crossover_individual.genes += individual_2.genes[crossover_point:] return crossover_individual
class TestEvaluateAgainst: def setup(self): self.individual_a = Individual('0123456789') def test_identical(self): chars = self.individual_a.chars assert_true(self.individual_a.evaluate_against(chars) == len(chars)) def test_no_similarity(self): assert_true(self.individual_a.evaluate_against('a tallship') == 0)
def crossover_random(self, individual_1, individual_2): crossover_individual = Individual() for i in range(0, len(crossover_individual.genes)): # crossover if random() <= self.uniform_rate: crossover_individual.genes[i] = individual_1.genes[i] else: crossover_individual.genes[i] = individual_2.genes[i] return crossover_individual
def run_once(self): newpop = [] # Elitism, keep the best chromosome to the next generation newpop = self.population[:3] for i in range(3, self.popsize): tmpchrom = Individual(mother=self.__my_choice(), father=self.__my_choice()) tmpchrom.mutate() newpop.append(tmpchrom) self.population = newpop self.evaluate_all() self.randomize_duplicates() self.apply_max() self.evaluate_all() self.population.sort(key=attrgetter("fitness"), reverse=True) self.inc_mutation_rate(MUTATION_RATE_INC)
def init_children_test(self, num_children): self.clear_test_state() player1 = Individual() testee = player1.get_robot() testee.location = constants.testee_loc self.robots = [testee] self.gamestate.add_robot(testee.location, testee.player_id) # Force the prime rule to be the move rule so direction is returned while testee.eval_order[0].action != 'move': random.shuffle(testee.eval_order) rule = self.robots[0].eval_order[0] rule.insert_random_parent() for x in range(num_children): self.insert_random_root_child(rule)
def setUp(self): self.indi = Individual() self.indi.addID('@I2@') self.indi.addName('John Rivas') self.indi.addSex('M') self.indi.addBirt('9 MAY 1978') self.indi.addDeat('12 APR 2013') self.indi.addFams('@F2@') self.indi.addFamc('@F1@')
def __init__(self, size): self.size = size self.pop = [] self.selected = [] self.selected_indexes = [] self.fitness_table = [] Individual.mutation_factor = 5 for i in xrange(size): self.pop.append(Individual.random_ind())
def make_json_record(case_name=CASE_NAME, seed=0, lineage=0, age=0): input_filepath = os.path.join(RESULT_DIR, case_name) output_file = os.path.join( ensure_exists(os.path.join(ANALYSIS_DIR, case_name, "seed-{}".format(seed))), "game.json" ) params = load("params", input_filepath, seed) TASKS = [(task[0], int(task[1][::-1], 2)) for task in params["TASKS"]] hit_multipliers, patterns = zip(*TASKS) lineages = load("lineages", input_filepath, seed) def i2s(i): return tuple((i >> n) & 1 for n in range(params["NUM_NODES"])) ind = Individual(lineages[lineage][age].genome) transitions = ind.play_game(hit_multipliers, patterns) states = [ ps[: params["NUM_SENSORS"]] + cs[params["NUM_SENSORS"] :] for ps, cs in zip(map(i2s, transitions[0]), map(i2s, transitions[1])) ] trial_length = params["WORLD_HEIGHT"] block_sizes = [] for pattern in patterns: block_sizes += [sum(i2s(pattern))] * int(params["NUM_TRIALS"] / len(patterns)) json_dict = { "generation": params["NGEN"] - age, "connectivityMatrix": ind.cm.T.tolist(), "nodeTypes": {"sensors": [0, 1], "hidden": [2, 3, 4, 5], "motors": [6, 7]}, "blockSize": block_sizes, "Trial": [ {"trialNum": i, "lifeTable": states[(i * trial_length) : ((i + 1) * trial_length)]} for i in range(params["NUM_TRIALS"]) ], } with open(output_file, "w") as f: json.dump(json_dict, f) print("Saved game representation to `{}`.".format(output_file)) return json_dict
def __init__( self, data, expected_result, popsize=50, mut_rate=20, GA_printers=None ): Individual.expected_result = {"rowdata": expected_result} Individual.mutation_rate = mut_rate Individual.data = data self.popsize = popsize self.population = [] for i in range(0, popsize): c = Individual() c.randomize() self.population.append(c) self.population.sort(key=attrgetter("fitness"), reverse=True) self.GA_printers = GA_printers self.generation = 0 self.wheel_size = sum(range(1, popsize + 1)) self.wheel = [] self.__init_wheel() self.test = [0 for i in range(0, self.popsize)]
def test_addSex(self): indi = Individual() value = "M" indi.addSex(value) self.assertEqual(indi.getSex(), value) value = "F" indi.addSex(value) self.assertEqual(indi.getSex(), value)
def mutate(indiv: individual.Individual): # for i in range(individual.Individual.gene_length): # if elitism and i == 0: # continue # if random.random() <= mutation_rate: # indiv.genes[i // 8] ^= 1 << (i % 8) for i, _ in enumerate(indiv.genes): # if elitism and i == 0: # continue if random.random() <= mutation_rate: indiv.genes[i] = random.randint(0, 255)
def init_node_type_test(self): """Puts Test in known state for Node type tests.""" self.clear_test_state() player1 = Individual() player2 = Individual() testee = player1.get_robot() testee.location = constants.testee_loc ally = player1.get_robot() ally.location = constants.ally_loc enemy = player2.get_robot() enemy.location = constants.enemy_loc enemy.player_id = 1 self.robots = [testee, ally, enemy] for bot in self.robots: self.gamestate.add_robot(bot.location, bot.player_id) # I use the default 'guard' action to determine when a rule evaluates # False, so the test rule must not be the guard rule while testee.eval_order[0].action == 'guard': random.shuffle(testee.eval_order) testee.eval_order[0].insert_random_parent()
def setUp(self): self.indi = Individual() self.indi.addID('@I2@') self.indi.addName('John Rivas') self.indi.addSex('M') self.indi.addBirt('9 MAY 1978') self.indi.addDeat('12 APR 2013') self.indi.addFams('@F2@') self.indi.addFamc('@F1@') self.fam1 = Family() self.fam1.addFamID('@F2@') self.fam1.addHusb('@I2@') self.fam1.addWife('@I2@') self.fam1.addChil('@I2@') self.fam1.addChil('@I2@') self.individuals = dict() self.individuals["one"] = self.indi self.families = dict() self.families["one"] = self.fam1
class OutputTest(unittest.TestCase): def setUp(self): self.indi = Individual() self.indi.addID('@I2@') self.indi.addName('John Rivas') self.indi.addSex('M') self.indi.addBirt('9 MAY 1978') self.indi.addDeat('12 APR 2013') self.indi.addFams('@F2@') self.indi.addFamc('@F1@') self.fam1 = Family() self.fam1.addFamID('@F2@') self.fam1.addHusb('@I2@') self.fam1.addWife('@I2@') self.fam1.addChil('@I2@') self.fam1.addChil('@I2@') self.individuals = dict() self.individuals["one"] = self.indi self.families = dict() self.families["one"] = self.fam1 def test_outputIndiSummary(self): outputIndiSummary(self.individuals) def test_outputFamSummary(self): outputFamSummary(self.families, self.individuals)
from individual import Individual from mutator import Mutator num_tries = 0 num_moves = 0 TARGET = "Methinks it is like a weasel" mutator = Mutator(2) ind = Individual(len(TARGET)) fitness = ind.evaluate_against(TARGET) while fitness < len(TARGET): new_ind = mutator.reproduce_asexually(ind) new_fitness = new_ind.evaluate_against(TARGET) num_tries = num_tries + 1 if new_fitness > fitness: ind = new_ind fitness = new_fitness num_moves = num_moves + 1 print(new_ind) print("Found in",num_tries,"tries and",num_moves,"moves.")
def build_lists_from_file(filename): """Parses the Ged file and builds the Family and Individual objects. Returns a touple of dictionaries, in the for ({},{}), where the first is the list of families (indexed by family ID) and the second is the list of individuals (indexed by the individual ID). """ load_valid_tags() lines = open(filename, "r").readlines() individuals = {} families = {} def generateUntilLevelZero(seq): """Creates a list of GedLine objects until the given sequence has a GedLine with level zero. This is useful for retrieving a sequence of lines of a single object (family of individual) """ for e in seq: line = GedLine(e) if line.level() != 0: yield line else: break index = 0 # line index while index < len(lines)-1: line = GedLine(lines[index]) if line.level() == 0 and line.content() == "INDI": # Create Individual ind = Individual(line.tag()) # Tag is the ID individual_lines = generateUntilLevelZero(lines[index+1:]) for l in individual_lines: if l.tag() == "NAME": ind.name = l.content() elif l.tag() == "GIVN": ind.givenname = l.content() elif l.tag() == "SURN": ind.surname = l.content() elif l.tag() == "SEX": ind.sex = l.content() elif l.tag() == "NOTE": ind.note = l.content() elif l.tag() == "BIRT": ind.setbirthday(individual_lines.next().content()) elif l.tag() == "DEAT": ind.setdeathday(individual_lines.next().content()) individuals[ind.id] = ind elif line.level() == 0 and line.content() == "FAM": # Create Family fam = Family(line.tag()) # Tag is the ID family_lines = generateUntilLevelZero(lines[index+1:]) for l in family_lines: if l.tag() == "HUSB": fam.husband = l.content() elif l.tag() == "WIFE": fam.wife = l.content() elif l.tag() == "CHIL": fam.children.append(l.content()) elif l.tag() == "MARR": fam.setmarrydate(family_lines.next().content()) families[fam.id] = fam index += 1 return families, individuals
def test_getName(self): NAME = 'John Rivas' self.assertEqual(self.indi.getName(), NAME) indi = Individual() self.assertEqual(indi.getName(), None)
def test_getBirt(self): BIRT = '9 MAY 1978' self.assertEqual(self.indi.getBirt(), BIRT) indi = Individual() self.assertEqual(indi.getBirt(), None)
def test_getSex(self): SEX = 'M' self.assertEqual(self.indi.getSex(), SEX) indi = Individual() self.assertEqual(indi.getSex(), None)
class GedcomTest(unittest.TestCase): def setUp(self): self.indi1 = Individual() self.indi1.addID('@I1@') self.indi1.addName('John Rivas') self.indi1.addSex('M') self.indi1.addBirt('9 MAY 1978') self.indi1.addDeat('12 APR 2013') self.indi2 = Individual() self.indi2.addID('@I2@') self.indi2.addName('Mary Rivas') self.indi2.addSex('F') self.indi2.addBirt('21 APR 1980') self.indi2.addDeat('12 SEP 1990') self.indi3 = Individual() self.indi3.addID('@I3@') self.indi3.addName('Mary Rivas') self.indi3.addSex('F') self.indi3.addBirt('21 APR 1980') self.indi3.addDeat('12 SEP 2014') self.indi4 = Individual() self.indi4.addID('@I4@') self.indi4.addName('Mike Rivas') self.indi4.addSex('M') self.indi4.addBirt('21 APR 1976') self.indi5 = Individual() self.indi5.addID('@I5@') self.indi5.addName('Mike Rivas') self.indi5.addSex('M') self.indi5.addBirt('21 APR 2012') self.indi6 = Individual() self.indi6.addID('@I6@') self.indi6.addName('Mike Rivas') self.indi6.addSex('M') self.indi6.addBirt('21 APR 1988') self.indi6.addFamc('@F8@') self.indi7 = Individual() self.indi7.addID('@I7@') self.indi7.addName('Laura Rivas') self.indi7.addSex('F') self.indi7.addBirt('21 APR 1990') self.indi7.addFamc('@F8@') self.indi8 = Individual() self.indi8.addID('@I8@') self.indi8.addName('Laura Rivas') self.indi8.addSex('F') self.indi8.addBirt('21 APR 1990') self.indi8.addFamc('@F9@') self.individuals = dict() self.individuals['1'] = self.indi1 self.individuals['2'] = self.indi2 self.individuals['3'] = self.indi3 self.individuals['4'] = self.indi4 self.individuals['5'] = self.indi5 self.individuals['6'] = self.indi6 self.individuals['7'] = self.indi7 self.individuals['8'] = self.indi8 self.fam1 = Family() self.fam1.addFamID('@F2@') self.fam1.addHusb('@I1@') self.fam1.addWife('@I2@') self.fam1.addChil('@I4@') self.fam1.addChil('@I5@') self.fam1.addMarr('5 OCT 1999') self.fam1.addDiv('12 JUN 2012') self.fam2 = Family() self.fam2.addFamID('@F3@') self.fam2.addHusb('@I3@') self.fam2.addWife('@I3@') self.fam3 = Family() self.fam3.addFamID('@F3@') self.fam3.addHusb('@I1@') self.fam3.addWife('@I2@') self.fam3.addChil('@I4@') self.fam3.addChil('@I5@') self.fam3.addMarr('5 OCT 1999') self.fam3.addDiv('12 JUN 2012') self.fam4 = Family() self.fam4.addFamID('@F4@') self.fam4.addHusb('@I1@') self.fam4.addWife('@I3@') self.fam4.addChil('@I4@') self.fam4.addMarr('5 OCT 1999') self.fam4.addDiv('12 JUN 2012') self.fam5 = Family() self.fam5.addFamID('@F5@') self.fam5.addHusb('@I1@') self.fam5.addWife('@I3@') self.fam5.addChil('@I5@') self.fam5.addMarr('5 OCT 1999') self.fam5.addDiv('12 JUN 2012') def test_checkSameHusbWife(self): self.assertTrue(checkSameHusbWife(self.fam2)) self.assertFalse(checkSameHusbWife(self.fam1)) def test_checkDeathBeforeBirth(self): self.indi1.addBirt('9 MAY 1978') self.indi1.addDeat('9 MAY 1913') self.assertTrue(checkDeathBeforeBirth(self.indi1)) self.indi1.addDeat('9 MAY 1978') self.assertFalse(checkDeathBeforeBirth(self.indi1)) self.indi1.addDeat('12 APR 2013') self.assertFalse(checkDeathBeforeBirth(self.indi1)) self.indi1.addDeat(None) self.assertFalse(checkDeathBeforeBirth(self.indi1)) def test_checkMarryDead(self): self.assertTrue(checkMarryDead(self.fam3, self.individuals)) self.assertFalse(checkMarryDead(self.fam4, self.individuals)) def test_checkChildBeforeParents(self): self.assertTrue(checkChildBeforeParents(self.fam4, self.individuals)) self.assertFalse(checkChildBeforeParents(self.fam5, self.individuals)) def test_checkWifeIsMale(self): self.fam1.addWife('@I1@') self.assertTrue(checkWifeIsMale(self.fam1, self.individuals)) self.fam1.addWife('@I2@') self.assertFalse(checkWifeIsMale(self.fam1, self.individuals)) def test_checkHusbandIsFemale(self): self.fam1.addHusb('@I2@') self.assertTrue(checkHusbandIsFemale(self.fam1, self.individuals)) self.fam1.addHusb('@Ii@') self.assertFalse(checkHusbandIsFemale(self.fam1, self.individuals)) def test_marriedBeforeBirth(self): self.indi1.addBirt('9 MAY 1915') self.indi2.addBirt('21 APR 1980') self.fam1.addMarr('9 MAY 1914') self.assertTrue(marriedBeforeBirth(self.fam1, self.individuals)) self.indi1.addBirt('9 MAY 1800') self.indi2.addBirt('21 APR 1980') self.fam1.addMarr('9 MAY 1994') self.assertFalse(marriedBeforeBirth(self.fam1, self.individuals)) def test_marriedTooYoung(self): self.indi1.addBirt('9 MAY 1900') self.indi2.addBirt('21 APR 1900') self.fam1.addMarr('9 MAY 1912') self.assertTrue(marriedTooYoung(self.fam1, self.individuals)) self.indi1.addBirt('9 MAY 1800') self.indi2.addBirt('21 APR 1980') self.fam1.addMarr('9 MAY 1994') self.assertFalse(marriedTooYoung(self.fam1, self.individuals)) self.indi1.addBirt('9 MAY 1800') self.indi2.addBirt('21 APR 1980') self.fam1.addMarr('9 MAY 1600') self.assertFalse(marriedTooYoung(self.fam1, self.individuals)) def test_deathBeforeMarriage(self): self.indi1.addDeat('9 MAY 2013') self.indi2.addDeat('12 SEP 1990') self.fam1.addMarr('9 MAY 2014') self.assertTrue(deathBeforeMarriage(self.fam1, self.individuals)) self.indi1.addDeat('9 MAY 1800') self.indi2.addDeat('12 SEP 1990') self.fam1.addMarr('9 MAY 1800') self.assertFalse(deathBeforeMarriage(self.fam1, self.individuals)) self.indi1.addDeat('9 MAY 2015') self.indi2.addDeat('12 SEP 1990') self.fam1.addMarr('9 MAY 1800') self.assertFalse(deathBeforeMarriage(self.fam1, self.individuals)) self.assertTrue(checkMarryDead(self.fam3, self.individuals)) self.assertFalse(checkMarryDead(self.fam4, self.individuals)) def test_divorceBeforeMarriage(self): self.fam1.addMarr('9 MAY 1914') self.fam1.addDiv('9 MAY 1900') self.assertTrue(divorceBeforeMarriage(self.fam1, self.individuals)) self.fam1.addMarr('9 MAY 1914') self.fam1.addDiv('9 MAY 1925') self.assertFalse(divorceBeforeMarriage(self.fam1, self.individuals)) self.assertFalse(divorceBeforeMarriage(self.fam2, self.individuals)) def test_tooManyChildren(self): self.assertFalse(tooManyChildren(self.fam1)) famT = Family() self.assertFalse(tooManyChildren(famT)) famT.addChil("1") famT.addChil("2") famT.addChil("3") famT.addChil("4") famT.addChil("5") self.assertTrue(tooManyChildren(famT)) def test_tooOldParent(self): self.assertFalse(tooOldParent(self.fam1, self.individuals)) self.indi1.addBirt('9 MAY 1578') self.assertTrue(tooOldParent(self.fam1, self.individuals)) self.indi1.addBirt('9 MAY 1978') self.indi4.addBirt('21 APR 2076') self.assertTrue(tooOldParent(self.fam1, self.individuals)) def test_marriedMoreThanOnePerson(self): self.families = dict() self.famA = Family() self.famA.addFamID('@A1@') self.famA.addHusb('@H1@') self.famA.addWife('@W1@') self.families['1'] = self.famA self.assertFalse(marriedMoreThanOnePerson(self.families)) self.famB = Family() self.famB.addFamID('@B1@') self.famB.addHusb('@H2@') self.famB.addWife('@W2@') self.families['2'] = self.famB self.assertFalse(marriedMoreThanOnePerson(self.families)) self.famB.addWife('@W1@') self.assertTrue(marriedMoreThanOnePerson(self.families)) self.famA.addDiv('12 JUN 2012') self.famB.addWife('@W1@') self.assertFalse(marriedMoreThanOnePerson(self.families)) def test_marriedToSiblings(self): self.famA = Family() self.famA.addFamID('@F6@') self.famA.addHusb('@I6@') self.famA.addWife('@I7@') self.famA.addMarr('5 OCT 1999') self.assertTrue(marriedToSiblings(self.famA, self.individuals)) self.famB = Family() self.famB.addFamID('@F6@') self.famB.addHusb('@I6@') self.famB.addWife('@I8@') self.famB.addMarr('5 OCT 1999') self.assertFalse(marriedToSiblings(self.famB, self.individuals))
def test_getDeat(self): DEAT = '12 APR 2013' self.assertEqual(self.indi.getDeat(), DEAT) indi = Individual() self.assertEqual(indi.getDeat(), None)
def test_random(self): ind1 = Individual.random_ind() ind2 = Individual.random_ind(20) self.assertEqual(len(ind1.genome), 15) self.assertEqual(len(ind2.genome), 20) self.assertEqual(ind1.fitness, 0)
def evolve(G, p, popsize, gener, mutprob, coprob, tsize, elitism=None): nodes_ordered_by_demand = sorted(G.node.items(), key=lambda t: t[1]['demand'], reverse=True) t1 = clock() pop = [] # generating first population, which will be random for i in range(popsize): individual = Individual(p, G) individual.calculate_fitness(G, nodes_ordered_by_demand) pop.append(individual) rank_population(pop) report = { 'worst_i': pop[-1].fitness, 'best_i': pop[0].fitness, 'generation': 0, 'better_sons': 0, 'total_sons': 0, 'best_i_hist': [pop[0].fitness], 'mean_fitness_hist': [sum([i.fitness for i in pop]) / popsize], 'repeated_i_hist': [popsize - unique_individuals(pop)] } for generation in range(gener): # applying elitism if relevant if elitism: topelite = int(ceil(elitism * popsize)) new_pop = pop[0:topelite] else: # if no elitism specified, simply create a new population new_pop = [] # while the population is not complete while len(new_pop) < popsize: random_number = random() subpop = sample(pop, tsize) # tournament individuals if random_number < mutprob: # mutating new_pop.append(mutate(subpop[0], G)) new_pop[-1].calculate_fitness(G, nodes_ordered_by_demand) elif random_number < coprob: # doing crossover mean_fitness = (subpop[0].fitness + subpop[1].fitness) / 2.0 i1, i2 = crossover(subpop[0], subpop[1]) i1.calculate_fitness(G, nodes_ordered_by_demand) if i1.fitness > mean_fitness: report['better_sons'] += 1 report['total_sons'] += 1 new_pop.append(i1) if i2 is not None: i2.calculate_fitness(G, nodes_ordered_by_demand) if i2.fitness > mean_fitness: report['better_sons'] += 1 new_pop.append(i2) report['total_sons'] += 1 else: # if no mutation or crossover, insert the best individual new_pop.append(deepcopy(subpop[0])) if len(new_pop) > popsize: new_pop.pop() report['total_sons'] -= 1 pop = rank_population(new_pop) report['best_i_hist'].append(pop[0].fitness) report['mean_fitness_hist'].append(sum([i.fitness for i in pop]) / popsize) report['repeated_i_hist'].append(popsize - unique_individuals(pop)) if report['best_i'] > pop[0].fitness: report['best_i'] = pop[0].fitness report['generation'] = generation if report['worst_i'] < pop[-1].fitness: report['worst_i'] = pop[-1].fitness t2 = clock() report['time'] = round(t2 - t1, 3) report['gener_per_s'] = gener / report['time'] return report
def test_mutation_decision(self): self.assertIn(Individual.decide_if_mutate(), [True, False])
def test_breeding(self): ind1 = Individual("111") ind2 = Individual("111") child1, child2 = ind1.breed_with(ind2) self.assertEqual(child1.genome, child2.genome)
def test_mutation(self): ind1 = Individual.random_ind() mutated_gene_index, mutated_value = ind1.mutate_random_gene() self.assertEqual(ind1.genome[mutated_gene_index], mutated_value)
logger = logging.getLogger() logger.setLevel(logging.DEBUG) console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) console_handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT)) logger.addHandler(console_handler) parser = argparse.ArgumentParser(description = "Individual prac runner") parser.add_argument('-d') parser.add_argument('-p') args = parser.parse_args() part = args.p user_id = re.search("([a-z]){6}([0-9]){3}", args.d).group(0) submitter = Individual(user_id = user_id, logger = logger.getChild('manual_marker')) submitter.directory = args.d submitter.submission_directory = args.d tester_module = importlib.import_module("prac_exam_2_part_{n}_tests".format(n = part)) TesterClass = getattr(tester_module, "PracExam2Part{n}Tests".format(n = part)) #tester_module = importlib.import_module("prac_exam_0_tests".format(n = part)) #TesterClass = getattr(tester_module, "PracExam0Tests".format(n = part)) tester = TesterClass(submitter, logger.getChild('pe2')) tester.catalogue_submission_files() tester.build() tester.run_tests() logger.info("Final Mark: {m:g}".format(m = float(submitter.mark)))
def setUp(self): self.indi1 = Individual() self.indi1.addID('@I1@') self.indi1.addName('John Rivas') self.indi1.addSex('M') self.indi1.addBirt('9 MAY 1978') self.indi1.addDeat('12 APR 2013') self.indi2 = Individual() self.indi2.addID('@I2@') self.indi2.addName('Mary Rivas') self.indi2.addSex('F') self.indi2.addBirt('21 APR 1980') self.indi2.addDeat('12 SEP 1990') self.indi3 = Individual() self.indi3.addID('@I3@') self.indi3.addName('Mary Rivas') self.indi3.addSex('F') self.indi3.addBirt('21 APR 1980') self.indi3.addDeat('12 SEP 2014') self.indi4 = Individual() self.indi4.addID('@I4@') self.indi4.addName('Mike Rivas') self.indi4.addSex('M') self.indi4.addBirt('21 APR 1976') self.indi5 = Individual() self.indi5.addID('@I5@') self.indi5.addName('Mike Rivas') self.indi5.addSex('M') self.indi5.addBirt('21 APR 2012') self.indi6 = Individual() self.indi6.addID('@I6@') self.indi6.addName('Mike Rivas') self.indi6.addSex('M') self.indi6.addBirt('21 APR 1988') self.indi6.addFamc('@F8@') self.indi7 = Individual() self.indi7.addID('@I7@') self.indi7.addName('Laura Rivas') self.indi7.addSex('F') self.indi7.addBirt('21 APR 1990') self.indi7.addFamc('@F8@') self.indi8 = Individual() self.indi8.addID('@I8@') self.indi8.addName('Laura Rivas') self.indi8.addSex('F') self.indi8.addBirt('21 APR 1990') self.indi8.addFamc('@F9@') self.individuals = dict() self.individuals['1'] = self.indi1 self.individuals['2'] = self.indi2 self.individuals['3'] = self.indi3 self.individuals['4'] = self.indi4 self.individuals['5'] = self.indi5 self.individuals['6'] = self.indi6 self.individuals['7'] = self.indi7 self.individuals['8'] = self.indi8 self.fam1 = Family() self.fam1.addFamID('@F2@') self.fam1.addHusb('@I1@') self.fam1.addWife('@I2@') self.fam1.addChil('@I4@') self.fam1.addChil('@I5@') self.fam1.addMarr('5 OCT 1999') self.fam1.addDiv('12 JUN 2012') self.fam2 = Family() self.fam2.addFamID('@F3@') self.fam2.addHusb('@I3@') self.fam2.addWife('@I3@') self.fam3 = Family() self.fam3.addFamID('@F3@') self.fam3.addHusb('@I1@') self.fam3.addWife('@I2@') self.fam3.addChil('@I4@') self.fam3.addChil('@I5@') self.fam3.addMarr('5 OCT 1999') self.fam3.addDiv('12 JUN 2012') self.fam4 = Family() self.fam4.addFamID('@F4@') self.fam4.addHusb('@I1@') self.fam4.addWife('@I3@') self.fam4.addChil('@I4@') self.fam4.addMarr('5 OCT 1999') self.fam4.addDiv('12 JUN 2012') self.fam5 = Family() self.fam5.addFamID('@F5@') self.fam5.addHusb('@I1@') self.fam5.addWife('@I3@') self.fam5.addChil('@I5@') self.fam5.addMarr('5 OCT 1999') self.fam5.addDiv('12 JUN 2012')