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 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 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 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_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
) """ ## Customized Search Space For advanced users, you may customize your search space by using AutoModel instead of ImageClassifier. You can configure the ImageBlock for some high-level configurations, e.g., block_type for the type of neural network to search, normalize for whether to do data normalization, augment for whether to do data augmentation. You can also do not specify these arguments, which would leave the different choices to be tuned automatically. See the following example for detail. """ 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, max_trials=1) clf.fit(x_train, y_train, epochs=10) """ The usage of AutoModel is similar to the functional API of Keras. Basically, you are building a graph, whose edges are blocks and the nodes are intermediate outputs of blocks. To add an edge from input_node to output_node with output_node = ak.[some_block]([block_args])(input_node). You can even also use more fine grained blocks to customize the search space even further. See the following example. """
data # encoding labels base on task(regession/classification) # train-test split data_train, data_test = train_test_split(data, train_size=0.8, random_state=123) # validation/cross-validation applied data_train, data_val = train_test_split(data_train, train_size=0.8, random_state=456) # build AutoML (e.g. autokeras & try one from semi-scratch) input_node = ak.ImageInput() output_node = ak.ImageBlock()(input_node) output_node = ak.ClassificationHead() model = ak.AutoModel(tuner='bayesian', inputs=input_node, outputs=output_node, max_trials=100, overwrite=True, seed=10) # Train model model.fit(x_train, y_train, epochs=200, validation_data=(x_val, y_val)) # Evaluate model score = model.evaluate(x_test, y_test) print(score)
def autokeras_train(self, ui): import autokeras as ak # simple pre-processing required of just scaling the data # autokeras makes a mess of reshaping input and one hot encoding label outputs by creating a custom layer # load the training and testing data, then scale it into the range [0, 1] print("[INFO] pre-processing", ui.dataset, "...") trainX, trainY, testX, testY = pre_processor(ui) for model in range(ui.ak_model): # train our Auto-Keras model print("[INFO] Training a new Autokeras model: ", model) # max_trials is max number of Keras Models to try. # search may finish before reaching the max_trials. Defaults to 100. # for exhaustive search set max_trials=50 if ui.optimize == 'autokeras': print("Training with Autokeras ..") test_model = ak.ImageClassifier(max_trials=ui.ak_trial, seed=ui.my_seed) if ui.optimize == 'automodel': print("Training with Automodel ..") input_node = ak.ImageInput() output_node = ak.ImageBlock( # Specify architecture subset to search block_type=ui.ak_seek, # Normalize the dataset normalize=True, # don't use data augmentation. augment=False)(input_node) output_node = ak.ClassificationHead()(output_node) test_model = ak.AutoModel(inputs=input_node, outputs=output_node, max_trials=ui.ak_trial, objective="val_accuracy", seed=ui.my_seed) # number of epochs to train each model during search, if unspecified, defaults to max of 1000. # Training stops if the validation loss stops improving for 10 epochs. # for exhaustive search set epochs=100 test_model.fit(trainX, trainY, validation_split=0.3, epochs=ui.epochs, verbose=2) print("saving the model ..") best_model = test_model.export_model() best_model.summary() filename = ui.dataset + '-' + 'model_number_' + str(model) + '.h5' print("filename: ", filename) best_model.save(filename) # Save the model return
num_classes = 10 shape = (28, 28, 1) # Simple (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() auto_pipeline = ak.ImageClassifier(shape, num_classes) # Loss, optimizer are picked automatically auto_pipeline.fit(x_train, y_train) # The predict function should output the labels instead of numerical vectors. auto_pipeline.predict(x_test) # Intermediate inputs = ak.ImageInput(shape=...) x = ak.ImageBlock(inputs) head = ak.ClassificationHead(num_classes, metrics=['accuracy']) outputs = head(x) automodel = ak.GraphAutoModel(inputs=inputs, outputs=outputs) # Loss, optimizer are picked automatically automodel.fit(x_train, y_train) # Advanced inputs = ak.ImageInput(shape=...) outputs1 = ak.ResNetBlock()(inputs) outputs2 = ak.XceptionBlock()(inputs) outputs = ak.Merge()((outputs1, outputs2)) outputs = ak.ClassificationHead(num_classes)(outputs) automodel = ak.GraphAutoModel(inputs=inputs, outputs=outputs)