xybrid-core 0.1.0

Core runtime for hybrid cloud-edge AI inference: model execution, pipeline orchestration, and routing primitives.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Postprocessing step implementations.
//!
//! This module contains all postprocessing operations that transform model outputs
//! into final results:
//!
//! | Module | Operations |
//! |--------|-----------|
//! | [`decode`] | `CTCDecode`, `BPEDecode`, `WhisperDecode` |
//! | [`tensor_ops`] | `Argmax`, `Softmax`, `TopK`, `Threshold`, `MeanPool`, `Denormalize` |
//! | [`audio`] | `TTSAudioEncode` |

pub mod audio;
pub mod codec;
pub mod decode;
pub mod tensor_ops;

use super::types::{ExecutorResult, RawOutputs};
use crate::execution::template::PostprocessingStep;

/// Apply a postprocessing step to data.
///
/// This is the main dispatcher that routes to the appropriate step implementation.
pub fn apply_postprocessing_step(
    step: &PostprocessingStep,
    data: RawOutputs,
    base_path: &str,
) -> ExecutorResult<RawOutputs> {
    match step {
        PostprocessingStep::CTCDecode {
            vocab_file,
            blank_index,
        } => {
            let vocab_path = resolve_file_path(base_path, vocab_file);
            decode::ctc_decode_step(data, &vocab_path, *blank_index)
        }

        PostprocessingStep::BPEDecode { vocab_file } => {
            let vocab_path = resolve_file_path(base_path, vocab_file);
            decode::bpe_decode_step(data, &vocab_path)
        }

        PostprocessingStep::WhisperDecode { tokenizer_file } => {
            let tokenizer_path = resolve_file_path(base_path, tokenizer_file);
            decode::whisper_decode_step(data, &tokenizer_path)
        }

        PostprocessingStep::Argmax { dim } => tensor_ops::argmax_step(data, *dim),

        PostprocessingStep::Softmax { dim } => tensor_ops::softmax_step(data, *dim),

        PostprocessingStep::TopK { k, dim } => tensor_ops::topk_step(data, *k, *dim),

        PostprocessingStep::Threshold {
            threshold,
            return_indices,
        } => tensor_ops::threshold_step(data, *threshold, *return_indices),

        PostprocessingStep::MeanPool { dim } => tensor_ops::meanpool_step(data, *dim),

        PostprocessingStep::TemperatureSample {
            temperature: _,
            top_k: _,
            top_p: _,
        } => {
            // TODO: Implement temperature sampling
            Ok(data)
        }

        PostprocessingStep::Denormalize { mean, std } => {
            tensor_ops::denormalize_step(data, mean, std)
        }

        PostprocessingStep::TTSAudioEncode {
            sample_rate,
            apply_postprocessing,
            trim_trailing_silence,
        } => audio::tts_audio_encode_step(
            data,
            *sample_rate,
            *apply_postprocessing,
            *trim_trailing_silence,
        ),

        PostprocessingStep::CodecDecode { .. } => Err(
            crate::runtime_adapter::AdapterError::InvalidInput(
                "CodecDecode is handled by CodecTtsStrategy, not the generic postprocessing dispatcher".into(),
            ),
        ),
    }
}

/// Resolve a file path relative to base_path.
fn resolve_file_path(base_path: &str, file: &str) -> String {
    if base_path.is_empty() {
        file.to_string()
    } else {
        std::path::Path::new(base_path)
            .join(file)
            .to_string_lossy()
            .to_string()
    }
}