def make_model(
        config,
        peptide_length=9):
    """
    If we're using a learned vector embedding for amino acids
    then generate a network that expects index inputs,
    otherwise assume a 1-of-k binary encoding.
    """
    print("===")
    print(config)
    if config.embedding_size:
        return make_embedding_network(
            peptide_length=peptide_length,
            embedding_input_dim=20,
            embedding_output_dim=config.embedding_size,
            layer_sizes=[config.hidden_layer_size],
            activation=config.activation,
            init=config.init,
            loss=config.loss,
            dropout_probability=config.dropout_probability,
            learning_rate=config.learning_rate,
            optimizer=config.optimizer)
    else:
        return make_hotshot_network(
            peptide_length=peptide_length,
            layer_sizes=[config.hidden_layer_size],
            activation=config.activation,
            init=config.init,
            loss=config.loss,
            dropout_probability=config.dropout_probability,
            learning_rate=config.learning_rate,
            optimizer=config.optimizer)
def test_make_embedding_network_properties():
    layer_sizes = [3, 4]
    nn = make_embedding_network(
        peptide_length=3,
        n_amino_acids=3,
        layer_sizes=layer_sizes,
        loss=mse,
        optimizer=RMSprop(lr=0.7, rho=0.9, epsilon=1e-6),
        batch_normalization=False,)
    eq_(nn.layers[0].input_dim, 3)
    eq_(nn.loss, mse)
    assert np.allclose(nn.optimizer.lr.eval(), 0.7)
    print(nn.layers)
    # embedding + flatten + (dense->activation) * hidden layers and last layer
    eq_(len(nn.layers), 2 + 2 * (1 + len(layer_sizes)))
def test_make_embedding_network_properties():
    layer_sizes = [3, 4]
    nn = make_embedding_network(
        peptide_length=3,
        n_amino_acids=3,
        layer_sizes=layer_sizes,
        loss=mse,
        optimizer=RMSprop(lr=0.7, rho=0.9, epsilon=1e-6),
        batch_normalization=False,
    )
    eq_(nn.layers[0].input_dim, 3)
    eq_(nn.loss, mse)
    assert np.allclose(nn.optimizer.lr.eval(), 0.7)
    print(nn.layers)
    # embedding + flatten + (dense->activation) * hidden layers and last layer
    eq_(len(nn.layers), 2 + 2 * (1 + len(layer_sizes)))
def test_make_embedding_network_small_dataset():
    nn = make_embedding_network(peptide_length=3,
                                n_amino_acids=3,
                                layer_sizes=[3],
                                activation="tanh",
                                init="lecun_uniform",
                                loss="mse",
                                embedding_output_dim=20,
                                optimizer=RMSprop(lr=0.05,
                                                  rho=0.9,
                                                  epsilon=1e-6),
                                batch_normalization=False)
    X_negative = np.array([
        [0] * 3,
        [1] * 3,
        [1, 0, 0],
        [1, 1, 0],
        [0, 1, 0],
        [0, 0, 1],
        [1, 0, 1],
    ])
    X_positive = np.array([
        [0, 2, 0],
        [1, 2, 0],
        [1, 2, 1],
        [0, 2, 1],
        [2, 2, 0],
        [2, 2, 1],
        [2, 2, 2],
    ])
    X_index = np.vstack([X_negative, X_positive])
    Y = np.array([0.0] * len(X_negative) + [1.0] * len(X_positive))
    nn.fit(X_index, Y, nb_epoch=20)
    Y_pred = nn.predict(X_index)
    print(Y)
    print(Y_pred)
    for (Y_i, Y_pred_i) in zip(Y, Y_pred):
        assert abs(Y_i - Y_pred_i) <= 0.25, (Y_i, Y_pred_i)
def test_make_embedding_network_small_dataset():
    nn = make_embedding_network(
        peptide_length=3,
        n_amino_acids=3,
        layer_sizes=[3],
        activation="tanh",
        init="lecun_uniform",
        loss="mse",
        embedding_output_dim=20,
        optimizer=RMSprop(lr=0.05, rho=0.9, epsilon=1e-6),
        batch_normalization=False)
    X_negative = np.array([
        [0] * 3,
        [1] * 3,
        [1, 0, 0],
        [1, 1, 0],
        [0, 1, 0],
        [0, 0, 1],
        [1, 0, 1],
    ])
    X_positive = np.array([
        [0, 2, 0],
        [1, 2, 0],
        [1, 2, 1],
        [0, 2, 1],
        [2, 2, 0],
        [2, 2, 1],
        [2, 2, 2],
    ])
    X_index = np.vstack([X_negative, X_positive])
    Y = np.array([0.0] * len(X_negative) + [1.0] * len(X_positive))
    nn.fit(X_index, Y, nb_epoch=20)
    Y_pred = nn.predict(X_index)
    print(Y)
    print(Y_pred)
    for (Y_i, Y_pred_i) in zip(Y, Y_pred):
        assert abs(Y_i - Y_pred_i) <= 0.25, (Y_i, Y_pred_i)