def network_builder(topology, op_sets, input_dropout=None, dropout=None,
    regularizer=None, constraint=None, output_activation=None, use_bias=True):
    """Building Keras model using given topology and parameters

    Args:
        topology (list): Data about network topology
        op_sets (dict): Operator sets of each block
        input_dropout (float): Dropout applied to input layer, default None
        dropout (float): Dropout applied to hidden layers, default None
        regularizer (float): Weight decay coefficient, default None
        constraint (float): Max-norm constraint of weights, default None
        output_activation (str): Optional activation applied to output layer, default None
        use_bias (bool): Allow using bias if True

    Returns:
        Keras model without compilation

    """
    from ..layers import gop
    from keras.layers import Dropout, Input, Dense, BatchNormalization as BN, Concatenate
    from keras.models import Model
    from keras import regularizers, constraints
    inputs = Input((topology[0],))
    if input_dropout:
        hiddens = Dropout(input_dropout, name='input_dropout')(inputs)
    else:
        hiddens = inputs
    no_layer = len(topology)
    for layer_idx in range(1, no_layer - 1):
        layer_blocks = []
        layer_output_dim = 0
        no_block = len(topology[layer_idx])
        for block_idx in range(no_block):
            suffix = '_' + str(layer_idx - 1) + '_' + str(block_idx)
            block_type, units = topology[layer_idx][block_idx]
            layer_output_dim += units
            if block_type == 'gop':
                hiddens_ = gop.GOP(units, op_sets[block_type + suffix],
                    regularizer, constraint, use_bias, name='gop' + suffix)(
                    hiddens)
                hiddens_ = BN(name='bn' + suffix)(hiddens_)
            elif block_type == 'mem':
                hiddens_ = BN(name='mem_pre_bn' + suffix)(hiddens)
                hiddens_ = Dense(units, use_bias=use_bias, name='mem' + suffix
                    )(hiddens_)
                hiddens_ = BN(name='bn' + suffix)(hiddens_)
            else:
                raise ('Invalid block type ´´%s´´' % block_type)
            layer_blocks.append(hiddens_)
        if len(layer_blocks) > 1:
            hiddens = Concatenate(axis=-1, name='concat_' + str(layer_idx - 1)
                )(layer_blocks)
        else:
            hiddens = layer_blocks[0]
        if dropout:
            hiddens = Dropout(dropout, name='dropout_' + str(layer_idx - 1))(
                hiddens)
    output_type, output_units = topology[-1]
    if output_type == 'dense':
        outputs = Dense(output_units, kernel_regularizer=regularizers.l2(
            regularizer) if regularizer else None, kernel_constraint=
            constraints.max_norm(constraint, axis=0) if constraint else
            None, activation=output_activation, use_bias=use_bias, name=
            'output')(hiddens)
    elif output_type == 'gop':
        outputs = gop.GOP(output_units, op_sets['output'], regularizer,
            constraint, use_bias, name='output')(hiddens)
    model = Model(inputs=inputs, outputs=outputs)
    return model
