def main():
problem_dataset_dir = os.path.join('Problems', 'Problem17')
solution_dir = os.path.join("Problems", "Problem17Solution")
data_reader = DataReader(problem_dataset_dir)
test_cases, output = data_reader.get_data()
for train_i in range(0, len(output)):
dna = test_cases[train_i][0]
k = test_cases[train_i][1][0]
score_matrix = test_cases[train_i][1][1]
case_output = output[train_i]
most_probable_k_mer = DNA(dna).get_most_probable_k_mer(int(k), score_matrix)
if most_probable_k_mer != case_output:
raise Exception("Output not matched!\nExpecting: " + str(case_output) + "\nFound: " + str(most_probable_k_mer))
print("Passed training data..")
writer = DataWriter(solution_dir)
usage = Usage()
for test_i in range(len(test_cases) - len(output) - 1, len(test_cases)):
usage.start()
dna = test_cases[test_i][0]
k = test_cases[test_i][1][0]
score_matrix = test_cases[test_i][1][1]
most_probable_k_mer = DNA(dna).get_most_probable_k_mer(int(k), score_matrix)
usage.end()
writer.write_data(test_i + 1, most_probable_k_mer, usage.get_execution_time(), usage.get_memory_usage())
print("\n\nInput:\n" + str(dna) + "\n" + str(k) + "\n" + str(score_matrix))
print("\n\nOutput")
print("=====")
print(most_probable_k_mer)
print("\n")
print("======")
print("Execution Time: " + str(usage.get_execution_time()) + " s")
print("Memory Used: " + str(usage.get_memory_usage()) + " MB")
def mate(self, dad, mom):
size = dad.dnaLength
offspring = DNA()
for i in range(0, size):
if random() > 0.5: # 50% chance to get dad's gene
offspring.dna[i] = dad.dna[i]
else: # 50% chance to get mom's gene
offspring.dna[i] = mom.dna[i]
if random() < self.mutation_chance:
offspring.mutate_gene(i)
return offspring
def __init__(self,
x: float,
y: float,
dna: DNA = DNA(),
brain_dna: DNA = BrainDNA(),
direction: float = 0.0,
name: str = 'object',
health: int = None):
super().__init__(x, y, dna, direction, name, health=health)
# objective function
self.brain = Brain(brain_dna)
def run(self, target_string):
self.target = DNA(target_string)
self.generations = self._initialise(target_string)
result = []
while True:
next_generation = self.generations[-1].next_generation(self.target)
result.append(self.generations[-1].best_fit())
if result[-1][0] == target_string or len(result) > 1000:
break
self.generations.append(next_generation)
return result
def create_population(self, pop_size, genius=None):
population = []
for i in range(0, pop_size):
creature = DNA()
creature.generate_DNA()
population.append(creature)
if genius != None:
population = population[:-1] + [genius]
return population
def generate(self):
for n in range(len(self.population)):
try:
member1, member2 = random.sample(self.mating_pool, 2)
except:
member1, member2 = [DNA(len(self.target)) for _ in range(2)]
child = member1.crossover(member2)
child.mutate(self.mutation_rate)
self.population[n] = child
self.generations += 1
def create_creature(self,
position=None,
creature_information=CreatureInformation(0, None)):
"""create a creature with default parameters"""
if (position is None):
position = (int(random.uniform(0,
400)), int(random.uniform(0, 400)))
information = creature_information
dna = DNA(100, 100, 1, 5)
#print(f"x:{position[0]} y:{position[1]}")
creature = Creature(position, dna, information, self.world)
self.register(creature, position)
return creature
def run(self, pcr_model_path="hybrid_pcr_model.ml", record_path=None, warm_up=True, stagnant_period=None):
population = []
if warm_up:
best_creature = self.create_genius()
else:
best_creature = DNA()
best_creature.generate_DNA()
best_creature.score = -1000000
cgeneration = 0
if stagnant_period == None:
stagnant_period = self.max_generation
# Increase mutation chance if the fitness score not improved over generations
# Reach the mutation limit in half of the stagnant period
mutation_initial_value = self.mutation_chance
mutation_step = (self.mutation_limit - mutation_initial_value) / stagnant_period * 2
for noGeneration in range(0, self.max_generation):
population = self.breed_population(population=population, genius=best_creature)
print(f"-------- Generation={noGeneration} / {self.max_generation} Population={len(population)} --------")
for loc, creature in enumerate(population):
self.eval_fitness_score(creature=creature, pcr_model=self.load_model(pcr_model_path))
print(f"Creature {loc} scores {creature.score:.2f} fitness points")
# Rank the creature fitness scores
population.sort(key=self.getScore, reverse=True)
# Kill the bottom half of the population
population = population[:self.pop_size // 2]
if population[0].score > best_creature.score:
best_creature = population[0].copy()
self.mutation_chance = mutation_initial_value
cgeneration = 0
print(f"*** Generation {noGeneration} new genius scores {best_creature.score} fitness points\n\n")
else:
cgeneration += 1
if self.mutation_chance < self.mutation_limit:
self.mutation_chance += mutation_step
print(f"-------- Stagnant Period = {cgeneration} / {stagnant_period}")
if cgeneration >= stagnant_period:
print(f"WARNING: Population quality has reach its peak. Algorithm ends.\n")
break
print("==============================================================")
print(f"The best creature score is {best_creature.score:.2f} fitness points")
self.export_creature(creature=best_creature,
filepath=record_path[:-4] + f"score{int(best_creature.score)}" + record_path[-4:],
pcr_model_path=pcr_model_path,)
def __init__(self, target):
self.population = []
self.selected_inds = []
self.target = target
self.length = len(target)
self.pop_size = 200
for i in range(self.pop_size):
dna = DNA(self.target)
for j in range(self.length):
num = random.randint(32, 127)
char = chr(num)
dna.genes.append(char)
self.population.append(dna)
def get_a_dna_with_some_structure():
cards = [
ScoreCard(0, 10),
ScoreCard(1, 20),
ScoreCard(2, 30),
ScoreCard(3, 40),
ScoreCard(4, 50),
ScoreCard(5, 60),
ScoreCard(6, 70),
ScoreCard(7, 80),
ScoreCard(8, 90),
ScoreCard(9, 100)
]
return DNA(structure=cards)
def __init__(self, target, mutation_rate, max_pop):
self.target = target
self.mutation_rate = mutation_rate
self.population = [DNA(len(target)) for _ in range(max_pop)]
self.mating_pool = []
self.finished = False
self.perfect_score = len(target)
self.generations = 0
self.best = ""
self.max_fitness = 0
self.calc_fitness()
def __init__(self, dna = -1):
# Genetic
if dna == -1:
self.dna = DNA()
else:
self.dna = deepcopy(dna)
self.dna.mutate()
# Copying evaluation function
m, b = self.dna.eval_data
self.evaluate = lambda x: m * x + b > 0
# Cultural
self.meme = np.random.choice([0, 1], size = str_len)
def read_file(data_list, filename):
""" Reads a file with DNA promoter data
and fills a list with that data.
Args:
data_list (list) : the empty list you want to put data into
filename (str) : path to the file you want to open
"""
with open(filename, newline='') as f:
reader = csv.reader(f, delimiter=' ')
for line in reader:
# splits the line into the part with the promoter and the sequence for easy
# processing
# gene = [field.strip() for field in line.split(' ')]
dna = DNA(line[0], line[1])
# slow way of growing a list but it works for this purpose
data_list.append(dna)
def __init__(self, p, m, num):
self.population = []
self.matingPool = []
self.generations = 0
self.finished = False
self.target = p
self.mutationRate = m
self.perfectScore = 1
self.best = ""
for x in range(num):
self.population.append(DNA(len(self.target)))
self.calcFitness()
def snakes_init(self):
self.snakes = []
for i in range(0, self.population):
if self.dna is None:
snake_dna = DNA()
snake_dna.Q_table = self.load_dna()
self.dna = snake_dna
else:
snake_dna = self.dna
snake = Snake(self.gameDisplay,
self.w,
self.h,
snake_len=SNAKE_LEN,
life=LIFE,
food_energy=FOOD_ENERGY,
dna=snake_dna)
self.snakes.append(snake)
def __init__(self, dna=None):
self.position = pygame.math.Vector2(width / 2, height / 2)
self.velocity = pygame.math.Vector2()
self.acceleration = pygame.math.Vector2()
if dna == None:
self.dna = DNA()
else:
self.dna = dna
self.n = 3
self.r = 10
self.fitness = 0
self.count = 0
self.calculate_angle()
self.re_calculate_points()
def __init__(self, target, dna, id):
self.pos = PVector(width / 2, height)
self.vel = PVector()
self.acc = PVector()
self.reached = False
self.isCollided = False
self.rotMod = 0
self.fitMod = 0
if dna:
self.dna = dna
else:
self.dna = DNA(None)
self.count = 0
self.target = target
self.fitness = 0
self.id = id
self.col = color(0)
def __init__(self, canvas, dna=None):
self.pos = np.array([50, 200]).astype(np.float)
self.vel = np.array([0, 0]).astype(np.float)
self.acc = np.array([0, 0]).astype(np.float)
self.completed = False
self.crashed = False
if (dna is None):
self.dna = DNA()
else:
self.dna = dna
self.fitness = 0
self.size = 5
self.canv = canvas
self.idLine = self.canv.create_line(self.pointsLine, fill="white")
self.id = self.canv.create_oval(self.points,
fill="white",
outline="white")
def create_initial_population(self):
"""
Create an initial population consisting of *population_size*
primitive neural networks with an input-output structure
"""
for individual_i in range(self.population_size):
individual_dna = DNA(Settings.INPUT_SHAPE, Settings.OUTPUT_SHAPE)
individual_dna.create_primitive_structure()
individual_fitness = self.build_and_train_network(individual_dna)
self.population.append(individual_dna)
self.fitness.append(individual_fitness)
self.best_generations_fitness.append(min(self.fitness))
def main():
problem_dataset_dir = os.path.join('Problems', 'Problem5')
solution_dir = os.path.join("Problems", "Problem5Solution")
data_reader = DataReader(problem_dataset_dir)
test_cases, output = data_reader.get_data()
for train_i in range(0, len(output)):
case = test_cases[train_i]
case_output = output[train_i]
pattern = case[0]
genome = case[1]
dna = DNA(genome)
pattern_indices = dna.get_pattern_indices(pattern)
if pattern_indices != case_output:
raise Exception("Output not matched!\nExpecting: " +
str(case_output) + "\nFound: " + pattern_indices)
def main(_):
flags_obj = tf.flags.FLAGS
euler_graph = tf_euler.dataset.get_dataset(flags_obj.dataset)
euler_graph.load_graph()
dims = [flags_obj.hidden_dim] * (flags_obj.layers + 1)
if flags_obj.run_mode == 'train':
metapath = [euler_graph.train_edge_type] * flags_obj.layers
else:
metapath = [euler_graph.all_edge_type] * flags_obj.layers
num_steps = int((euler_graph.total_size + 1) // flags_obj.batch_size *
flags_obj.num_epochs)
model = DNA(dims,
metapath,
euler_graph.feature_idx,
euler_graph.feature_dim,
euler_graph.label_idx,
euler_graph.label_dim,
group_num=flags_obj.group_num,
head_num=flags_obj.head_num)
params = {
'train_node_type': euler_graph.train_node_type[0],
'batch_size': flags_obj.batch_size,
'optimizer': flags_obj.optimizer,
'learning_rate': flags_obj.learning_rate,
'log_steps': flags_obj.log_steps,
'model_dir': flags_obj.model_dir,
'id_file': euler_graph.id_file,
'infer_dir': flags_obj.model_dir,
'total_step': num_steps
}
config = tf.estimator.RunConfig(log_step_count_steps=None)
model_estimator = NodeEstimator(model, params, config)
if flags_obj.run_mode == 'train':
model_estimator.train()
elif flags_obj.run_mode == 'evaluate':
model_estimator.evaluate()
elif flags_obj.run_mode == 'infer':
model_estimator.infer()
else:
raise ValueError('Run mode not exist!')
def import_from_json(self, load):
self.handler.load_file(load)
self.json_object = self.handler.get_data()
self.name = self.json_object["name"]
self.uid = self.json_object["uid"]
self.parents = self.json_object["parents"]
self.personality = self.json_object["personality"]
self.color = self.json_object["color"]
self.happiness = self.json_object["happiness"]
strand = self.json_object["dna"]
self.dna = DNA(strand)
self.handler.close()
logger.logging.info("---Importing Pudgi---")
logger.logging.info("UID: " + str(self.uid))
logger.logging.info("Name: " + self.name)
logger.logging.info("Color: " + self.color)
logger.logging.info("Personality: " + self.personality)
logger.logging.info("Parents: " + str(self.parents))
def main():
problem_dataset_dir = os.path.join('Problems', 'Problem9')
solution_dir = os.path.join("Problems", "Problem9Solution")
data_reader = DataReader(problem_dataset_dir)
test_cases, output = data_reader.get_data()
for train_i in range(0, len(output)):
case = test_cases[train_i]
case_output = output[train_i]
genome = case[0]
k = case[1][0]
d = case[1][1]
dna = DNA(genome)
k_mers = dna.most_frequent_missmatched_k_mer(int(k), int(d))
if set(case_output) != set(k_mers):
raise Exception("Output not matched!\nExpecting: " +
str(case_output) + "\nFound: " + str(k_mers))
def evaluate(self):
max_fitness_gene = heapq.nlargest(1, self.gene_pool)[0]
max_fitness = float(max_fitness_gene.fitness())
mating_pool = []
for gene in self.gene_pool:
num_occurrences = int(gene.fitness() / max_fitness * 100)
for _ in repeat(None, num_occurrences):
mating_pool.append(gene)
for _ in repeat(None, self.POPULATION_SIZE):
parent_0 = mating_pool[random.randint(0, len(mating_pool)-1)]
parent_1 = mating_pool[random.randint(0, len(mating_pool)-1)]
new_gene = DNA(parent_0.crossover(parent_1))
heapq.heappush(self.gene_pool, new_gene)
self.gene_pool = heapq.nlargest(self.POPULATION_SIZE, self.gene_pool)
return self.gene_pool[0]
def main():
problem_dataset_dir = os.path.join('Problems', 'Problem6')
solution_dir = os.path.join("Problems", "Problem6Solution")
data_reader = DataReader(problem_dataset_dir)
test_cases, output = data_reader.get_data()
for train_i in range(0, len(output)):
case = test_cases[train_i]
case_output = output[train_i]
genome = case[0]
k = case[1][0]
l = case[1][1][0]
t = case[1][1][1]
dna = DNA(genome)
clumps_patterns = dna.get_clumps_patterns(int(k), int(t), int(l))
if clumps_patterns.sort() != case_output.sort():
raise Exception("Output not matched!\nExpecting: " +
str(case_output) + "\nFound: " + clumps_patterns)
def __init__(self,
x: float,
y: float,
dna=DNA(),
direction: float = 0.0,
name: str = 'object',
health: int = None):
color = pygame.Color(int(dna.genes[0] * 255), int(dna.genes[1] * 255),
int(dna.genes[2] * 255))
speed = auxiliary.map(dna.genes[3], 0, 1, self.min_speed,
self.max_speed)
size = auxiliary.map(dna.genes[4], 0, 1, self.min_size, self.max_size)
multiply_chance = (auxiliary.map(dna.genes[5], 0, 1,
self.min_s_multiply,
self.max_s_multiply),
auxiliary.map(dna.genes[5], 0, 1,
self.max_a_multiply,
self.min_a_multiply))
vision_radius = auxiliary.map(dna.genes[6], 0, 1, size,
self.max_vision_radius)
super().__init__(x,
y,
size,
speed,
color,
direction,
vision_radius,
name=name,
multiply_chance=multiply_chance,
health=health)
self.dna = dna
# counter for food consumed
self.log("creature created")
self.log(f"health dna creature: {self.health}")
@author: WRShipway
"""
import pandas as pd
from dna import DNA
if __name__ == "__main__":
database_list = ["small" if i < 4 else "large" for i in range(20)]
assert_list = [
"Bob", "No match", "No match", "Alice", "Lavender", "Luna", "Ron",
"Ginny", "Draco", "Albus", "HermioneTest", "Lily", "No match",
"Severus", "Sirius", "No match", "Harry", "No match", "Fred",
"No match"
]
for i in range(len(database_list)):
database = 'databases/{}.csv'.format(database_list[i])
sequence = 'sequences/{}.txt'.format(i + 1)
df_STR = pd.read_csv(database)
df_sequence = pd.read_csv(sequence)
result = DNA(database, sequence)
assert result == assert_list[i], \
"--error in test {}--\nYour program should output '{}'" \
.format((i+1), assert_list[i])
if DNA(database, sequence) != assert_list[i]:
pass
#print("--error in test {}--". format(i+1))
is_staff,
login,
get_user,
)
from common.rpc.auth import is_admin
from common.rpc.slack import post_message
CERTBOT_ARGS = [
"--dns-google",
"--dns-google-propagation-seconds",
"180",
]
app = Flask(__name__)
dna = DNA(
"hosted",
cb_args=CERTBOT_ARGS,
)
if not os.path.exists("data"):
os.makedirs("data")
if not os.path.exists("data/saves"):
os.makedirs("data/saves")
sh("chmod", "666", f"{os.getcwd()}/dna.sock")
@list_apps.bind(app)
@only("buildserver")
def list_apps():
return {
def fitness(agent):
correct = 0
for i in range(LENGTH_TARGET):
if TARGET[i] == agent.dna[i]:
correct += 1
return correct / LENGTH_TARGET
last_population = []
current_population = [[], []] # current_population[0] = agent
# current_population[1] = fitness
for _ in range(POPULATION_SIZE):
agent = DNA(size=LENGTH_TARGET,
random_generator=random_generator.RandomLetterGenerator())
fitness_score = fitness(agent)
current_population[AGENTS].append(agent)
current_population[FITNESS_SCORES].append(fitness_score)
best_dna = ''
while best_dna != TARGET:
last_population = current_population
current_population = [[], []]
for i in range(POPULATION_SIZE):
random_agent, another_random_agent = random.choices(
population=last_population[AGENTS],
weights=last_population[FITNESS_SCORES],
k=2)
child_agent = random_agent.crossover(another_random_agent).mutated(
mutation_rate=0.01)
if pattern_indices != case_output:
raise Exception("Output not matched!\nExpecting: " +
str(case_output) + "\nFound: " + pattern_indices)
print("Passed training data..")
writer = DataWriter(solution_dir)
usage = Usage()
for test_i in range(len(test_cases) - len(output), len(test_cases)):
usage.start()
case = test_cases[test_i]
pattern = case[0]
genome = case[1]
dna = DNA(genome)
pattern_indices = dna.get_pattern_indices(pattern)
usage.end()
writer.write_data(test_i + 1, pattern_indices,
usage.get_execution_time(), usage.get_memory_usage())
print("\n\nInput:\n" + pattern + "\n" + genome)
print("\n\nOutput")
print("=====")
print(pattern_indices)
print("\n")
print("======")
print("Execution Time: " + str(usage.get_execution_time()) + " s")
