Method run

src/models/chatterbox/s3gen_flow.cpp:933–968

          output_frames_(frames * 2),
          embed_prelook_runner_(weights, frames, hidden_size, backend_config),
          upsample_runner_(weights, frames, hidden_size, backend_config),
          after_norm_runner_(weights.after_norm, *weights.execution_context, output_frames_, hidden_size, backend_config) {
        encoder_runners_.reserve(weights.encoders.size());
        for (const auto & layer : weights.encoders) {
            encoder_runners_.push_back(
                std::make_unique<FlowEncoderLayerBackendRunner>(
                    layer, *weights.execution_context, input_frames_, hidden_size_, backend_config));
        }
        up_encoder_runners_.reserve(weights.up_encoders.size());
        for (const auto & layer : weights.up_encoders) {
            up_encoder_runners_.push_back(
                std::make_unique<FlowEncoderLayerBackendRunner>(
                    layer, *weights.execution_context, output_frames_, hidden_size_, backend_config));
        }
    }

    S3FlowEncoderOutputs run(const std::vector<float> & input, int64_t valid_frames) {
        const auto attention_mask_values = make_attention_key_mask(1, input_frames_, input_frames_, valid_frames);
        embed_prelook_runner_.write_input(input);
        embed_prelook_runner_.compute();

        auto * previous_output = &embed_prelook_runner_.output_tensor();
        for (auto & runner : encoder_runners_) {
            runner->write_attention_mask(attention_mask_values);
            copy_backend_tensor(*previous_output, runner->input_tensor());
            runner->compute();
            previous_output = &runner->output_tensor();
        }

        copy_backend_tensor(*previous_output, upsample_runner_.input_tensor());
        upsample_runner_.compute();

        const int64_t valid_output_frames = valid_frames * 2;
        const auto up_attention_mask_values = make_attention_key_mask(1, output_frames_, output_frames_, valid_output_frames);
        previous_output = &upsample_runner_.output_tensor();
        for (auto & runner : up_encoder_runners_) {
            runner->write_attention_mask(up_attention_mask_values);
            copy_backend_tensor(*previous_output, runner->input_tensor());
            runner->compute();