def get_multi_io_auto_model(tmp_path):
return ak.AutoModel(
[ak.ImageInput(), ak.ImageInput()],
[ak.RegressionHead(), ak.RegressionHead()],
directory=tmp_path,
max_trials=2,
overwrite=False)
def dataset_error(x, y, validation_data, message, tmp_path):
auto_model = ak.AutoModel(
[ak.ImageInput(), ak.ImageInput()],
[ak.RegressionHead(), ak.RegressionHead()],
directory=tmp_path,
max_trials=2,
overwrite=False)
with pytest.raises(ValueError) as info:
auto_model.fit(x, y, epochs=2, validation_data=validation_data)
assert message in str(info.value)
def test_multi_io_with_tf_dataset(tuner_fn, tmp_path):
auto_model = ak.AutoModel(
[ak.ImageInput(), ak.ImageInput()],
[ak.RegressionHead(), ak.RegressionHead()],
directory=tmp_path,
max_trials=2,
overwrite=False)
x1 = utils.generate_data()
y1 = utils.generate_data(shape=(1, ))
dataset = tf.data.Dataset.from_tensor_slices(((x1, x1), (y1, y1)))
auto_model.fit(dataset, epochs=2)
for adapter in auto_model._input_adapters + auto_model._output_adapters:
assert adapter.shape is not None
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_evaluate(tuner_fn, tmp_dir):
pg = mock.Mock()
pg.preprocess.return_value = (mock.Mock(), mock.Mock())
tuner_class = tuner_fn.return_value
tuner = tuner_class.return_value
tuner.get_best_model.return_value = (pg, mock.Mock())
x_train = np.random.rand(100, 32)
y_train = np.random.rand(100, 1)
input_node = ak.Input()
output_node = input_node
output_node = ak.DenseBlock()(output_node)
output_node = ak.RegressionHead()(output_node)
auto_model = ak.GraphAutoModel(input_node,
output_node,
directory=tmp_dir,
max_trials=1)
auto_model.fit(x_train,
y_train,
epochs=1,
validation_data=(x_train, y_train))
auto_model.evaluate(x_train, y_train)
assert tuner_fn.called
assert tuner_class.called
assert tuner.get_best_model.called
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_merge(tmp_dir):
x_train = np.random.rand(100, 32)
y_train = np.random.rand(100)
input_node1 = ak.Input()
input_node2 = ak.Input()
output_node1 = ak.DenseBlock()(input_node1)
output_node2 = ak.DenseBlock()(input_node2)
output_node = ak.Merge()([output_node1, output_node2])
output_node = ak.RegressionHead()(output_node)
input_node1.shape = (32, )
input_node2.shape = (32, )
output_node[0].shape = (1, )
graph = ak.GraphAutoModel([input_node1, input_node2],
output_node,
directory=tmp_dir)
model = graph.build(kerastuner.HyperParameters())
model.fit([x_train, x_train],
y_train,
epochs=1,
batch_size=100,
verbose=False)
result = model.predict([x_train, x_train])
assert result.shape == (100, 1)
def test_preprocessing():
input_shape = (33, )
output_shape = (1, )
x_train_1 = common.generate_data(num_instances=100,
shape=input_shape,
dtype='dataset')
x_train_2 = common.generate_data(num_instances=100,
shape=input_shape,
dtype='dataset')
y_train = common.generate_data(num_instances=100,
shape=output_shape,
dtype='dataset')
dataset = tf.data.Dataset.zip(((x_train_1, x_train_2), y_train))
input_node1 = ak.Input(shape=input_shape)
temp_node1 = ak.Normalization()(input_node1)
output_node1 = ak.DenseBlock()(temp_node1)
output_node3 = ak.Normalization()(temp_node1)
output_node3 = ak.DenseBlock()(output_node3)
input_node2 = ak.Input(shape=input_shape)
output_node2 = ak.Normalization()(input_node2)
output_node2 = ak.DenseBlock()(output_node2)
output_node = ak.Merge()([output_node1, output_node2, output_node3])
output_node = ak.RegressionHead()(output_node)
graph = graph_module.HyperBuiltGraphHyperModel([input_node1, input_node2],
output_node)
graph.preprocess(hp=kerastuner.HyperParameters(),
dataset=dataset,
validation_data=dataset,
fit=True)
def main():
deaths, recoveries, cases, deaths_validation, recoveries_validation, cases_validation = get_dfs()
X, y = get_ds(deaths, recoveries, cases)
X_train, X_test, y_train, y_test = train_test_split(X, y)
data = convert_dfs(deaths_validation, recoveries_validation, cases_validation)
column_names = []
model_input = ak.Input()
model_output = ak.blocks.basic.DenseBlock()(model_input)
model_output = ak.blocks.basic.DenseBlock()(model_output)
model_output = ak.blocks.basic.DenseBlock()(model_output)
model_output = ak.RegressionHead()(model_output)
trainer = ak.AutoModel(inputs=model_input, outputs=model_output)
trainer.fit(X_train, y_train)
model = trainer.export_model()
y_fit = model.predict(X_test)
tf.keras.models.save_model(model, 'model.tf')
with open('data.json', 'wt') as f:
json.dump(data, f)
print(model.evaluate(X_test, y_test))
plt.scatter(y_test, y_fit)
plt.savefig('results.png')
def test_preprocessing(tmp_dir):
x_train = np.random.rand(100, 32)
y_train = np.random.rand(100)
input_node1 = ak.Input()
temp_node1 = ak.Normalize()(input_node1)
output_node1 = ak.DenseBlock()(temp_node1)
output_node3 = ak.Normalize()(temp_node1)
output_node3 = ak.DenseBlock()(output_node3)
input_node2 = ak.Input()
output_node2 = ak.Normalize()(input_node2)
output_node2 = ak.DenseBlock()(output_node2)
output_node = ak.Merge()([output_node1, output_node2, output_node3])
output_node = ak.RegressionHead()(output_node)
graph = ak.GraphAutoModel([input_node1, input_node2],
output_node,
directory=tmp_dir,
max_trials=1)
graph.fit([x_train, x_train],
y_train,
epochs=1,
batch_size=100,
validation_data=([x_train, x_train], y_train),
validation_split=0.5,
verbose=False)
result = graph.predict([x_train, x_train])
assert result.shape == (100, 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 train():
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Initialize the image regressor.
input_node = ak.ImageInput()
output_node = ak.ImageBlock(
# Only search ResNet architectures.
block_type="resnet",
# Normalize the dataset.
normalize=False,
# Do not do data augmentation.
augment=False,
)(input_node)
output_node = ak.RegressionHead()(output_node)
reg = ak.AutoModel(inputs=input_node,
outputs=output_node,
overwrite=True,
max_trials=1)
# Feed the image regressor with training data.
reg.fit(
x_train,
y_train,
# Split the training data and use the last 15% as validation data.
validation_split=0.15,
epochs=2,
)
# Predict with the best model.
predicted_y = reg.predict(x_test)
print(predicted_y)
# Evaluate the best model with testing data.
print(reg.evaluate(x_test, y_test))
def test_auto_model_max_trial_field_as_specified(tmp_path):
auto_model = ak.AutoModel(ak.ImageInput(),
ak.RegressionHead(),
directory=tmp_path,
max_trials=10)
assert auto_model.max_trials == 10
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_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 applyAutoKeras(X_train, y_train, X_test, y_test, SavePath,
max_trials=100, epochs=300, useSavedModels = True):
if not useSavedModels or not os.path.isdir(SavePath+"/keras_auto_model/best_model/"):
input_node = ak.StructuredDataInput()
output_node = ak.DenseBlock()(input_node)
#output_node = ak.ConvBlock()(output_node)
output_node = ak.RegressionHead()(output_node)
AKRegressor = ak.AutoModel(
inputs=input_node,
outputs=output_node,
max_trials=max_trials,
overwrite=True,
tuner="bayesian",
project_name=SavePath+"/keras_auto_model"
)
print(" X_train shape: {0}\n y_train shape: {1}\n X_test shape: {2}\n y_test shape: {3}".format(X_train.shape, y_train.shape, X_test.shape, y_test.shape))
AKRegressor.fit(x=X_train, y=y_train[:,0],epochs=epochs,verbose=1, batch_size=int(X_train.shape[0]/10), shuffle=False, use_multiprocessing=True)
AKRegressor.export_model()
else:
AKRegressor = tf.keras.models.load_model(SavePath+"/keras_auto_model/best_model/")
y_hat = AKRegressor.predict(X_test)
print("AUTOKERAS - Score: ")
print("MAE: %.4f" % mean_absolute_error(y_test[:,0], y_hat))
return y_hat
def test_set_hp():
input_node = ak.Input((32, ))
output_node = input_node
output_node = ak.DenseBlock()(output_node)
head = ak.RegressionHead()
head.output_shape = (1, )
output_node = head(output_node)
graph = graph_module.HyperGraph(input_node,
output_node,
override_hps=[
hp_module.Choice(
'dense_block_1/num_layers', [6],
default=6)
])
hp = kerastuner.HyperParameters()
plain_graph = graph.hyper_build(hp)
plain_graph.build_keras_graph().build(hp)
for single_hp in hp.space:
if single_hp.name == 'dense_block_1/num_layers':
assert len(single_hp.values) == 1
assert single_hp.values[0] == 6
return
assert False
def test_invalid_tuner_name_error(tmp_path):
with pytest.raises(ValueError) as info:
ak.AutoModel(
ak.ImageInput(), ak.RegressionHead(), directory=tmp_path, tuner="unknown"
)
assert "Expected the tuner argument to be one of" in str(info.value)
def test_predict_tuple_x_and_tuple_y_predict_doesnt_crash(tuner_fn, tmp_path):
auto_model = ak.AutoModel(ak.ImageInput(),
ak.RegressionHead(),
directory=tmp_path)
dataset = tf.data.Dataset.from_tensor_slices(
((np.random.rand(100, 32, 32, 3), ), (np.random.rand(100, 1), )))
auto_model.fit(dataset)
auto_model.predict(dataset)
def test_auto_model_basic(_, tmp_dir):
x_train = np.random.rand(100, 32, 32, 3)
y_train = np.random.rand(100, 1)
auto_model = ak.AutoModel(ak.ImageInput(),
ak.RegressionHead(),
directory=tmp_dir,
max_trials=2)
auto_model.fit(x_train, y_train, epochs=2, validation_split=0.2)
def test_graph_compile_with_adadelta():
input_node = ak.ImageInput(shape=(32, 32, 3))
output_node = ak.ConvBlock()(input_node)
output_node = ak.RegressionHead(output_shape=(1, ))(output_node)
graph = graph_module.Graph(input_node, output_node)
hp = kerastuner.HyperParameters()
hp.values = {"optimizer": "adadelta"}
graph.build(hp)
def test_auto_model_project_name_field_as_specified(tmp_path):
auto_model = ak.AutoModel(
ak.ImageInput(),
ak.RegressionHead(),
directory=tmp_path,
project_name="auto_model",
)
assert auto_model.project_name == "auto_model"
def test_graph_basics():
input_node = ak.Input(shape=(30, ))
output_node = input_node
output_node = ak.DenseBlock()(output_node)
output_node = ak.RegressionHead(output_shape=(1, ))(output_node)
graph = graph_module.HyperBuiltGraphHyperModel(input_node, output_node)
model = graph.build(kerastuner.HyperParameters())
assert model.input_shape == (None, 30)
assert model.output_shape == (None, 1)
def test_input_missing(tmp_dir):
input_node1 = ak.Input()
input_node2 = ak.Input()
output_node1 = ak.DenseBlock()(input_node1)
output_node2 = ak.DenseBlock()(input_node2)
output_node = ak.Merge()([output_node1, output_node2])
output_node = ak.RegressionHead()(output_node)
with pytest.raises(ValueError) as info:
ak.GraphAutoModel(input_node1, output_node, directory=tmp_dir)
assert str(info.value).startswith('A required input is missing for HyperModel')
def test_auto_model_predict(tuner_fn, tmp_path):
x_train = np.random.rand(100, 32, 32, 3)
y_train = np.random.rand(100, 1)
auto_model = ak.AutoModel(ak.ImageInput(),
ak.RegressionHead(),
directory=tmp_path,
max_trials=2)
auto_model.fit(x_train, y_train, epochs=2, validation_split=0.2)
auto_model.predict(x_train)
assert tuner_fn.called
def test_input_missing():
input_node1 = ak.Input()
input_node2 = ak.Input()
output_node1 = ak.DenseBlock()(input_node1)
output_node2 = ak.DenseBlock()(input_node2)
output_node = ak.Merge()([output_node1, output_node2])
output_node = ak.RegressionHead()(output_node)
with pytest.raises(ValueError) as info:
graph_module.Graph(inputs=input_node1, outputs=output_node)
assert "A required input is missing for HyperModel" in str(info.value)
def test_input_missing():
input_node1 = ak.Input()
input_node2 = ak.Input()
output_node1 = ak.DenseBlock()(input_node1)
output_node2 = ak.DenseBlock()(input_node2)
output_node = ak.Merge()([output_node1, output_node2])
output_node = ak.RegressionHead()(output_node)
with pytest.raises(ValueError) as info:
ak.hypermodel.graph.GraphHyperModel(input_node1, output_node)
assert 'A required input is missing for HyperModel' in str(info.value)
def train():
house_dataset = fetch_california_housing()
df = pd.DataFrame(np.concatenate(
(house_dataset.data, house_dataset.target.reshape(-1, 1)), axis=1),
columns=house_dataset.feature_names + ['Price'])
train_size = int(df.shape[0] * 0.9)
df[:train_size].to_csv('train.csv', index=False)
df[train_size:].to_csv('eval.csv', index=False)
train_file_path = 'train.csv'
test_file_path = 'eval.csv'
# 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('Price')
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('Price')
# Initialize the structured data regressor.
input_node = ak.StructuredDataInput()
output_node = ak.StructuredDataBlock(
categorical_encoding=True)(input_node)
output_node = ak.RegressionHead()(output_node)
reg = ak.AutoModel(inputs=input_node,
outputs=output_node,
overwrite=True,
max_trials=3)
# Feed the structured data regressor with training data.
reg.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 = reg.predict(test_file_path)
# Evaluate the best model with testing data.
print(reg.evaluate(test_file_path, 'Price'))
def create_image_regressor(self):
input_node = ak.ImageInput()
output_node = ak.ConvBlock()(input_node)
output_node = ak.DenseBlock()(output_node)
output_node = ak.RegressionHead()(output_node)
reg = ak.AutoModel(inputs=input_node,
outputs=output_node,
max_trials=10)
return reg
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)
