def main(): num_classes = 10 num_samples = 4 num_training_epochs = 2 # NOTE: change to True for graph visualization show_graph = False # load data (X_train, y_train, X_val, y_val, X_test, y_test) = load_mnist('data/mnist', flatten=True) train_dataset = InMemoryDataset(X_train, y_train, True) val_dataset = InMemoryDataset(X_val, y_val, False) test_dataset = InMemoryDataset(X_test, y_test, False) # defining evaluator and searcher evaluator = SimpleClassifierEvaluator( train_dataset, val_dataset, num_classes, num_training_epochs=num_training_epochs, log_output_to_terminal=True) ssf = mo.SearchSpaceFactory(lambda: dnn_net(num_classes)) searcher = se.RandomSearcher(ssf.get_search_space) for i in range(num_samples): inputs, outputs, _, searcher_eval_token = searcher.sample() if show_graph: # try setting draw_module_hyperparameter_info=False and # draw_hyperparameters=True for a different visualization. vi.draw_graph(outputs, draw_module_hyperparameter_info=False, draw_hyperparameters=True) results = evaluator.evaluate(inputs, outputs) # updating the searcher. no-op for the random searcher. searcher.update(results['validation_accuracy'], searcher_eval_token)
def get_conv_search_space_fn(num_classes): def search_space_fn(): h_num_spatial_reductions = D([2, 3, 4]) h_pool_op = D(['max', 'avg']) return mo.siso_sequential([ css_cnn2d.conv_net(h_num_spatial_reductions), css_cnn2d.spatial_squeeze(h_pool_op, D([num_classes])) ]) return mo.SearchSpaceFactory(search_space_fn).get_search_space
def main(): # Loading the config file. cfg = ut.get_config() num_classes = 10 num_samples = cfg['num_samples'] # Loading the data. (Xtrain, ytrain, Xval, yval, Xtest, ytest) = load_mnist('data/mnist') train_dataset = InMemoryDataset(Xtrain, ytrain, True) val_dataset = InMemoryDataset(Xval, yval, False) test_dataset = InMemoryDataset(Xtest, ytest, False) # Creating up the evaluator. evaluator = SimpleClassifierEvaluator( train_dataset, val_dataset, num_classes, './temp', max_eval_time_in_minutes=cfg['max_eval_time_in_minutes'], log_output_to_terminal=True, test_dataset=test_dataset) # Creating the search space. search_space_fn = lambda: css_dnn.dnn_net(num_classes) search_space_factory = mo.SearchSpaceFactory(search_space_fn) sl.create_search_folderpath( cfg["folderpath"], cfg["search_name"], delete_if_exists=cfg['delete_if_exists'], abort_if_exists=False, create_parent_folders=True) # Creating the searcher. searcher = RandomSearcher(search_space_factory.get_search_space) # Search loop. for evaluation_id in range(num_samples): eval_logger = sl.EvaluationLogger(cfg["folderpath"], cfg["search_name"], evaluation_id) if not eval_logger.config_exists(): inputs, outputs, hyperp_value_lst, eval_token = searcher.sample() results = evaluator.eval(inputs, outputs) # Logging results (including graph). eval_logger.log_config(hyperp_value_lst, eval_token) eval_logger.log_results(results) vi.draw_graph( outputs, draw_module_hyperparameter_info=True, print_to_screen=False, out_folderpath=eval_logger.get_evaluation_data_folderpath()) # Updating the searcher given the results of logging. searcher.update(results['validation_accuracy'], eval_token)
def main(): num_classes = 10 num_samples = 4 num_training_epochs = 2 validation_frac = 0.2 # NOTE: change to True for graph visualization show_graph = False # load the data. (X_train, y_train), (X_test, y_test) = mnist.load_data() fn = lambda X: X.reshape((X.shape[0], -1)) X_train = fn(X_train) / 255.0 X_test = fn(X_test) / 255.0 num_train = int((1.0 - validation_frac) * X_train.shape[0]) X_train, X_val = X_train[:num_train], X_train[num_train:] y_train, y_val = y_train[:num_train], y_train[num_train:] # define the search and the evalutor evaluator = SimpleClassifierEvaluator( X_train, y_train, X_val, y_val, num_classes, num_training_epochs=num_training_epochs) ssf = mo.SearchSpaceFactory(lambda: dnn_net(num_classes)) searcher = se.RandomSearcher(ssf.get_search_space) for i in range(num_samples): (inputs, outputs, hyperp_value_lst, searcher_eval_token) = searcher.sample() if show_graph: # try setting draw_module_hyperparameter_info=False and # draw_hyperparameters=True for a different visualization. vi.draw_graph(outputs, draw_module_hyperparameter_info=False, draw_hyperparameters=True) results = evaluator.evaluate(inputs, outputs) # updating the searcher. no-op for the random searcher. searcher.update(results['validation_accuracy'], searcher_eval_token)
def main(): num_classes = 10 num_samples = 8 (Xtrain, ytrain, Xval, yval, Xtest, ytest) = load_mnist('data/mnist') train_dataset = InMemoryDataset(Xtrain, ytrain, True) val_dataset = InMemoryDataset(Xval, yval, False) test_dataset = InMemoryDataset(Xtest, ytest, False) evaluator = SimpleClassifierEvaluator(train_dataset, val_dataset, num_classes, './temp', max_eval_time_in_minutes=1.0, log_output_to_terminal=True) search_space_fn = lambda: css_dnn.dnn_net(num_classes) search_space_factory = mo.SearchSpaceFactory(search_space_fn) searcher = RandomSearcher(search_space_factory.get_search_space) for _ in range(num_samples): inputs, outputs, searcher_eval_token, _ = searcher.sample() val_acc = evaluator.eval(inputs, outputs)['validation_accuracy'] searcher.update(val_acc, searcher_eval_token)
def get_dnn_search_space_fn(num_classes): return mo.SearchSpaceFactory( lambda: css_dnn.dnn_net(num_classes)).get_search_space
# First, create the communicator. This communicator is used by by to master to # send candidate architectures to the workers to evaluate, and by the workers # to send back the results for the architectures they evaluated. Currently, # the communicator can be MPI based or file based (file based requires the # processes to share a filesystem). comm = get_communicator(args.comm, num_procs=args.num_procs) # This is the number of total models to be evaluated in search num_total_models = 25 # Now we set up the datasets and the search space factory. X_train, y_train, X_val, y_val, _, _ = load_mnist('data/mnist', normalize_range=True) train_dataset = InMemoryDataset(X_train, y_train, True) val_dataset = InMemoryDataset(X_val, y_val, False) ssf = mo.SearchSpaceFactory(lambda: dnn.dnn_net(10)) # Each process should have a unique rank. The process with rank 0 will act as the # master process that is in charge of the searcher. Every other process acts # as a worker that evaluates architectures sent to them. if comm.get_rank() == 0: searcher = RandomSearcher(ssf.get_search_space) models_sampled = 0 killed = 0 finished = 0 # This process keeps going as long as we have not received results for all sampled # models and not all the worker processes have been killed. Kill signals start # being sent out once the searcher has finished sampling the number of models # specified by the `num_total_models` parameter
import deep_architect.modules as mo import deep_architect.contrib.misc.search_spaces.tensorflow.dnn as css_dnn def get_dnn_search_space_fn(num_classes): return mo.SearchSpaceFactory( lambda: css_dnn.dnn_net(num_classes)).get_search_space num_classes = 10 search_space_fn = mo.SearchSpaceFactory( get_dnn_search_space_fn(num_classes)).get_search_space
name_to_hyperp = { ut.json_object_to_json_string({ "node_id": i, "in_node_id": j }): D([0, 1]) for i in range(num_nodes) for j in range(i) } return mo.substitution_module("ConvStage", substitution_fn, name_to_hyperp, ["in"], ["out"], scope=None) (inputs, outputs ) = mo.SearchSpaceFactory(lambda: conv_stage(32, 3, 8)).get_search_space() random_specify(outputs) # for h in co.unassigned_independent_hyperparameter_iterator(outputs): # h.assign_value(1) vi.draw_graph(outputs, draw_module_hyperparameter_info=False) # inputs_val = Input((32, 32, 3)) # co.forward({inputs["in"]: inputs_val}) # outputs_val = outputs["out"].val # model = Model(inputs=inputs_val, outputs=outputs_val) # model.summary() ### NOTE: these are done.
node_id_to_outputs.append(c_outputs) out_outputs = node_id_to_outputs[-1] return in_inputs, out_outputs name_to_hyperp = { ut.json_object_to_json_string({ "node_id": i, "in_node_id": j }): D([0, 1]) for i in range(1, num_nodes) for j in range(i - 1) } return mo.substitution_module( "Motif", substitution_fn, name_to_hyperp, ["in"], ["out"], scope=None) (inputs, outputs) = mo.SearchSpaceFactory( lambda: motif(lambda: motif(batch_normalization, 4), 4)).get_search_space() # (inputs, outputs) = mo.SearchSpaceFactory( # lambda: motif(batch_normalization, 4)).get_search_space() # random_specify(outputs) for h in co.unassigned_independent_hyperparameter_iterator(outputs): h.assign_value(1) vi.draw_graph(outputs, draw_module_hyperparameter_info=False) # inputs_val = Input((32, 32, 3)) # co.forward({inputs["in"]: inputs_val}) # outputs_val = outputs["out"].val # model = Model(inputs=inputs_val, outputs=outputs_val) # model.summary()
def __init__(self, search_space_fn, reset_default_scope_upon_sample=True): x = mo.SearchSpaceFactory(search_space_fn, reset_default_scope_upon_sample) self.search_space_fn = x.get_search_space