def METHOD_NAME(lbann):
    """Construct LBANN model.
    Args:
        lbann (module): Module for LBANN Python frontend
    """
    from lbann.modules.rnn import ChannelwiseGRU
    # Input data
    # Note: Sum with a weights layer so that gradient checking will
    # verify that error signals are correct.
    x_weights = lbann.Weights(initializer=lbann.ConstantInitializer(value=0.0),
                              name='input')
    h_weights = lbann.Weights(initializer=lbann.ConstantInitializer(value=0.0),
                              name='inital_hidden')
    input_ = lbann.Input(data_field='samples')
    input_slice = lbann.Slice(
        input_,
        slice_points=[0, _num_channels*_input_size, _sample_size],
    )
    x = lbann.Reshape(input_slice, dims=[_num_channels,_input_size], name="input_reshape")
    x = lbann.Sum(x, lbann.WeightsLayer(weights=x_weights, dims=[_num_channels,_input_size]), name="input_sum")
    h = lbann.Reshape(input_slice, dims=[_num_channels,_hidden_size],name="hidden_reshape")
    h = lbann.Sum(h, lbann.WeightsLayer(weights=h_weights, dims=[_num_channels,_hidden_size]), name="input_hidden_sum")
    x_lbann = x
    h_lbann = h
    # Objects for LBANN model
    obj = []
    metrics = []
    callbacks = []
    # Weights
    rnn_weights_numpy = []
    ih_matrix = np.random.uniform(
        low=-1,
        high=1,
        size=(3*_hidden_size,_input_size),
    )
    hh_matrix = np.random.uniform(
        low=-1,
        high=1,
        size=(3*_hidden_size,_hidden_size),
    )
    ih_bias = np.random.uniform(low=-1, high=1, size=(3*_hidden_size,))
    hh_bias = np.random.uniform(low=-1, high=1, size=(3*_hidden_size,))
    rnn_weights_numpy.extend([ih_matrix, ih_bias, hh_matrix, hh_bias])
    rnn_weights_lbann = [
        lbann.Weights(
            initializer=lbann.ValueInitializer(
                values=np.nditer(w, order='F')))
        for w in rnn_weights_numpy
    ]
    # LBANN implementation
    x = x_lbann
    h = h_lbann
    channelwise_GRU_cell = ChannelwiseGRU(num_channels=_num_channels,
                                          size=_hidden_size,
                                          weights=rnn_weights_lbann)
    y = channelwise_GRU_cell(x, h)
    z = lbann.L2Norm2(y)
    obj.append(z)
    metrics.append(lbann.Metric(z, name="Multi-channel, Unidirectional, GRU Cell"))
    # NumPy implementation
    vals = []
    for i in range(num_samples()):
        input_ = get_sample(i).astype(np.float64)
        x = input_[:_num_channels*_input_size].reshape((_num_channels,_input_size))
        h = input_[_num_channels*_input_size:].reshape((_num_channels,_hidden_size))
        y = numpy_gru_cell(x, h, rnn_weights_numpy)
        z = tools.numpy_l2norm2(y)
        vals.append(z)
    val = np.mean(vals)
    tol = 8 * val * np.finfo(np.float32).eps
    callbacks.append(lbann.CallbackPrintModelDescription())
    callbacks.append(lbann.CallbackCheckMetric(
        metric=metrics[-1].name,
        lower_bound=val-tol,
        upper_bound=val+tol,
        error_on_failure=True,
        execution_modes='test'))
    # ------------------------------------------
    # Gradient checking
    # ------------------------------------------
    callbacks.append(lbann.CallbackCheckGradients(error_on_failure=True))
    # ------------------------------------------
    # Construct model
    # ------------------------------------------
    num_epochs = 0
    return lbann.Model(num_epochs,
                       layers=lbann.traverse_layer_graph(x_lbann),
                       objective_function=obj,
                       metrics=metrics,
                       callbacks=callbacks)