How to use the autokeras.Input function in autokeras

def test_conv_block(tmp_dir):
    x_train = np.random.rand(100, 3, 3, 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.ConvBlock()(output_node)
    output_node = ak.ClassificationHead()(output_node)

    input_node.shape = (3, 3, 3)
    output_node[0].shape = (10,)

    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)
    result = graph.predict(x_train)

def test_evaluate(tmp_dir):
    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)

def test_rnn_block(tmp_dir):
    x_train = np.random.rand(100, 32, 10)
    y_train = np.random.randint(5, size=100)
    y_train = tf.keras.utils.to_categorical(y_train)

    input_node = ak.Input()
    output_node = input_node
    output_node = ak.RNNBlock()(output_node)
    output_node = ak.ClassificationHead()(output_node)

    input_node.shape = (32, 10)
    output_node[0].shape = (5,)

    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)
    result = graph.predict(x_train)

def test_merge(tmp_dir):
    x_train = np.random.rand(100, 33)
    y_train = np.random.rand(100, 1)

    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)

    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,
              verbose=False,
              validation_split=0.5)
    result = graph.predict([x_train, x_train])

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 test_add_early_stopping(_2, get_trials, _1, _, run_trial, tmp_dir):
    trial = kerastuner.engine.trial.Trial()
    trial.hyperparameters = kerastuner.HyperParameters()
    get_trials.return_value = [trial]
    input_shape = (32,)
    num_instances = 100
    num_classes = 10
    x = common.generate_data(num_instances=num_instances,
                             shape=input_shape,
                             dtype='dataset')
    y = common.generate_one_hot_labels(num_instances=num_instances,
                                       num_classes=num_classes,
                                       dtype='dataset')

    input_node = ak.Input(shape=input_shape)
    output_node = input_node
    output_node = ak.DenseBlock()(output_node)
    output_node = ak.ClassificationHead(output_shape=(num_classes,))(output_node)
    hypermodel = ak.hypermodel.graph.HyperBuiltGraphHyperModel(input_node,
                                                               output_node)
    tuner = ak.tuner.RandomSearch(
        hypermodel=hypermodel,
        objective='val_loss',
        max_trials=1,
        directory=tmp_dir,
        seed=common.SEED)
    tuner.search(x=tf.data.Dataset.zip((x, y)),
                 validation_data=(x, y),
                 epochs=20,
                 callbacks=[])

def test_hyper_graph_cycle(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])
    head = ak.RegressionHead()
    output_node = head(output_node)
    head.outputs = output_node1

    with pytest.raises(ValueError) as info:
        ak.GraphAutoModel([input_node1, input_node2],
                          output_node,
                          directory=tmp_dir)
    assert str(info.value) == 'The network has a cycle.'

def test_preprocessing(_, tmp_dir):
    x_train = np.random.rand(100, 33)
    y_train = np.random.rand(100, 1)

    input_node1 = ak.Input()
    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()
    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 = ak.GraphAutoModel([input_node1, input_node2],
                              output_node,
                              directory=tmp_dir,

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 = ak.hypermodel.graph.HyperBuiltGraphHyperModel(input_node, output_node)
    hp = kerastuner.HyperParameters()
    graph.set_hps([hp_module.Choice('dense_block_1/num_layers', [6], default=6)])
    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