def test_graph_save_load(tmp_path): input1 = ak.Input() input2 = ak.Input() output1 = ak.DenseBlock()(input1) output2 = ak.ConvBlock()(input2) output = ak.Merge()([output1, output2]) output1 = ak.RegressionHead()(output) output2 = ak.ClassificationHead()(output) graph = graph_module.Graph( inputs=[input1, input2], outputs=[output1, output2], override_hps=[ hp_module.Choice("dense_block_1/num_layers", [6], default=6) ], ) path = os.path.join(tmp_path, "graph") graph.save(path) graph = graph_module.load_graph(path) assert len(graph.inputs) == 2 assert len(graph.outputs) == 2 assert isinstance(graph.inputs[0].out_blocks[0], ak.DenseBlock) assert isinstance(graph.inputs[1].out_blocks[0], ak.ConvBlock) assert isinstance(graph.override_hps[0], hp_module.Choice)
def test_image_blocks(tmp_path): num_instances = 10 (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train[:num_instances] y_regression = utils.generate_data(num_instances=num_instances, shape=(1, )) input_node = ak.ImageInput() output = ak.Normalization()(input_node) output = ak.ImageAugmentation()(output) outputs1 = ak.ResNetBlock(version="v2")(output) outputs2 = ak.XceptionBlock()(output) output_node = ak.Merge()((outputs1, outputs2)) output_node = ak.ClassificationHead()(output_node) automodel = ak.AutoModel( inputs=input_node, outputs=output_node, directory=tmp_path, max_trials=1, seed=utils.SEED, ) automodel.fit(x_train, y_regression, validation_data=(x_train, y_regression), epochs=1)
def train(): (x_train, y_train), (x_test, y_test) = mnist.load_data() # Initialize the image classifier. input_node = ak.ImageInput() output_node = ak.ImageBlock( # Only search ResNet architectures. block_type="resnet", # Normalize the dataset. normalize=True, # Do not do data augmentation. augment=False, )(input_node) output_node = ak.ClassificationHead()(output_node) clf = ak.AutoModel(inputs=input_node, outputs=output_node, overwrite=True, max_trials=1) # Feed the image classifier with training data. clf.fit( x_train, y_train, # Split the training data and use the last 15% as validation data. validation_split=0.15, epochs=10, ) # Predict with the best model. predicted_y = clf.predict(x_test) print(predicted_y) # Evaluate the best model with testing data. print(clf.evaluate(x_test, y_test))
def test_io_api(tmp_path): num_instances = 100 (image_x, train_y), (test_x, test_y) = mnist.load_data() (text_x, train_y), (test_x, test_y) = utils.imdb_raw(num_instances=num_instances) image_x = image_x[:num_instances] text_x = text_x[:num_instances] structured_data_x = utils.generate_structured_data( num_instances=num_instances) classification_y = utils.generate_one_hot_labels( num_instances=num_instances, num_classes=3) regression_y = utils.generate_data(num_instances=num_instances, shape=(1, )) # Build model and train. automodel = ak.AutoModel( inputs=[ak.ImageInput(), ak.TextInput(), ak.StructuredDataInput()], outputs=[ ak.RegressionHead(metrics=['mae']), ak.ClassificationHead(loss='categorical_crossentropy', metrics=['accuracy']) ], directory=tmp_path, max_trials=2, seed=utils.SEED) automodel.fit([image_x, text_x, structured_data_x], [regression_y, classification_y], epochs=1, validation_split=0.2)
def test_io_api(tmp_path): num_instances = 20 image_x = utils.generate_data(num_instances=num_instances, shape=(28, 28)) text_x = utils.generate_text_data(num_instances=num_instances) image_x = image_x[:num_instances] structured_data_x = (pd.read_csv(utils.TRAIN_CSV_PATH).to_numpy().astype( np.unicode)[:num_instances]) classification_y = utils.generate_one_hot_labels( num_instances=num_instances, num_classes=3) regression_y = utils.generate_data(num_instances=num_instances, shape=(1, )) # Build model and train. automodel = ak.AutoModel( inputs=[ak.ImageInput(), ak.TextInput(), ak.StructuredDataInput()], outputs=[ ak.RegressionHead(metrics=["mae"]), ak.ClassificationHead(loss="categorical_crossentropy", metrics=["accuracy"]), ], directory=tmp_path, max_trials=2, tuner=ak.RandomSearch, seed=utils.SEED, ) automodel.fit( [image_x, text_x, structured_data_x], [regression_y, classification_y], epochs=1, validation_split=0.2, batch_size=4, )
def test_graph_can_init_with_one_missing_output(): input_node = ak.ImageInput() output_node = ak.ConvBlock()(input_node) output_node = ak.RegressionHead()(output_node) ak.ClassificationHead()(output_node) graph_module.Graph(input_node, output_node)
def test_greedy_oracle_populate_doesnt_crash_with_init_hps(get_best_trials): hp = keras_tuner.HyperParameters() tf.keras.backend.clear_session() input_node = ak.ImageInput(shape=(32, 32, 3)) input_node.batch_size = 32 input_node.num_samples = 1000 output_node = ak.ImageBlock()(input_node) head = ak.ClassificationHead(num_classes=10) head.shape = (10, ) output_node = head(output_node) graph = ak.graph.Graph(inputs=input_node, outputs=output_node) graph.build(hp) oracle = greedy.GreedyOracle( initial_hps=task_specific.IMAGE_CLASSIFIER, objective="val_loss", seed=utils.SEED, ) trial = mock.Mock() trial.hyperparameters = hp get_best_trials.return_value = [trial] for i in range(10): tf.keras.backend.clear_session() values = oracle.populate_space("a")["values"] hp = oracle.hyperparameters.copy() hp.values = values graph.build(hp) oracle.update_space(hp)
def test_image_blocks(tmp_path): num_instances = 10 x_train = test_utils.generate_data(num_instances=num_instances, shape=(28, 28)) y_train = np.random.randint(0, 10, num_instances) input_node = ak.ImageInput() output = ak.Normalization()(input_node) output = ak.ImageAugmentation()(output) outputs1 = ak.ResNetBlock(version="v2")(output) outputs2 = ak.XceptionBlock()(output) output_node = ak.Merge()((outputs1, outputs2)) output_node = ak.ClassificationHead()(output_node) automodel = ak.AutoModel( inputs=input_node, outputs=output_node, directory=tmp_path, max_trials=1, seed=test_utils.SEED, ) automodel.fit(x_train, y_train, validation_data=(x_train, y_train), epochs=1)
def test_graph_save_load(tmp_dir): input1 = ak.Input() input2 = ak.Input() output1 = ak.DenseBlock()(input1) output2 = ak.ConvBlock()(input2) output = ak.Merge()([output1, output2]) output1 = ak.RegressionHead()(output) output2 = ak.ClassificationHead()(output) graph = graph_module.HyperGraph(inputs=[input1, input2], outputs=[output1, output2], override_hps=[ hp_module.Choice( 'dense_block_1/num_layers', [6], default=6) ]) path = os.path.join(tmp_dir, 'graph') graph.save(path) config = graph.get_config() graph = graph_module.HyperGraph.from_config(config) graph.reload(path) assert len(graph.inputs) == 2 assert len(graph.outputs) == 2 assert isinstance(graph.inputs[0].out_blocks[0], ak.DenseBlock) assert isinstance(graph.inputs[1].out_blocks[0], ak.ConvBlock) assert isinstance(graph.override_hps[0], hp_module.Choice)
def build_graph(): tf.keras.backend.clear_session() image_input = ak.ImageInput(shape=(32, 32, 3)) merged_outputs = ak.ImageBlock()(image_input) head = ak.ClassificationHead(num_classes=10) head.output_shape = (10, ) classification_outputs = head(merged_outputs) return ak.graph.Graph(inputs=image_input, outputs=classification_outputs)
def io_api(): (x_train, y_train), (x_test, y_test) = mnist.load_data() clf = ak.AutoModel(ak.ImageInput(), ak.ClassificationHead(), seed=5, max_trials=3) clf.fit(x_train, y_train, validation_split=0.2) return clf.evaluate(x_test, y_test)
def test_image_classifier_tuner1(): tf.keras.backend.clear_session() input_node = ak.ImageInput(shape=(32, 32, 3)) output_node = ak.ImageBlock()(input_node) output_node = ak.ClassificationHead(loss='categorical_crossentropy', output_shape=(10, ))(output_node) graph = graph_module.Graph(input_node, output_node) check_initial_hp(task_specific.IMAGE_CLASSIFIER[1], graph)
def test_text_classifier_tuner0(): tf.keras.backend.clear_session() input_node = ak.TextInput(shape=(1, )) output_node = ak.TextBlock()(input_node) output_node = ak.ClassificationHead(loss='categorical_crossentropy', output_shape=(10, ))(output_node) graph = graph_module.Graph(input_node, output_node) check_initial_hp(task_specific.TEXT_CLASSIFIER[0], graph)
def build_graph(): tf.keras.backend.clear_session() image_input = ak.ImageInput(shape=(32, 32, 3)) image_input.batch_size = 32 image_input.num_samples = 1000 merged_outputs = ak.SpatialReduction()(image_input) head = ak.ClassificationHead(num_classes=10, shape=(10, )) classification_outputs = head(merged_outputs) return ak.graph.Graph(inputs=image_input, outputs=classification_outputs)
def test_structured_data_block(): block = hyperblock_module.StructuredDataBlock() block.heads = [ak.ClassificationHead()] block.set_state(block.get_state()) hp = kerastuner.HyperParameters() block.build(hp, ak.Input()) assert common.name_in_hps('module_type', hp)
def train_ak(): image_count = len(list(config.database_path.glob('**/*.jpg'))) print("# of images found:", image_count) list_ds = tf.data.Dataset.list_files(str(config.database_path / '*/*.jpg'), shuffle=False) list_ds = list_ds.shuffle(image_count, reshuffle_each_iteration=False) # Set `num_parallel_calls` so multiple images are loaded/processed in parallel. AUTOTUNE = tf.data.experimental.AUTOTUNE train_ds = list_ds.map(utils.process_path, num_parallel_calls=AUTOTUNE) features = np.array([list(x[0].numpy()) for x in list(train_ds)]) labels = np.array([x[1].numpy() for x in list(train_ds)]) input_node = ak.ImageInput() output_node = ak.Normalization()(input_node) output_node = ak.ImageAugmentation(horizontal_flip=False, vertical_flip=False, rotation_factor=False, zoom_factor=False)(output_node) output_node = ak.ClassificationHead()(output_node) clf = ak.AutoModel(inputs=input_node, outputs=output_node, overwrite=True, max_trials=config.max_trials, directory=config.outpath_mpii) # Feed the tensorflow Dataset to the classifier. split = config.split x_val = features[split:] y_val = labels[split:] x_train = features[:split] y_train = labels[:split] clf.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=config.epochs) # Predict with the best model. #predicted_y = clf.predict(x_val) #print(predicted_y) # Evaluate the best model with testing data. print(clf.evaluate(x_val, y_val)) # Export as a Keras Model. model = clf.export_model() print( type(model)) # <class 'tensorflow.python.keras.engine.training.Model'> model.save(config.output_path + "model_ak_imgClsf.h5") return 0
def test_functional_api(tmp_dir): # Prepare the data. num_instances = 20 (image_x, train_y), (test_x, test_y) = mnist.load_data() (text_x, train_y), (test_x, test_y) = common.imdb_raw() (structured_data_x, train_y), (test_x, test_y) = common.dataframe_numpy() image_x = image_x[:num_instances] text_x = text_x[:num_instances] structured_data_x = structured_data_x[:num_instances] classification_y = common.generate_one_hot_labels( num_instances=num_instances, num_classes=3) regression_y = common.generate_data(num_instances=num_instances, shape=(1, )) # Build model and train. image_input = ak.ImageInput() output = ak.Normalization()(image_input) output = ak.ImageAugmentation()(output) outputs1 = ak.ResNetBlock(version='next')(image_input) outputs2 = ak.XceptionBlock()(image_input) image_output = ak.Merge()((outputs1, outputs2)) structured_data_input = ak.StructuredDataInput( column_names=common.COLUMN_NAMES_FROM_CSV, column_types=common.COLUMN_TYPES_FROM_CSV) structured_data_output = ak.FeatureEngineering()(structured_data_input) structured_data_output = ak.DenseBlock()(structured_data_output) text_input = ak.TextInput() outputs1 = ak.TextToIntSequence()(text_input) outputs1 = ak.EmbeddingBlock()(outputs1) outputs1 = ak.ConvBlock(separable=True)(outputs1) outputs1 = ak.SpatialReduction()(outputs1) outputs2 = ak.TextToNgramVector()(text_input) outputs2 = ak.DenseBlock()(outputs2) text_output = ak.Merge()((outputs1, outputs2)) merged_outputs = ak.Merge()( (structured_data_output, image_output, text_output)) regression_outputs = ak.RegressionHead()(merged_outputs) classification_outputs = ak.ClassificationHead()(merged_outputs) automodel = ak.GraphAutoModel( inputs=[image_input, text_input, structured_data_input], directory=tmp_dir, outputs=[regression_outputs, classification_outputs], max_trials=2, seed=common.SEED) automodel.fit((image_x, text_x, structured_data_x), (regression_y, classification_y), validation_split=0.2, epochs=2)
def build_model(): input_layer = ak.Input() cnn_layer = ak.ConvBlock()(input_layer) cnn_layer2 = ak.ConvBlock()(cnn_layer) dense_layer = ak.DenseBlock()(cnn_layer2) dense_layer2 = ak.DenseBlock()(dense_layer) output_layer = ak.ClassificationHead(num_classes=10)(dense_layer2) automodel = ak.auto_model.AutoModel(input_layer, output_layer, max_trials=20, seed=123, project_name='autoML') return automodel
def test_partial_column_types(): input_node = node.StructuredDataInput( column_names=common.COLUMN_NAMES_FROM_CSV, column_types=common.PARTIAL_COLUMN_TYPES_FROM_CSV) (x, y), (val_x, val_y) = common.dataframe_numpy() dataset = tf.data.Dataset.zip( ((tf.data.Dataset.from_tensor_slices(x.values.astype(np.unicode)), ), (tf.data.Dataset.from_tensor_slices(y), ))) hm = meta_model.assemble(input_node, ak.ClassificationHead(), dataset) for block in hm._blocks: if isinstance(block, ak.FeatureEngineering): assert block.input_node.column_types['fare'] == 'categorical'
def functional_api(): (x_train, y_train), (x_test, y_test) = mnist.load_data() input_node = ak.ImageInput() output_node = input_node output_node = ak.Normalization()(output_node) output_node = ak.ConvBlock()(output_node) output_node = ak.SpatialReduction()(output_node) output_node = ak.DenseBlock()(output_node) output_node = ak.ClassificationHead()(output_node) clf = ak.GraphAutoModel(input_node, output_node, seed=5, max_trials=3) clf.fit(x_train, y_train, validation_split=0.2) return clf.evaluate(x_test, y_test)
def test_functional_api(tmp_path): # Prepare the data. num_instances = 80 (image_x, train_y), (test_x, test_y) = mnist.load_data() (text_x, train_y), (test_x, test_y) = utils.imdb_raw() (structured_data_x, train_y), (test_x, test_y) = utils.dataframe_numpy() image_x = image_x[:num_instances] text_x = text_x[:num_instances] structured_data_x = structured_data_x[:num_instances] classification_y = utils.generate_one_hot_labels( num_instances=num_instances, num_classes=3) regression_y = utils.generate_data(num_instances=num_instances, shape=(1, )) # Build model and train. image_input = ak.ImageInput() output = ak.Normalization()(image_input) output = ak.ImageAugmentation()(output) outputs1 = ak.ResNetBlock(version='next')(output) outputs2 = ak.XceptionBlock()(output) image_output = ak.Merge()((outputs1, outputs2)) structured_data_input = ak.StructuredDataInput() structured_data_output = ak.CategoricalToNumerical()(structured_data_input) structured_data_output = ak.DenseBlock()(structured_data_output) text_input = ak.TextInput() outputs1 = ak.TextToIntSequence()(text_input) outputs1 = ak.Embedding()(outputs1) outputs1 = ak.ConvBlock(separable=True)(outputs1) outputs1 = ak.SpatialReduction()(outputs1) outputs2 = ak.TextToNgramVector()(text_input) outputs2 = ak.DenseBlock()(outputs2) text_output = ak.Merge()((outputs1, outputs2)) merged_outputs = ak.Merge()( (structured_data_output, image_output, text_output)) regression_outputs = ak.RegressionHead()(merged_outputs) classification_outputs = ak.ClassificationHead()(merged_outputs) automodel = ak.AutoModel( inputs=[image_input, text_input, structured_data_input], directory=tmp_path, outputs=[regression_outputs, classification_outputs], max_trials=2, tuner=ak.Hyperband, seed=utils.SEED) automodel.fit((image_x, text_x, structured_data_x), (regression_y, classification_y), validation_split=0.2, epochs=1)
def CreateSupergraph(output_dir, hp_tuner): input_node = ak.Input() conv2d_1 = ak.ConvBlock(num_blocks=1, num_layers=3, max_pooling=True, dropout=0)(input_node) dense_1 = ak.DenseBlock(dropout=0)(conv2d_1) output_node = ak.ClassificationHead(num_classes=4, metrics=['accuracy'])(dense_1) automodel = ak.AutoModel(inputs=input_node, outputs=output_node, max_trials=3, directory=output_dir, project_name="autoML", tuner=hp_tuner, seed=123) return automodel
def functional_api(): (x_train, y_train), (x_test, y_test) = cifar10.load_data() input_node = ak.ImageInput() output_node = input_node output_node = ak.Normalization()(output_node) output_node = ak.ImageAugmentation()(output_node) output_node = ak.ResNetBlock(version='next')(output_node) output_node = ak.SpatialReduction()(output_node) output_node = ak.DenseBlock()(output_node) output_node = ak.ClassificationHead()(output_node) clf = ak.AutoModel(input_node, output_node, seed=5, max_trials=3) clf.fit(x_train, y_train, validation_split=0.2) return clf.evaluate(x_test, y_test)
def train(): TRAIN_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/train.csv" TEST_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/eval.csv" train_file_path = tf.keras.utils.get_file("train.csv", TRAIN_DATA_URL) test_file_path = tf.keras.utils.get_file("eval.csv", TEST_DATA_URL) # x_train as pandas.DataFrame, y_train as pandas.Series x_train = pd.read_csv(train_file_path) print(type(x_train)) # pandas.DataFrame y_train = x_train.pop('survived') print(type(y_train)) # pandas.Series # You can also use pandas.DataFrame for y_train. y_train = pd.DataFrame(y_train) print(type(y_train)) # pandas.DataFrame # You can also use numpy.ndarray for x_train and y_train. x_train = x_train.to_numpy().astype(np.unicode) y_train = y_train.to_numpy() print(type(x_train)) # numpy.ndarray print(type(y_train)) # numpy.ndarray # Preparing testing data. x_test = pd.read_csv(test_file_path) y_test = x_test.pop('survived') # Initialize the structured data classifier. input_node = ak.StructuredDataInput() output_node = ak.StructuredDataBlock( categorical_encoding=True)(input_node) output_node = ak.ClassificationHead()(output_node) clf = ak.AutoModel(inputs=input_node, outputs=output_node, overwrite=True, max_trials=3) # Feed the structured data classifier with training data. clf.fit( x_train, y_train, # Split the training data and use the last 15% as validation data. validation_split=0.15, epochs=10) # Predict with the best model. predicted_y = clf.predict(test_file_path) # Evaluate the best model with testing data. print(clf.evaluate(test_file_path, 'survived'))
def test_multi_model(): context = an.AutoMLPipeline( an.MultiModel( inputs=[ak.ImageInput(), ak.StructuredDataInput()], outputs=[ ak.RegressionHead(metrics=["mae"]), ak.ClassificationHead(loss="categorical_crossentropy", metrics=["accuracy"]), ], overwrite=True, max_trials=2, )) context.run_automl() assert context.return_automl["model"] != None
def train(): # Load the integer sequence the IMDB dataset with Keras. index_offset = 3 # word index offset (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=1000, index_from=index_offset) y_train = y_train.reshape(-1, 1) y_test = y_test.reshape(-1, 1) # Prepare the dictionary of index to word. word_to_id = imdb.get_word_index() word_to_id = {k: (v + index_offset) for k, v in word_to_id.items()} word_to_id["<PAD>"] = 0 word_to_id["<START>"] = 1 word_to_id["<UNK>"] = 2 id_to_word = {value: key for key, value in word_to_id.items()} # Convert the word indices to words. x_train = list( map(lambda sentence: ' '.join(id_to_word[i] for i in sentence), x_train)) x_test = list( map(lambda sentence: ' '.join(id_to_word[i] for i in sentence), x_test)) x_train = np.array(x_train, dtype=np.str) x_test = np.array(x_test, dtype=np.str) # Initialize the text classifier. input_node = ak.TextInput() output_node = ak.TextBlock(vectorizer='ngram')(input_node) output_node = ak.ClassificationHead()(output_node) clf = ak.AutoModel(inputs=input_node, outputs=output_node, overwrite=True, max_trials=1) clf.fit(x_train, y_train, epochs=2) # Feed the text classifier with training data. clf.fit( x_train, y_train, # Split the training data and use the last 15% as validation data. validation_split=0.15) # Predict with the best model. predicted_y = clf.predict(x_test) # Evaluate the best model with testing data. print(clf.evaluate(x_test, y_test))
def test_text_and_structured_data(tmp_path): # Prepare the data. num_instances = 80 (x_text, y_train), (x_test, y_test) = utils.imdb_raw() x_structured_data = pd.read_csv(utils.TRAIN_CSV_PATH) x_text = x_text[:num_instances] x_structured_data = x_structured_data[:num_instances] y_classification = utils.generate_one_hot_labels( num_instances=num_instances, num_classes=3) y_regression = utils.generate_data(num_instances=num_instances, shape=(1, )) # Build model and train. structured_data_input = ak.StructuredDataInput() structured_data_output = ak.CategoricalToNumerical()(structured_data_input) structured_data_output = ak.DenseBlock()(structured_data_output) text_input = ak.TextInput() outputs1 = ak.TextToIntSequence()(text_input) outputs1 = ak.Embedding()(outputs1) outputs1 = ak.ConvBlock(separable=True)(outputs1) outputs1 = ak.SpatialReduction()(outputs1) outputs2 = ak.TextToNgramVector()(text_input) outputs2 = ak.DenseBlock()(outputs2) text_output = ak.Merge()((outputs1, outputs2)) merged_outputs = ak.Merge()((structured_data_output, text_output)) regression_outputs = ak.RegressionHead()(merged_outputs) classification_outputs = ak.ClassificationHead()(merged_outputs) automodel = ak.AutoModel( inputs=[text_input, structured_data_input], directory=tmp_path, outputs=[regression_outputs, classification_outputs], max_trials=2, tuner=ak.Hyperband, seed=utils.SEED, ) automodel.fit( (x_text, x_structured_data), (y_regression, y_classification), validation_split=0.2, epochs=1, )
def test_resnet_block(_, tmp_dir): x_train = np.random.rand(100, 32, 32, 3) y_train = np.random.randint(10, size=100) y_train = tf.keras.utils.to_categorical(y_train) input_node = ak.Input() output_node = input_node output_node = ak.ResNetBlock()(output_node) output_node = ak.ClassificationHead()(output_node) graph = ak.GraphAutoModel(input_node, output_node, directory=tmp_dir, max_trials=1) graph.fit(x_train, y_train, epochs=1, batch_size=100, verbose=False, validation_split=0.2)
def test_xception_block(tmp_dir): x_train = np.random.rand(100, 32, 32, 3) y_train = np.random.randint(10, size=100) y_train = tf.keras.utils.to_categorical(y_train) input_node = ak.Input() output_node = input_node output_node = ak.XceptionBlock()(output_node) output_node = ak.ClassificationHead()(output_node) input_node.shape = (32, 32, 3) output_node[0].shape = (10, ) graph = ak.GraphAutoModel(input_node, output_node, directory=tmp_dir) model = graph.build(kerastuner.HyperParameters()) model.fit(x_train, y_train, epochs=1, batch_size=100, verbose=False) result = model.predict(x_train) assert result.shape == (100, 10)
def test_image_classifier_oracle(): tf.keras.backend.clear_session() input_node = ak.ImageInput(shape=(32, 32, 3)) output_node = ak.ImageBlock()(input_node) output_node = ak.ClassificationHead(loss='categorical_crossentropy', output_shape=(10, ))(output_node) graph = graph_module.Graph(input_node, output_node) oracle = greedy.GreedyOracle(hypermodel=graph, initial_hps=task_specific.IMAGE_CLASSIFIER, objective='val_loss') oracle._populate_space('0') hp = oracle.get_space() hp.values = task_specific.IMAGE_CLASSIFIER[0] assert len( set(task_specific.IMAGE_CLASSIFIER[0].keys()) - set(oracle.get_space().values.keys())) == 0 oracle._populate_space('1') assert len( set(task_specific.IMAGE_CLASSIFIER[1].keys()) - set(oracle.get_space().values.keys())) == 0