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)