entrenar 0.7.9

Training & Optimization library with autograd, LoRA, quantization, and model merging
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Research artifact with full metadata.

use serde::{Deserialize, Serialize};

use super::{ArtifactType, Author, License};

/// Research artifact with full metadata
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResearchArtifact {
    /// Unique identifier
    pub id: String,
    /// Artifact title
    pub title: String,
    /// Authors with affiliations and roles
    pub authors: Vec<Author>,
    /// Type of artifact
    pub artifact_type: ArtifactType,
    /// License
    pub license: License,
    /// Digital Object Identifier (optional)
    pub doi: Option<String>,
    /// Version string
    pub version: String,
    /// Abstract or description
    pub description: Option<String>,
    /// Keywords for discovery
    pub keywords: Vec<String>,
    /// Creation timestamp
    pub created_at: chrono::DateTime<chrono::Utc>,
}

impl ResearchArtifact {
    /// Create a new research artifact
    pub fn new(
        id: impl Into<String>,
        title: impl Into<String>,
        artifact_type: ArtifactType,
        license: License,
    ) -> Self {
        Self {
            id: id.into(),
            title: title.into(),
            authors: Vec::new(),
            artifact_type,
            license,
            doi: None,
            version: "1.0.0".to_string(),
            description: None,
            keywords: Vec::new(),
            created_at: chrono::Utc::now(),
        }
    }

    /// Add an author
    pub fn with_author(mut self, author: Author) -> Self {
        self.authors.push(author);
        self
    }

    /// Add multiple authors
    pub fn with_authors(mut self, authors: impl IntoIterator<Item = Author>) -> Self {
        self.authors.extend(authors);
        self
    }

    /// Set the DOI
    pub fn with_doi(mut self, doi: impl Into<String>) -> Self {
        self.doi = Some(doi.into());
        self
    }

    /// Set the version
    pub fn with_version(mut self, version: impl Into<String>) -> Self {
        self.version = version.into();
        self
    }

    /// Set the description
    pub fn with_description(mut self, description: impl Into<String>) -> Self {
        self.description = Some(description.into());
        self
    }

    /// Add keywords
    pub fn with_keywords(mut self, keywords: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.keywords.extend(keywords.into_iter().map(Into::into));
        self
    }

    /// Get the first author (for citation keys)
    pub fn first_author(&self) -> Option<&Author> {
        self.authors.first()
    }
}