Function load_encoder

src/models/vibevoice/tokenizer_audio.cpp:253–320

}

VibeVoiceTokenizerEncoderWeights load_encoder(
    core::BackendWeightStore & store,
    const assets::TensorSource & source,
    const std::string & prefix,
    const VibeVoiceTokenizerConfig & config,
    assets::TensorStorageType weight_storage_type) {
    validate_tokenizer_config(config, false);
    auto depths = parse_depths(config.encoder_depths, "encoder_depths");
    auto ratios = config.encoder_ratios;
    std::reverse(ratios.begin(), ratios.end());
    if (depths.size() != ratios.size() + 1) {
        throw std::runtime_error("VibeVoice tokenizer encoder depths/ratios mismatch");
    }

    VibeVoiceTokenizerEncoderWeights weights;
    weights.downsample_layers.reserve(depths.size());
    weights.downsample_layers.push_back(load_conv1d(
        store,
        source,
        prefix + ".downsample_layers.0.0.conv.conv",
        config.channels,
        config.encoder_n_filters,
        kTokenizerKernelSize,
        weight_storage_type));
    for (size_t i = 0; i < ratios.size(); ++i) {
        const int64_t in_ch = config.encoder_n_filters * (int64_t{1} << static_cast<int64_t>(i));
        const int64_t out_ch = config.encoder_n_filters * (int64_t{1} << static_cast<int64_t>(i + 1));
        weights.downsample_layers.push_back(load_conv1d(
            store,
            source,
            prefix + ".downsample_layers." + std::to_string(i + 1) + ".0.conv.conv",
            in_ch,
            out_ch,
            ratios[i] * 2,
            weight_storage_type));
    }

    weights.stages.reserve(depths.size());
    for (size_t stage = 0; stage < depths.size(); ++stage) {
        const int64_t channels = config.encoder_n_filters * (int64_t{1} << static_cast<int64_t>(stage));
        std::vector<VibeVoiceTokenizerBlockWeights> blocks;
        blocks.reserve(static_cast<size_t>(depths[stage]));
        for (int64_t block = 0; block < depths[stage]; ++block) {
            blocks.push_back(load_block(
                store,
                source,
                prefix + ".stages." + std::to_string(stage) + "." + std::to_string(block),
                channels,
                weight_storage_type));
        }
        weights.stages.push_back(std::move(blocks));
    }
    const int64_t final_channels = config.encoder_n_filters * (int64_t{1} << static_cast<int64_t>(depths.size() - 1));
    if (config.disable_last_norm) {
        weights.norm = std::nullopt;
    } else {
        weights.norm = source.require_f32_tensor(prefix + ".norm.weight", {final_channels});
    }