Ejemplo n.º 1
0
def test_transformer_base():
    reset_session()
    # Construct the layer
    from rinokeras.core.v1x.models.transformer import Transformer
    layer = Transformer(discrete=True,
                        n_symbols_in=16,
                        n_symbols_out=16,
                        n_layers=6,
                        n_heads=4,
                        d_model=32,
                        d_filter=16)

    # Make sure that the layer is not None
    assert layer is not None

    # Encoded values
    source_tensor, _ = random_sequence_tensor(2, 32, 16)
    target_tensor, _ = random_sequence_tensor(2, 32, 16)
    source_mask, _ = random_mask_tensor(2, 32)
    target_mask, _ = random_mask_tensor(2, 32)

    # Get the output of the layer
    value = layer((source_tensor, target_tensor),
                  mask=(source_mask, target_mask))

    # Create a named temporary file for save/restore testing
    with tempfile.TemporaryFile() as weights_file:

        # Construct the session
        output = run_simple_session_save_weights(inputs=[value],
                                                 feed={},
                                                 weights=[layer],
                                                 weights_file=weights_file)

        assert_not_none(output)
        assert_expected_shapes(output, [(2, 32, 16)])

        # Check loading and restoring
        load_restore_test(output=output,
                          inputs=[value],
                          feed={},
                          weights=[layer],
                          weights_file=weights_file)

    # Do regression testing
    check_regression('transformer_base',
                     output,
                     __file__,
                     'regression_outputs/test_transformer_outputs.json',
                     debug=_RK_REBUILD_REGRESSION)

    # Do a config test
    from_config_test(Transformer, layer)
Ejemplo n.º 2
0
def test_qanet_base():
    reset_session()
    # Construct the layer
    from rinokeras.core.v1x.models.qanet import QANet
    layer = QANet(n_chars=32, n_symbols=32)

    # Make sure that the layer is not None
    assert layer is not None

    # Encoded values
    context_tensor, _ = random_sequence_tensor(2, 8, 32)
    query_tensor, _ = random_sequence_tensor(2, 8, 32)
    context_char_tensor = tf.convert_to_tensor(
        np.random.randint(0, 32, (2, 8, 16)))
    query_char_tensor = tf.convert_to_tensor(
        np.random.randint(0, 32, (2, 8, 16)))

    # Get the output of the layer
    value = layer(
        (context_tensor, query_tensor, context_char_tensor, query_char_tensor))

    # Create a named temporary file for save/restore testing
    with tempfile.TemporaryFile() as weights_file:

        # Construct the session
        output = run_simple_session_save_weights(inputs=[value],
                                                 feed={},
                                                 weights=[layer],
                                                 weights_file=weights_file)

        assert_not_none(output)
        assert_expected_shapes(output, [(2, 8, 128)])

        # Check loading and restoring
        load_restore_test(output=output,
                          inputs=[value],
                          feed={},
                          weights=[layer],
                          weights_file=weights_file)

    # Do regression testing
    check_regression('qanet_base_expected_output',
                     output,
                     __file__,
                     'regression_outputs/test_qanet_outputs.json',
                     debug=_RK_REBUILD_REGRESSION)

    # Do a config test
    from_config_test(QANet, layer)
Ejemplo n.º 3
0
def test_convert_to_attention_mask_2():
    reset_session()
    # Construct the layer
    from rinokeras.core.v1x.utils import convert_to_attention_mask
    # Encoded values
    input_tensor, _ = random_sequence_tensor(2, 32, 128)
    input_mask, _ = random_mask_tensor(2, 32)

    # Get the output of the layer
    value = convert_to_attention_mask(input_tensor, input_mask)
    # Construct the session
    output = run_simple_session(inputs=[value], feed={})
    assert_not_none(output)
    assert_expected_shapes(output, [(2, 32, 32)])
    # Do regression testing
    check_regression('convert_to_attention_mask_2',
                     output,
                     __file__,
                     'regression_outputs/test_utils_outputs.json',
                     debug=_RK_REBUILD_REGRESSION)