Struct EnhancedModel 

pub struct EnhancedModel<T: SerializableModel> {
    pub model: T,
    pub metadata: EnhancedModelMetadata,
}

Enhanced model wrapper with metadata

Fields

model: T

The actual model data

metadata: EnhancedModelMetadata

Enhanced metadata

Implementations

impl<T: SerializableModel> EnhancedModel<T>

pub fn new(model: T, metadata: EnhancedModelMetadata) -> Self

Create a new enhanced model with metadata

pub fn with_auto_metadata(model: T, algorithm_name: &str) -> Self

Create an enhanced model with automatic metadata generation

pub fn validate_integrity(&self) -> Result<bool>

Validate model integrity

pub fn format_version(&self) -> &str

Get model format version

pub fn is_compatible(&self) -> bool

Check if model is compatible with current library version

pub fn training_duration_seconds(&self) -> f64

Get training duration in seconds

pub fn peak_memory_mb(&self) -> f64

Get memory usage in MB

Trait Implementations

impl<T: Clone + SerializableModel> Clone for EnhancedModel<T>

fn clone(&self) -> EnhancedModel<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + SerializableModel> Debug for EnhancedModel<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T: SerializableModel> Deserialize<'de> for EnhancedModel<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: SerializableModel> SerializableModel for EnhancedModel<T>

fn save_to_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Save the model to a file

fn save_to_writer<W: Write>(&self, writer: W) -> Result<()>

Save the model to a writer

fn save_to_file_compressed<P: AsRef<Path>>(&self, path: P) -> Result<()>

Save the model to a file with compression

fn load_from_file_compressed<P: AsRef<Path>>(path: P) -> Result<Self>

Load the model from a compressed file

fn load_from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Load the model from a file

fn load_from_reader<R: Read>(reader: R) -> Result<Self>

Load the model from a reader

impl<T> Serialize for EnhancedModel<T>

where T: Serialize + SerializableModel,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.