def plot(matriz,
legends,
benchmark=None,
titulo='',
titulo_x='',
titulo_y='',
salvar=False,
limites=(0, 0),
dir=''):
x = [i for i in range(1, len(matriz[0]) + 1)]
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, matriz[0], '-.o', label=legends[0])
plt.plot(x, matriz[1], ':x', label=legends[1])
plt.plot(x, matriz[2], '--', label=legends[2])
lgd = plt.legend(loc=2, borderaxespad=0., bbox_to_anchor=(1.05, 1))
plt.title(titulo)
plt.xlabel(titulo_x)
plt.ylabel(titulo_y)
ax.set_ylim(
Benchmark.info(benchmark)[3][0] + limites[0],
Benchmark.info(benchmark)[3][0] + limites[1])
if salvar:
plt.savefig(dir + titulo + '.pdf')
plt.savefig(dir + titulo + '.pdf',
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
plt.show()
def run_benchmarks(self):
print "Executing Benchmarks for " + self.target_path
for bench_name in self.benchmarks:
bench = Benchmark(self.target_path, self.target_path+"/"+bench_name,
self.no_iterations)
bench.run()
self.csv.append(bench.get_csv())
def run_benchmarks(self):
print "Executing Benchmarks for " + self.target_path
for bench_name in self.benchmarks:
bench = Benchmark(self.target_path,
self.target_path + "/" + bench_name,
self.no_iterations)
bench.run()
self.csv.append(bench.get_csv())
def FluidGA(benchmark=Benchmark.rastrigin,
tam_entradas=24,
num_entradas=2,
max_geracoes=250,
populacao_inicial=100,
prob_mut=0.2,
prob_p_flip_bit=0.05,
prob_p_cruz=0.5,
tam_torneio=3):
lim_min, lim_max, pesos, solucoes, str_benchmark = Benchmark.info(
benchmark)
creator.create("avaliacao", base.Fitness,
weights=pesos) ##setando objetivo das avaliacoes ###
creator.create("Individuo", list,
fitness=creator.avaliacao) ##Criando tipo de Individuos
toolbox = base.Toolbox() ## Instanciando objeto Toolbox
toolbox.register(
"ini_gene", random.randint, 0,
1) ## registrando ferramenta para pegar bit ramdomico (0 ou 1)
tam = tam_entradas * num_entradas
toolbox.register(
"individuo", tools.initRepeat, creator.Individuo, toolbox.ini_gene, tam
) ## registrando ferramenta para criar individuo com 48 bits apartir da ferramenta "ini_gene"
toolbox.register(
"populacao", tools.initRepeat, list, toolbox.individuo
) ##registrando ferramenta para criar populacao com base na ferramenta "individuo"
indiv = Benchmark.Benchmark(
num_entradas, tam_entradas, lim_min, lim_max,
benchmark) ##Instanciando Objeto para Benchmark
toolbox.register(
"avaliacao", indiv.fitness
) ##registrando ferramenta para avaliar com base na nossa função fitness do Objeto Benchmark
#toolbox.register("crusar", tools.cxTwoPoint) ##registrando ferramenta para crusar dois individuos
#toolbox.register("mutar", tools.mutFlipBit, indpb=prob_p_flip_bit) ##registrando ferramenta para mutar individuos com chance de mutação de 5%
toolbox.register(
"selecionar", tools.selTournament, tournsize=tam_torneio
) ##registrando ferramenta para selecionar pais em um torneio.
toolbox.register(
"selecao_elitista", tools.selBest
) ##registrando ferramenta para selecionar pais de forma totalmente elitista.
return run_Fluid(toolbox, populacao_inicial, max_geracoes, pesos, solucoes,
tam)
def test_benchmark_none1(self):
input_json = {
'input_size_in_bytes': {
'fastq1': 93520,
'fastq2': 97604,
'bwa_index': 3364568
}
}
with self.assertRaises(B.AppNameUnavailableException):
B.benchmark('some_weird_name', input_json, raise_error=True)
def list_benchmark():
# list
list_results = list()
list_results_manager = ResultsManager()
list_results_manager.collection_name = 'List'
list_results_manager.number_of_operations = num_of_operations
for i in range(0, samples):
print('Progress: ' + str(i) + '/' + str(samples))
benchmark = Benchmark(ListTest(num_of_operations))
list_results.append(benchmark.perform_all_tests())
list_results_manager.save_to_csv(list_results, 'Python_ListTest.csv')
def dict_benchmark():
# dictionary
dictionary_results = list()
dict_results_manager = ResultsManager()
dict_results_manager.collection_name = 'Dictionary'
dict_results_manager.number_of_operations = num_of_operations
for i in range(0, samples):
print('Progress: ' + str(i) + '/' + str(samples))
benchmark = Benchmark(DictionaryTest(num_of_operations))
dictionary_results.append(benchmark.perform_all_tests())
dict_results_manager.save_to_csv(dictionary_results,
'Python_DictionaryTest.csv')
def salvar_resultados_teste(self, dir, titulo, melhores, geracoes_finais,
Max, Avg, Min, nao_convergidos):
file = open(dir + '/' + titulo + '.txt', 'w')
file.write('Resultados do Teste: ' + titulo + '\n')
file.write('\nAtributos do Teste: \n')
file.write(' Benchmark = ' + Benchmark.info(self.benchmark)[4] +
'\n')
file.write(' Número de Testes = ' + str(self.num) + '\n')
file.write(' Número de Testes não convergidos= ' +
str(nao_convergidos) + '\n')
Media, dp, va = media(melhores)
file.write('\nMelhores Individuos: \n')
file.write(' ' + str(melhores) + '\n')
file.write(' Media = ' + str(Media) + '\n')
file.write(' Desvio Padrão = ' + str(dp) + '\n')
file.write(' Variância = ' + str(va) + '\n')
Media, dp, va = media(geracoes_finais)
file.write('\nGerações Finais: \n')
file.write(' ' + str(geracoes_finais) + '\n')
file.write(' Media = ' + str(Media) + '\n')
file.write(' Desvio Padrão = ' + str(dp) + '\n')
file.write(' Variância = ' + str(va) + '\n')
file.close()
print('Arquivo Salvo em: ' + dir + '/' + titulo + '.txt')
def test_benchmark10(self):
input_json = {'input_size_in_bytes': {'input_pairs': 1000000000}}
res = B.benchmark('pairs-patch', input_json)
print(res)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.micro'
def test_benchmark7(self):
input_json = {'input_size_in_bytes': {'input_pairsam': 1000000000}}
res = B.benchmark('pairsam-filter', input_json)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.xlarge'
print(res)
def test_benchmark6(self):
input_json = {'input_size_in_bytes': {'input_pairsam': 1000000000}}
res = B.benchmark('pairsam-markasdup', input_json)
print(res)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'r4.large'
def classifyData(self, algo=None, saveModel=False):
bench = Benchmark()
classifier = None
prediction = None
if algo == SVM_SGD:
classifier = SGDClassifier(n_jobs=-1,
loss='hinge',
penalty='l2',
alpha=1e-5,
n_iter=50,
random_state=42)
# classifier = self.doSVMwithGridSearch()
elif algo == NEURAL_NETWORK:
classifier = sknn.mlp.Classifier(
layers=[ # Sigmoid, Tanh, Rectifier, Softmax, Linear
# sknn.mlp.Layer("Tanh", units=300),
(sknn.mlp.Layer("Linear", units=300) for i in range(2)),
sknn.mlp.Layer("Softmax"),
],
learning_rate=NN_LEARNING_RATE,
n_iter=10,
learning_momentum=.9,
debug=False,
regularize=None, # L1, L2, dropout, and batch normalization.
learning_rule=
'sgd' # sgd, momentum, nesterov, adadelta, adagrad, rmsprop, adam
)
elif algo == RANDOM_FOREST:
classifier = RandomForestClassifier(
n_estimators=NR_FOREST_ESTIMATORS, n_jobs=-1)
elif algo == NAIVE_BAYES:
classifier = MultinomialNB()
classifier.fit(self.dataset.X_train, self.dataset.Y_train)
bench.end('Training Data using: ' + algo)
# save that training model
if saveModel:
joblib.dump(classifier,
'./model/classifier_{}_{}'.format(algo, time.time()),
compress=9)
bench.end('Dumping Classifier Data')
prediction = classifier.predict(self.dataset.X_test)
score = classifier.score(self.dataset.X_test, self.dataset.Y_test)
bench.end('Predicting Data using: ' + algo)
if algo == NEURAL_NETWORK:
prediction = [x[0] for x in prediction]
self.saveResults(prediction, algo, score=score)
def test_benchmark1(self):
res = B.benchmark('md5',
{'input_size_in_bytes': {
'input_file': 200000000
}})
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.micro'
print(res)
def test_benchmark_none2(self):
input_json = {
'input_size_in_bytes': {
'fastq1': 93520,
'fastq2': 97604,
'bwa_index': 3364568
}
}
res = B.benchmark('some_weird_name', input_json)
assert res is None
def run_solver():
if len(sys.argv) > 1 and sys.argv[1] and sys.argv[2]:
assert int(sys.argv[1]) > 0 and int(sys.argv[1]) not in [0, 2, 3]
assert int(sys.argv[2]) > 1
b = Benchmark(int(sys.argv[1]), int(sys.argv[2]))
b.run()
else:
n = int(input("Please insert the number of queens: "))
it = int(input("Please insert the number of iterations: "))
assert it > 1
assert n > 0 and n not in [0, 2, 3]
b = Benchmark(n, it)
b.run()
def run():
config_exo = {
'access': 'EXO84e091ac6a22bf8fb7b916f2',
'secret': '-DU8_52ivubZb0-hdrx788GKtbTjw7r32LUOlFKV_VA'
}
config_aws = {'access': '', 'secret': ''}
provider_exo = Provider(name='exoscale', config=config_exo, region='')
provider_aws = Provider(name='aws', config=config_aws, region='us-east-1')
semaphore = threading.BoundedSemaphore(2)
instance_exo = Instance(provider_exo, 'test', 'Medium',
'Linux Ubuntu 18.04 LTS 64-bit')
instance_aws = Instance(provider_aws, 'COCA-BENCH', 't2.micro',
'ami-0a313d6098716f372')
key = RSA.generate(2048)
keypair = (key.exportKey('PEM'), key.publickey().exportKey('OpenSSH'))
benchmark_exo = Benchmark(instance_exo, keypair, semaphore)
# benchmark_aws = Benchmark(instance_aws, keypair, semaphore)
print "start tests"
benchmark_exo.start()
# benchmark_aws.start()
print "wait threads"
benchmark_exo.join()
# benchmark_aws.join()
print "end"
def full_experiment(self):
total_container = self.width * self.height
for ii in range(5):
self.reinforce(iterations=5, units=5, instances=200, train=True)
self.train_and_update_models()
for ii in range(6, total_container - 5):
print("Training: Currently training on {} units.".format(ii))
self.reinforce(iterations=20, units=ii, instances=2000)
self.buffer.remove_duplicates()
if ii % 3 == 0:
data = self.buffer.get_sample(self.buffer.max_size,
remove=True)
self.policy_net.retrain_model(data)
self.value_net.retrain_model(data)
self.buffer.increase_max_size(0.1)
del data
else:
self.train_and_update_models()
for ii in range(total_container - 5, total_container + 1):
print("Training: Currently training on {} units.".format(ii))
self.reinforce(iterations=20, units=ii, instances=2000)
self.buffer.remove_duplicates()
data = self.buffer.storage
self.policy_net.retrain_model(data)
self.value_net.retrain_model(data)
self.buffer.increase_max_size(0.1)
for ii in range(10):
print("Training with all units. Currently on iteration ",
str(ii + 1))
bm = Benchmark()
bm.benchmark_caserta()
self.reinforce(iterations=10,
units=self.height * self.width,
instances=2000)
self.buffer.remove_duplicates()
self.train_and_update_models()
def run():
parser = argparse.ArgumentParser(description='Run benchmarks in all instances defined by the config file')
parser.add_argument("providers", help='Configuration file describing providers')
parser.add_argument("instances", help='Configuration file describing instances to create and benchmark')
parser.add_argument("--nThreads", type=int, help='Number of threads to start')
parser.add_argument("--keyLength", type=int, default=2048, help='Length of the generated SSH key')
args = parser.parse_args()
key = RSA.generate(2048)
keypair = (key.exportKey('PEM'), key.publickey().exportKey('OpenSSH'))
pkey_name = "coca-bench.pem"
os.system("chmod 777 " + pkey_name)
file1 = open(pkey_name, "w")
file1.write(keypair[0])
file1.close()
os.system("chmod 400 " + pkey_name)
providers_config = ConfigParser.ConfigParser()
providers_config.read(args.providers)
instances_config = ConfigParser.ConfigParser()
instances_config.read(args.instances)
nthreads = len(instances_config.sections())
if args.nThreads is not None:
nthreads = args.nThreads
semaphore = threading.BoundedSemaphore(nthreads)
jobs = list()
for instance_name in instances_config.sections():
provider_name = instances_config.get(instance_name, "provider")
flavor = instances_config.get(instance_name, "flavor")
image = instances_config.get(instance_name, "image")
provider_data = dict(providers_config.items(provider_name))
username = None
if instances_config.has_option(instance_name, "username"):
username = instances_config.get(instance_name, "username")
region = instances_config.get(instance_name, "region")
provider = Provider(provider_name, region, provider_data)
instance = Instance(provider, instance_name, flavor, image, username)
bench = Benchmark(instance, keypair, semaphore)
jobs.append(bench)
for job in jobs:
job.start()
for job in jobs:
job.join()
print("all threads are finished")
def test_benchmark2(self):
res = B.benchmark(
'fastqc-0-11-4-1', {
'input_size_in_bytes': {
'input_fastq': 20000000000
},
'parameters': {
'threads': 2
}
})
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.medium'
print(res)
def test_benchmark4(self):
res = B.benchmark(
'pairsam-parse-sort', {
'input_size_in_bytes': {
'bam': 1000000000
},
'parameters': {
'nThreads': 16
}
})
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'c4.8xlarge'
print(res)
def test_benchmark5(self):
input_json = {
'input_size_in_bytes': {
'input_pairsams': [1000000000, 2000000000, 3000000000]
},
'parameters': {
'nThreads': 32
}
}
res = B.benchmark('pairsam-merge', input_json)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'c4.8xlarge'
print(res)
def test_benchmark9(self):
input_json = {
'input_size_in_bytes': {
'input_pairs': [1000000000, 2000000000, 3000000000]
},
'parameters': {
'ncores': 16,
'maxmem': '1900g'
}
}
res = B.benchmark('hi-c-processing-partb', input_json)
print(res)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'x1.32xlarge'
def test_benchmark11(self):
input_json = {
'input_size_in_bytes': {
'input_cool': 1000000000,
'input_hic': 2000000000
},
'parameters': {
'ncores': 1
}
}
res = B.benchmark('hi-c-processing-partc', input_json)
print('hi-c-processing-partc')
print(res)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'r4.large'
def test_benchmark3(self):
input_json = {
'input_size_in_bytes': {
'fastq1': 93520000,
'fastq2': 97604000,
'bwa_index': 3364568000
},
'parameters': {
'nThreads': 4
}
}
res = B.benchmark('bwa-mem', input_json)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.xlarge'
print(res)
def classifyData(self, algo=None, saveModel=False):
bench = Benchmark()
classifier = None
prediction = None
if algo == SVM_SGD:
classifier = SGDClassifier(n_jobs=-1, loss='hinge', penalty='l2', alpha=1e-5, n_iter=50, random_state=42)
# classifier = self.doSVMwithGridSearch()
elif algo == NEURAL_NETWORK:
classifier = sknn.mlp.Classifier(
layers=[ # Sigmoid, Tanh, Rectifier, Softmax, Linear
# sknn.mlp.Layer("Tanh", units=300),
(sknn.mlp.Layer("Linear", units=300) for i in range(2)),
sknn.mlp.Layer("Softmax"),
],
learning_rate=NN_LEARNING_RATE,
n_iter=10,
learning_momentum=.9,
debug=False,
regularize=None, # L1, L2, dropout, and batch normalization.
learning_rule='sgd' # sgd, momentum, nesterov, adadelta, adagrad, rmsprop, adam
)
elif algo == RANDOM_FOREST:
classifier = RandomForestClassifier(n_estimators=NR_FOREST_ESTIMATORS, n_jobs=-1)
elif algo == NAIVE_BAYES:
classifier = MultinomialNB()
classifier.fit(self.dataset.X_train, self.dataset.Y_train)
bench.end('Training Data using: ' + algo)
# save that training model
if saveModel:
joblib.dump(classifier, './model/classifier_{}_{}'.format(algo, time.time()), compress=9)
bench.end('Dumping Classifier Data')
prediction = classifier.predict(self.dataset.X_test)
score = classifier.score(self.dataset.X_test, self.dataset.Y_test)
bench.end('Predicting Data using: ' + algo)
if algo == NEURAL_NETWORK:
prediction = [x[0] for x in prediction]
self.saveResults(prediction, algo, score=score)
def salvar_resultados(titulo, entrada, GAs, benchmark, dir=''):
dir = criar_dir(dir + 'Test - ' + titulo)
file = open(dir + '/' + titulo + '_info' + '.csv', 'w')
file.write('Resultados do Teste:, ' + titulo + '\n')
file.write('\nAtributos do Teste: \n')
file.write('Benchmark ,' + Benchmark.info(benchmark)[4] + '\n')
file.write('Número de Testes ,' + str(len(entrada[0])) + '\n')
file.write('\n\nAlgoritimo, Média, Desvio Padrão, Variância\n')
for i in range(len(entrada)):
med, desv, var = media(entrada[i])
file.write(
str(GAs[i]) + ',' + str(med) + ',' + str(desv) + ',' + str(var) +
'\n')
file.close()
print('Arquivo Salvo em: ' + dir + '/' + titulo + '_info' + '.csv')
def test_benchmark13(self):
input_json = {
'input_size_in_bytes': {
'input_pairs': [1000000000, 2000000000, 3000000000]
},
'parameters': {
'nthreads': 8,
'maxmem': '32g'
}
}
res = B.benchmark('hi-c-processing-pairs', input_json)
print('hi-c-processing-pairs')
print("benchmark13")
print(res)
assert 'aws' in res
assert res['min_CPU'] == 8
assert int(res['total_mem_in_MB']) == 45776
assert int(res['total_size_in_GB']) == 97
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 'r4.2xlarge'
def test_benchmark12(self):
input_json = {
'input_size_in_bytes': {
'input_bams': [1000000000, 2000000000],
'chromsize': 200000
},
'parameters': {
'nthreads_parse_sort': 1,
'nthreads_merge': 8
}
}
res = B.benchmark('hi-c-processing-bam', input_json)
print('hi-c-processing-bam')
print("benchmark12")
print(res)
assert 'aws' in res
assert 'recommended_instance_type' in res['aws']
assert res['aws']['recommended_instance_type'] == 't2.2xlarge'
assert res['min_CPU'] == 8
assert int(res['total_size_in_GB']) == 55
__author__ = 'Raphael'
SGD_CLASSIFIER_LOSS_OPTIONS = (
'hinge',
'log',
'modified_huber',
'squared_hinge',
'perceptron',
)
# REVIEW_DATA = './data/Season-1.csv'
REVIEW_DATA = './data/All-seasons.csv'
if __name__ == '__main__':
bench = Benchmark()
textAnalzyer = TextAnalyzer(REVIEW_DATA)
bench.end('Initializing')
textAnalzyer.createDataFrame(nameFilter=[
'Kyle', 'Stan', 'Kenny', 'Cartman', 'Butters', 'Jimmy', 'Timmy'
])
bench.end('Reading CSV')
textAnalzyer.cleanData()
bench.end('Cleaning Data')
textAnalzyer.splitData()
bench.end('Generating Test and Training Data')
message = 'Please insert a name-prefix for all stated vms (default is "TEST"): '
vm_name = raw_input(message+"\n:-> ").strip()
vm_name = vm_name.strip()
if vm_name == "": vm_name = "TEST"
message = 'Please insert a wait-time between the vm startups (default is 5.0 [sec]): '
wait_time = raw_input(message+"\n:-> ").strip()
if wait_time == "":
wait_time = 0.0
else:
wait_time = float(wait_time)
B1 = Benchmark()
B1.debug = False
B1.vm_amount = vm_amount
B1.flavor = flavor
B1.vm_name = vm_name
B1.wait_time = wait_time
B1.setImageId(image_id)
B1.startVMs()
image_ids = B1.getImageIds()
print "\nFor deletion of the started vms, use the these commands (copy/paste):\n"
for id in image_ids:
print "nova delete "+id
# generate_images.create_runtime_num_test(data_name, num_test_list, run_time_results)
if len(sys.argv) != 3:
print("Needs 2 arguments:\n"
"arg 1 - chrom_sizes_file\n"
"arg 2 - bigWig file")
exit(-1)
chrom_name = 'chr1'
start_time = time.time()
bedGraph = BedGraph(sys.argv[1], sys.argv[2], chrom_name)
print("Time for loading bedGraph file: ", time.time() - start_time)
start_time = time.time()
print(f"Time for loading {chrom_name}: ", time.time() - start_time, '\n')
bench = Benchmark(bedGraph, sys.argv[2])
data_name = Path(sys.argv[2]).stem
if not os.path.isdir(f'graphs'):
os.mkdir(f'graphs')
if not os.path.isdir(f'graphs/{data_name}'):
os.mkdir(f'graphs/{data_name}')
# runtime_benchmark()
interval_size_error_benchmark()
# interval_size_runtime_benchmark()
from sklearn.pipeline import Pipeline
from Benchmark import Benchmark
from TextAnalyzer import TextAnalyzer
__author__ = 'Raphael'
SGD_CLASSIFIER_LOSS_OPTIONS = ('hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron',)
# REVIEW_DATA = './data/Season-1.csv'
REVIEW_DATA = './data/All-seasons.csv'
if __name__ == '__main__':
bench = Benchmark()
textAnalzyer = TextAnalyzer(REVIEW_DATA)
bench.end('Initializing')
textAnalzyer.createDataFrame(nameFilter=['Kyle', 'Stan', 'Kenny', 'Cartman', 'Butters', 'Jimmy',
'Timmy'])
bench.end('Reading CSV')
textAnalzyer.cleanData()
bench.end('Cleaning Data')
textAnalzyer.splitData()
bench.end('Generating Test and Training Data')
textAnalzyer.determineBestParams()
def teste(self):
melhores = []
geracoes_finais = []
nao_convergidos = 0
for i in range(self.num):
print('Fazendo Teste Número ({})'.format(i))
if (self.algoritmo == TrangenicGA.trangenicGA):
melhor, geracao_f, Max, Avg, Min = self.algoritmo(
self.benchmark, self.tam_entradas, self.num_entradas,
self.max_geracoes, self.populacao_inicial, self.prob_mut,
self.prob_p_flip_bit, self.prob_p_cruz, self.tam_torneio,
self.fator_aprox_histo)
melhores.append(melhor)
geracoes_finais.append(geracao_f)
if geracao_f == self.max_geracoes:
nao_convergidos = nao_convergidos + 1
titulo, eixo_x_M, eixo_y_M, eixo_x_G, eixo_y_G = 'Transgenic GA with ' + Benchmark.info(
self.benchmark
)[4], 'Number of the Test', 'Evaluation of the Best Individual', 'Number of the Test', 'Final Generation'
elif self.algoritmo == Theory_Of_ChaosGA.chaosGA:
melhor, geracao_f, Max, Avg, Min = self.algoritmo(
self.benchmark, self.tam_entradas, self.num_entradas,
self.max_geracoes, self.populacao_inicial, self.prob_mut,
self.prob_p_flip_bit, self.tam_torneio)
melhores.append(melhor)
geracoes_finais.append(geracao_f)
if geracao_f == self.max_geracoes:
nao_convergidos = nao_convergidos + 1
titulo, eixo_x_M, eixo_y_M, eixo_x_G, eixo_y_G = 'Theory of Chaos GA with ' + Benchmark.info(
self.benchmark
)[4], 'Number of the Test', 'Evaluation of the Best Individual', 'Number of the Test', 'Final Generation'
elif self.algoritmo == GABasico.GAbasico:
melhor, geracao_f, Max, Avg, Min = self.algoritmo(
self.benchmark, self.tam_entradas, self.num_entradas,
self.max_geracoes, self.populacao_inicial, self.prob_mut,
self.prob_p_flip_bit, self.prob_p_cruz, self.tam_torneio)
melhores.append(melhor)
geracoes_finais.append(geracao_f)
if geracao_f == self.max_geracoes:
nao_convergidos = nao_convergidos + 1
titulo, eixo_x_M, eixo_y_M, eixo_x_G, eixo_y_G = 'Basic GA with ' + Benchmark.info(
self.benchmark
)[4], 'Number of the Test', 'Evaluation of the Best Individual', 'Number of the Test', 'Final Generation'
elif self.algoritmo == HomogeneousGA.homogeneousGA:
melhor, geracao_f, Max, Avg, Min = self.algoritmo(
self.benchmark, self.tam_entradas, self.num_entradas,
self.max_geracoes, self.populacao_inicial, self.prob_mut,
self.prob_p_flip_bit, self.prob_p_cruz, self.tam_torneio,
self.fator_aprox_histo)
melhores.append(melhor)
geracoes_finais.append(geracao_f)
if geracao_f == self.max_geracoes:
nao_convergidos = nao_convergidos + 1
titulo, eixo_x_M, eixo_y_M, eixo_x_G, eixo_y_G = 'Transgenic GA with ' + Benchmark.info(
self.benchmark
)[4], 'Number of the Test', 'Evaluation of the Best Individual', 'Number of the Test', 'Final Generation'
elif self.algoritmo == FluidGA.FluidGA:
melhor, geracao_f, Max, Avg, Min = self.algoritmo(
self.benchmark, self.tam_entradas, self.num_entradas,
self.max_geracoes, self.populacao_inicial, self.prob_mut,
self.prob_p_flip_bit, self.prob_p_cruz, self.tam_torneio)
melhores.append(melhor)
geracoes_finais.append(geracao_f)
if geracao_f == self.max_geracoes:
nao_convergidos = nao_convergidos + 1
titulo, eixo_x_M, eixo_y_M, eixo_x_G, eixo_y_G = 'Basic GA with ' + Benchmark.info(
self.benchmark
)[4], 'Number of the Test', 'Evaluation of the Best Individual', 'Number of the Test', 'Final Generation'
dir = 'Test - ' + titulo
if self.salvar:
dir = criar_dir(dir)
self.salvar_resultados_teste(dir, titulo, melhores,
geracoes_finais, Max, Avg, Min,
nao_convergidos)
self.plot(melhores, "Best Individuals - " + titulo, eixo_x_M, eixo_y_M,
self.salvar, dir)
self.plot(geracoes_finais, "Final Generations - " + titulo, eixo_x_G,
eixo_y_G, self.salvar, dir)
return melhores, geracoes_finais, nao_convergidos
}
)
output.to_csv("./results/{}.csv".format(classifierName), index=False)
logger.info('Accuracy: {} %'.format(round(kwargs['score'] * 100, 3)))
def optimizeParams(self):
self.params = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': (True, False),
'clf__alpha': (1e-1, 1e-2, 1e-3),
}
if __name__ == '__main__':
bench = Benchmark()
anal = TextAnalyzer(REVIEW_DATA)
bench.end('Initializing')
anal.createDataFrame(nameFilter=['Kyle', 'Stan', 'Kenny', 'Cartman', 'Butters', 'Jimmy',
'Timmy'])
bench.end('Reading CSV')
anal.cleanData() # Prepare data in a format that is good for scikitlearn
bench.end('Cleaning Data')
anal.vectorizeData(scheme='bagofwords')
bench.end('Generating Bag of Words Representation')
anal.genTfIdf() #
import Initializer, Mutator, Recombiner, Selector, Replacer, Terminator, LocalSearcher
from GeneticAlgorithm import GeneticAlgorithm
from ProblemDefinition import ProblemDefinition
from Benchmark import Benchmark
# Choose your operators
initializer = Initializer.RandomInitializer()
mutator = Mutator.RandomMutator(0.2, dynAdapt=True)
recombiner = Recombiner.CrossoverRecombiner()
selector = Selector.TournamentSelector(s=20, dynAdapt=True)
replacer = Replacer.bottomReplacer()
terminator = Terminator.maxRuntimeTerminator(10)
# Add a local searcher if you want LocalSearcher.Idle() does nothing
localSearcher = LocalSearcher.Idle()
# Set up an example problem
nrMachines, jobRuntimes = Benchmark.benchmark1()
probDef = ProblemDefinition(nrMachines, jobRuntimes)
# Set up GA parameters
popSize = 100
nrOffspring = int(popSize / 10)
# Create Genetic Algorithm instance
GA = GeneticAlgorithm(initializer, selector, recombiner, mutator, replacer,
terminator, probDef, popSize, nrOffspring, localSearcher)
bestIndividual, results = GA.run()
print("best Individuals fitness: ", bestIndividual.fitness)
