Skip to main content

trustformers_models/developer_tools/
model_generator.rs

1//! Model Generator
2//!
3//! Automatic generation of model architecture scaffolding and boilerplate code.
4
5use anyhow::{anyhow, Result};
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8use std::path::Path;
9
10/// Configuration for model generation
11#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct ModelGeneratorConfig {
13    /// Model name
14    pub model_name: String,
15    /// Model type (encoder, decoder, encoder-decoder)
16    pub model_type: ModelType,
17    /// Configuration parameters
18    pub config_params: HashMap<String, ConfigParam>,
19    /// Layer definitions
20    pub layers: Vec<LayerDefinition>,
21    /// Task heads to generate
22    pub task_heads: Vec<TaskHead>,
23}
24
25/// Model architecture type
26#[derive(Debug, Clone, Serialize, Deserialize)]
27pub enum ModelType {
28    Encoder,
29    Decoder,
30    EncoderDecoder,
31    Multimodal,
32    Custom,
33}
34
35/// Configuration parameter definition
36#[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/// Layer definition for model generation
45#[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
52/// Code fragments for one generated layer.
53struct GeneratedLayer {
54    /// Import path inside `trustformers_core::layers`.
55    import: &'static str,
56    /// Rust type of the struct field.
57    field_type: &'static str,
58    /// Expression that constructs the layer.
59    constructor: String,
60    /// Statement that applies the layer in the forward pass.
61    forward: String,
62}
63
64/// Task head definition
65#[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
72/// Model generator
73pub struct ModelGenerator {
74    config: ModelGeneratorConfig,
75}
76
77impl ModelGenerator {
78    /// Create a new model generator
79    pub fn new(config: ModelGeneratorConfig) -> Self {
80        Self { config }
81    }
82
83    /// Generate model architecture code
84    pub fn generate_model(&self, output_dir: &Path) -> Result<()> {
85        // Create output directory structure
86        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        // Generate configuration file
92        self.generate_config_file(&model_dir)?;
93
94        // Generate model implementation
95        self.generate_model_file(&model_dir)?;
96
97        // Generate module file
98        self.generate_mod_file(&model_dir)?;
99
100        // Generate test file
101        self.generate_test_file(&model_dir)?;
102
103        Ok(())
104    }
105
106    /// Generate configuration file
107    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    /// Generate model implementation file
115    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    /// Generate module file
123    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    /// Generate test file
136    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    /// Generate configuration code
144    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        // Add configuration parameters
152        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        // Add Default implementation
162        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    /// Description of a layer type this generator can emit.
180    ///
181    /// Every entry maps onto a type that really exists in
182    /// [`trustformers_core::layers`]; there is no entry for layers core does not
183    /// provide, so the generator can never emit an import that will not resolve.
184    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                // `Linear::new` is infallible.
194                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                // `Dropout::new` is infallible.
255                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                // `Embedding` consumes token ids, not a tensor, so it is applied
268                // to the raw input before the tensor pipeline starts.
269                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            // Activations are tensor methods: no field, no import.
283            "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    /// Forward-pass expression for an activation layer type.
304    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    /// Generate model code
317    ///
318    /// # Errors
319    ///
320    /// Fails when the configuration requests a layer type that has no
321    /// implementation in `trustformers_core::layers`: emitting an import for a
322    /// module that does not exist would produce a file that cannot compile.
323    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    /// Generate forward pass implementation based on model type and layers
361    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    /// Generate encoder forward pass
372    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    /// Generate decoder forward pass
391    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    /// Generate encoder-decoder forward pass
396    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    /// Generate multimodal forward pass
401    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    /// Generate custom forward pass
406    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() // Default to encoder-style for custom with layers
411        }
412    }
413
414    /// Generate layer field declarations, initialisation code and the exact set
415    /// of imports the generated file needs.
416    ///
417    /// Only layer types that exist in `trustformers_core::layers` are emitted;
418    /// anything else is an error rather than an import that cannot resolve.
419    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                // Activation: no field, no import.
431                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    /// Generate test code
451    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
464/// Predefined model templates
465pub struct ModelTemplates;
466
467impl ModelTemplates {
468    /// Get BERT-style encoder template
469    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    /// Get GPT-style decoder template
500    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        // Clean up
659        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        // Check files were created
671        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 &params {
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    // ------------------------------------------------------------------
841    // Regression tests: generated code must reference real core modules
842    // ------------------------------------------------------------------
843
844    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        // Modules that exist in trustformers_core::layers.
875        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        // Modules that do NOT exist and must never be emitted.
889        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}