Struct ModelCard 

pub struct ModelCard {

    pub model_id: String,
    pub name: String,
    pub version: String,
    pub author: Option<String>,
    pub created_at: String,
    pub framework_version: String,
    pub rust_version: Option<String>,
    pub description: Option<String>,
    pub license: Option<String>,
    pub training_data: Option<TrainingDataInfo>,
    pub hyperparameters: HashMap<String, Value>,
    pub metrics: HashMap<String, Value>,
    pub architecture: Option<String>,
    pub param_count: Option<u64>,
    pub target_hardware: Vec<String>,
    pub extra: HashMap<String, Value>,
}

Model card metadata embedded in .apr files.

Designed for dual compatibility:

• APR sovereign format (full control)
• Hugging Face ecosystem (interoperability)

Example

use aprender::format::model_card::{ModelCard, TrainingDataInfo};

let card = ModelCard::new("my-model", "1.0.0")
    .with_author("user@host")
    .with_description("A test model");

assert_eq!(card.version, "1.0.0");

Fields

model_id: String

Unique model identifier (e.g., “aprender-shell-markov-3gram-20251127”)

name: String

Human-readable model name

version: String

Semantic version (e.g., “1.2.3”)

author: Option<String>

Model author or organization

created_at: String

Creation timestamp (ISO 8601)

framework_version: String

Training framework version (e.g., “aprender 0.10.0”)

rust_version: Option<String>

Rust toolchain used (e.g., “1.82.0”)

description: Option<String>

Short description (one line)

license: Option<String>

License (SPDX identifier)

training_data: Option<TrainingDataInfo>

Training dataset description

hyperparameters: HashMap<String, Value>

Hyperparameters used

metrics: HashMap<String, Value>

Training/evaluation metrics

architecture: Option<String>

Model architecture type (e.g., “MarkovModel”, “LinearRegression”)

param_count: Option<u64>

Number of parameters (for complexity estimation)

target_hardware: Vec<String>

Target hardware platforms

extra: HashMap<String, Value>

Custom metadata (extensible)

Implementations

impl ModelCard

pub fn new(model_id: impl Into<String>, version: impl Into<String>) -> Self

Create a new model card with required fields.

pub fn with_name(self, name: impl Into<String>) -> Self

Set the model name (human-readable).

pub fn with_author(self, author: impl Into<String>) -> Self

Set the author.

pub fn with_description(self, desc: impl Into<String>) -> Self

Set the description.

pub fn with_license(self, license: impl Into<String>) -> Self

Set the license (SPDX identifier).

pub fn with_architecture(self, arch: impl Into<String>) -> Self

Set the architecture type.

pub fn with_param_count(self, count: u64) -> Self

Set the parameter count.

pub fn with_training_data(self, data: TrainingDataInfo) -> Self

Set training data info.

pub fn with_hyperparameter( self, key: impl Into<String>, value: impl Into<Value>, ) -> Self

Add a hyperparameter.

pub fn with_metric( self, key: impl Into<String>, value: impl Into<Value>, ) -> Self

Add a metric.

pub fn to_huggingface(&self) -> String

Export to Hugging Face model card format (YAML front matter + Markdown).

pub fn to_json(&self) -> Result<String, Error>

Serialize to JSON.

pub fn from_json(json: &str) -> Result<Self, Error>

Deserialize from JSON.

Trait Implementations

impl Clone for ModelCard

fn clone(&self) -> ModelCard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelCard

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

Formats the value using the given formatter.

impl Default for ModelCard

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ModelCard

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ModelCard

fn eq(&self, other: &ModelCard) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ModelCard

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ModelCard