Method build

src/framework/codecs/neural_audio.cpp:121–178

}

TensorValue SEANetDecoder::build(
    engine::core::ModuleBuildContext & ctx,
    const TensorValue & input,
    const SEANetDecoderWeights & weights) const {
    if (weights.stages.size() != config_.stage_channels.size()) {
        throw std::runtime_error("SEANetDecoderWeights stage count does not match config");
    }

    int64_t current_channels = config_.input_channels;
    auto x = StreamingConv1dModule({
        config_.input_channels,
        config_.input_channels,
        7,
        1,
        1,
        config_.use_bias,
        config_.pad_mode,
    }).build(ctx, input, weights.input_projection);

    for (size_t stage_index = 0; stage_index < config_.stage_channels.size(); ++stage_index) {
        const int64_t next_channels = config_.stage_channels[stage_index];
        const int stride = static_cast<int>(config_.stage_strides[stage_index]);
        const int64_t kernel_size = static_cast<int64_t>(stride) * 2;
        x = EluModule().build(ctx, x);
        x = build_streaming_convtranspose1d(ctx, x, weights.stages[stage_index].upsample, current_channels, next_channels, kernel_size, stride, config_.use_bias);

        if (weights.stages[stage_index].residual_blocks.size() != static_cast<size_t>(config_.residual_layers)) {
            throw std::runtime_error("SEANetDecoder stage residual block count does not match config.residual_layers");
        }
        for (int64_t residual_index = 0; residual_index < config_.residual_layers; ++residual_index) {
            int64_t dilation = 1;
            for (int64_t i = 0; i < residual_index; ++i) {
                dilation *= config_.residual_dilation_base;
            }
            x = build_seanet_residual_block(
                ctx,
                x,
                weights.stages[stage_index].residual_blocks[static_cast<size_t>(residual_index)],
                next_channels,
                next_channels / config_.residual_hidden_divisor,
                dilation,
                config_.use_bias,
                config_.pad_mode);
        }
        current_channels = next_channels;
    }

    x = EluModule().build(ctx, x);
    return StreamingConv1dModule({
        current_channels,
        config_.output_channels,
        config_.final_kernel_size,
        1,
        1,
        config_.use_bias,
        config_.pad_mode,
    }).build(ctx, x, weights.output_projection);
}