1use anyhow::{anyhow, Result};
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8use std::path::Path;
9
10#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct ModelGeneratorConfig {
13 pub model_name: String,
15 pub model_type: ModelType,
17 pub config_params: HashMap<String, ConfigParam>,
19 pub layers: Vec<LayerDefinition>,
21 pub task_heads: Vec<TaskHead>,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27pub enum ModelType {
28 Encoder,
29 Decoder,
30 EncoderDecoder,
31 Multimodal,
32 Custom,
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37pub struct ConfigParam {
38 pub name: String,
39 pub param_type: String,
40 pub default_value: String,
41 pub description: String,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct LayerDefinition {
47 pub name: String,
48 pub layer_type: String,
49 pub parameters: HashMap<String, String>,
50}
51
52struct GeneratedLayer {
54 import: &'static str,
56 field_type: &'static str,
58 constructor: String,
60 forward: String,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
66pub struct TaskHead {
67 pub name: String,
68 pub task_type: String,
69 pub output_size: Option<usize>,
70}
71
72pub struct ModelGenerator {
74 config: ModelGeneratorConfig,
75}
76
77impl ModelGenerator {
78 pub fn new(config: ModelGeneratorConfig) -> Self {
80 Self { config }
81 }
82
83 pub fn generate_model(&self, output_dir: &Path) -> Result<()> {
85 std::fs::create_dir_all(output_dir)?;
87
88 let model_dir = output_dir.join(&self.config.model_name);
89 std::fs::create_dir_all(&model_dir)?;
90
91 self.generate_config_file(&model_dir)?;
93
94 self.generate_model_file(&model_dir)?;
96
97 self.generate_mod_file(&model_dir)?;
99
100 self.generate_test_file(&model_dir)?;
102
103 Ok(())
104 }
105
106 fn generate_config_file(&self, output_dir: &Path) -> Result<()> {
108 let config_content = self.generate_config_code();
109 let config_path = output_dir.join("config.rs");
110 std::fs::write(config_path, config_content)?;
111 Ok(())
112 }
113
114 fn generate_model_file(&self, output_dir: &Path) -> Result<()> {
116 let model_content = self.generate_model_code()?;
117 let model_path = output_dir.join("model.rs");
118 std::fs::write(model_path, model_content)?;
119 Ok(())
120 }
121
122 fn generate_mod_file(&self, output_dir: &Path) -> Result<()> {
124 let mod_content = format!(
125 "//! {} Model Implementation\n\npub mod config;\npub mod model;\n\npub use config::{}Config;\npub use model::{}Model;\n",
126 self.config.model_name,
127 self.config.model_name,
128 self.config.model_name
129 );
130 let mod_path = output_dir.join("mod.rs");
131 std::fs::write(mod_path, mod_content)?;
132 Ok(())
133 }
134
135 fn generate_test_file(&self, output_dir: &Path) -> Result<()> {
137 let test_content = self.generate_test_code();
138 let test_path = output_dir.join("tests.rs");
139 std::fs::write(test_path, test_content)?;
140 Ok(())
141 }
142
143 fn generate_config_code(&self) -> String {
145 let mut code = format!(
146 "//! {} Configuration\n\nuse serde::{{Deserialize, Serialize}};\n\n#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct {}Config {{\n",
147 self.config.model_name,
148 self.config.model_name
149 );
150
151 for param in self.config.config_params.values() {
153 code.push_str(&format!(
154 " /// {}\n pub {}: {},\n",
155 param.description, param.name, param.param_type
156 ));
157 }
158
159 code.push_str("}\n\n");
160
161 code.push_str(&format!(
163 "impl Default for {}Config {{\n fn default() -> Self {{\n Self {{\n",
164 self.config.model_name
165 ));
166
167 for param in self.config.config_params.values() {
168 code.push_str(&format!(
169 " {}: {},\n",
170 param.name, param.default_value
171 ));
172 }
173
174 code.push_str(" }\n }\n}\n");
175
176 code
177 }
178
179 fn layer_spec(layer: &LayerDefinition) -> Result<Option<GeneratedLayer>> {
185 let parameter = |key: &str, fallback: &str| -> String {
186 layer.parameters.get(key).cloned().unwrap_or_else(|| fallback.to_string())
187 };
188
189 let spec = match layer.layer_type.as_str() {
190 "linear" => GeneratedLayer {
191 import: "linear::Linear",
192 field_type: "Linear",
193 constructor: format!(
195 "Linear::new({}, {}, {})",
196 parameter("input_size", "768"),
197 parameter("output_size", "768"),
198 parameter("bias", "true")
199 ),
200 forward: format!("let x = self.{}.forward(x)?;", layer.name),
201 },
202 "attention" => GeneratedLayer {
203 import: "attention::MultiHeadAttention",
204 field_type: "MultiHeadAttention",
205 constructor: format!(
206 "MultiHeadAttention::new({}, {}, {}, {})?",
207 parameter("hidden_size", "768"),
208 parameter("num_heads", "12"),
209 parameter("dropout_prob", "0.1"),
210 parameter("bias", "true")
211 ),
212 forward: format!(
213 "let x = self.{}.forward_self_attention(&x, None, false)?;",
214 layer.name
215 ),
216 },
217 "conv2d" => GeneratedLayer {
218 import: "conv2d::Conv2d",
219 field_type: "Conv2d",
220 constructor: format!(
221 "Conv2d::new({}, {}, ({k}, {k}), ({s}, {s}), ({p}, {p}), {bias})?",
222 parameter("in_channels", "1"),
223 parameter("out_channels", "64"),
224 k = parameter("kernel_size", "3"),
225 s = parameter("stride", "1"),
226 p = parameter("padding", "0"),
227 bias = parameter("bias", "true")
228 ),
229 forward: format!("let x = self.{}.forward(x)?;", layer.name),
230 },
231 "layernorm" => GeneratedLayer {
232 import: "layernorm::LayerNorm",
233 field_type: "LayerNorm",
234 constructor: format!(
235 "LayerNorm::new(vec![{}], {})?",
236 parameter("normalized_shape", "768"),
237 parameter("eps", "1e-5")
238 ),
239 forward: format!("let x = self.{}.forward(x)?;", layer.name),
240 },
241 "rmsnorm" => GeneratedLayer {
242 import: "layernorm::RMSNorm",
243 field_type: "RMSNorm",
244 constructor: format!(
245 "RMSNorm::new({}, {})?",
246 parameter("hidden_size", "768"),
247 parameter("eps", "1e-6")
248 ),
249 forward: format!("let x = self.{}.forward(x)?;", layer.name),
250 },
251 "dropout" => GeneratedLayer {
252 import: "dropout::Dropout",
253 field_type: "Dropout",
254 constructor: format!("Dropout::new({})", parameter("p", "0.1")),
256 forward: format!("let x = self.{}.forward(x)?;", layer.name),
257 },
258 "embedding" => GeneratedLayer {
259 import: "embedding::Embedding",
260 field_type: "Embedding",
261 constructor: format!(
262 "Embedding::new({}, {}, {})?",
263 parameter("num_embeddings", "30522"),
264 parameter("embedding_dim", "768"),
265 parameter("padding_idx", "None")
266 ),
267 forward: format!("let x = self.{}.forward(input_ids.to_vec())?;", layer.name),
270 },
271 "feedforward" => GeneratedLayer {
272 import: "feedforward::FeedForward",
273 field_type: "FeedForward",
274 constructor: format!(
275 "FeedForward::new({}, {}, {})?",
276 parameter("hidden_size", "768"),
277 parameter("intermediate_size", "3072"),
278 parameter("dropout_prob", "0.1")
279 ),
280 forward: format!("let x = self.{}.forward(x)?;", layer.name),
281 },
282 "relu" => return Ok(None),
284 "gelu" => return Ok(None),
285 "silu" => return Ok(None),
286 "tanh" => return Ok(None),
287 "sigmoid" => return Ok(None),
288 "softmax" => return Ok(None),
289 other => {
290 return Err(anyhow!(
291 "layer type `{other}` (layer `{}`) has no implementation in \
292 trustformers_core::layers, so no compilable code can be generated for it. \
293 Supported types: linear, attention, conv2d, layernorm, rmsnorm, dropout, \
294 embedding, feedforward, relu, gelu, silu, tanh, sigmoid, softmax",
295 layer.name
296 ))
297 },
298 };
299
300 Ok(Some(spec))
301 }
302
303 fn activation_call(layer_type: &str) -> Option<&'static str> {
305 match layer_type {
306 "relu" => Some("let x = x.relu()?;"),
307 "gelu" => Some("let x = x.gelu()?;"),
308 "silu" => Some("let x = x.silu()?;"),
309 "tanh" => Some("let x = x.tanh()?;"),
310 "sigmoid" => Some("let x = x.sigmoid()?;"),
311 "softmax" => Some("let x = x.softmax(1)?;"),
312 _ => None,
313 }
314 }
315
316 fn generate_model_code(&self) -> Result<String> {
324 let forward_impl = self.generate_forward_implementation()?;
325 let (layer_fields, layer_init, imports) = self.generate_layers_code()?;
326
327 let import_block = if imports.is_empty() {
328 String::new()
329 } else {
330 format!(
331 "use trustformers_core::layers::{{{}}};\nuse trustformers_core::traits::Layer;\n",
332 imports.join(", ")
333 )
334 };
335
336 Ok(format!(
337 "//! {name} Model Implementation\n\
338 //!\n\
339 //! This file is auto-generated by `trustformers_models::developer_tools`.\n\n\
340 use super::config::{name}Config;\n\
341 use trustformers_core::errors::Result;\n\
342 use trustformers_core::tensor::Tensor;\n\
343 {imports}\n\
344 #[derive(Debug, Clone)]\n\
345 pub struct {name}Model {{\n config: {name}Config,{fields}\n}}\n\n\
346 impl {name}Model {{\n\
347 \x20 pub fn new(config: {name}Config) -> Result<Self> {{\n\
348 \x20 Ok(Self {{\n config,{init}\n }})\n }}\n\n\
349 \x20 pub fn config(&self) -> &{name}Config {{\n &self.config\n }}\n\n\
350 \x20 pub fn forward(&self, input: &Tensor) -> Result<Tensor> {{\n{forward}\n }}\n\
351 }}\n",
352 name = self.config.model_name,
353 imports = import_block,
354 fields = layer_fields,
355 init = layer_init,
356 forward = forward_impl
357 ))
358 }
359
360 fn generate_forward_implementation(&self) -> Result<String> {
362 match self.config.model_type {
363 ModelType::Encoder => self.generate_encoder_forward(),
364 ModelType::Decoder => Ok(self.generate_decoder_forward()),
365 ModelType::EncoderDecoder => Ok(self.generate_encoder_decoder_forward()),
366 ModelType::Multimodal => Ok(self.generate_multimodal_forward()),
367 ModelType::Custom => self.generate_custom_forward(),
368 }
369 }
370
371 fn generate_encoder_forward(&self) -> Result<String> {
373 let mut layer_calls = Vec::with_capacity(self.config.layers.len());
374 for layer in &self.config.layers {
375 if let Some(activation) = Self::activation_call(&layer.layer_type) {
376 layer_calls.push(format!(" {activation}"));
377 continue;
378 }
379 let spec = Self::layer_spec(layer)?
380 .ok_or_else(|| anyhow!("layer `{}` produced no code to call", layer.name))?;
381 layer_calls.push(format!(" {}", spec.forward));
382 }
383
384 Ok(format!(
385 " let x = input.clone();\n{}\n\n Ok(x)",
386 layer_calls.join("\n")
387 ))
388 }
389
390 fn generate_decoder_forward(&self) -> String {
392 " let mut x = input.clone();\n \n // Decoder layers with causal masking\n for i in 0..self.config.num_layers {\n // Self-attention with causal mask\n // Feed-forward network\n }\n \n Ok(x)".to_string()
393 }
394
395 fn generate_encoder_decoder_forward(&self) -> String {
397 " let mut encoder_output = input.clone();\n \n // Encoder pass\n for i in 0..self.config.encoder_layers {\n // Encoder self-attention and FFN\n }\n \n // Decoder pass with cross-attention\n let mut decoder_output = encoder_output.clone();\n for i in 0..self.config.decoder_layers {\n // Decoder self-attention, cross-attention, and FFN\n }\n \n Ok(decoder_output)".to_string()
398 }
399
400 fn generate_multimodal_forward(&self) -> String {
402 " // Extract different modalities from input\n let text_features = input.slice(1, 0, self.config.text_dim)?;\n let visual_features = input.slice(1, self.config.text_dim, input.shape()[1])?;\n \n // Process each modality\n let text_output = self.process_text_modality(&text_features)?;\n let visual_output = self.process_visual_modality(&visual_features)?;\n \n // Fusion layer\n let fused = Tensor::concat(&[text_output, visual_output], 1)?;\n \n Ok(fused)".to_string()
403 }
404
405 fn generate_custom_forward(&self) -> Result<String> {
407 if self.config.layers.is_empty() {
408 Ok(" // Custom model implementation: no layers were configured,\n // so the generated forward pass is the identity.\n let output = input.clone();\n\n Ok(output)".to_string())
409 } else {
410 self.generate_encoder_forward() }
412 }
413
414 fn generate_layers_code(&self) -> Result<(String, String, Vec<String>)> {
420 if self.config.layers.is_empty() {
421 return Ok((String::new(), String::new(), Vec::new()));
422 }
423
424 let mut fields = String::new();
425 let mut init = String::new();
426 let mut imports: Vec<String> = Vec::new();
427
428 for layer in &self.config.layers {
429 let Some(spec) = Self::layer_spec(layer)? else {
430 continue;
432 };
433
434 fields.push_str(&format!("\n {}: {},", layer.name, spec.field_type));
435 init.push_str(&format!(
436 "\n {}: {},",
437 layer.name, spec.constructor
438 ));
439
440 let import = spec.import.to_string();
441 if !imports.contains(&import) {
442 imports.push(import);
443 }
444 }
445
446 imports.sort();
447 Ok((fields, init, imports))
448 }
449
450 fn generate_test_code(&self) -> String {
452 format!(
453 "//! {} Tests\n\nuse super::{{{}Config, {}Model}};\n\n#[test]\nfn test_{}_creation() {{\n let config = {}Config::default();\n let model = {}Model::new(config).expect(\"operation failed\");\n // Add assertions here\n}}\n",
454 self.config.model_name,
455 self.config.model_name,
456 self.config.model_name,
457 self.config.model_name.to_lowercase(),
458 self.config.model_name,
459 self.config.model_name
460 )
461 }
462}
463
464pub struct ModelTemplates;
466
467impl ModelTemplates {
468 pub fn bert_encoder() -> ModelGeneratorConfig {
470 let mut config_params = HashMap::new();
471 config_params.insert(
472 "vocab_size".to_string(),
473 ConfigParam {
474 name: "vocab_size".to_string(),
475 param_type: "usize".to_string(),
476 default_value: "30522".to_string(),
477 description: "Vocabulary size".to_string(),
478 },
479 );
480 config_params.insert(
481 "hidden_size".to_string(),
482 ConfigParam {
483 name: "hidden_size".to_string(),
484 param_type: "usize".to_string(),
485 default_value: "768".to_string(),
486 description: "Hidden dimension size".to_string(),
487 },
488 );
489
490 ModelGeneratorConfig {
491 model_name: "CustomBert".to_string(),
492 model_type: ModelType::Encoder,
493 config_params,
494 layers: vec![],
495 task_heads: vec![],
496 }
497 }
498
499 pub fn gpt_decoder() -> ModelGeneratorConfig {
501 let mut config_params = HashMap::new();
502 config_params.insert(
503 "vocab_size".to_string(),
504 ConfigParam {
505 name: "vocab_size".to_string(),
506 param_type: "usize".to_string(),
507 default_value: "50257".to_string(),
508 description: "Vocabulary size".to_string(),
509 },
510 );
511
512 ModelGeneratorConfig {
513 model_name: "CustomGPT".to_string(),
514 model_type: ModelType::Decoder,
515 config_params,
516 layers: vec![],
517 task_heads: vec![],
518 }
519 }
520}
521
522#[cfg(test)]
523mod tests {
524 use super::*;
525
526 #[test]
527 fn test_model_generator_config_creation() {
528 let config = ModelGeneratorConfig {
529 model_name: "TestModel".to_string(),
530 model_type: ModelType::Encoder,
531 config_params: HashMap::new(),
532 layers: vec![],
533 task_heads: vec![],
534 };
535 assert_eq!(config.model_name, "TestModel");
536 assert!(config.config_params.is_empty());
537 assert!(config.layers.is_empty());
538 assert!(config.task_heads.is_empty());
539 }
540
541 #[test]
542 fn test_model_type_variants() {
543 let types = vec![
544 ModelType::Encoder,
545 ModelType::Decoder,
546 ModelType::EncoderDecoder,
547 ModelType::Multimodal,
548 ModelType::Custom,
549 ];
550 for t in &types {
551 let dbg = format!("{:?}", t);
552 assert!(!dbg.is_empty());
553 }
554 }
555
556 #[test]
557 fn test_config_param_creation() {
558 let param = ConfigParam {
559 name: "hidden_size".to_string(),
560 param_type: "usize".to_string(),
561 default_value: "768".to_string(),
562 description: "Hidden dimension size".to_string(),
563 };
564 assert_eq!(param.name, "hidden_size");
565 assert_eq!(param.param_type, "usize");
566 assert_eq!(param.default_value, "768");
567 }
568
569 #[test]
570 fn test_layer_definition_creation() {
571 let layer = LayerDefinition {
572 name: "self_attention".to_string(),
573 layer_type: "attention".to_string(),
574 parameters: HashMap::from([
575 ("num_heads".to_string(), "12".to_string()),
576 ("hidden_size".to_string(), "768".to_string()),
577 ]),
578 };
579 assert_eq!(layer.name, "self_attention");
580 assert_eq!(layer.layer_type, "attention");
581 assert_eq!(layer.parameters.len(), 2);
582 }
583
584 #[test]
585 fn test_task_head_creation() {
586 let head = TaskHead {
587 name: "classification".to_string(),
588 task_type: "sequence_classification".to_string(),
589 output_size: Some(10),
590 };
591 assert_eq!(head.name, "classification");
592 assert_eq!(head.output_size, Some(10));
593 }
594
595 #[test]
596 fn test_task_head_no_output_size() {
597 let head = TaskHead {
598 name: "lm_head".to_string(),
599 task_type: "language_modeling".to_string(),
600 output_size: None,
601 };
602 assert!(head.output_size.is_none());
603 }
604
605 #[test]
606 fn test_model_generator_new() {
607 let config = ModelGeneratorConfig {
608 model_name: "MyModel".to_string(),
609 model_type: ModelType::Decoder,
610 config_params: HashMap::new(),
611 layers: vec![],
612 task_heads: vec![],
613 };
614 let _generator = ModelGenerator::new(config);
615 }
616
617 #[test]
618 fn test_bert_encoder_template() {
619 let config = ModelTemplates::bert_encoder();
620 assert_eq!(config.model_name, "CustomBert");
621 assert!(matches!(config.model_type, ModelType::Encoder));
622 assert!(config.config_params.contains_key("vocab_size"));
623 assert!(config.config_params.contains_key("hidden_size"));
624 }
625
626 #[test]
627 fn test_gpt_decoder_template() {
628 let config = ModelTemplates::gpt_decoder();
629 assert_eq!(config.model_name, "CustomGPT");
630 assert!(matches!(config.model_type, ModelType::Decoder));
631 assert!(config.config_params.contains_key("vocab_size"));
632 }
633
634 #[test]
635 fn test_bert_template_defaults() {
636 let config = ModelTemplates::bert_encoder();
637 let vocab_param = config.config_params.get("vocab_size").expect("vocab_size not found");
638 assert_eq!(vocab_param.default_value, "30522");
639 let hidden_param = config.config_params.get("hidden_size").expect("hidden_size not found");
640 assert_eq!(hidden_param.default_value, "768");
641 }
642
643 #[test]
644 fn test_gpt_template_defaults() {
645 let config = ModelTemplates::gpt_decoder();
646 let vocab_param = config.config_params.get("vocab_size").expect("vocab_size not found");
647 assert_eq!(vocab_param.default_value, "50257");
648 }
649
650 #[test]
651 fn test_model_generator_generate_to_temp_dir() {
652 let config = ModelTemplates::bert_encoder();
653 let generator = ModelGenerator::new(config);
654 let temp_dir = std::env::temp_dir().join("test_model_gen");
655 let _ = std::fs::remove_dir_all(&temp_dir);
656 let result = generator.generate_model(&temp_dir);
657 assert!(result.is_ok());
658 let _ = std::fs::remove_dir_all(&temp_dir);
660 }
661
662 #[test]
663 fn test_model_generator_creates_files() {
664 let config = ModelTemplates::gpt_decoder();
665 let generator = ModelGenerator::new(config);
666 let temp_dir = std::env::temp_dir().join("test_model_gen_files");
667 let _ = std::fs::remove_dir_all(&temp_dir);
668 let result = generator.generate_model(&temp_dir);
669 assert!(result.is_ok());
670 let model_dir = temp_dir.join("CustomGPT");
672 assert!(model_dir.exists());
673 let _ = std::fs::remove_dir_all(&temp_dir);
674 }
675
676 #[test]
677 fn test_config_with_layers() {
678 let config = ModelGeneratorConfig {
679 model_name: "LayeredModel".to_string(),
680 model_type: ModelType::Encoder,
681 config_params: HashMap::new(),
682 layers: vec![
683 LayerDefinition {
684 name: "embedding".to_string(),
685 layer_type: "embedding".to_string(),
686 parameters: HashMap::from([
687 ("vocab_size".to_string(), "30000".to_string()),
688 ("hidden_size".to_string(), "512".to_string()),
689 ]),
690 },
691 LayerDefinition {
692 name: "encoder".to_string(),
693 layer_type: "attention".to_string(),
694 parameters: HashMap::from([
695 ("num_heads".to_string(), "8".to_string()),
696 ("hidden_size".to_string(), "512".to_string()),
697 ]),
698 },
699 ],
700 task_heads: vec![],
701 };
702 assert_eq!(config.layers.len(), 2);
703 assert_eq!(config.layers[0].name, "embedding");
704 assert_eq!(config.layers[1].name, "encoder");
705 }
706
707 #[test]
708 fn test_config_with_task_heads() {
709 let config = ModelGeneratorConfig {
710 model_name: "MultiTask".to_string(),
711 model_type: ModelType::Encoder,
712 config_params: HashMap::new(),
713 layers: vec![],
714 task_heads: vec![
715 TaskHead {
716 name: "cls".to_string(),
717 task_type: "classification".to_string(),
718 output_size: Some(10),
719 },
720 TaskHead {
721 name: "ner".to_string(),
722 task_type: "token_classification".to_string(),
723 output_size: Some(9),
724 },
725 ],
726 };
727 assert_eq!(config.task_heads.len(), 2);
728 }
729
730 #[test]
731 fn test_generator_with_attention_layer() {
732 let mut params = HashMap::new();
733 params.insert("num_heads".to_string(), "8".to_string());
734 params.insert("hidden_size".to_string(), "512".to_string());
735 let layer = LayerDefinition {
736 name: "self_attn".to_string(),
737 layer_type: "attention".to_string(),
738 parameters: params,
739 };
740 assert_eq!(layer.parameters["num_heads"], "8");
741 }
742
743 #[test]
744 fn test_generator_with_feedforward_layer() {
745 let mut params = HashMap::new();
746 params.insert("input_size".to_string(), "512".to_string());
747 params.insert("hidden_size".to_string(), "2048".to_string());
748 let layer = LayerDefinition {
749 name: "ffn".to_string(),
750 layer_type: "feedforward".to_string(),
751 parameters: params,
752 };
753 assert_eq!(layer.parameters["hidden_size"], "2048");
754 }
755
756 #[test]
757 fn test_generator_with_linear_layer() {
758 let layer = LayerDefinition {
759 name: "linear".to_string(),
760 layer_type: "linear".to_string(),
761 parameters: HashMap::from([
762 ("input_size".to_string(), "768".to_string()),
763 ("output_size".to_string(), "3072".to_string()),
764 ]),
765 };
766 assert_eq!(layer.layer_type, "linear");
767 }
768
769 #[test]
770 fn test_generator_with_conv1d_layer() {
771 let layer = LayerDefinition {
772 name: "conv".to_string(),
773 layer_type: "conv1d".to_string(),
774 parameters: HashMap::from([
775 ("in_channels".to_string(), "768".to_string()),
776 ("out_channels".to_string(), "768".to_string()),
777 ]),
778 };
779 assert_eq!(layer.layer_type, "conv1d");
780 }
781
782 #[test]
783 fn test_config_param_types() {
784 let params = vec![
785 ConfigParam {
786 name: "int_param".to_string(),
787 param_type: "usize".to_string(),
788 default_value: "42".to_string(),
789 description: "An integer".to_string(),
790 },
791 ConfigParam {
792 name: "float_param".to_string(),
793 param_type: "f32".to_string(),
794 default_value: "0.1".to_string(),
795 description: "A float".to_string(),
796 },
797 ConfigParam {
798 name: "bool_param".to_string(),
799 param_type: "bool".to_string(),
800 default_value: "true".to_string(),
801 description: "A boolean".to_string(),
802 },
803 ConfigParam {
804 name: "str_param".to_string(),
805 param_type: "String".to_string(),
806 default_value: "hello".to_string(),
807 description: "A string".to_string(),
808 },
809 ];
810 assert_eq!(params.len(), 4);
811 for p in ¶ms {
812 assert!(!p.name.is_empty());
813 assert!(!p.param_type.is_empty());
814 }
815 }
816
817 #[test]
818 fn test_generate_test_code() {
819 let config = ModelTemplates::bert_encoder();
820 let generator = ModelGenerator::new(config);
821 let test_code = generator.generate_test_code();
822 assert!(test_code.contains("test_"));
823 assert!(test_code.contains("CustomBert"));
824 }
825
826 #[test]
827 fn test_model_name_in_generated_output() {
828 let config = ModelGeneratorConfig {
829 model_name: "UniqueTestModel".to_string(),
830 model_type: ModelType::Encoder,
831 config_params: HashMap::new(),
832 layers: vec![],
833 task_heads: vec![],
834 };
835 let generator = ModelGenerator::new(config);
836 let test_code = generator.generate_test_code();
837 assert!(test_code.contains("UniqueTestModel"));
838 }
839
840 fn layer(name: &str, layer_type: &str) -> LayerDefinition {
845 LayerDefinition {
846 name: name.to_string(),
847 layer_type: layer_type.to_string(),
848 parameters: HashMap::new(),
849 }
850 }
851
852 fn generator_with_layers(layers: Vec<LayerDefinition>) -> ModelGenerator {
853 ModelGenerator::new(ModelGeneratorConfig {
854 model_name: "Generated".to_string(),
855 model_type: ModelType::Encoder,
856 config_params: HashMap::new(),
857 layers,
858 task_heads: vec![],
859 })
860 }
861
862 #[test]
863 fn test_generated_imports_reference_existing_core_modules() {
864 let generator = generator_with_layers(vec![
865 layer("embed", "embedding"),
866 layer("norm", "layernorm"),
867 layer("attn", "attention"),
868 layer("proj", "linear"),
869 layer("drop", "dropout"),
870 ]);
871
872 let code = generator.generate_model_code().expect("model code generation");
873
874 for expected in [
876 "embedding::Embedding",
877 "layernorm::LayerNorm",
878 "attention::MultiHeadAttention",
879 "linear::Linear",
880 "dropout::Dropout",
881 ] {
882 assert!(
883 code.contains(expected),
884 "generated code must import {expected}:\n{code}"
885 );
886 }
887
888 for forbidden in [
890 "layers::conv::",
891 "conv::{",
892 "normalization::",
893 "transformer::TransformerBlock",
894 "rnn::",
895 "PositionalEncoding",
896 "BatchNorm",
897 "Conv1d",
898 "LSTM",
899 "GRU",
900 ] {
901 assert!(
902 !code.contains(forbidden),
903 "generated code must not reference `{forbidden}`, which does not exist in \
904 trustformers_core::layers:\n{code}"
905 );
906 }
907 }
908
909 #[test]
910 fn test_generated_imports_are_limited_to_the_configured_layers() {
911 let generator = generator_with_layers(vec![layer("proj", "linear")]);
912 let code = generator.generate_model_code().expect("model code generation");
913
914 assert!(code.contains("linear::Linear"));
915 for unused in [
916 "Dropout",
917 "MultiHeadAttention",
918 "Conv2d",
919 "Embedding",
920 "FeedForward",
921 "RMSNorm",
922 ] {
923 assert!(
924 !code.contains(unused),
925 "an unused import for `{unused}` would make the generated file warn:\n{code}"
926 );
927 }
928 }
929
930 #[test]
931 fn test_activation_layers_need_no_field_or_import() {
932 let generator = generator_with_layers(vec![layer("act", "gelu")]);
933 let code = generator.generate_model_code().expect("model code generation");
934
935 assert!(code.contains("x.gelu()?"), "{code}");
936 assert!(
937 !code.contains("use trustformers_core::layers::"),
938 "an activation needs no layer import:\n{code}"
939 );
940 }
941
942 #[test]
943 fn test_unsupported_layer_type_is_rejected() {
944 for unsupported in [
945 "lstm",
946 "gru",
947 "rnn",
948 "conv1d",
949 "batchnorm",
950 "transformer_block",
951 ] {
952 let generator = generator_with_layers(vec![layer("x", unsupported)]);
953 let error = generator
954 .generate_model_code()
955 .expect_err("generating code for a non-existent layer must fail");
956 assert!(
957 error.to_string().contains(unsupported),
958 "the error must name the unsupported layer type: {error}"
959 );
960 }
961 }
962
963 #[test]
964 fn test_generate_model_propagates_unsupported_layers() {
965 let generator = generator_with_layers(vec![layer("recurrent", "lstm")]);
966 let temp_dir = std::env::temp_dir().join("trustformers_model_generator_unsupported");
967 let _ = std::fs::remove_dir_all(&temp_dir);
968
969 let result = generator.generate_model(&temp_dir);
970 assert!(
971 result.is_err(),
972 "a model that cannot be generated must not be written to disk"
973 );
974 assert!(
975 !temp_dir.join("Generated").join("model.rs").exists(),
976 "no model.rs may be written for an unsupported configuration"
977 );
978 let _ = std::fs::remove_dir_all(&temp_dir);
979 }
980}