def long(generations:int):
data = "/netapp/home/tianjiao.zhang/data/microstates.dat";
targetFreqs = "/netapp/home/tianjiao.zhang/data/ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
ensembleSizes = numpy.array([16, 24, 32, 64, 128]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([-1, 5]);
steepnessRange = numpy.array([1, 7]);
minWeights = numpy.array([0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 1, 1, 1]);
optimizer = Optimizer(MACROSTATES, True);
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readFormattedMicrostateData(data);
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), True, 128, 1.25, 0.25);
search.setMaxIterations(generations);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setAllSearchToTrue();
search.suppressOutputs = True;
optimizer.useAlgorithm(search);
optimizer.optimize();
now = datetime.now();
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "var ensembles " + now.strftime('%Y%m%d%H%M') + ".fasta");
optimizer.writeBestParamsToText("var ensembles " + now.strftime('%Y%m%d%H%M'));
def start(self):
self.input_controller.fault_tolerance_request()
self.input_controller.initial_groups_request()
self.input_controller.blocked_vector_request()
tested_faults = len(max(self.input_controller.initial_groups, key=len))
processors = Processors(self.input_controller.initial_groups)
generator = FormulasGenerator(processors,
self.input_controller.fault_tolerance)
selector = Selector(self.input_controller.blocked_vectors)
tester = PrTester(processors)
blocker = Blocker(self.input_controller.blocked_vectors, tester,
selector, processors)
'''
For original formulas
'''
generator.generate(self.input_controller.initial_groups,
self.original_formulas_file)
optimizer_original = Optimizer(self.input_controller.fault_tolerance,
processors,
self.optimized_original_file)
optimizer_original.optimize(generator.origin_formulas_arr)
blocking_original_formulas = blocker.block_original(
selector.select_group(optimizer_original.result_formulas))
tester.test(self.result_of_testing_original_file,
blocking_original_formulas, tested_faults,
self.input_controller.fault_tolerance)
'''
For researched formulas
'''
self.input_controller.researched_way_request()
if self.input_controller.researched_way:
generator.generate(
processors.form_groups_according_to_blocked_vector(
self.input_controller.blocked_vectors),
self.researched_formulas_file)
optimizer_researched = Optimizer(
self.input_controller.fault_tolerance, processors,
self.optimized_researched_file)
optimizer_researched.optimize(generator.origin_formulas_arr)
#selector.select_group(optimizer_researched.result_formulas)
blocking_researched_formulas = blocker.block_researched(
selector.select_group(optimizer_researched.result_formulas))
tester.test(self.result_of_testing_researched_file,
blocking_researched_formulas, tested_faults,
self.input_controller.fault_tolerance)
self.input_controller.repeat_request()
return self.input_controller.repeat
def smalltestPrevOptimalVals():
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
# only looking at MACROSTATE.TS
# only optimizing backrub temperature and steepness
ensembleSizes = numpy.array([50]);
backrubTemps = numpy.array([1.8]);
boltzmannTemps = numpy.array([0.0]);
steepnessRange = numpy.array([3.0]);
minWeights = numpy.array([0.80, 0.55, 0, 0.90, 0.35, 1.00]);
maxWeights = numpy.array([0.80, 0.55, 0, 0.90, 0.35, 1.00]);
print("Initializing objects\n");
targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqsAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat6.tsv";
dataAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat5.tsv";
optimizer = Optimizer(MACROSTATES);
# slightly different paths on my two computers
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
except:
optimizer.readTargetFrequencies(targetFreqsAlt);
optimizer.readData(dataAlt);
print("Files read in");
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 1, 1, 0.25);
search.setMaxIterations(1);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, False, False, False, numpy.array([False, False, False, False, False, False]));
optimizer.useAlgorithm(search);
#print("Cos similiarity");
#optimizer.optimize();
#optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "testOutCos.fasta");
#print(optimizer.getBestParameters()['match']);
print("\nJS Dist");
#search.setSimilarityMeasure(JensenShannonDistance(optimizer.targetFrequencies));
optimizer.optimize();
now = datetime.now();
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "prev opt vals " + now.strftime('%Y%m%d%H%M') + ".fasta");
optimizer.writeBestParamsToText("prev opt vals " + now.strftime('%Y%m%d%H%M'))
print(optimizer.getBestParameters()['match']);
return None;
def testChi2(iterations = 64):
print("Hello!\n");
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
# only looking at MACROSTATE.TS
# only optimizing backrub temperature and steepness
ensembleSizes = numpy.array([20, 50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 0, 1, 1, 1]);
print("Initializing objects\n");
data = "/netapp/home/tianjiao.zhang/data/DHFR_MSD_M20loop_repeat1.tsv";
#data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat" + str(i + 1) + ".tsv";
#targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqs = "/netapp/home/tianjiao.zhang/data/ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
optimizer = Optimizer(MACROSTATES);
# slightly different paths on my two computers
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
except:
optimizer.readTargetFrequencies(targetFreqsAlt);
optimizer.readData(dataAlt);
print("Files read in");
search = CuckooSearch(optimizer.models, Chi2Kernel(optimizer.targetFrequencies), False, 64, 1, 0.25);
search.setMaxIterations(iterations);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, True, True, True, numpy.array([True, True, False, True, True, True]));
optimizer.useAlgorithm(search);
print("\nChi2 kernel");
#search.setSimilarityMeasure(JensenShannonDistance(optimizer.targetFrequencies));
optimizer.optimize();
now = datetime.now();
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "Chi2 test " + now.strftime('%Y%m%d%H%M%S') + ".fasta");
optimizer.writeBestParamsToText("Chi2 test " + now.strftime('%Y%m%d%H%M%S'));
print(optimizer.getBestParameters()['match']);
return None;
def do_stuff_with_map(map):
# the following code is exactly the same as in do_stuff_with_map in ROSstuff.py
# setting the parameters for the STL specification generator
time_bound = 20
goal = (3, 1)
accuracy = 0.25
time_steps = time_bound + 1
# setting the parameters for the optimizer
initial_state = np.asarray([0.5, 0, 0.5, 0])[:, np.newaxis]
u_guess = np.zeros((2, time_steps)).flatten()
u_guess = np.asarray(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[
0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1
]])
# optimization method
method = 'Powell'
my_reachavoid = ReachAvoid(map, time_bound, goal, accuracy)
ax = my_reachavoid.return_region()
my_finished_specification = my_reachavoid.full_spec
my_optimizer = Optimizer(initial_state, my_finished_specification,
time_bound, time_steps, u_guess, ax)
optimal_trajectory = my_optimizer.optimize(method)
print("robustness: %s" % (my_optimizer.rho(optimal_trajectory)))
my_optimizer.plot_trajectory(optimal_trajectory)
print(my_reachavoid.full_spec)
def testRandUniformInput():
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
# only looking at MACROSTATE.TS
# only optimizing backrub temperature and steepness
ensembleSizes = numpy.array([50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 0, 1, 1, 1]);
print("Initializing objects\n");
targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqsAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
dataAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
optimizer = Optimizer(MACROSTATES);
# slightly different paths on my two computers
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
except:
optimizer.readTargetFrequencies(targetFreqsAlt);
optimizer.readData(dataAlt);
# make energies uniform
for model in optimizer.models:
optimizer.models[model].macrostateResidueEnergies = numpy.ones_like(optimizer.models[model].macrostateResidueEnergies);
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 1, 1, 0.25);
search.setMaxIterations(1);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, False, False, False, numpy.array([False, False, False, False, False, False]));
optimizer.useAlgorithm(search);
outfile = open("uniform energy similarities.txt", 'w');
optimizer.optimize();
outfile.write("JSD: {:.4f}\n".format(optimizer.getBestParameters()['match']));
search.setSimilarityMeasure(CosineSimilarity(optimizer.targetFrequencies));
optimizer.optimize();
outfile.write("Cosine similarity: {:.4f}\n".format(optimizer.getBestParameters()['match']));
search.setSimilarityMeasure(KLDivergence(optimizer.targetFrequencies));
optimizer.optimize();
outfile.write("K-L divergence: {:.4f}\n".format(optimizer.getBestParameters()['match']));
search.setSimilarityMeasure(EntropyWeightsMixedSimilarity(CosineSimilarity(), JensenShannonDistance(), optimizer.targetFrequencies));
optimizer.optimize();
outfile.write("Weighted mixed similarity: {:.4f}\n".format(optimizer.getBestParameters()['match']));
outfile.close();
return None;
def DHFRcomparemeasures(similarity:int):
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
ensembleSizes = numpy.array([20, 50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 0, 1, 1, 1]);
data = "/netapp/home/tianjiao.zhang/data/DHFR_MSD_M20loop_repeat1.tsv";
targetFreqs = "/netapp/home/tianjiao.zhang/data/ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
optimizer = Optimizer(MACROSTATES);
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
measure = "";
if similarity == 0:
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = " JSD";
elif similarity == 1:
search = CuckooSearch(optimizer.models, CosineSimilarity(optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = " Cos";
elif similarity == 2:
search = CuckooSearch(optimizer.models, KLDivergence(optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = " KLD";
elif similarity == 3:
search = CuckooSearch(optimizer.models, EntropyWeightsMixedSimilarity(CosineSimilarity(), JensenShannonDistance(), optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = " Mix"
elif similarity == 4:
search = CuckooSearch(optimizer.models, EntropyWeightedSimilarity(JensenShannonDistance(), optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = "Weighted JSD";
else:
search = CuckooSearch(optimizer.models, Chi2Kernel(optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = "Chi2 kernel";
search.setMaxIterations(2048);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(True, True, True, True, numpy.array([True, True, False, True, True, True]));
optimizer.useAlgorithm(search);
optimizer.optimize();
name = "DHFR compare measures " + measure + " " + datetime.now().strftime('%Y%m%d%H%M');
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), name + ".fasta", 3);
optimizer.writeBestParamsToText(name + ".txt");
def smallTestBoltz():
print("Hello!\n");
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
ensembleSizes = numpy.array([128]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([-1, 5]);
steepnessRange = numpy.array([1, 7]);
minWeights = numpy.array([0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 1, 1, 1]);
print("Initializing objects\n");
targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqsAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
dataMicro = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\microstates.dat";
dataMicroAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\microstates.dat";
optimizer = Optimizer(MACROSTATES, True);
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readFormattedMicrostateData(dataMicro);
except FileNotFoundError:
optimizer.readtargetfrequencies(targetfreqsalt);
optimizer.readFormattedMicrostatedata(datamicroalt);
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), True, 64, 1, 0.25);
search.setMaxIterations(2048);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, True, True, True, numpy.array([True, True, True, True, True, True]));
optimizer.useAlgorithm(search);
optimizer.optimize();
now = datetime.now();
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "var ensembles " + now.strftime('%Y%m%d%H%M') + ".fasta");
optimizer.writeBestParamsToText("var ensembles " + now.strftime('%Y%m%d%H%M'));
#for i in range(8):
# thread = optimizerThread();
# thread.copyOptimizer(optimizer);
# thread.run();
return None;
def start(self):
self.input_controller.fault_tolerance_request()
self.input_controller.initial_groups_request()
self.input_controller.blocked_vector_request()
tested_faults = len(max(self.input_controller.initial_groups, key=len))
processors = Processors(self.input_controller.initial_groups)
generator = FormulasGenerator(processors, self.input_controller.fault_tolerance)
selector = Selector(self.input_controller.blocked_vectors)
tester = PrTester(processors)
blocker = Blocker(self.input_controller.blocked_vectors, tester, selector, processors)
'''
For original formulas
'''
generator.generate(self.input_controller.initial_groups, self.original_formulas_file)
optimizer_original = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_original_file)
optimizer_original.optimize(generator.origin_formulas_arr)
blocking_original_formulas = blocker.block_original(selector.select_group(optimizer_original.result_formulas))
tester.test(self.result_of_testing_original_file, blocking_original_formulas, tested_faults, self.input_controller.fault_tolerance)
'''
For researched formulas
'''
self.input_controller.researched_way_request()
if self.input_controller.researched_way:
generator.generate(processors.form_groups_according_to_blocked_vector(self.input_controller.blocked_vectors), self.researched_formulas_file)
optimizer_researched = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_researched_file)
optimizer_researched.optimize(generator.origin_formulas_arr)
#selector.select_group(optimizer_researched.result_formulas)
blocking_researched_formulas = blocker.block_researched(selector.select_group(optimizer_researched.result_formulas))
tester.test(self.result_of_testing_researched_file,blocking_researched_formulas, tested_faults, self.input_controller.fault_tolerance)
self.input_controller.repeat_request()
return self.input_controller.repeat
def onlyMacro():
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
i = 0;
# only looking at MACROSTATE.TS
# only optimizing backrub temperature and steepness
ensembleSizes = numpy.array([20, 50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 0, 1, 1, 1]);
data = "/netapp/home/tianjiao.zhang/data/DHFR_MSD_M20loop_repeat" + str(i + 1) + ".tsv";
#data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat" + str(i + 1) + ".tsv";
#targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqs = "/netapp/home/tianjiao.zhang/data/ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
optimizer = Optimizer(MACROSTATES);
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 64, 1, 0.25);
measure = " JSD";
search.setMaxIterations(2048);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(True, True, True, True, numpy.array([True, True, False, True, True, True]));
optimizer.useAlgorithm(search);
optimizer.optimize();
name = "Macrostates " + str(i + 1) + measure + datetime.now().strftime('%Y%m%d%H%M');
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), name + ".fasta", 3);
optimizer.writeBestParamsToText(name + ".txt");
return None;
def do_stuff_with_map(map):
# setting the parameters for the STL specification generator
time_bound = 20
goal = (11.1, 8.8)
accuracy = 0.45
time_steps = time_bound + 1
# setting the parameters for the optimizer
initial_state = np.asarray([7.9, 0, 11, 0])[:, np.newaxis]
u_guess = np.zeros((2, time_steps))
# optimization method
method = 'Nelder-Mead'
my_reachavoid = ReachAvoid(map, time_bound, goal, accuracy)
ax = my_reachavoid.return_region()
my_finished_specification = my_reachavoid.full_spec
my_optimizer = Optimizer(initial_state, my_finished_specification,
time_bound, time_steps, u_guess, ax)
optimal_trajectory = my_optimizer.optimize(method)
print("robustness: %s" % (my_optimizer.rho(optimal_trajectory)))
my_optimizer.plot_trajectory(optimal_trajectory)
def main():
# Creating function optimalization model implementing genetic algorithm
opt = Optimizer(target=function,
epochs=EPOCHS,
args_num=N,
x1_range=X1_RANGE,
x2_range=X2_RANGE,
precision=PRECISION,
population_size=POPULATION_SIZE,
type="min")
# Initiation of pupulation
opt.initPopulation()
print(opt.population)
# TEST : Decoding population's chtomosomes
for x in opt.population:
print(x.decode(), ", ", opt.target(x.decode()))
# Evaluating current population
opt.evaluate()
# TEST : Selecting parents
# Truncation
best = opt.truncation(2)
print("TRUNCATION : best = ", best, " decimal : ", best.decode(),
"target : ", best.getTargetValue())
# Tournament
best = opt.tournament(0.3)
print("TOURNAMENT : best = ", best, " decimal : ", best.decode(),
"target : ", best.getTargetValue())
# Roulette
opt.normalizePopulation()
best = opt.roulette()
print("Roulette : best = ", best, " decimal : ", best.decode(),
"target : ", best.getTargetValue())
# Mutation
print("MUTATION : ",
opt.mutate(Chromosome([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 10), 2, 1))
print("MUTATION EDGE : ",
opt.mutateEdge(Chromosome([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 10), 2, 1))
# Generating next generation with truncation
# print("old pop : ", opt.population)
# print("old pop decimal : ", [x.getTargetValue() for x in opt.population])
# opt.nextGen("tournament", 5)
# print("new pop : ", opt.population)
# print("new pop decimal : ", [x.getTargetValue() for x in opt.population])
# Proper optimalization of target function
# opt.initPopulation()
# print("~~~~~~~~~~~~~ OPTIMALIZATION ~~~~~~~~~~~~~~~")
# print("old pop : ", opt.population)
# opt.evaluate()
# print("old pop decimal : ", [x.getTargetValue() for x in opt.population])
# opt.optimize()
# print("new pop : ", opt.population)
# print("new pop decimal : ", [x.getTargetValue() for x in opt.population])
# GENEREAL TEST
opt_test = Optimizer(target=function,
epochs=EPOCHS,
args_num=N,
x1_range=X1_RANGE,
x2_range=X2_RANGE,
precision=PRECISION,
population_size=POPULATION_SIZE,
type="min")
opt_test.initPopulation()
opt_test.optimize()
print("best = ", opt_test.getBest().getTargetValue())
optimizer.readTargetFrequencies(targetFreqs)
optimizer.readData(data)
except:
optimizer.readTargetFrequencies(targetFreqsAlt)
optimizer.readData(dataAlt)
search = CuckooSearch(optimizer.models,
JensenShannonDistance(optimizer.targetFrequencies),
False, 128, 1, 0.25)
search.setMaxIterations(16)
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps,
steepnessRange, minWeights, maxWeights)
search.setSearchParameters(False, True, True, True,
numpy.array([True, True, False, True, True, True]))
optimizer.useAlgorithm(search)
optimizer.optimize()
print("16 iterations | runtime {:s} | match {:.6f}".format(
str(search.elapsedTime),
optimizer.getBestParameters()['match']))
search = CuckooSearch(optimizer.models,
JensenShannonDistance(optimizer.targetFrequencies),
False, 128, 1, 0.25)
search.setMaxIterations(32)
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps,
steepnessRange, minWeights, maxWeights)
search.setSearchParameters(False, True, True, True,
numpy.array([True, True, False, True, True, True]))
optimizer.useAlgorithm(search)
optimizer.optimize()
print("32 iterations | runtime {:s} | match {:.6f}".format(
def simpleRepeatTest():
print("Hello!\n");
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
ensembleSizes = numpy.array([50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 1]);
maxWeights = numpy.array([0, 0, 0, 0, 0, 1]);
print("Initializing objects\n");
targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqsAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
dataAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
dataMicro = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\20160120_M20_enumeration_scores.tsv";
dataMicroAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\20160120_M20_enumeration_scores.tsv";
optimizer = Optimizer(MACROSTATES);
# slightly different paths on my two computers
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
except:
optimizer.readTargetFrequencies(targetFreqsAlt);
optimizer.readData(dataAlt);
print("Files read in");
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 1, 1, 0.25);
search.setMaxIterations(1);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
#search.setSearchParameters(False, True, True, True, numpy.array([True, True, False, True, True, True]));
search.setAllSearchToFalse();
search.suppressOutputs = True;
optimizer.useAlgorithm(search);
print("\nJS Dist");
for i in range(64):
optimizer.optimize();
params = optimizer.getBestParameters();
m = search.population[0];
#print(search.similarityMeasure.getSimilarityMeasure(m.getFrequencies()));
# TODO: getModelByParams doesn't always return the same object.
m1 = Model.constructFromExisting(optimizer.getModelByParams(m.backrubTemp, m.ensembleSize, m.boltzmannTemp), m.ensembleSize, m.backrubTemp, m.boltzmannTemp, m.getWeights(), m.steepness);
#print(search.similarityMeasure.getSimilarityMeasure(m1.getFrequencies()));
if not m.equalTo(m1):
print("\t{:s}".format(Optimizer.calcParamsID(m.backrubTemp, m.ensembleSize, m.boltzmannTemp)));
print("\t{:s}".format(Optimizer.calcParamsID(m1.backrubTemp, m1.ensembleSize, m1.boltzmannTemp)));
#m2 = Model.constructFromExisting(m, m.ensembleSize, m.backrubTemp, m.boltzmannTemp, m.getWeights(), m.steepness);
#print(search.similarityMeasure.getSimilarityMeasure(m2.getFrequencies()));
#print(m.equalTo(m2));
#print(m2.backrubTemp);
#print(m2.boltzmannTemp);
#print(m2.ensembleSize);
#print(m2.steepness);
#print(m2.weights);
#print(search.similarityMeasure.getSimilarityMeasure(m2.getFrequencies()));
#print(numpy.sum(numpy.sum(numpy.abs( m.getFrequencies() - m2.getFrequencies()))));
return None;
def repeatTest():
print("Hello!\n");
MACROSTATES = enum("E-DHF-NADPH", "E-NADPH", "E-OPEN", "E-THF", "E-THF-NADPX", "TS");
RESIDUES = enum('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y');
ensembleSizes = numpy.array([50]);
backrubTemps = numpy.array([0.3, 0.6, 0.9, 1.2, 1.5, 1.8]);
boltzmannTemps = numpy.array([0, -1, 1, 5.0]);
steepnessRange = numpy.array([0.5, 5]);
minWeights = numpy.array([0, 0, 0, 0, 0, 0]);
maxWeights = numpy.array([1, 1, 0, 1, 1, 1]);
print("Initializing objects\n");
targetFreqs = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
targetFreqsAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\ecDHFR_openseq_bacterial_representative_final_align_trim.fasta";
data = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
dataAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\DHFR_MSD_M20loop\\DHFR_MSD_M20loop_repeat1.tsv";
dataMicro = "C:\\Users\\Candy\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\20160120_M20_enumeration_scores.tsv";
dataMicroAlt = "C:\\Users\\Candy_000\\SkyDrive\\Documents\\rotation 2\\20160120_M20_enumeration_scores\\20160120_M20_enumeration_scores.tsv";
optimizer = Optimizer(MACROSTATES);
# slightly different paths on my two computers
try:
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readData(data);
except:
optimizer.readTargetFrequencies(targetFreqsAlt);
optimizer.readData(dataAlt);
print("Files read in");
for i in range(32):
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), False, 8, 1, 0.25);
search.setMaxIterations(16);
search.suppressOutputs = True;
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, True, True, True, numpy.array([True, True, False, True, True, True]));
optimizer.useAlgorithm(search);
print("\nJS Dist");
#search.setSimilarityMeasure(JensenShannonDistance(optimizer.targetFrequencies));
optimizer.optimize();
params = optimizer.getBestParameters();
print(params['match']);
print(optimizer.verifyFoundParams(params['ensembleSize'], params['backrubTemp'], params['boltzmannTemp'], params['steepness'], params['weights']));
search = CuckooSearch(optimizer.models, CosineSimilarity(optimizer.targetFrequencies), False, 8, 1, 0.25);
search.setMaxIterations(16);
search.suppressOutputs = True;
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setSearchParameters(False, True, True, True, numpy.array([True, True, False, True, True, True]));
optimizer.useAlgorithm(search);
print("\nCosine")
optimizer.optimize();
params = optimizer.getBestParameters();
print(params['match']);
print(optimizer.verifyFoundParams(params['ensembleSize'], params['backrubTemp'], params['boltzmannTemp'], params['steepness'], params['weights']));
return None;
# slightly different paths on my two computers
optimizer.readTargetFrequencies(targetFreqs);
optimizer.readFormattedMicrostateData(data);
if similarityMeasure == 0:
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), True, 32, 1, 0.25);
elif similarityMeasure == 1:
search = CuckooSearch(optimizer.models, CosineSimilarity(optimizer.targetFrequencies), True, 32, 1, 0.25);
elif similarityMeasure == 2:
search = CuckooSearch(optimizer.models, KLDivergence(optimizer.targetFrequencies), True, 32, 1, 0.25);
elif similarityMeasure == 3:
search = CuckooSearch(optimizer.models, Chi2Kernel(optimizer.targetFrequencies), True, 32, 1, 0.25);
elif similarityMeasure == 4:
search = CuckooSearch(optimizer.models, EntropyWeightedSimilarity(JensenShannonDistance(), optimizer.targetFrequencies), True, 32, 1, 0.25);
elif similarityMeasure == 5:
search = CuckooSearch(optimizer.models, EntropyWeightsMixedSimilarity(JensenShannonDistance(), CosineSimilarity(), optimizer.targetFrequencies), True, 32, 1, 0.25);
else:
search = CuckooSearch(optimizer.models, JensenShannonDistance(optimizer.targetFrequencies), True, 32, 1, 0.25);
print(search.similarityMeasure.__str__());
search.setMaxIterations(2048);
search.setParamBounds(ensembleSizes, backrubTemps, boltzmannTemps, steepnessRange, minWeights, maxWeights);
search.setAllSearchToTrue();
optimizer.useAlgorithm(search);
optimizer.optimize();
now = datetime.now();
optimizer.writeFrequenciesToFASTA(optimizer.getBestFrequencies(), "Similarity measure compare " + str(similarityMeasure) + now.strftime('%Y%m%d%H%M%S') + ".fasta");
optimizer.writeBestParamsToText("Similarity measure compare " + str(similarityMeasure) + now.strftime('%Y%m%d%H%M%S'));
