def fitness(*params): # Preprocessing parameters for different experiments if experiment == "bayesianCNN": es = EarlyStopping( monitor='val_loss', patience=Config.get("ESValPatience"), min_delta=Config.get("ESValMinDelta"), baseline=Config.get("ESValThresholdBaseline")) model, hist = training_func(root_logger, X_train_int, y_train_int, X_val, y_val, es, *params[0]) else: hidden_layers_comb = get_hidden_layers_combinations( BOconfig["hiddenLayers"], 3, BOconfig["allowFirstLevelZero"]) model, hist = training_func(root_logger, X_train_int, y_train_int, X_val, y_val, features_size, hidden_layers_comb, *params[0]) del model K.clear_session() val_auprc = hist.history['val_auprc'][-1] root_logger.debug( "BAYESIAN OPTIMIZER - Validation auprc: {}".format( val_auprc)) return -val_auprc
def train_fixed_cnn(root_logger, X_train_int, y_train_int, X_val, y_val, type): model = fixed_cnn(type) #nadam_opt = Nadam(lr=0.002, beta_1=0.9, beta_2=0.999) nadam_opt = Nadam(lr="learningRate", beta_1="nadamBeta1", beta_2="nadamBeta2") model.compile(loss='binary_crossentropy', optimizer=nadam_opt, metrics=[auprc, auroc]) es = EarlyStopping(monitor='val_loss', patience=Config.get("ESPatience"), min_delta=Config.get("ESMinDelta")) validation_set = None if X_val is not None and y_val is not None: y_val = encoding_labels(y_val) validation_set = (X_val, y_val) y_train_int = encoding_labels(y_train_int) history = model.fit(x=X_train_int, y=y_train_int, validation_data=validation_set, epochs=Config.get('epochs'), batch_size=Config.get("batchSize"), callbacks=[es], verbose=Config.get("kerasVerbosity")) return model, history
def sendToPostEndpoint(fileName): directory = Config.paths('DIRECTORY_TO_MONITOR') user = Config.dev('USERNAME') password = Config.dev('PASSWORD') file = open(directory + fileName, 'rb') url = 'http://localhost:8080/postRule' files = {'file': file} r = requests.post(url, files=files, auth=(user, password)) print("uploaded: " + fileName + "-- response from server: " + str(r))
def main(): #print (Config.paths('DIRECTORY_TO_MONITOR')) #print (Config.dev('USERNAME')) #print (Config.dev('PASSWORD')) print("starting reading of directory:" + Config.paths('DIRECTORY_TO_MONITOR')) #initial scan of the local directory files = os.listdir(Config.paths('DIRECTORY_TO_MONITOR')) initialRulesProcessing(files) #initiate watcher class instance and update database as changes are made w = Watcher() w.run()
def fitness_mlp(kernel_space_1, units_2, kernel_space_2, dense_1, dense_2): es = EarlyStopping(monitor='val_loss', patience=Config.get("ESValPatience"), min_delta=Config.get("ESValMinDelta"), baseline=0.2) model, hist = train_bayesian_cnn(X_train_int, y_train_int, (X_val, y_val), es, kernel_space_1, units_2, kernel_space_2, dense_1, dense_2) val_auprc = hist.history['val_auprc'][-1] print() print("Validation Loss: {}".format(val_auprc)) print() return -val_auprc
def __init__(self, file_path): """Initializes the provisioning handler Arguments: file_path {string} -- path to your configuration file """ #Logging logging.basicConfig(level=logging.ERROR) self.logger = logging.getLogger(__name__) #Load configuration settings from config.ini config = Config(file_path) self.config_parameters = config.get_section('SETTINGS') self.secure_cert_path = self.config_parameters['SECURE_CERT_PATH'] self.iot_endpoint = self.config_parameters['IOT_ENDPOINT'] self.template_name = self.config_parameters['PRODUCTION_TEMPLATE'] self.rotation_template = self.config_parameters['CERT_ROTATION_TEMPLATE'] self.claim_cert = self.config_parameters['CLAIM_CERT'] self.secure_key = self.config_parameters['SECURE_KEY'] self.root_cert = self.config_parameters['ROOT_CERT'] # Sample Provisioning Template requests a serial number as a # seed to generate Thing names in IoTCore. Simulating here. self.unique_id = "1234567-abcde-fghij-klmno-1234567abc-TLS350" self.unique_id = str(int(round(time.time() * 1000))) # ------------------------------------------------------------------------------ # -- PROVISIONING HOOKS EXAMPLE -- # Provisioning Hooks are a powerful feature for fleet provisioning. Most of the # heavy lifting is performed within the cloud lambda. However, you can send # device attributes to be validated by the lambda. An example is show in the line # below (.hasValidAccount could be checked in the cloud against a database). # Alternatively, a serial number, geo-location, or any attribute could be sent. # # -- Note: This attribute is passed up as part of the register_thing method and # will be validated in your lambda's event data. # ------------------------------------------------------------------------------ self.primary_MQTTClient = AWSIoTMQTTClient(self.unique_id) self.test_MQTTClient = AWSIoTMQTTClient(self.unique_id) self.primary_MQTTClient.onMessage = self.on_message_callback self.callback_returned = False self.message_payload = {} self.isRotation = False
def train_bayesian_cnn(root_logger, X_train_int, y_train_int, X_val, y_val, es, ks1, u2, ks2, d1, d2): root_logger.debug("Kernel space 1: {}".format(ks1)) root_logger.debug("Units 2: {}".format(u2)) root_logger.debug("Kernel space 2: {}".format(ks2)) root_logger.debug("Dense 1: {}".format(d1)) root_logger.debug("Dense 2: {}".format(d2)) model = bayesian_cnn(kernel_size_1=ks1, units_2=u2, kernel_size_2=ks2, dense_units_1=d1, dense_units_2=d2) parallel_model = multi_gpu_model(model, gpus=4) nadam_opt = Nadam(lr=0.002, beta_1=0.9, beta_2=0.999) parallel_model.compile(loss='binary_crossentropy', optimizer=nadam_opt, metrics=[auprc, auroc]) # Building dataset validation_set = None if X_val is not None and y_val is not None: y_val = encoding_labels(y_val) validation_set = (X_val, y_val) y_train_int = encoding_labels(y_train_int) history = parallel_model.fit(x=X_train_int, y=y_train_int, validation_data=validation_set, epochs=Config.get('epochs'), batch_size=Config.get("batchSize"), callbacks=[es], verbose=Config.get("kerasVerbosity")) return parallel_model, history
def upload(): name = request.values['name'] data = request.values['data'] if name and data: path = Path(Config.files("download_path")) with open(path / name, 'w') as file: file.write(data) return "File created !" else: return "Parameters missing or wrong."
def get_logger(exp): logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) format_string = "%(asctime)s — %(message)s" log_format = logging.Formatter(format_string) # Creating and adding the console handler console_handler = logging.StreamHandler(sys.stdout) console_handler.setFormatter(log_format) logger.addHandler(console_handler) # Creating and adding the file handler file_handler = logging.FileHandler( "{}/{}_{}.log".format(Config.get("logDir"), time.strftime("%Y%m%d-%H%M%S"), exp), mode='a') file_handler.setFormatter(log_format) logger.addHandler(file_handler) return logger
def train_bayesian_mlp(root_logger, X_train_int, y_train_int, X_val, y_val, features_size, hidden_layers_comb, learning_rate, num_hidden_layer, hidden_layer_choice): if num_hidden_layer > 0: hidden_layer_choice = int(hidden_layer_choice * len(hidden_layers_comb[num_hidden_layer]) / len(hidden_layers_comb[-1])) hidden_layer_configuration = hidden_layers_comb[num_hidden_layer][hidden_layer_choice] else: hidden_layer_configuration = [] root_logger.debug("Training with parameters: ") root_logger.debug('Learning rate: {}'.format(learning_rate)) root_logger.debug('number of hidden layers: {}'.format(num_hidden_layer)) root_logger.debug('hidden layers configuration: {}'.format(hidden_layer_configuration)) model = bayesian_mlp(features_size, hidden_layer_configuration) parallel_model = multi_gpu_model(model, gpus=4) sgd_opt = SGD(lr=learning_rate, decay=Config.get('decay'), momentum=Config.get('momentum'), nesterov=Config.get('nesterov')) parallel_model.compile(loss='binary_crossentropy', optimizer=sgd_opt, metrics=[auprc, auroc]) es = EarlyStopping(monitor='val_loss', patience=Config.get("ESTestPatience"), min_delta=Config.get("ESTestMinDelta")) validation_set = None if X_val is not None and y_val is not None: y_val = encoding_labels(y_val) validation_set = (X_val, y_val) y_train_int = encoding_labels(y_train_int) history = parallel_model.fit(x=X_train_int, y=y_train_int, validation_data=validation_set, epochs=Config.get('epochs'), batch_size=Config.get("batchSize"), callbacks=[es], verbose=Config.get("kerasVerbosity"), workers=Config.get("fitWorkers")) return parallel_model, history
class Watcher: #DIRECTORY_TO_WATCH = "/Users/xai/rules/" directory = Config.paths('DIRECTORY_TO_MONITOR') def __init__(self): self.observer = Observer() def run(self): event_handler = Handler() self.observer.schedule(event_handler, self.directory, recursive=True) self.observer.start() try: while True: time.sleep(10) except: self.observer.stop() print("Error in running program") self.observer.join()
def main(): # initialize core objects scraper = Scraper(Config.praw('CLIENT_ID'), Config.praw('CLIENT_SECRET'), Config.praw('USER_AGENT'), Config.praw('USERNAME'), Config.praw('PASSWORD')) parser = Parser() notifier = Notifier(Config.twilio('ACCOUNT_SID'), Config.twilio('AUTH_TOKEN')) # initialize time for loop startTime = time.time() while True: try: # grab last 100 new mechmarket posts posts = scraper.grabNewPosts('mechmarket', 100) # loop through posts for post in posts: have = parser.parseHave(post.title) # does this need the or? or is the search case insensitive? if parser.keywordSearch('milkshake', have) or parser.keywordSearch( 'Milkshake', have): # notify if we found it notify(notifier, post, f'Milkshake found '\ f'{post.title} '\ f'{post.url} ') # sleep for 60 seconds time.sleep(60.0 - ((time.time() - startTime) % 60.0)) print( f'Starting new loop at {time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())}' ) except: # disable during testing # notifier.sendMessage('8042100901','17572092974','Something broke and the bot has stopped') break
def fixed_cnn_exp(gene, mode): X, y, features_size = filter_by_tasks(*import_sequence_dataset( "data", gene), Config.get("task"), perc=Config.get("samplePerc")) metrics = {'losses': [], 'auprc': [], 'auroc': []} for ext_holdout in range(Config.get("nExternalHoldout")): print() print("{}/{} EXTERNAL HOLDOUTS".format(ext_holdout, Config.get("nExternalHoldout"))) print() X_train, X_test, y_train, y_test = split(X, y, random_state=42, proportions=None, mode=mode) # Internal holdouts X_train_int, X_val, y_train_int, y_val = split(X_train, y_train, random_state=42, proportions=None, mode=mode) model, _ = train_fixed_cnn(X_train_int, y_train_int, (X_val, y_val), Config.get("type")) #external holdout model, history = train_fixed_cnn(X_train_int, y_train_int, None, Config.get("type")) eval_score = model.evaluate(X_test, y_test) print("Metrics names: ", model.metrics_names) print("Final Scores: ", eval_score) metrics['losses'].append(eval_score[0]) metrics['auprc'].append(eval_score[1]) metrics['auroc'].append(eval_score[2]) return metrics
import shutil import time import numpy as np from config_loader import Config from src.bayesian_cnn_exp import bayesian_cnn_exp from src.bayesian_mlp_exp import bayesian_mlp_exp from src.fixed_cnn_exp import fixed_cnn_exp from src.utilities import build_log_filename exp = {"bMLP": bayesian_mlp_exp, "fixedCNN": fixed_cnn_exp, "bayesianCNN": bayesian_cnn_exp} gene = Config.get("gene") mode = Config.get("mode") experiment = Config.get("experiment") f = exp[experiment] metrics = f(gene, mode) #Saving results metrics np.save(build_log_filename(), metrics) # copying the configuration json file with experiments details dest = "experiment_configurations/{}_{}_{}_experiment_configuration.json".format( time.strftime("%Y%m%d-%H%M%S"), gene, mode ) shutil.copy("experiment_configurations/experiment.json", dest)
import numpy as np from keras.callbacks import EarlyStopping from skopt import gp_minimize from skopt.callbacks import DeltaYStopper from config_loader import Config from keras import backend as K from src.dataset_utils import get_data, split, encoding_labels, filter_by_tasks from src.logging_utils import save_metrics, copy_experiment_configuration, get_logger from src.models import get_training_function from src.utilities import get_parameters_space, get_hidden_layers_combinations if __name__ == "__main__": experiment = Config.get("experiment") root_logger = get_logger(experiment) genes = Config.get("gene") modes = Config.get("mode") tasks = Config.get("task") for gene in genes: root_logger.debug("IMPORTING DATA") X, y = get_data(experiment, "data", gene, Config.get("samplePerc")) features_size = len(X[0]) for task in tasks: for mode in modes: root_logger.debug( "EXPERIMENT: {}, GENE: {}, MODE: {}\nTASK: {}".format(
def adminhome(): cur = cnxn.cursor() result = cur.execute("Select * from Things") rows = result.fetchall() data = [] for row in rows: data.append(list(row)) return jsonify({'result':data}), status.HTTP_200_OK ######### Provisioning certificate ##################### #Set Config path CONFIG_PATH = 'config.ini' config = Config(CONFIG_PATH) config_parameters = config.get_section('SETTINGS') secure_cert_path = config_parameters['SECURE_CERT_PATH'] bootstrap_cert = config_parameters['CLAIM_CERT'] def callback(payload): print(payload) card = "" @app.route('/provisioning-cert',methods=['POST']) def run_provisioning(isRotation=False): provisioner = ProvisioningHandler(CONFIG_PATH) if isRotation:
def get_parameters_space(hidden_layers_comb): params = [conf_to_params(conf) for conf in Config.get("bayesianOpt")["hyperparameters"]] max = len(hidden_layers_comb[-1])-1 params.append(Integer(0, max, name="hidden_layer_choice")) return params
def bayesian_mlp_exp(gene, mode): BOconfig = Config.get("bayesianOpt") hidden_layers_comb = get_hidden_layers_combinations( BOconfig["hiddenLayers"], 3, BOconfig["allowFirstLevelZero"]) mlp_parameters_space = get_parameters_space(hidden_layers_comb) @use_named_args(mlp_parameters_space) def fitness_mlp(learning_rate, num_hidden_layer, hidden_layer_choice): model, hist = train_bayesian_mlp(X_train_int, y_train_int, (X_val, y_val), features_size, learning_rate, num_hidden_layer, hidden_layer_choice, hidden_layers_comb) val_auprc = hist.history['val_auprc'][-1] print() print("Validation Loss: {}".format(val_auprc)) print() return -val_auprc print() print("Importing Epigenetic data...") print() X, y, features_size = filter_by_tasks(*import_epigenetic_dataset("data", gene), Config.get("task"), perc=Config.get("samplePerc")) print("Datasets length: {}, {}".format(len(X), len(y))) print("Features sizes: {}".format(features_size)) metrics = {'losses': [], 'auprc': [], 'auroc': []} delta_stopper = DeltaYStopper(n_best=BOconfig["n_best"], delta=BOconfig["delta"]) for ext_holdout in range(Config.get("nExternalHoldout")): print() print("{}/{} EXTERNAL HOLDOUTS".format(ext_holdout, Config.get("nExternalHoldout"))) print() X_train, X_test, y_train, y_test = split(X, y, random_state=42, proportions=None, mode=mode) # Internal holdouts X_train_int, X_val, y_train_int, y_val = split(X_train, y_train, random_state=42, proportions=None, mode=mode) print("Searching Parameters...") print() min_res = gp_minimize(func=fitness_mlp, dimensions=mlp_parameters_space, acq_func=BOconfig["acq_function"], callback=[delta_stopper], n_calls=BOconfig["nBayesianOptCall"]) print() print("Training with best parameters found: {}".format(min_res.x)) print() print(X_train) model, _ = train_bayesian_mlp(X_train, y_train, None, features_size, min_res.x[0], min_res.x[1], min_res.x[2], hidden_layers_comb) eval_score = model.evaluate(X_test, y_test) #K.clear_session() print("Metrics names: ", model.metrics_names) print("Final Scores: ", eval_score) metrics['losses'].append(eval_score[0]) metrics['auprc'].append(eval_score[1]) metrics['auroc'].append(eval_score[2]) return metrics
return "No file or directory" @app.route('/upload', methods=['POST']) def upload(): name = request.values['name'] data = request.values['data'] if name and data: path = Path(Config.files("download_path")) with open(path / name, 'w') as file: file.write(data) return "File created !" else: return "Parameters missing or wrong." @app.route('/', methods=['GET', 'POST']) def hello(): return "Hello, world !" if __name__ == "__main__": host = Config.server("host") port = Config.server("port") app.run(debug=True, host=host, port=port)
def train(): # Load the config variables cfg = Config(FLAGS.config) steps_per_phase = cfg.get('steps_per_phase') add_steps_exp = cfg.get('add_steps_exp') min_steps = cfg.get('min_steps') dg_steps = cfg.get('dg_steps') checkpoints_folder = cfg.get('checkpoints_folder') path_input_train = cfg.get('path_input_train') path_input_val = cfg.get('path_input_test') path_input_test = cfg.get('path_input_val') input_resolution = cfg.get('input_resolution') batch_size = cfg.get('batch_size') learning_rate = cfg.get('learning_rate') latent_input_dim = cfg.get('latent_input_dim') model_name = cfg.get('model_name') seed = cfg.get('seed') n_critic = cfg.get('n_critic') version = cfg.get('version') inference_steps = cfg.get('inference_steps') is_training = cfg.get('is_training') dg_freq = cfg.get('dg_freq') sum_freq = cfg.get('sum_freq') snap_freq = cfg.get('snap_freq') is_cpu = cfg.get('is_cpu') save_model_freq = cfg.get('save_model_freq') is_testing = cfg.get('is_testing') dataset_name = cfg.get("dataset_name") growth_ip_steps = cfg.get("act_ip_steps") # Define training steps and images per phase kimg_per_phase = steps_per_phase * batch_size * n_critic / 1000.0 num_phases = 2 * (int(np.log2(input_resolution)) - 2) + 1 training_steps = int(num_phases * steps_per_phase) + 1 + add_steps_exp if training_steps < min_steps: training_steps = min_steps # When training is continued model_name is non-empty load_model = model_name is not None and model_name != "" if not load_model: model_basename = cfg.get('model_basename') model_name = construct_model_name(model_basename, version) # Define checkpoint folder checkpoint_folder = os.path.join(checkpoints_folder, model_name) if not os.path.exists(checkpoint_folder): os.makedirs(checkpoint_folder) # For traceability of experiments, copy the config file shutil.copyfile( FLAGS.config, os.path.join(checkpoint_folder, "{}__{}.ini".format(model_name, FLAGS.section))) # One training step #--------------------------------------------------------------- def training_step(sess, step, model, n_critic, d_train, sum_freq, g_train, gan_summary, snap_freq, snap_summary, dg_freq, current_to_tmp_op, iter_val_init_op, dg_steps, d_train_worst, iter_test_init_op, minmax, g_train_worst, maxmin, iter_train_init_op): # Train discriminator for n_critic for critic_iter in range(n_critic): results = sess.run(d_train) # Train generator and add summaries every sum_freq steps if step % sum_freq == 0 and step > 0: results, summary1 = sess.run([g_train, gan_summary]) train_writer.add_summary(summary1, step) train_writer.flush() else: results = sess.run(g_train) # Chane to EMA variables when adding snapshot summary # (for inference we take exp. running avg. of weights) if step % snap_freq == 0 and step > 0: sess.run(model.to_testing()) summary2 = sess.run(snap_summary) train_writer.add_summary(summary2, step) train_writer.flush() sess.run(model.to_training()) duality_gap = None maxmin_value = None minmax_value = None # Compute duality gap at dg_freq if step % dg_freq == 0 and step > 0: # Assign current weights to g_worst, d_worst sess.run(current_to_tmp_op) # Train d_worst on validation data sess.run(iter_val_init_op) for i in range(0, dg_steps): _ = sess.run(d_train_worst) # Compute minmax on test data sess.run(iter_test_init_op) minmax_value = sess.run(minmax) # Train g_worst on validation data sess.run(iter_val_init_op) for j in range(0, dg_steps): _ = sess.run(g_train_worst) # Compute maxmin on test data sess.run(iter_test_init_op) maxmin_value = sess.run(maxmin) # Compute DG duality_gap = minmax_value - maxmin_value # Add to summaries summary3 = tf.Summary() summary3.value.add(tag="minmax", simple_value=minmax_value) summary3.value.add(tag="maxmin", simple_value=maxmin_value) summary3.value.add(tag="duality_gap", simple_value=duality_gap) train_writer.add_summary(summary3, step) train_writer.flush() # Print in log file logging.info('-----------Step %d:-------------' % step) logging.info(' Time: {}'.format( datetime.now().strftime('%b-%d-%I%M%p-%G'))) logging.info(' Duality Gap : {}'.format(duality_gap)) # Reinit train OP's sess.run(iter_train_init_op) return duality_gap, maxmin_value, minmax_value # To undo dynamic weight scaling at transition #--------------------------------------------------------------- def get_wscale(shape, gain=np.sqrt(2), fan_in=None): if fan_in is None: fan_in = np.prod(shape[:-1]) std = gain / np.sqrt(fan_in) # He init return std # Built graph #--------------------------------------------------------------- graph = tf.Graph() with graph.as_default(): # Get datasets, iterators and initializers (train/val/test) #--------------------------------------------------------------- dataset_train = Dataset(path_input_train, batch_size=batch_size, new_size=input_resolution, what_dataset=dataset_name).get_dataset() dataset_val = Dataset(path_input_val, batch_size=batch_size, new_size=input_resolution, what_dataset=dataset_name).get_dataset() dataset_test = Dataset(path_input_test, batch_size=batch_size, new_size=input_resolution, what_dataset=dataset_name).get_dataset() data_iterator = tf.data.Iterator.from_structure( dataset_train.output_types, dataset_train.output_shapes) iter_train_init_op = data_iterator.make_initializer(dataset_train) iter_test_init_op = data_iterator.make_initializer(dataset_val) iter_val_init_op = data_iterator.make_initializer(dataset_test) # Create model #--------------------------------------------------------------- model = GAN_DG(iterator=data_iterator, batch_size=batch_size, input_resolution=input_resolution, latent_input_dim=latent_input_dim, learning_rate=learning_rate, is_cpu=is_cpu) # Get training OPs #--------------------------------------------------------------- d_train, d_opt_reset, g_train, g_opt_reset, g_summary = model.gan() current_to_tmp_op = model.assign_vars() d_train_worst, minmax = model.minmax() g_train_worst, maxmin = model.maxmin() # Check snapshots during morphing #--------------------------------------------------------------- im_fk = model.get_fake_images(g_var_scope="generator") snap_summary = tf.summary.image("snapshot_fake", tf.transpose(im_fk, [0, 2, 3, 1]), max_outputs=2) snap_summary_1 = tf.summary.image("snapshot_after_morph", tf.transpose(im_fk, [0, 2, 3, 1]), max_outputs=4) snap_summary_2 = tf.summary.image("snapshot_before_morph", tf.transpose(im_fk, [0, 2, 3, 1]), max_outputs=4) # Create lod placeholder, assign lod values (lod_in_g = lod_in_d), add to summary #--------------------------------------------------------------- lod_in_g = tf.placeholder(tf.float32, name='lod_in_g', shape=[]) lod_in_d = tf.placeholder(tf.float32, name='lod_in_d', shape=[]) lod_in_im = tf.placeholder(tf.float32, name='lod_in_im', shape=[]) lod_in_grow = tf.placeholder(tf.float32, name='lod_in_grow', shape=[]) lod_image_a = [ v for v in tf.global_variables() if v.name == "lod_image:0" ][0] lod_g_a = [ v for v in tf.global_variables() if v.name == "generator/lod_g:0" ][0] lod_d_a = [ v for v in tf.global_variables() if v.name == "discriminator/lod_d:0" ][0] lod_gtmp_a = [ v for v in tf.global_variables() if v.name == "worst_calc_g/genTMP/lod_g:0" ][0] lod_dtmp_a = [ v for v in tf.global_variables() if v.name == "worst_calc_d/discTMP/lod_d:0" ][0] lod_grow_g_a = [ v for v in tf.global_variables() if v.name == "generator/lod_grow:0" ][0] lod_grow_d_a = [ v for v in tf.global_variables() if v.name == "discriminator/lod_grow:0" ][0] lod_grow_gtmp_a = [ v for v in tf.global_variables() if v.name == "worst_calc_g/genTMP/lod_grow:0" ][0] lod_grow_dtmp_a = [ v for v in tf.global_variables() if v.name == "worst_calc_d/discTMP/lod_grow:0" ][0] lod_assign_ops = [ tf.assign(lod_g_a, lod_in_g), tf.assign(lod_d_a, lod_in_d), tf.assign(lod_gtmp_a, lod_in_g), tf.assign(lod_dtmp_a, lod_in_d) ] lod_grow_assign_ops = [ tf.assign(lod_grow_g_a, lod_in_grow), tf.assign(lod_grow_d_a, lod_in_grow), tf.assign(lod_grow_gtmp_a, lod_in_grow), tf.assign(lod_grow_dtmp_a, lod_in_grow) ] gan_summary = tf.summary.merge([ g_summary, tf.summary.scalar('lod_in_gen', lod_g_a), tf.summary.scalar('lod_in_disc', lod_d_a), tf.summary.scalar('lod_in_grow', lod_grow_g_a) ]) #--------------------------------------------------------------- # Morphing Vars and OPs (Reference at the bottom), only supports up to reoslution 128 #---------------------------------------------------------------------------------- tvars_d = [ var for var in tf.trainable_variables() if "discriminator" in var.name ] tvars_g = [ var for var in tf.trainable_variables() if "generator" in var.name ] to_rgb_names = [ "ToRGB_lod" + num for num in ["5", "4", "3", "2", "1", "0"] ] fr_rgb_names = [ "FromRGB_lod" + num for num in ["5", "4", "3", "2", "1", "0"] ] layer_names = ["8x8", "16x16", "32x32", "64x64", "128x128"] conv_names_g = ["Conv0", "Conv1"] conv_names_d = ["Conv0", "Conv1"] weight_names = ["weight", "bias"] all_rgb_vars_g = [] all_rgb_plh_g = [] all_rgb_asgn_ops_g = [] all_rgb_vars_d = [] all_rgb_plh_d = [] all_rgb_asgn_ops_d = [] for rgb_g, rgb_d in zip(to_rgb_names, fr_rgb_names): layer_asgn_ops_g = [] layer_plh_list_g = [] layer_var_names_g = [] layer_asgn_ops_d = [] layer_plh_list_d = [] layer_var_names_d = [] for weight in weight_names: var_name_g = rgb_g + "/" + weight + ":0" var_name_d = rgb_d + "/" + weight + ":0" pl_rgb_g = "pl_gen_" + rgb_g + "_" + weight pl_rgb_d = "pl_dis_" + rgb_d + "_" + weight tvar_g = [var for var in tvars_g if var_name_g in var.name][0] tvar_d = [var for var in tvars_d if var_name_d in var.name][0] pl_g = tf.placeholder(tf.float32, name=pl_rgb_g, shape=tvar_g.shape) pl_d = tf.placeholder(tf.float32, name=pl_rgb_d, shape=tvar_d.shape) asgn_op_g = tf.assign(tvar_g, pl_g) asgn_op_d = tf.assign(tvar_d, pl_d) layer_var_names_g.append(tvar_g) layer_plh_list_g.append(pl_g) layer_asgn_ops_g.append(asgn_op_g) layer_var_names_d.append(tvar_d) layer_plh_list_d.append(pl_d) layer_asgn_ops_d.append(asgn_op_d) all_rgb_vars_g.append(layer_var_names_g) all_rgb_plh_g.append(layer_plh_list_g) all_rgb_asgn_ops_g.append(layer_asgn_ops_g) all_rgb_vars_d.append(layer_var_names_d) all_rgb_plh_d.append(layer_plh_list_d) all_rgb_asgn_ops_d.append(layer_asgn_ops_d) all_var_names_g = [] all_plh_list_g = [] all_asgn_ops_g = [] all_var_names_d = [] all_plh_list_d = [] all_asgn_ops_d = [] for layer in layer_names: layer_asgn_ops_g = [] layer_plh_list_g = [] layer_var_names_g = [] layer_asgn_ops_d = [] layer_plh_list_d = [] layer_var_names_d = [] for conv_g, conv_d in zip(conv_names_g, conv_names_d): for weight in weight_names: var_name_g = "/" + layer + "/" + conv_g + "/" + weight + ":0" var_name_d = "/" + layer + "/" + conv_d + "/" + weight + ":0" pl_name_g = "pl_gen_" + layer + "_" + conv_g + "_" + weight pl_name_d = "pl_dis_" + layer + "_" + conv_d + "_" + weight tvar_g = [ var for var in tvars_g if var_name_g in var.name ][0] tvar_d = [ var for var in tvars_d if var_name_d in var.name ][0] pl_g = tf.placeholder(tf.float32, name=pl_name_g, shape=tvar_g.shape) pl_d = tf.placeholder(tf.float32, name=pl_name_d, shape=tvar_d.shape) asgn_op_g = tf.assign(tvar_g, pl_g) asgn_op_d = tf.assign(tvar_d, pl_d) layer_var_names_g.append(tvar_g) layer_plh_list_g.append(pl_g) layer_asgn_ops_g.append(asgn_op_g) layer_var_names_d.append(tvar_d) layer_plh_list_d.append(pl_d) layer_asgn_ops_d.append(asgn_op_d) all_var_names_g.append(layer_var_names_g) all_plh_list_g.append(layer_plh_list_g) all_asgn_ops_g.append(layer_asgn_ops_g) all_var_names_d.append(layer_var_names_d) all_plh_list_d.append(layer_plh_list_d) all_asgn_ops_d.append(layer_asgn_ops_d) # Reference: # 1.) RGBs: # w,b = all_RGB[i] = i'th layer RGBs (4x4 [0]->128x128 [5]) # 2.) Convs: # Gen: w1, b1, w2, b2 = all_gen[i] = i'th layer Conv0_up and Conv1 weights and biases # Disc: w1, b1, w2, b2 = all_disc[i] = i'th layer Conv0, Conv1_down weights and biases #---------------------------------------------------------------------------------- #---------------------------------------------------------------------------------- #SESSION #---------------------------------------------------------------------------------- with tf.Session(graph=graph) as sess: # Load model or initialise vars/lod if load_model: step = restore_model(checkpoint_folder, sess) else: sess.run(tf.global_variables_initializer()) step = 0 # Saver, summary_op & writer, coordinator, Training Schedule TS = TrainingSchedule(final_resolution=input_resolution, lod_training_kimg=kimg_per_phase, lod_transition_kimg=kimg_per_phase) lod_step_g = step lod_step_d = step lod_step_grow = step lod_val_g = np.floor(TS.get_lod(lod_step_g * batch_size * n_critic)) lod_val_d = np.floor(TS.get_lod(lod_step_d * batch_size * n_critic)) lod_val_grow = lod_val_g lod_new_grow = lod_val_grow lod_grow_bool = 0 # Define saver, writer, etc saver = tf.train.Saver(max_to_keep=15) train_writer = tf.summary.FileWriter(checkpoint_folder, graph) coord = tf.train.Coordinator() # Ensure train init and assign current lod_vals sess.run(iter_train_init_op) sess.run([lod_assign_ops], feed_dict={ lod_in_g: lod_val_g, lod_in_d: lod_val_d }) sess.run([lod_grow_assign_ops], feed_dict={lod_in_grow: lod_val_grow}) # -------------------------------------------------- # Inference (generate and save images), either final model # -------------------------------------------------- if is_training == False: if is_testing == True: all_out = [] sess.run(model.to_testing()) for i in range(inference_steps): if i % 50 == 0: logging.info('Current inference Step: %d' % i) outputs = sess.run( [model.get_fake_images(g_var_scope="generator")]) all_out.append(outputs) if i % 100 == 0 and i > 0: np.save(checkpoint_folder + '/inf_' + str(i), all_out) all_out = [] sess.run(model.to_training()) np.save(checkpoint_folder + '/inf_' + str(i), all_out) raise ValueError('Inference done.') # -------------------------------------------------- # EMA initializer to_training sess.run(model.to_training()) # Train while step < training_steps and not coord.should_stop(): try: dg_val, maxmin_val, minmax_val = training_step( sess, step, model, n_critic, d_train, sum_freq, g_train, gan_summary, snap_freq, snap_summary, dg_freq, current_to_tmp_op, iter_val_init_op, dg_steps, d_train_worst, iter_test_init_op, minmax, g_train_worst, maxmin, iter_train_init_op) old_step = step lod_step_g = step lod_step_d = step # Update lod lod_new_g = np.floor( TS.get_lod(lod_step_g * batch_size * n_critic)) lod_new_d = np.floor( TS.get_lod(lod_step_d * batch_size * n_critic)) # Growth LOD helper to determine when to morph and to ip non-lins if step % steps_per_phase == 0 and step > 0 and step % ( 2 * steps_per_phase) != 0: lod_grow_bool = 1 if lod_grow_bool == 1: if lod_new_grow == np.floor(lod_new_grow): lod_new_grow = lod_new_grow - 1.0 / growth_ip_steps else: lod_new_grow = np.maximum( lod_new_grow - 1.0 / growth_ip_steps, np.floor(lod_new_grow)) if lod_new_grow % np.floor(lod_new_grow) < 1e-3: lod_new_grow = np.floor(lod_new_grow) lod_grow_bool = 0 if lod_new_grow < 0.0: lod_new_grow = 0.0 #---------------------------------------------------------------------------------- # MORPHISM #---------------------------------------------------------------------------------- # Reference: # GAN Filters: (K,K,Cin,Cout) # Morph Filters: (Cout,Cin,K,K) if lod_new_g != lod_val_g or lod_new_d != lod_val_d: # Snaps before Morphing sum_be_morph = sess.run(snap_summary_2) train_writer.add_summary(sum_be_morph, step) train_writer.flush() # Find morph layer, and get all weight variables/references ci = int(4.0 - lod_new_g) #0,1,2,3,4 w_torgb_old, b_torgb_old = sess.run(all_rgb_vars_g[ci]) w_fromrgb_old, b_fromrgb_old = sess.run(all_rgb_vars_d[ci]) w_torgb_new, b_torgb_new = sess.run(all_rgb_vars_g[ci + 1]) w_fromrgb_new, b_fromrgb_new = sess.run(all_rgb_vars_d[ci + 1]) wtorgb_shape = w_torgb_new.shape btorgb_shape = b_torgb_new.shape wfromrgb_shape = w_fromrgb_new.shape bfromrgb_shape = b_fromrgb_new.shape w1_g_shape = all_var_names_g[ci][0].shape b1_g_shape = all_var_names_g[ci][1].shape w2_g_shape = all_var_names_g[ci][2].shape b2_g_shape = all_var_names_g[ci][3].shape w1_d_shape = all_var_names_d[ci][0].shape b1_d_shape = all_var_names_d[ci][1].shape w2_d_shape = all_var_names_d[ci][2].shape b2_d_shape = all_var_names_d[ci][3].shape # ----------------------Generator --------------------- # Case 1: No halving of convolutional channels: if w1_g_shape == w2_g_shape: G = np.transpose( w_torgb_old, [3, 2, 0, 1]) #(K,K,Cin,Cout)->(Cout,Cin,K,K) Cout = w1_g_shape[3] F1, F3 = decomp_filters_lsq_iter( G, Cout, 3, 1, iters=100) # morph 1 step F2, F3 = decomp_filters_lsq_iter( F3, Cout, 3, 1, iters=100) # morph 2 step ## Identity Filter #F1 = np.zeros(w1_g_shape) #for i in range(0,w1_g_shape[2]): # F1[:,:,i,i] = np.array([[0,0,0],[0,1.0,0],[0,0,0]]) w1_g = np.transpose(F1, [2, 3, 1, 0]) w1_g = w1_g / get_wscale( w1_g.shape) #Undo wscaling effect b1_g = np.zeros(shape=b1_g_shape) w2_g = np.transpose( F2, [2, 3, 1, 0]) #(Cout,Cin,K,K)->(K,K,Cin,Cout) w2_g = w2_g / get_wscale( w2_g.shape) #Undo wscaling effect b2_g = np.zeros(shape=b2_g_shape) wrgb_g = np.transpose( F3, [2, 3, 1, 0] ) #(Cout,Cin,K,K)->(K,K,Cin,Cout) || Here no wscale undo because same as previous toRGB brgb_g = b_torgb_old assert w1_g.shape == w1_g_shape and w2_g.shape == w2_g_shape assert wrgb_g.shape == wtorgb_shape and brgb_g.shape == btorgb_shape # Case 2: Halving of convolutional channels: else: G = np.transpose( w_torgb_old, [3, 2, 0, 1]) #(K,K,Cin,Cout)->(Cout,Cin,K,K) Cout = w1_g_shape[3] F1, F3 = decomp_filters_lsq_iter(G, Cout, 3, 1, iters=100) ## Identity Filter #F2 = np.zeros(w2_g_shape) #for i in range(0,w2_g_shape[2]): # F2[:,:,i,i] = np.array([[0,0,0],[0,1.0,0],[0,0,0]]) F2, F3 = decomp_filters_lsq_iter(F3, Cout, 3, 1, iters=100) w1_g = np.transpose( F1, [2, 3, 1, 0]) #(Cout,Cin,K,K)->(K,K,Cin,Cout) w1_g = w1_g / get_wscale(w1_g.shape) #Undo wscale b1_g = np.zeros(shape=b1_g_shape) w2_g = np.transpose(F2, [2, 3, 1, 0]) w2_g = w2_g / get_wscale(w2_g.shape) #Undo wscale b2_g = np.zeros( shape=b2_g_shape) #(Cout,Cin,K,K)->(K,K,Cin,Cout) wrgb_g = np.transpose(F3, [2, 3, 1, 0]) wrgb_g = wrgb_g / get_wscale( wrgb_g.shape, gain=1) * get_wscale( w_torgb_old.shape, gain=1) brgb_g = b_torgb_old logging.info('w2_is %s, w2_should %s', w2_g.shape, w2_g_shape) logging.info('w1_is %s, w1_should %s', w1_g.shape, w1_g_shape) logging.info('wrgb_is %s, wrgb_should %s', wrgb_g.shape, wtorgb_shape) logging.info('brgb_is %s, brgb_should %s', brgb_g.shape, btorgb_shape) assert w1_g.shape == w1_g_shape and w2_g.shape == w2_g_shape assert wrgb_g.shape == wtorgb_shape and brgb_g.shape == btorgb_shape # Assign new Weights: sess.run( [ all_rgb_asgn_ops_g[ci + 1][0], all_rgb_asgn_ops_g[ci + 1][1] ], feed_dict={ all_rgb_plh_g[ci + 1][0]: wrgb_g, all_rgb_plh_g[ci + 1][1]: brgb_g }) sess.run( [ all_asgn_ops_g[ci][0], all_asgn_ops_g[ci][1], all_asgn_ops_g[ci][2], all_asgn_ops_g[ci][3] ], feed_dict={ all_plh_list_g[ci][0]: w1_g, all_plh_list_g[ci][1]: b1_g, all_plh_list_g[ci][2]: w2_g, all_plh_list_g[ci][3]: b2_g }) # ----------------------------------------------------- # ----------------- Discriminator --------------------- # Case 1: No Doubling of convolutional channels: if w1_d_shape == w2_d_shape: G = np.transpose( w_fromrgb_old, [3, 2, 0, 1]) #(K,K,Cin,Cout)->(Cout,Cin,K,K) Cout = w2_d_shape[2] F1, F3 = decomp_filters_lsq_iter(G, Cout, 1, 3, iters=100) F1, F2 = decomp_filters_lsq_iter(F1, Cout, 1, 3, iters=100) # Identity filter (no longer) #F3 = np.zeros(w2_d_shape) #for i in range(0,w2_d_shape[2]): # F3[:,:,i,i] = np.array([[0,0,0],[0,1.0,0],[0,0,0]]) wrgb_d = np.transpose( F1, [2, 3, 1, 0] ) #(Cout,Cin,K,K)->(K,K,Cin,Cout), here no undo-wscale: Same Dim as fromRGB_old brgb_d = np.zeros(bfromrgb_shape) w1_d = np.transpose( F2, [2, 3, 1, 0]) #(Cout,Cin,K,K)->(K,K,Cin,Cout) w1_d = w1_d / get_wscale(w1_d.shape) #Undo wscale b1_d = np.zeros(shape=b1_d_shape) w2_d = np.transpose(F3, [2, 3, 1, 0]) w2_d = w2_d / get_wscale(w2_d.shape) #Undo wscale b2_d = b_fromrgb_old assert w1_d.shape == w1_d_shape and w2_d.shape == w2_d_shape assert wrgb_d.shape == wfromrgb_shape and brgb_d.shape == bfromrgb_shape # Case 2: Doubling of convolutional channels: else: G = np.transpose( w_fromrgb_old, [3, 2, 0, 1]) #(K,K,Cin,Cout)->(Cout,Cin,K,K) Cout = w2_d_shape[2] F1, F3 = decomp_filters_lsq_iter(G, Cout, 1, 3, iters=100) F1, F2 = decomp_filters_lsq_iter(F1, Cout, 1, 3, iters=100) #F2 = np.zeros(w1_d_shape) #for i in range(0,w1_d_shape[2]): # F2[:,:,i,i] = np.array([[0,0,0],[0,1.0,0],[0,0,0]]) wrgb_d = np.transpose( F1, [2, 3, 1, 0]) #(Cout,Cin,K,K)->(K,K,Cin,Cout) wrgb_d = wrgb_d / get_wscale( wrgb_d.shape, gain=1) * get_wscale( w_fromrgb_old.shape, gain=1) #Same wscale as old brgb_d = np.zeros(bfromrgb_shape) w1_d = np.transpose(F2, [2, 3, 1, 0]) w1_d = w1_d / get_wscale(w1_d.shape) b1_d = np.zeros(shape=b1_d_shape) w2_d = np.transpose( F3, [2, 3, 1, 0]) #(Cout,Cin,K,K)->(K,K,Cin,Cout) w2_d = w2_d / get_wscale(w2_d.shape) b2_d = b_fromrgb_old logging.info('w2_is %s, w2_should %s', w2_d.shape, w2_d_shape) logging.info('w1_is %s, w1_should %s', w1_d.shape, w1_d_shape) logging.info('wrgb_is %s, wrgb_should %s', wrgb_d.shape, wfromrgb_shape) logging.info('brgb_is %s, brgb_should %s', brgb_d.shape, bfromrgb_shape) assert w1_d.shape == w1_d_shape and w2_d.shape == w2_d_shape assert wrgb_d.shape == wfromrgb_shape and brgb_d.shape == bfromrgb_shape # ----------------------------------------------------- # Assign new weights: sess.run( [ all_rgb_asgn_ops_d[ci + 1][0], all_rgb_asgn_ops_d[ci + 1][1] ], feed_dict={ all_rgb_plh_d[ci + 1][0]: wrgb_d, all_rgb_plh_d[ci + 1][1]: brgb_d }) sess.run( [ all_asgn_ops_d[ci][0], all_asgn_ops_d[ci][1], all_asgn_ops_d[ci][2], all_asgn_ops_d[ci][3] ], feed_dict={ all_plh_list_d[ci][0]: w1_d, all_plh_list_d[ci][1]: b1_d, all_plh_list_d[ci][2]: w2_d, all_plh_list_d[ci][3]: b2_d }) # ----------------------------------------------------- # Assign new lod's sess.run([lod_assign_ops], feed_dict={ lod_in_g: lod_new_g, lod_in_d: lod_new_d }) sess.run([g_opt_reset, d_opt_reset]) # Sumamry after morphing sum_be_morph_3 = sess.run(snap_summary_1) train_writer.add_summary(sum_be_morph_3, step) train_writer.flush() if lod_new_grow != lod_val_grow: sess.run([lod_grow_assign_ops], feed_dict={lod_in_grow: lod_new_grow}) lod_val_g = lod_new_g lod_val_d = lod_new_d lod_val_grow = lod_new_grow # Saver if step > 0 and step % save_model_freq == 0: save_path = saver.save(sess, checkpoint_folder + "/model.ckpt", global_step=step) logging.info("Model saved in file: {}".format(save_path)) if step == old_step: step += 1 except KeyboardInterrupt: logging.info('Interrupted') coord.request_stop() except Exception as e: logging.warning( "Unforeseen error at step {}. Requesting stop...".format( step)) coord.request_stop(e) save_path = saver.save(sess, checkpoint_folder + "/model.ckpt", global_step=step) logging.info("Model saved in file: %s" % save_path)
def main(stdscr): # if config.ini exists, contine # else create it and exit if not os.path.exists(config): with open(config, 'w') as cfgFile: cfgFile.write(configContents) print("created config file") leave() # get settings from file try: com = 'COM' + Config.gen('COM') baudrate = int(Config.gen('BAUD')) except: print("invalid inputs") leave() # name dataFiles after date and time or user chosen dataPath = Config.gen('FOLDER') if Config.gen('FILENAMEDATE')[0] == 'y': tm = time.localtime() dataFile = f'{tm[7]:03}{tm[3]:02}{tm[4]:02}{tm[5]:02}' else: dataFile = input("file to store data: ") while dataFile == "": dataFile = input("file to store data: ") while os.path.exists(dataFile): if input("overwrite existing file? (y for yes): ") == "y": break else: dataFile = input("file to store data: ") while dataFile == "": dataFile = input("file to store data: ") dataPath = dataPath + '/' + dataFile # from here on we want a nicer output stdscr.clear() # open serial port ser.baudrate = baudrate ser.port = com ser.timeout = 2 cnt = 0; while not ser.is_open: try: ser.open() except: stdscr.clear() stdscr.addstr(0, 0, 'opening port: ' + com + ' at ' + str(baudrate) + " try: " + str(cnt)) stdscr.refresh() cnt += 1 # collect and log data numMismatch = 0 maxMismatch = 5 allKeys = list(sensors.keys()) buf = bytearray() stdscr.nodelay(1) # make getch() non-blocking while True: # rewrite of ser.readline() # used since readline() is slow try: buf = buf + ser.read(max(1, ser.in_waiting)) i = buf.find(b'\n') if i >= 0: line = buf[:i+1] buf = buf[i+1:] else: continue except Exception as e: stdscr.clear() stdscr.addstr(0, 0, 'error') stdscr.refresh() continue if line == '': stdscr.clear() stdscr.addstr(0, 0, 'empty buffer') stdscr.refresh() continue vals = line.split(b':') if len(vals) != len(allKeys): numMismatch += 1 if numMismatch >= maxMismatch: numMismatch = 0 stdscr.clear() stdscr.addstr(0, 0, 'mismatch in sensor number') stdscr.addstr(1, 0, 'press enter to continue') stdscr.refresh() stdscr.nodelay(0) stdscr.getkey() stdscr.nodelay(1) continue else: continue; numMismatch = 0 # if we get here, no consecutive mismatch output = '' for k in range(len(allKeys)): try: sensors[allKeys[k]].append(float(vals[k])) except ValueError: sensors[allKeys[k]].append(vals[k]) for k in sensors: try: output = output + k + ": " + str(float(vals[allKeys.index(k)])) + '\n' except ValueError: output = output + k + ": " + str(vals[allKeys.index(k)]) + '\n' output = output + 'saving to: ' + dataPath + '\n' output = output + 'len of TPS: ' + str(len(sensors['TPS'])) + '\n' output = output + 'shift-s to save and exit' stdscr.clear() stdscr.addstr(output) stdscr.refresh() if stdscr.getch() == ord('S'): break with open(dataPath, 'wb') as df: pickle.dump(sensors, df) # save file
def bayesian_cnn_exp(gene, mode): BOconfig = Config.get("bayesianOpt") mlp_parameters_space = [ conf_to_params(conf) for conf in Config.get("bayesianOpt")["hyperparameters"] ] @use_named_args(mlp_parameters_space) def fitness_mlp(kernel_space_1, units_2, kernel_space_2, dense_1, dense_2): es = EarlyStopping(monitor='val_loss', patience=Config.get("ESValPatience"), min_delta=Config.get("ESValMinDelta"), baseline=0.2) model, hist = train_bayesian_cnn(X_train_int, y_train_int, (X_val, y_val), es, kernel_space_1, units_2, kernel_space_2, dense_1, dense_2) val_auprc = hist.history['val_auprc'][-1] print() print("Validation Loss: {}".format(val_auprc)) print() return -val_auprc print() print("Importing Epigenetic data...") print() X, y, features_size = filter_by_tasks(*import_sequence_dataset( "data", gene), Config.get("task"), perc=Config.get("samplePerc")) print("Datasets length: {}, {}".format(len(X), len(y))) print("Features sizes: {}".format(features_size)) metrics = {'losses': [], 'auprc': [], 'auroc': []} delta_stopper = DeltaYStopper(n_best=BOconfig["n_best"], delta=BOconfig["delta"]) for ext_holdout in range(Config.get("nExternalHoldout")): print() print("{}/{} EXTERNAL HOLDOUTS".format(ext_holdout, Config.get("nExternalHoldout"))) print() X_train, X_test, y_train, y_test = split(X, y, random_state=42, proportions=None, mode=mode) # Internal holdouts X_train_int, X_val, y_train_int, y_val = split(X_train, y_train, random_state=42, proportions=None, mode=mode) print("Searching Parameters...") print() min_res = gp_minimize(func=fitness_mlp, dimensions=mlp_parameters_space, acq_func=BOconfig["acq_function"], callback=[delta_stopper], n_calls=BOconfig["nBayesianOptCall"]) print() print("Training with best parameters found: {}".format(min_res.x)) print() print(X_train) es = EarlyStopping(monitor='val_loss', patience=Config.get("ESPatience"), min_delta=Config.get("ESMinDelta")) model, _ = train_bayesian_cnn(X_train, y_train, None, es, min_res.x[0], min_res.x[1], min_res.x[2], min_res.x[3]) eval_score = model.evaluate(X_test, y_test) # K.clear_session() print("Metrics names: ", model.metrics_names) print("Final Scores: ", eval_score) metrics['losses'].append(eval_score[0]) metrics['auprc'].append(eval_score[1]) metrics['auroc'].append(eval_score[2]) return metrics