Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

Stricter tts configs (#425)

uuuvn44366b1645f6
diff --git a/crates/backend-uzu/src/audio/nanocodec/runtime.rs b/crates/backend-uzu/src/audio/nanocodec/runtime.rs
index 25478b74d..65304cde7 100644
--- a/crates/backend-uzu/src/audio/nanocodec/runtime.rs
+++ b/crates/backend-uzu/src/audio/nanocodec/runtime.rs
@@ -22,8 +22,8 @@ use crate::{
},
},
config::{
- ConfigDataType, DecoderConfig, DescriptAudioCodecConfig, DescriptAudioConvNeXtNormConfig, EmbeddingConfig,
- EmbeddingConfigCommon, TtsAudioDecoderConfig, TtsConfig,
+ ConfigDataType, DecoderConfig, DescriptAudioCodecConfig, EmbeddingConfig, EmbeddingConfigCommon,
+ NormalizationConfig, TtsAudioDecoderConfig, TtsConfig,
},
encodable_block::{Decoder, LayerExecutables, RMSNorm},
forward_pass::{model_shape::ModelShape, state::SharedBuffers},
diff --git a/crates/backend-uzu/src/audio/nanocodec/runtime/loaders.rs b/crates/backend-uzu/src/audio/nanocodec/runtime/loaders.rs
index a81ea9359..6f75dde5a 100644
--- a/crates/backend-uzu/src/audio/nanocodec/runtime/loaders.rs
+++ b/crates/backend-uzu/src/audio/nanocodec/runtime/loaders.rs
@@ -1,37 +1,25 @@
use super::*;
pub(super) fn resolve_descript_audio_codec_vocoder_data_type(
- top_level_precision: Option<ConfigDataType>,
+ top_level_precision: ConfigDataType,
config: &DescriptAudioCodecConfig,
) -> AudioResult<DataType> {
- let mut resolved_precision: Option<ConfigDataType> = None;
+ let resolved_precision = top_level_precision;
for (field_name, precision) in [
- ("tts_config.activation_precision", top_level_precision),
- ("tts_config.audio_decoder_config.precision", Some(config.precision)),
+ ("tts_config.audio_decoder_config.precision", config.precision),
("tts_config.audio_decoder_config.quantizer_config.precision", config.quantizer_config.precision),
] {
- if let Some(precision) = precision {
- if let Some(existing) = resolved_precision {
- if existing != precision {
- return Err(AudioError::Runtime(format!(
- "conflicting DescriptAudioCodec precision in Lalamo export: {field_name}={precision:?} conflicts with {existing:?}"
- )));
- }
- } else {
- resolved_precision = Some(precision);
- }
+ if resolved_precision != precision {
+ return Err(AudioError::Runtime(format!(
+ "conflicting DescriptAudioCodec precision in Lalamo export: {field_name}={precision:?} conflicts with {resolved_precision:?}"
+ )));
}
}
- let precision = resolved_precision.ok_or(AudioError::Runtime(
- "missing DescriptAudioCodec precision in Lalamo export; expected one of tts_config.activation_precision, \
-tts_config.audio_decoder_config.precision, or tts_config.audio_decoder_config.quantizer_config.precision"
- .to_string(),
- ))?;
- let data_type: DataType = precision.into();
+ let data_type: DataType = resolved_precision.into();
if !matches!(data_type, DataType::F32 | DataType::F16 | DataType::BF16) {
return Err(AudioError::Runtime(format!(
- "unsupported DescriptAudioCodec vocoder precision in Lalamo export: {precision:?} (expected float32/float16/bfloat16)"
+ "unsupported DescriptAudioCodec vocoder precision in Lalamo export: {resolved_precision:?} (expected float32/float16/bfloat16)"
)));
}
Ok(data_type)
@@ -42,9 +30,7 @@ pub(super) fn load_audio_runtime_from_tts_config(
model_path: &Path,
) -> AudioResult<(RuntimeConfigJson, StructuredAudioCodecGraph)> {
let cfg = match &tts_config.audio_decoder_config {
- TtsAudioDecoderConfig::DescriptAudioCodecConfig {
- config,
- } => config,
+ TtsAudioDecoderConfig::DescriptAudioCodec(config) => config,
};
let fishaudio_weights = model_path.join("model.safetensors");
if !fishaudio_weights.is_file() {
diff --git a/crates/backend-uzu/src/audio/nanocodec/runtime/structured/build.rs b/crates/backend-uzu/src/audio/nanocodec/runtime/structured/build.rs
index cc0b16259..d6e718cfe 100644
--- a/crates/backend-uzu/src/audio/nanocodec/runtime/structured/build.rs
+++ b/crates/backend-uzu/src/audio/nanocodec/runtime/structured/build.rs
@@ -190,7 +190,7 @@ pub(super) fn read_convnext_layer<B: Backend>(
context: &Rc<B::Context>,
tree: &BackendParameterTree<B>,
data_type: DataType,
- norm_config: &DescriptAudioConvNeXtNormConfig,
+ norm_config: &NormalizationConfig,
) -> AudioResult<StructuredAudioConvNeXt<B>> {
let depthwise_tree = tree.subtree("dwconv")?;
let (depthwise_shape, depthwise_weight) = read_float_array::<B, 3>(&depthwise_tree, "weights", data_type)?;
diff --git a/crates/backend-uzu/src/config/metadata.rs b/crates/backend-uzu/src/config/metadata.rs
index 792cf08ba..a52151cff 100644
--- a/crates/backend-uzu/src/config/metadata.rs
+++ b/crates/backend-uzu/src/config/metadata.rs
@@ -1,18 +1,26 @@
-use serde::{Deserialize, Serialize};
+use proc_macros::uzu_config;
-use super::ModelType;
-use crate::backends::common::gpu_types::QuantizationMode;
+use super::{ClassifierModelConfig, LanguageModelConfig, ModelType};
+#[cfg(metal_backend)]
+use super::TtsModelConfig;
+use crate::{backends::common::gpu_types::QuantizationMode, utils::strict_serde::DeserializeStrictOwned};
-// TODO: Switch to #[uzu_config] once tts configs are migrated too
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct ModelMetadata<T> {
+#[uzu_config]
+#[serde(untagged)]
+pub enum ModelConfig {
+ LanguageModel(LanguageModelConfig),
+ ClassifierModel(ClassifierModelConfig),
+ #[cfg(metal_backend)]
+ TtsModel(TtsModelConfig),
+}
+
+#[uzu_config]
+pub struct ModelMetadata<T: DeserializeStrictOwned> {
pub toolchain_version: String,
pub vendor: String,
pub family: String,
pub name: String,
pub size: String,
- #[serde(deserialize_with = "crate::utils::strict_serde::required")]
pub quantization: Option<QuantizationMode>,
pub repo: String,
pub use_cases: Vec<String>,
diff --git a/crates/backend-uzu/src/config/tts_model.rs b/crates/backend-uzu/src/config/tts_model.rs
index a60ab6ee6..b34f9ebfb 100644
--- a/crates/backend-uzu/src/config/tts_model.rs
+++ b/crates/backend-uzu/src/config/tts_model.rs
@@ -1,74 +1,45 @@
-use std::collections::BTreeMap;
#[cfg(metal_backend)]
use std::path::Path;
-use serde::{Deserialize, Serialize};
+use proc_macros::uzu_config;
-use super::{EmbeddingConfig, EmbeddingConfigCommon, LinearConfig, TransformerConfig};
-use crate::ConfigDataType;
+use super::{EmbeddingConfig, EmbeddingConfigCommon, NormalizationConfig, TransformerConfig};
+use crate::{ConfigDataType, backends::common::ActivationConfig};
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct TtsMessageProcessorConfig {
pub prompt_template: String,
- #[serde(default = "default_drop_initial_newline")]
pub drop_initial_newline: bool,
- #[serde(default = "default_system_role_name")]
- pub system_role_name: String,
- #[serde(default = "default_user_role_name")]
- pub user_role_name: String,
- #[serde(default = "default_assistant_role_name")]
- pub assistant_role_name: String,
- #[serde(default = "default_tts_message_fields")]
- pub default_message_fields: BTreeMap<String, String>,
}
-fn default_drop_initial_newline() -> bool {
- true
-}
-
-fn default_system_role_name() -> String {
- String::from("system")
-}
-
-fn default_user_role_name() -> String {
- String::from("user")
-}
-
-fn default_assistant_role_name() -> String {
- String::from("assistant")
-}
-
-fn default_tts_message_fields() -> BTreeMap<String, String> {
- BTreeMap::new()
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct TtsConfig {
pub text_decoder_config: TtsTextDecoderConfig,
pub audio_decoder_config: TtsAudioDecoderConfig,
- #[serde(default)]
- pub activation_precision: Option<ConfigDataType>,
+ pub vocoder_config: NoopVocoderConfig,
+ pub activation_precision: ConfigDataType,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
+pub struct NoopVocoderConfig {}
+
+#[uzu_config]
#[serde(tag = "type")]
pub enum TtsTextDecoderConfig {
- FishAudioTextDecoderConfig {
- #[serde(flatten)]
- config: FishAudioTextDecoderConfig,
- },
+ #[serde(rename = "FishAudioTextDecoderConfig")]
+ FishAudio(FishAudioTextDecoderConfig),
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct FishAudioTextDecoderConfig {
- pub slow_embeddings_config: FishAudioEmbeddingConfig,
+ pub slow_embeddings_config: TiedEmbeddingConfig,
pub slow_model_config: TransformerConfig,
- pub slow_readout_config: FishAudioLinearConfig,
- pub fast_embeddings_config: FishAudioEmbeddingConfig,
+ pub slow_readout_config: FullPrecisionLinearConfig,
+ pub fast_embeddings_config: TiedEmbeddingConfig,
pub fast_model_config: TransformerConfig,
- pub fast_readout_config: FishAudioLinearConfig,
- pub codebook_embeddings_config: FishAudioEmbeddingConfig,
- pub fast_model_projection_config: Option<FishAudioLinearConfig>,
+ pub fast_readout_config: FullPrecisionLinearConfig,
+ pub codebook_embeddings_config: TiedEmbeddingConfig,
+ pub fast_model_projection_config: Option<FullPrecisionLinearConfig>,
pub semantic_token_begin_id: i64,
pub semantic_token_end_id: i64,
pub im_end_token_id: i64,
@@ -79,90 +50,41 @@ pub struct FishAudioTextDecoderConfig {
pub num_codebooks: usize,
pub max_seq_len: usize,
pub scale_codebook_embeddings: bool,
- #[serde(default)]
- pub precision: Option<ConfigDataType>,
+ pub precision: ConfigDataType,
pub short_logits_size: usize,
pub repeat_window_size: usize,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(untagged)]
-pub enum FishAudioLinearConfig {
- Tagged(LinearConfig),
- UntaggedFullPrecision {
- #[serde(rename = "precision")]
- precision: ConfigDataType,
- },
-}
-
-impl FishAudioLinearConfig {
- pub fn is_full_precision(&self) -> bool {
- matches!(
- self,
- FishAudioLinearConfig::Tagged(LinearConfig::FullPrecision { .. })
- | FishAudioLinearConfig::UntaggedFullPrecision { .. }
- )
- }
+#[uzu_config]
+pub struct FullPrecisionLinearConfig {
+ pub precision: ConfigDataType,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(untagged)]
-pub enum FishAudioEmbeddingConfig {
- Tagged(EmbeddingConfig),
- UntaggedFullPrecision {
- input_scale: Option<f32>,
- logit_soft_cap: Option<f32>,
- precision: ConfigDataType,
- },
+#[uzu_config]
+pub struct TiedEmbeddingConfig {
+ #[serde(flatten)]
+ pub common: EmbeddingConfigCommon,
+ pub precision: ConfigDataType,
}
-impl FishAudioEmbeddingConfig {
- pub fn to_embedding_config(&self) -> EmbeddingConfig {
- match self {
- FishAudioEmbeddingConfig::Tagged(config) => config.clone(),
- FishAudioEmbeddingConfig::UntaggedFullPrecision {
- input_scale,
- logit_soft_cap,
- precision,
- } => EmbeddingConfig::Tied {
- common: EmbeddingConfigCommon {
- input_scale: *input_scale,
- logit_soft_cap: *logit_soft_cap,
- },
- precision: *precision,
- },
- }
- }
-
+impl TiedEmbeddingConfig {
#[cfg(metal_backend)]
pub(crate) fn to_text_decoder_embedding_config(&self) -> EmbeddingConfig {
- match self {
- FishAudioEmbeddingConfig::Tagged(config) => config.clone(),
- FishAudioEmbeddingConfig::UntaggedFullPrecision {
- input_scale,
- logit_soft_cap,
- precision,
- } => EmbeddingConfig::Untied {
- common: EmbeddingConfigCommon {
- input_scale: *input_scale,
- logit_soft_cap: *logit_soft_cap,
- },
- precision: *precision,
- },
+ EmbeddingConfig::Untied {
+ common: self.common.clone(),
+ precision: self.precision,
}
}
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
#[serde(tag = "type")]
pub enum TtsAudioDecoderConfig {
- DescriptAudioCodecConfig {
- #[serde(flatten)]
- config: DescriptAudioCodecConfig,
- },
+ #[serde(rename = "DescriptAudioCodecConfig")]
+ DescriptAudioCodec(DescriptAudioCodecConfig),
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct DescriptAudioCodecConfig {
pub precision: ConfigDataType,
pub quantizer_config: DescriptAudioQuantizerConfig,
@@ -180,8 +102,7 @@ pub struct DescriptAudioCodecConfig {
pub semantic_codebook_size: usize,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioDacDecoderConfig {
pub precision: ConfigDataType,
pub conv_config: DescriptAudioCausalConv1dConfig,
@@ -190,8 +111,7 @@ pub struct DescriptAudioDacDecoderConfig {
pub causal: bool,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioDacDecoderBlockConfig {
pub precision: ConfigDataType,
pub snake_config: DescriptAudioSnake1dConfig,
@@ -200,8 +120,7 @@ pub struct DescriptAudioDacDecoderBlockConfig {
pub causal: bool,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioResidualUnitConfig {
pub precision: ConfigDataType,
pub snake_config: DescriptAudioSnake1dConfig,
@@ -209,59 +128,67 @@ pub struct DescriptAudioResidualUnitConfig {
pub causal: bool,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioCausalConv1dConfig {
pub precision: ConfigDataType,
pub has_biases: bool,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioCausalTransposeConv1dConfig {
pub precision: ConfigDataType,
pub has_biases: bool,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[uzu_config]
pub struct DescriptAudioSnake1dConfig {
pub precision: ConfigDataType,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct DescriptAudioQuantizerConfig {
- #[serde(default)]
- pub precision: Option<ConfigDataType>,
+ pub precision: ConfigDataType,
+ pub semantic_quantizer_config: DescriptAudioResidualVectorQuantizeConfig,
+ pub quantizer_config: DescriptAudioResidualVectorQuantizeConfig,
pub post_module_config: TransformerConfig,
pub upsampler_config: DescriptAudioUpsamplerConfig,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
+pub struct DescriptAudioResidualVectorQuantizeConfig {
+ pub precision: ConfigDataType,
+ pub vq_config: DescriptAudioVectorQuantizeConfig,
+}
+
+#[uzu_config]
+pub struct DescriptAudioVectorQuantizeConfig {
+ pub precision: ConfigDataType,
+ pub codebook_config: TiedEmbeddingConfig,
+ pub out_proj_config: FullPrecisionLinearConfig,
+}
+
+#[uzu_config]
pub struct DescriptAudioUpsamplerConfig {
pub block_configs: Vec<DescriptAudioUpsamplingBlockConfig>,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct DescriptAudioUpsamplingBlockConfig {
+ pub precision: ConfigDataType,
+ pub trans_conv_config: DescriptAudioCausalTransposeConv1dConfig,
pub convnext_config: DescriptAudioConvNeXtConfig,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct DescriptAudioConvNeXtConfig {
- pub norm_config: DescriptAudioConvNeXtNormConfig,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
-pub struct DescriptAudioConvNeXtNormConfig {
- pub epsilon: f32,
- #[serde(default)]
- pub subtract_mean: bool,
- #[serde(default)]
- pub use_bias: bool,
+ pub precision: ConfigDataType,
+ pub activation: ActivationConfig,
+ pub dwconv_config: DescriptAudioCausalConv1dConfig,
+ pub norm_config: NormalizationConfig,
+ pub pwconv_config: FullPrecisionLinearConfig,
}
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[uzu_config]
pub struct TtsModelConfig {
pub tts_config: TtsConfig,
pub message_processor_config: TtsMessageProcessorConfig,
diff --git a/crates/backend-uzu/src/inference/model_metadata.rs b/crates/backend-uzu/src/inference/model_metadata.rs
index d45b4cd09..a71afb779 100644
--- a/crates/backend-uzu/src/inference/model_metadata.rs
+++ b/crates/backend-uzu/src/inference/model_metadata.rs
@@ -1,9 +1,8 @@
use std::{fs::File, io::BufReader, path::Path};
-use serde::de::IgnoredAny;
use shoji::types::model::ModelSpecialization;
-use crate::config::{ModelMetadata as InnerModelMetadata, ModelType};
+use crate::config::{ModelConfig, ModelMetadata as InnerModelMetadata, ModelType};
pub struct ModelMetadata {
pub toolchain_version: String,
@@ -13,7 +12,7 @@ pub struct ModelMetadata {
pub fn resolve_model_metadata(model_path: &Path) -> Option<ModelMetadata> {
let config_path = model_path.join("config.json");
let file = File::open(&config_path).ok()?;
- let metadata: InnerModelMetadata<IgnoredAny> = serde_json::from_reader(BufReader::new(file)).ok()?;
+ let metadata: InnerModelMetadata<ModelConfig> = serde_json::from_reader(BufReader::new(file)).ok()?;
let specialization = match metadata.model_type {
ModelType::LanguageModel => ModelSpecialization::Chat {},
ModelType::ClassifierModel => ModelSpecialization::Classification {},
diff --git a/crates/backend-uzu/src/session/tts_session/backend_factory.rs b/crates/backend-uzu/src/session/tts_session/backend_factory.rs
index 0302a2015..2732d11eb 100644
--- a/crates/backend-uzu/src/session/tts_session/backend_factory.rs
+++ b/crates/backend-uzu/src/session/tts_session/backend_factory.rs
@@ -51,10 +51,7 @@ pub(super) fn build_text_decoder_backend<B: Backend>(
options: &TtsSessionOptions,
) -> Result<Box<dyn SemanticDecoderBackend>, Error> {
match &tts_model_config.tts_config.text_decoder_config {
- TtsTextDecoderConfig::FishAudioTextDecoderConfig {
- config,
- } => {
- fishaudio::validate_fishaudio_message_processor_config(&tts_model_config.message_processor_config)?;
+ TtsTextDecoderConfig::FishAudio(config) => {
fishaudio::build_fishaudio_text_decoder_runtime(config, audio, model_path, &options.text_decoder)
},
}
diff --git a/crates/backend-uzu/src/session/tts_session/fishaudio.rs b/crates/backend-uzu/src/session/tts_session/fishaudio.rs
index 3f56851ae..eb87e5091 100644
--- a/crates/backend-uzu/src/session/tts_session/fishaudio.rs
+++ b/crates/backend-uzu/src/session/tts_session/fishaudio.rs
@@ -1,15 +1,11 @@
-use std::{collections::BTreeSet, sync::LazyLock};
-
-use regex::Regex;
-
use super::*;
use crate::{
array::ArrayContextExt,
backends::common::{Allocation, AsBufferRangeRef, DenseBuffer},
- config::{DecoderConfig, TtsMessageProcessorConfig},
+ config::DecoderConfig,
encodable_block::SamplingInputs,
forward_pass::token_inputs::TokenInputs,
- session::types::{TtsModelConfigError, TtsPromptConfigError},
+ session::types::TtsModelConfigError,
};
pub(super) struct FishAudioTextDecoderRuntime<B: Backend> {
@@ -194,29 +190,6 @@ fn validate_fishaudio_decoder_contract(
Ok(semantic_cardinality)
}
-static MESSAGE_FIELD_REF_REGEX: LazyLock<Regex> =
- LazyLock::new(|| Regex::new(r"message\.([A-Za-z_][A-Za-z0-9_]*)").expect("message field regex"));
-
-pub(super) fn validate_fishaudio_message_processor_config(config: &TtsMessageProcessorConfig) -> Result<(), Error> {
- let builtin_fields =
- ["role", "content", "reasoning_content", "speaker_id", "style"].into_iter().collect::<BTreeSet<_>>();
- let referenced_fields = MESSAGE_FIELD_REF_REGEX
- .captures_iter(config.prompt_template.as_str())
- .filter_map(|capture| capture.get(1).map(|field| field.as_str().to_owned()))
- .collect::<BTreeSet<_>>();
-
- for field in referenced_fields {
- if !builtin_fields.contains(field.as_str()) && !config.default_message_fields.contains_key(field.as_str()) {
- return Err(TtsPromptConfigError::MissingDefaultMessageField {
- field: field.into_boxed_str(),
- }
- .into());
- }
- }
-
- Ok(())
-}
-
pub(super) fn build_fishaudio_text_decoder_runtime<B: Backend>(
config: &crate::config::FishAudioTextDecoderConfig,
audio: &AudioGenerationContext<B>,
@@ -235,12 +208,6 @@ pub(super) fn build_fishaudio_text_decoder_runtime<B: Backend>(
audio.codec_cardinality(),
audio_semantic_cardinality,
)?;
- if !config.slow_readout_config.is_full_precision() {
- return Err(Error::UnableToLoadConfig);
- }
- if !config.fast_readout_config.is_full_precision() {
- return Err(Error::UnableToLoadConfig);
- }
if config.slow_model_config.model_dim != config.slow_model_dim {
return Err(Error::UnableToLoadConfig);
}
diff --git a/crates/backend-uzu/src/session/types/error.rs b/crates/backend-uzu/src/session/types/error.rs
index f2f2531ba..794454017 100644
--- a/crates/backend-uzu/src/session/types/error.rs
+++ b/crates/backend-uzu/src/session/types/error.rs
@@ -160,14 +160,6 @@ pub enum TtsModelConfigError {
},
}
-#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
-pub enum TtsPromptConfigError {
- #[error("FishAudio prompt template references message.{field}, but default_message_fields does not provide it")]
- MissingDefaultMessageField {
- field: Box<str>,
- },
-}
-
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("Model folder not found")]
@@ -184,8 +176,6 @@ pub enum Error {
InvalidTtsModelConfig(#[from] TtsModelConfigError),
#[error("Invalid TTS run config: {0}")]
InvalidTtsRunConfig(#[from] TtsRunConfigError),
- #[error("Invalid TTS prompt config: {0}")]
- InvalidTtsPromptConfig(#[from] TtsPromptConfigError),
#[error("Unable to load model weights")]
UnableToLoadWeights,
#[error("Unable to load tokenizer")]
diff --git a/crates/backend-uzu/src/session/types/message.rs b/crates/backend-uzu/src/session/types/message.rs
index c59d6e437..134ead89c 100644
--- a/crates/backend-uzu/src/session/types/message.rs
+++ b/crates/backend-uzu/src/session/types/message.rs
@@ -73,21 +73,12 @@ impl ConfigResolvableValue<MessageProcessorConfig, HashMap<String, String>> for
impl ConfigResolvableValue<TtsMessageProcessorConfig, HashMap<String, String>> for Message {
fn resolve(
&self,
- config: &TtsMessageProcessorConfig,
+ _config: &TtsMessageProcessorConfig,
) -> HashMap<String, String> {
- let role = match self.role {
- Role::System => config.system_role_name.clone(),
- Role::User => config.user_role_name.clone(),
- Role::Assistant => config.assistant_role_name.clone(),
- };
- let mut result: HashMap<String, String> = config.default_message_fields.clone().into_iter().collect();
- result.entry(String::from("speaker_id")).or_insert_with(|| String::from(DEFAULT_TTS_SPEAKER_ID));
- result.entry(String::from("style")).or_insert_with(|| String::from(DEFAULT_TTS_STYLE));
- result.insert(String::from("role"), role);
- result.insert(String::from("content"), self.content.clone());
- if let Some(reasoning_content) = self.reasoning_content.clone() {
- result.insert(String::from("reasoning_content"), reasoning_content);
- }
- result
+ HashMap::from([
+ (String::from("content"), self.content.clone()),
+ (String::from("speaker_id"), String::from(DEFAULT_TTS_SPEAKER_ID)),
+ (String::from("style"), String::from(DEFAULT_TTS_STYLE)),
+ ])
}
}
diff --git a/crates/backend-uzu/src/session/types/mod.rs b/crates/backend-uzu/src/session/types/mod.rs
index 85e4668b4..347da0aa3 100644
--- a/crates/backend-uzu/src/session/types/mod.rs
+++ b/crates/backend-uzu/src/session/types/mod.rs
@@ -5,7 +5,7 @@ mod output;
mod role;
mod stats;
mod text;
-pub use error::{Error, TtsModelConfigError, TtsPromptConfigError};
+pub use error::{Error, TtsModelConfigError};
pub use input::Input;
pub use message::Message;
pub use output::{FinishReason, Output};
diff --git a/crates/backend-uzu/src/utils/strict_serde.rs b/crates/backend-uzu/src/utils/strict_serde.rs
index b36db1f62..bc2ec29d6 100644
--- a/crates/backend-uzu/src/utils/strict_serde.rs
+++ b/crates/backend-uzu/src/utils/strict_serde.rs
@@ -5,6 +5,8 @@ use serde::{Deserialize, Deserializer, Serialize};
pub enum Unsupported {}
pub trait DeserializeStrict<'de>: Deserialize<'de> {}
+pub trait DeserializeStrictOwned: for<'de> DeserializeStrict<'de> {}
+impl<T> DeserializeStrictOwned for T where T: for<'de> DeserializeStrict<'de> {}
macro_rules! impl_strict {
($($ty:ty),* $(,)?) => {
@@ -12,7 +14,7 @@ macro_rules! impl_strict {
};
}
-impl_strict!(Unsupported, String, f32, u32, usize, bool);
+impl_strict!(Unsupported, String, f32, i64, u32, usize, bool);
impl<'de, T: DeserializeStrict<'de>> DeserializeStrict<'de> for Box<T> {}
impl<'de, T: DeserializeStrict<'de>> DeserializeStrict<'de> for Vec<T> {}
diff --git a/crates/backend-uzu/tests/integration/tracer/trace_validator.rs b/crates/backend-uzu/tests/integration/tracer/trace_validator.rs
index db5a3341e..018a6bbaf 100644
--- a/crates/backend-uzu/tests/integration/tracer/trace_validator.rs
+++ b/crates/backend-uzu/tests/integration/tracer/trace_validator.rs
@@ -15,7 +15,7 @@ use backend_uzu::{
Array, ArrayElement, DataType, allocation_to_vec,
backends::common::{Allocation, Backend, Encoder, kernel::kv_cache_update::KVCacheUpdate},
classifier::Classifier,
- config::{ClassifierModelConfig, LanguageModelConfig, ModelMetadata, ModelType},
+ config::{ModelConfig, ModelMetadata, ModelType},
encodable_block::{DecoderDecodeInput, Sampling},
forward_pass::{cache_layers::CacheLayers, token_inputs::TokenInputs, traces::ActivationTrace},
language_model::{
@@ -171,20 +171,46 @@ impl<B: Backend> TraceValidator<B> {
}
let config_file = File::open(&config_path).map_err(|_| Error::UnableToLoadConfig)?;
- let raw_metadata: ModelMetadata<serde_json::Value> =
+ let raw_metadata: ModelMetadata<ModelConfig> =
serde_json::from_reader(std::io::BufReader::new(config_file)).map_err(|_| Error::UnableToLoadConfig)?;
- let context = match raw_metadata.model_type {
+ let context = match raw_metadata.model_type.clone() {
ModelType::ClassifierModel => {
- let metadata: ModelMetadata<ClassifierModelConfig> =
- serde_json::from_value(serde_json::to_value(&raw_metadata).map_err(|_| Error::UnableToLoadConfig)?)
- .map_err(|_| Error::UnableToLoadConfig)?;
+ let ModelConfig::ClassifierModel(model_config) = raw_metadata.model_config.clone() else {
+ return Err(Error::UnableToLoadConfig);
+ };
+ let metadata = ModelMetadata {
+ toolchain_version: raw_metadata.toolchain_version,
+ vendor: raw_metadata.vendor,
+ family: raw_metadata.family,
+ name: raw_metadata.name,
+ size: raw_metadata.size,
+ quantization: raw_metadata.quantization,
+ repo: raw_metadata.repo,
+ use_cases: raw_metadata.use_cases,
+ model_type: raw_metadata.model_type,
+ model_config,
+ grammar_start_tokens: raw_metadata.grammar_start_tokens,
+ };
ModelContext::Classifier(Classifier::new(model_path, &metadata)?)
},
ModelType::LanguageModel => {
- let metadata: ModelMetadata<LanguageModelConfig> =
- serde_json::from_value(serde_json::to_value(&raw_metadata).map_err(|_| Error::UnableToLoadConfig)?)
- .map_err(|_| Error::UnableToLoadConfig)?;
+ let ModelConfig::LanguageModel(model_config) = raw_metadata.model_config.clone() else {
+ return Err(Error::UnableToLoadConfig);
+ };
+ let metadata = ModelMetadata {
+ toolchain_version: raw_metadata.toolchain_version,
+ vendor: raw_metadata.vendor,
+ family: raw_metadata.family,
+ name: raw_metadata.name,
+ size: raw_metadata.size,
+ quantization: raw_metadata.quantization,
+ repo: raw_metadata.repo,
+ use_cases: raw_metadata.use_cases,
+ model_type: raw_metadata.model_type,
+ model_config,
+ grammar_start_tokens: raw_metadata.grammar_start_tokens,
+ };
let prefill_step_size = Self::determine_prefill_step_size(model_path);
let decoding_config = DecodingConfig::new(
ContextMode::default(),