Function parse_config

src/models/stable_audio/assets.cpp:63–197

    config.same_decoder_sinusoidal_blocks = json::optional_i64_array(decoder_config, "sinusoidal_blocks", std::vector<int64_t>(config.same_decoder_transformer_depths.size(), 0));
    config.same_sliding_window = json::optional_i64_array(encoder_config, "sliding_window");
    config.same_differential = json::optional_bool(encoder_config, "differential", true);
    if (config.same_differential != json::optional_bool(decoder_config, "differential", config.same_differential)) {
        throw std::runtime_error("Stable Audio SAME encoder/decoder differential settings must match");
    }
    config.same_variable_stride = json::optional_bool(encoder_config, "variable_stride", false);
    if (config.same_variable_stride != json::optional_bool(decoder_config, "variable_stride", config.same_variable_stride)) {
        throw std::runtime_error("Stable Audio SAME encoder/decoder variable_stride settings must match");
    }
    config.same_encoder_conv_mapping = json::optional_bool(encoder_config, "conv_mapping", false);
    config.same_decoder_conv_mapping = json::optional_bool(decoder_config, "conv_mapping", false);
    config.same_chunk_midpoint_shift =
        json::optional_bool(encoder_config, "chunk_midpoint_shift", false) ||
        json::optional_bool(decoder_config, "chunk_midpoint_shift", false);
    config.same_encoder_mask_noise = json::optional_f32(encoder_config, "mask_noise", 0.0F);
    config.same_decoder_mask_noise = json::optional_f32(decoder_config, "mask_noise", 0.0F);
    const auto & bottleneck = pretransform_config.require("bottleneck");
    if (const auto * bottleneck_config = bottleneck.find("config"); bottleneck_config != nullptr && bottleneck_config->is_object()) {
        config.same_bottleneck_noise_regularize = json::optional_bool(*bottleneck_config, "noise_regularize", false);
        config.same_bottleneck_auto_scale = json::optional_bool(*bottleneck_config, "auto_scale", false);
        config.same_bottleneck_noise_augment_dim = json::optional_i64(*bottleneck_config, "noise_augment_dim", 0);
    }

    const auto & conditioning = model.require("conditioning");
    config.cond_dim = json::require_i64(conditioning, "cond_dim");
    for (const auto & item : conditioning.require("configs").as_array()) {
        const std::string id = json::require_string(item, "id");
        const std::string type = json::require_string(item, "type");
        const auto & item_config = item.require("config");
        if (id == "prompt") {
            config.prompt_conditioner_type = type;
            config.prompt_max_length = json::require_i64(item_config, "max_length");
        } else if (id == "seconds_total" && type == "number") {
            config.seconds_min = json::require_f32(item_config, "min_val");
            config.seconds_max = json::require_f32(item_config, "max_val");
        }
    }
    if (config.prompt_conditioner_type.empty()) {
        throw std::runtime_error("Stable Audio config is missing prompt conditioner");
    }
    if (config.prompt_conditioner_type != "t5gemma" && config.prompt_conditioner_type != "t5") {
        throw std::runtime_error("Stable Audio unsupported prompt conditioner type: " + config.prompt_conditioner_type);
    }

    const auto & diffusion = model.require("diffusion");
    config.diffusion_type = json::require_string(diffusion, "type");
    config.diffusion_objective = json::optional_string(diffusion, "diffusion_objective", "v");
    if (const auto * shift = diffusion.find("sampling_distribution_shift_options"); shift != nullptr && !shift->is_null()) {
        config.distribution_shift_type = json::optional_string(*shift, "type", "full");
        config.distribution_shift_base_shift = json::optional_f32(*shift, "base_shift", 0.5F);
        config.distribution_shift_max_shift = json::optional_f32(*shift, "max_shift", 1.15F);
        config.distribution_shift_min_length = json::optional_i64(*shift, "min_length", 256);
        config.distribution_shift_max_length = json::optional_i64(*shift, "max_length", 4096);
        config.distribution_shift_use_sine = json::optional_bool(*shift, "use_sine", false);
    }
    const auto & diffusion_config = diffusion.require("config");
    config.diffusion_io_channels = json::require_i64(diffusion_config, "io_channels");
    config.embed_dim = json::require_i64(diffusion_config, "embed_dim");
    config.depth = json::require_i64(diffusion_config, "depth");