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
