1use anyhow::{bail, Context, Result};
7use regex::Regex;
8use serde::{Deserialize, Serialize};
9use std::collections::HashMap;
10use std::path::Path;
11use std::sync::LazyLock;
12use tch::Tensor;
13use tracing::info;
14
15static VERSION_REGEX: LazyLock<Option<Regex>> = LazyLock::new(|| Regex::new(r"(\d+)").ok());
18
19static LAYER_REGEX: LazyLock<Option<Regex>> = LazyLock::new(|| Regex::new(r"layers\.(\d+)").ok());
21
22static DECODER_LAYER_REGEX: LazyLock<Option<Regex>> =
34 LazyLock::new(|| Regex::new(r"(?:^|\.)(?:language_model\.)?model\.layers\.(\d+)\.").ok());
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38pub struct ModelConfig {
39 pub architecture: ModelArchitecture,
41 pub model_type: String,
42 pub version: u32,
43
44 pub hidden_size: usize,
46 pub num_hidden_layers: usize,
47 pub num_attention_heads: usize,
48 pub num_key_value_heads: usize,
49 pub head_dim: usize,
50 pub intermediate_size: usize,
51
52 pub vocab_size: usize,
54 pub max_position_embeddings: usize,
55 pub rope_theta: f32,
56 pub rope_scaling: Option<RopeScaling>,
57
58 pub sliding_window: Option<usize>,
64 pub rope_local_base_freq: Option<f32>,
65
66 pub rms_norm_eps: f32,
68 pub layer_norm_eps: Option<f32>,
69
70 pub hidden_activation: String,
72
73 pub use_qk_norm: bool,
75 pub scale_embeddings: bool,
76 pub query_pre_attn_scalar: Option<f32>,
77
78 pub dtype: String,
80 pub use_flash_attention: bool,
81 pub use_kv_cache: bool,
82
83 pub partial_rotary_factor: Option<f32>,
85 pub layer_types: Vec<String>,
86 pub linear_conv_kernel_dim: usize,
87 pub linear_key_head_dim: usize,
88 pub linear_value_head_dim: usize,
89 pub linear_num_key_heads: usize,
90 pub linear_num_value_heads: usize,
91
92 pub is_moe: bool,
94 pub num_experts: usize,
95 pub num_experts_per_tok: usize,
96 pub moe_intermediate_size: usize,
97 pub shared_expert_intermediate_size: usize,
98
99 pub has_vision: bool,
101 pub vision_out_hidden_size: usize,
102}
103
104#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct RopeScaling {
106 pub rope_type: String,
107 pub factor: f32,
108}
109
110#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
111pub enum ModelArchitecture {
112 Llama,
113 Qwen,
114 Gemma,
115 Mistral,
116 Janus,
117 Qwen3_5,
119 Unknown(String),
120}
121
122#[derive(Debug, Clone)]
124pub enum ConfigSource {
125 Flat(Box<ModelConfig>),
127
128 Nested(Box<NestedModelConfig>),
130}
131
132#[derive(Debug, Clone, Serialize, Deserialize)]
134pub struct NestedModelConfig {
135 pub architecture: ModelArchitecture,
137
138 pub language_config: Option<serde_json::Value>,
140 pub vision_config: Option<serde_json::Value>,
141 pub aligner_config: Option<serde_json::Value>,
142
143 pub gen_aligner_config: Option<serde_json::Value>,
145 pub gen_vision_config: Option<serde_json::Value>,
146 pub gen_head_config: Option<serde_json::Value>,
147
148 pub num_hidden_layers: Option<usize>,
150 pub image_token_id: Option<u32>,
151 pub pad_token_id: Option<u32>,
152 pub begin_image_token_id: Option<u32>,
153 pub torch_dtype: Option<String>,
154}
155
156const ALLOW_WEIGHT_DETECT_ENV: &str = "HYPRSTREAM_ALLOW_WEIGHT_DETECT";
161
162fn env_flag(name: &str) -> bool {
164 std::env::var(name)
165 .map(|v| {
166 matches!(
167 v.trim().to_lowercase().as_str(),
168 "1" | "true" | "yes" | "on"
169 )
170 })
171 .unwrap_or(false)
172}
173
174fn require_u64(source: &serde_json::Value, field: &str, config_path: &Path) -> Result<u64> {
179 source[field].as_u64().with_context(|| {
180 format!(
181 "config.json ({path}) is missing required field `{field}` (or it is not a non-negative integer)",
182 path = config_path.display()
183 )
184 })
185}
186
187impl ModelConfig {
188 pub fn load(model_path: &Path, weights: &HashMap<String, Tensor>) -> Result<Self> {
200 let config_path = model_path.join("config.json");
202 let mut config = if config_path.exists() {
203 info!("Loading model configuration");
204 Self::from_json_file(&config_path)?
205 } else if env_flag(ALLOW_WEIGHT_DETECT_ENV) {
206 info!(
207 "⚠️ No config.json in {}; {ALLOW_WEIGHT_DETECT_ENV} is set, detecting from weights (fragile)",
208 model_path.display()
209 );
210 Self::detect_from_weights(weights)?
211 } else {
212 bail!(
213 "config.json is required but was not found in {}. \
214 A model's config.json is authoritative for its architecture; refusing to guess. \
215 Set {ALLOW_WEIGHT_DETECT_ENV}=1 to opt into the legacy weight-name heuristic.",
216 model_path.display()
217 );
218 };
219
220 config.validate_against_index(model_path)?;
222
223 config.validate_with_weights(weights)?;
225
226 info!("✅ Final model configuration:");
228 info!(" Architecture: {:?}", config.architecture);
229 info!(" Hidden size: {}", config.hidden_size);
230 info!(" Layers: {}", config.num_hidden_layers);
231 info!(" Attention heads: {}", config.num_attention_heads);
232 info!(" KV heads: {}", config.num_key_value_heads);
233 info!(" Vocab size: {}", config.vocab_size);
234 info!(" RoPE theta: {}", config.rope_theta);
235 info!(" Max position: {}", config.max_position_embeddings);
236 info!(" RMSNorm eps: {}", config.rms_norm_eps);
237
238 Ok(config)
239 }
240
241 fn from_json_file(path: &Path) -> Result<Self> {
243 let content = std::fs::read_to_string(path)?;
244 let json: serde_json::Value = serde_json::from_str(&content)?;
245
246 let architecture = Self::detect_architecture_from_json(&json);
248
249 let nested_json_opt = if architecture == ModelArchitecture::Janus {
252 info!("Detected Janus multimodal model - loading from language_config");
253
254 let lang_config = json["language_config"].as_object().ok_or_else(|| {
255 anyhow::anyhow!("Janus config missing required 'language_config'")
256 })?;
257
258 let lang_json = serde_json::Value::Object(lang_config.clone());
259 info!(
260 "Language config hidden_size: {}",
261 lang_json["hidden_size"].as_u64().unwrap_or(0)
262 );
263 Some(lang_json)
264 } else if architecture == ModelArchitecture::Qwen3_5 {
265 info!("Detected Qwen3.5 model - loading from text_config");
266 if let Some(text_cfg) = json["text_config"].as_object() {
267 let text_json = serde_json::Value::Object(text_cfg.clone());
268 info!(
269 "text_config hidden_size: {}",
270 text_json["hidden_size"].as_u64().unwrap_or(0)
271 );
272 Some(text_json)
273 } else {
274 None }
276 } else {
277 None
278 };
279
280 let config_source = nested_json_opt.as_ref().unwrap_or(&json);
282
283 let num_hidden_layers = config_source["num_hidden_layers"]
290 .as_u64()
291 .or_else(|| json["num_hidden_layers"].as_u64())
292 .map(|v| v as usize)
293 .with_context(|| {
294 format!(
295 "config.json ({path}) is missing required field `num_hidden_layers`",
296 path = path.display()
297 )
298 })?;
299 let hidden_size = require_u64(config_source, "hidden_size", path)? as usize;
300 let num_attention_heads = require_u64(config_source, "num_attention_heads", path)? as usize;
301 if num_attention_heads == 0 || num_hidden_layers == 0 || hidden_size == 0 {
302 bail!(
303 "config.json ({}) has invalid zero dimension(s): \
304 hidden_size={hidden_size}, num_hidden_layers={num_hidden_layers}, \
305 num_attention_heads={num_attention_heads}",
306 path.display()
307 );
308 }
309
310 let config = Self {
312 architecture: architecture.clone(),
313 model_type: json["model_type"].as_str().unwrap_or("unknown").to_owned(),
314 version: Self::detect_version(&json, &architecture),
315
316 hidden_size,
317 num_hidden_layers,
318 num_attention_heads,
319 num_key_value_heads: config_source["num_key_value_heads"]
321 .as_u64()
322 .map(|v| v as usize)
323 .unwrap_or(num_attention_heads),
324 head_dim: config_source["head_dim"]
326 .as_u64()
327 .map(|v| v as usize)
328 .unwrap_or(hidden_size / num_attention_heads),
329 intermediate_size: config_source["intermediate_size"].as_u64().unwrap_or(11008)
330 as usize,
331
332 vocab_size: config_source["vocab_size"].as_u64().unwrap_or(32000) as usize,
333 max_position_embeddings: config_source["max_position_embeddings"]
334 .as_u64()
335 .unwrap_or(4096) as usize,
336 rope_theta: config_source["rope_parameters"]["rope_theta"]
337 .as_f64()
338 .or_else(|| config_source["rope_theta"].as_f64())
339 .unwrap_or(10_000.0) as f32,
340 rope_scaling: Self::parse_rope_scaling(config_source),
341 sliding_window: config_source["sliding_window"].as_u64().map(|v| v as usize),
344 rope_local_base_freq: config_source["rope_local_base_freq"]
345 .as_f64()
346 .map(|v| v as f32),
347
348 rms_norm_eps: config_source["rms_norm_eps"].as_f64().unwrap_or(1e-5) as f32,
349 layer_norm_eps: config_source["layer_norm_eps"].as_f64().map(|v| v as f32),
350
351 hidden_activation: config_source["hidden_activation"]
352 .as_str()
353 .unwrap_or("silu")
354 .to_owned(),
355
356 use_qk_norm: config_source["use_qk_norm"].as_bool().unwrap_or(false),
357 scale_embeddings: config_source["scale_embeddings"].as_bool().unwrap_or(false),
358 query_pre_attn_scalar: config_source["query_pre_attn_scalar"]
359 .as_f64()
360 .map(|v| v as f32),
361
362 dtype: "bfloat16".to_owned(),
363 use_flash_attention: true,
364 use_kv_cache: true,
365
366 partial_rotary_factor: if architecture == ModelArchitecture::Qwen3_5 {
368 Some(
369 config_source["rope_parameters"]["partial_rotary_factor"]
370 .as_f64()
371 .or_else(|| config_source["partial_rotary_factor"].as_f64())
372 .unwrap_or(0.25) as f32,
373 )
374 } else {
375 None
376 },
377 layer_types: if architecture == ModelArchitecture::Qwen3_5 {
378 let num_layers = num_hidden_layers;
379 config_source["layer_types"]
380 .as_array()
381 .map(|a| {
382 a.iter()
383 .filter_map(|v| v.as_str().map(str::to_owned))
384 .collect()
385 })
386 .unwrap_or_else(|| {
387 let interval = config_source["full_attention_interval"]
388 .as_u64()
389 .unwrap_or(4) as usize;
390 (0..num_layers)
391 .map(|i| {
392 if (i + 1) % interval == 0 {
393 "full_attention".to_owned()
394 } else {
395 "linear_attention".to_owned()
396 }
397 })
398 .collect()
399 })
400 } else {
401 vec![]
402 },
403 linear_conv_kernel_dim: config_source["linear_conv_kernel_dim"]
404 .as_u64()
405 .unwrap_or(0) as usize,
406 linear_key_head_dim: config_source["linear_key_head_dim"].as_u64().unwrap_or(0)
407 as usize,
408 linear_value_head_dim: config_source["linear_value_head_dim"].as_u64().unwrap_or(0)
409 as usize,
410 linear_num_key_heads: config_source["linear_num_key_heads"].as_u64().unwrap_or(0)
411 as usize,
412 linear_num_value_heads: config_source["linear_num_value_heads"]
413 .as_u64()
414 .unwrap_or(0) as usize,
415
416 is_moe: json["model_type"]
418 .as_str()
419 .map(|s| s.contains("moe"))
420 .unwrap_or(false),
421 num_experts: config_source["num_experts"].as_u64().unwrap_or(0) as usize,
422 num_experts_per_tok: config_source["num_experts_per_tok"].as_u64().unwrap_or(0)
423 as usize,
424 moe_intermediate_size: config_source["moe_intermediate_size"].as_u64().unwrap_or(0)
425 as usize,
426 shared_expert_intermediate_size: config_source["shared_expert_intermediate_size"]
427 .as_u64()
428 .unwrap_or(0) as usize,
429
430 has_vision: json["vision_config"].is_object(),
432 vision_out_hidden_size: json["vision_config"]["out_hidden_size"]
433 .as_u64()
434 .unwrap_or(3584) as usize,
435 };
436
437 Ok(config)
438 }
439
440 #[allow(clippy::field_reassign_with_default)]
442 fn detect_from_weights(weights: &HashMap<String, Tensor>) -> Result<Self> {
443 let mut config = Self::default();
445
446 config.architecture = Self::detect_architecture_from_weights(weights);
448
449 if let Some(embed) = weights
451 .get("model.embed_tokens.weight")
452 .or_else(|| weights.get("embed_tokens.weight"))
453 {
454 let shape = embed.size();
455 config.vocab_size = shape[0] as usize;
456 config.hidden_size = shape[1] as usize;
457 }
458
459 config.num_hidden_layers = Self::count_layers(weights);
461
462 Self::detect_attention_config(weights, &mut config)?;
464
465 config.apply_architecture_defaults();
467
468 Ok(config)
469 }
470
471 pub fn detect_architecture(model_path: &Path) -> ModelArchitecture {
476 let config_path = model_path.join("config.json");
477 let content = match std::fs::read_to_string(&config_path) {
478 Ok(c) => c,
479 Err(_) => return ModelArchitecture::Unknown("unknown".to_owned()),
480 };
481 let json: serde_json::Value = match serde_json::from_str(&content) {
482 Ok(v) => v,
483 Err(_) => return ModelArchitecture::Unknown("unknown".to_owned()),
484 };
485 Self::detect_architecture_from_json(&json)
486 }
487
488 fn detect_architecture_from_json(json: &serde_json::Value) -> ModelArchitecture {
489 if let Some(model_type) = json["model_type"].as_str() {
491 return match model_type.to_lowercase().as_str() {
492 "janus" => ModelArchitecture::Janus,
493 "llama" => ModelArchitecture::Llama,
494 "qwen3_5" | "qwen3_5_text" | "qwen3_5_moe" => ModelArchitecture::Qwen3_5,
495 "qwen" | "qwen2" | "qwen3" => ModelArchitecture::Qwen,
496 "gemma" => ModelArchitecture::Gemma,
497 "mistral" => ModelArchitecture::Mistral,
498 _ => ModelArchitecture::Unknown(model_type.to_owned()),
499 };
500 }
501
502 if let Some(architectures) = json["architectures"].as_array() {
504 if let Some(first) = architectures.first() {
505 if let Some(arch_str) = first.as_str() {
506 return match arch_str.to_lowercase().as_str() {
507 s if s.contains("janus") => ModelArchitecture::Janus,
508 s if s.contains("llama") => ModelArchitecture::Llama,
509 s if s.contains("qwen3_5") || s.contains("Qwen3_5") => {
510 ModelArchitecture::Qwen3_5
511 }
512 s if s.contains("qwen") => ModelArchitecture::Qwen,
513 s if s.contains("gemma") => ModelArchitecture::Gemma,
514 s if s.contains("mistral") => ModelArchitecture::Mistral,
515 _ => ModelArchitecture::Unknown(arch_str.to_owned()),
516 };
517 }
518 }
519 }
520
521 ModelArchitecture::Unknown("unknown".to_owned())
522 }
523
524 fn detect_architecture_from_weights(weights: &HashMap<String, Tensor>) -> ModelArchitecture {
525 let has_vision_model = weights
529 .keys()
530 .any(|k| k.starts_with("vision_model.") || k.starts_with("vision_encoder."));
531 let has_aligner = weights
532 .keys()
533 .any(|k| k.starts_with("aligner.") || k.starts_with("vision_aligner."));
534 let has_language_model = weights.keys().any(|k| k.starts_with("language_model."));
535
536 if has_vision_model || has_aligner || has_language_model {
537 info!("Detected Janus multimodal model from weight patterns");
538 info!(" has_vision_model: {}", has_vision_model);
539 info!(" has_aligner: {}", has_aligner);
540 info!(" has_language_model: {}", has_language_model);
541 return ModelArchitecture::Janus;
542 }
543
544 if weights.keys().any(|k| k.contains("linear_attn.")) {
546 return ModelArchitecture::Qwen3_5;
547 }
548
549 for key in weights.keys() {
550 if key.contains("q_norm") || key.contains("k_norm") {
551 return ModelArchitecture::Qwen;
552 }
553 if key.contains("gated_gemm") {
554 return ModelArchitecture::Gemma;
555 }
556 }
557
558 ModelArchitecture::Llama
560 }
561
562 fn detect_version(json: &serde_json::Value, architecture: &ModelArchitecture) -> u32 {
563 if let Some(model_type) = json["model_type"].as_str() {
565 let lower = model_type.to_lowercase();
566
567 if lower.contains("qwen3") || lower.contains("qwen-3") {
569 return 3;
570 } else if lower.contains("qwen2") || lower.contains("qwen-2") {
571 return 2;
572 } else if lower.contains("llama3") || lower.contains("llama-3") {
573 return 3;
574 } else if lower.contains("llama2") || lower.contains("llama-2") {
575 return 2;
576 }
577
578 if let Some(ref regex) = *VERSION_REGEX {
580 if let Some(captures) = regex.captures(model_type) {
581 if let Ok(version) = captures[1].parse::<u32>() {
582 return version;
583 }
584 }
585 }
586 }
587
588 if let Some(architectures) = json["architectures"].as_array() {
590 if let Some(first_arch) = architectures.first().and_then(|v| v.as_str()) {
591 let lower = first_arch.to_lowercase();
592
593 if lower.contains("qwen3") {
594 return 3;
595 } else if lower.contains("qwen2") {
596 return 2;
597 } else if lower.contains("llama3") {
598 return 3;
599 } else if lower.contains("llama2") {
600 return 2;
601 }
602 }
603 }
604
605 match architecture {
609 ModelArchitecture::Qwen | ModelArchitecture::Llama => 2,
611 _ => 1,
612 }
613 }
614
615 fn parse_rope_scaling(json: &serde_json::Value) -> Option<RopeScaling> {
616 json["rope_scaling"].as_object().map(|obj| RopeScaling {
617 rope_type: obj["type"].as_str().unwrap_or("linear").to_owned(),
618 factor: obj["factor"].as_f64().unwrap_or(1.0) as f32,
619 })
620 }
621
622 fn count_layers(weights: &HashMap<String, Tensor>) -> usize {
623 let mut max_layer = 0;
624 if let Some(ref regex) = *LAYER_REGEX {
625 for key in weights.keys() {
626 if let Some(captures) = regex.captures(key) {
627 if let Ok(layer_idx) = captures[1].parse::<usize>() {
628 max_layer = max_layer.max(layer_idx + 1);
629 }
630 }
631 }
632 }
633 max_layer
634 }
635
636 fn detect_attention_config(weights: &HashMap<String, Tensor>, config: &mut Self) -> Result<()> {
637 let q_proj = weights
639 .keys()
640 .find(|k| k.contains("q_proj.weight"))
641 .and_then(|k| weights.get(k));
642 let k_proj = weights
643 .keys()
644 .find(|k| k.contains("k_proj.weight"))
645 .and_then(|k| weights.get(k));
646
647 if let (Some(q), Some(k)) = (q_proj, k_proj) {
648 let q_out = q.size()[0] as usize;
649 let k_out = k.size()[0] as usize;
650
651 for head_dim in &[256, 128, 64, 32] {
653 if q_out.is_multiple_of(*head_dim) && k_out.is_multiple_of(*head_dim) {
654 config.num_attention_heads = q_out / head_dim;
655 config.num_key_value_heads = k_out / head_dim;
656 config.head_dim = *head_dim;
657 break;
658 }
659 }
660 }
661
662 Ok(())
663 }
664
665 fn apply_architecture_defaults(&mut self) {
666 match &self.architecture {
667 ModelArchitecture::Qwen => {
668 if self.vocab_size == 151936 {
670 self.rope_theta = 5_000_000.0; self.version = 3;
672 }
673 }
674 ModelArchitecture::Qwen3_5 => {
675 if self.rope_theta == 10_000.0 {
677 self.rope_theta = 10_000_000.0; }
679 }
680 ModelArchitecture::Gemma if self.vocab_size == 262144 => {
681 self.rope_theta = 1_000_000.0;
682 self.use_qk_norm = true;
683 self.scale_embeddings = true;
684 self.query_pre_attn_scalar = Some(256.0);
685 }
686 _ => {}
687 }
688 }
689
690 fn validate_against_index(&self, model_path: &Path) -> Result<()> {
702 let index_path = model_path.join("model.safetensors.index.json");
703 if !index_path.exists() {
704 return Ok(());
705 }
706
707 let content = std::fs::read_to_string(&index_path)
708 .with_context(|| format!("failed to read shard manifest {}", index_path.display()))?;
709 let index: serde_json::Value = serde_json::from_str(&content)
710 .with_context(|| format!("failed to parse shard manifest {}", index_path.display()))?;
711 let weight_map = index["weight_map"].as_object().ok_or_else(|| {
712 anyhow::anyhow!(
713 "shard manifest {} is missing required `weight_map` object",
714 index_path.display()
715 )
716 })?;
717
718 let mut layer_indices = std::collections::HashSet::new();
722 if let Some(ref regex) = *DECODER_LAYER_REGEX {
723 for key in weight_map.keys() {
724 if let Some(captures) = regex.captures(key) {
725 if let Ok(idx) = captures[1].parse::<usize>() {
726 layer_indices.insert(idx);
727 }
728 }
729 }
730 }
731
732 if layer_indices.is_empty() {
735 return Ok(());
736 }
737
738 let manifest_layers = layer_indices.len();
739 if manifest_layers != self.num_hidden_layers {
740 bail!(
741 "num_hidden_layers mismatch: config.json declares {} but \
742 {} lists {} distinct transformer layers in its weight_map. \
743 Refusing to load with a layer count that disagrees with the checkpoint.",
744 self.num_hidden_layers,
745 index_path.display(),
746 manifest_layers
747 );
748 }
749
750 info!(
751 "✅ num_hidden_layers ({}) matches shard manifest weight_map",
752 self.num_hidden_layers
753 );
754 Ok(())
755 }
756
757 fn validate_with_weights(&mut self, weights: &HashMap<String, Tensor>) -> Result<()> {
759 if let Some(embed) = weights.get("model.embed_tokens.weight") {
761 let actual_vocab = embed.size()[0] as usize;
762 let actual_hidden = embed.size()[1] as usize;
763
764 if self.vocab_size != actual_vocab {
765 info!(
766 "⚠️ Config vocab_size {} doesn't match weights {}, using weights",
767 self.vocab_size, actual_vocab
768 );
769 self.vocab_size = actual_vocab;
770 }
771
772 if self.hidden_size != actual_hidden {
773 info!(
774 "⚠️ Config hidden_size {} doesn't match weights {}, using weights",
775 self.hidden_size, actual_hidden
776 );
777 self.hidden_size = actual_hidden;
778 }
779 }
780
781 Ok(())
782 }
783}
784
785impl Default for ModelConfig {
786 fn default() -> Self {
787 Self {
788 architecture: ModelArchitecture::Llama,
789 model_type: "llama".to_owned(),
790 version: 2,
791 hidden_size: 4096,
792 num_hidden_layers: 32,
793 num_attention_heads: 32,
794 num_key_value_heads: 32,
795 head_dim: 128,
796 intermediate_size: 11008,
797 vocab_size: 32000,
798 max_position_embeddings: 4096,
799 rope_theta: 10_000.0,
800 rope_scaling: None,
801 sliding_window: None,
802 rope_local_base_freq: None,
803 rms_norm_eps: 1e-5,
804 layer_norm_eps: None,
805 hidden_activation: "silu".to_owned(),
806 use_qk_norm: false,
807 scale_embeddings: false,
808 query_pre_attn_scalar: None,
809 dtype: "bfloat16".to_owned(),
810 use_flash_attention: true,
811 use_kv_cache: true,
812
813 partial_rotary_factor: None,
814 layer_types: vec![],
815 linear_conv_kernel_dim: 0,
816 linear_key_head_dim: 0,
817 linear_value_head_dim: 0,
818 linear_num_key_heads: 0,
819 linear_num_value_heads: 0,
820
821 is_moe: false,
822 num_experts: 0,
823 num_experts_per_tok: 0,
824 moe_intermediate_size: 0,
825 shared_expert_intermediate_size: 0,
826
827 has_vision: false,
828 vision_out_hidden_size: 0,
829 }
830 }
831}
832
833impl ModelConfig {
838 pub fn load_training_config(
842 model_path: &Path,
843 ) -> Option<crate::config::HyprstreamTrainingConfig> {
844 let config_path = model_path.join("config.json");
845 if !config_path.exists() {
846 return None;
847 }
848
849 let content = std::fs::read_to_string(&config_path).ok()?;
850 let json: serde_json::Value = serde_json::from_str(&content).ok()?;
851
852 json.get("hyprstream_training")
854 .and_then(|v| serde_json::from_value(v.clone()).ok())
855 }
856
857 pub fn save_training_config(
861 model_path: &Path,
862 training_config: &crate::config::HyprstreamTrainingConfig,
863 ) -> Result<()> {
864 let config_path = model_path.join("config.json");
865
866 let content = std::fs::read_to_string(&config_path)?;
868 let mut json: serde_json::Value = serde_json::from_str(&content)?;
869
870 json["hyprstream_training"] = serde_json::to_value(training_config)?;
872
873 let output = serde_json::to_string_pretty(&json)?;
875 std::fs::write(&config_path, output)?;
876
877 info!(
878 "✅ Training config saved to {}: mode={:?}, target_adapter={:?}",
879 config_path.display(),
880 training_config.mode,
881 training_config.target_adapter
882 );
883
884 Ok(())
885 }
886}
887
888#[cfg(test)]
889#[allow(clippy::unwrap_used, clippy::expect_used)]
890mod tests {
891 use super::*;
892 use std::collections::HashMap;
893 use tch::Tensor;
894
895 fn empty_weights() -> HashMap<String, Tensor> {
896 HashMap::new()
897 }
898
899 fn write(dir: &Path, name: &str, contents: &str) {
900 std::fs::write(dir.join(name), contents).unwrap();
901 }
902
903 fn valid_config_json(num_layers: usize) -> String {
905 format!(
906 r#"{{
907 "model_type": "llama",
908 "hidden_size": 4096,
909 "num_hidden_layers": {num_layers},
910 "num_attention_heads": 32,
911 "num_key_value_heads": 8,
912 "intermediate_size": 11008,
913 "vocab_size": 32000,
914 "max_position_embeddings": 4096,
915 "rms_norm_eps": 1e-5
916 }}"#
917 )
918 }
919
920 #[test]
923 fn valid_config_loads_with_declared_dims() {
924 let dir = tempfile::tempdir().unwrap();
925 write(dir.path(), "config.json", &valid_config_json(40));
926
927 let cfg = ModelConfig::load(dir.path(), &empty_weights()).expect("valid config must load");
928 assert_eq!(cfg.num_hidden_layers, 40);
929 assert_eq!(cfg.hidden_size, 4096);
930 assert_eq!(cfg.num_attention_heads, 32);
931 assert_eq!(cfg.head_dim, 128);
933 assert_eq!(cfg.num_key_value_heads, 8);
935 }
936
937 #[test]
939 fn missing_config_is_hard_error() {
940 let dir = tempfile::tempdir().unwrap();
941 let err = ModelConfig::load(dir.path(), &empty_weights())
942 .expect_err("missing config.json must fail");
943 assert!(
944 err.to_string().contains("config.json is required"),
945 "unexpected error: {err}"
946 );
947 }
948
949 #[test]
952 fn missing_num_hidden_layers_is_hard_error() {
953 let dir = tempfile::tempdir().unwrap();
954 write(
955 dir.path(),
956 "config.json",
957 r#"{"model_type":"llama","hidden_size":4096,"num_attention_heads":32}"#,
958 );
959 let err = ModelConfig::load(dir.path(), &empty_weights())
960 .expect_err("missing num_hidden_layers must fail");
961 assert!(
962 err.to_string().contains("num_hidden_layers"),
963 "unexpected error: {err}"
964 );
965 }
966
967 #[test]
969 fn missing_hidden_size_is_hard_error() {
970 let dir = tempfile::tempdir().unwrap();
971 write(
972 dir.path(),
973 "config.json",
974 r#"{"model_type":"llama","num_hidden_layers":32,"num_attention_heads":32}"#,
975 );
976 let err = ModelConfig::load(dir.path(), &empty_weights())
977 .expect_err("missing hidden_size must fail");
978 assert!(
979 err.to_string().contains("hidden_size"),
980 "unexpected error: {err}"
981 );
982 }
983
984 #[test]
986 fn index_layer_count_mismatch_is_hard_error() {
987 let dir = tempfile::tempdir().unwrap();
988 write(dir.path(), "config.json", &valid_config_json(4));
990 write(
992 dir.path(),
993 "model.safetensors.index.json",
994 r#"{"weight_map":{
995 "model.layers.0.self_attn.q_proj.weight":"model-00001-of-00002.safetensors",
996 "model.layers.1.self_attn.q_proj.weight":"model-00001-of-00002.safetensors",
997 "model.layers.2.self_attn.q_proj.weight":"model-00002-of-00002.safetensors",
998 "model.embed_tokens.weight":"model-00001-of-00002.safetensors"
999 }}"#,
1000 );
1001 let err = ModelConfig::load(dir.path(), &empty_weights())
1002 .expect_err("layer-count mismatch must fail");
1003 assert!(
1004 err.to_string().contains("num_hidden_layers mismatch"),
1005 "unexpected error: {err}"
1006 );
1007 }
1008
1009 #[test]
1011 fn index_layer_count_match_loads() {
1012 let dir = tempfile::tempdir().unwrap();
1013 write(dir.path(), "config.json", &valid_config_json(3));
1014 write(
1015 dir.path(),
1016 "model.safetensors.index.json",
1017 r#"{"weight_map":{
1018 "model.layers.0.self_attn.q_proj.weight":"model-00001-of-00002.safetensors",
1019 "model.layers.1.self_attn.q_proj.weight":"model-00001-of-00002.safetensors",
1020 "model.layers.2.self_attn.q_proj.weight":"model-00002-of-00002.safetensors"
1021 }}"#,
1022 );
1023 let cfg = ModelConfig::load(dir.path(), &empty_weights())
1024 .expect("matching layer counts must load");
1025 assert_eq!(cfg.num_hidden_layers, 3);
1026 }
1027
1028 #[test]
1032 fn vision_tower_layers_do_not_inflate_decoder_count() {
1033 let dir = tempfile::tempdir().unwrap();
1034 write(dir.path(), "config.json", &valid_config_json(3));
1035 write(
1036 dir.path(),
1037 "model.safetensors.index.json",
1038 r#"{"weight_map":{
1039 "model.layers.0.self_attn.q_proj.weight":"a.safetensors",
1040 "model.layers.1.self_attn.q_proj.weight":"a.safetensors",
1041 "model.layers.2.self_attn.q_proj.weight":"a.safetensors",
1042 "vision_model.encoder.layers.0.self_attn.q_proj.weight":"v.safetensors",
1043 "vision_model.encoder.layers.10.self_attn.q_proj.weight":"v.safetensors",
1044 "vision_model.encoder.layers.23.self_attn.q_proj.weight":"v.safetensors",
1045 "visual.blocks.5.attn.qkv.weight":"v.safetensors"
1046 }}"#,
1047 );
1048 let cfg = ModelConfig::load(dir.path(), &empty_weights())
1049 .expect("decoder layer count (3) must match despite a 24-layer vision tower");
1050 assert_eq!(cfg.num_hidden_layers, 3);
1051 }
1052
1053 #[test]
1056 fn nested_language_model_layers_are_counted() {
1057 let dir = tempfile::tempdir().unwrap();
1058 write(dir.path(), "config.json", &valid_config_json(2));
1059 write(
1060 dir.path(),
1061 "model.safetensors.index.json",
1062 r#"{"weight_map":{
1063 "language_model.model.layers.0.self_attn.q_proj.weight":"a.safetensors",
1064 "language_model.model.layers.1.self_attn.q_proj.weight":"a.safetensors",
1065 "vision_model.encoder.layers.0.self_attn.q_proj.weight":"v.safetensors"
1066 }}"#,
1067 );
1068 let cfg = ModelConfig::load(dir.path(), &empty_weights())
1069 .expect("nested language_model decoder layers must be counted");
1070 assert_eq!(cfg.num_hidden_layers, 2);
1071 }
1072
1073 #[test]
1075 fn zero_dimension_is_hard_error() {
1076 let dir = tempfile::tempdir().unwrap();
1077 write(
1078 dir.path(),
1079 "config.json",
1080 r#"{"model_type":"llama","hidden_size":4096,"num_hidden_layers":0,"num_attention_heads":32}"#,
1081 );
1082 let err =
1083 ModelConfig::load(dir.path(), &empty_weights()).expect_err("zero dimension must fail");
1084 assert!(
1085 err.to_string().contains("zero dimension"),
1086 "unexpected error: {err}"
1087 );
1088 }
1089}