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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
#[cfg(feature = "use-serde")]
use serde::{Serialize, Deserialize, Serializer, Deserializer,
ser::SerializeStruct,
de, de::Visitor, de::SeqAccess, de::MapAccess};
use std::fmt;
use crate::var_inner::VarInner;
impl Serialize for VarInner {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer, {
let mut state = serializer.serialize_struct("VarInner", 3)?;
state.serialize_field("id", &self.get_id())?;
state.serialize_field("need_grad", &self.get_need_grad())?;
state.serialize_field("net", &*self.get_net().borrow())?;
state.end()
}
}
impl<'de> Deserialize<'de> for VarInner {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>, {
enum Field { Id, NeedGrad, Net }
impl<'de> Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
where D: Deserializer<'de>, {
struct FieldVisitor;
impl<'de> Visitor<'de> for FieldVisitor {
type Value = Field;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("id, need_grad, or net")
}
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: de::Error, {
match value {
"id" => Ok(Field::Id),
"need_grad" => Ok(Field::NeedGrad),
"net" => Ok(Field::Net),
_ => Err(de::Error::unknown_field(value, &FIELDS)),
}
}
}
deserializer.deserialize_identifier(FieldVisitor)
}
}
struct VarInnerVisitor;
impl<'de> Visitor<'de> for VarInnerVisitor {
type Value = VarInner;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct VarInner")
}
fn visit_map<V>(self, mut map: V) -> Result<VarInner, V::Error>
where V: MapAccess<'de>, {
let mut id = None;
let mut need_grad = None;
let mut net = None;
while let Some(key) = map.next_key()? {
match key {
Field::Id => {
if id.is_some() {
return Err(de::Error::duplicate_field("id"));
}
id = Some(map.next_value()?);
},
Field::NeedGrad => {
if need_grad.is_some() {
return Err(de::Error::duplicate_field("need_grad"));
}
need_grad = Some(map.next_value()?);
},
Field::Net => {
if net.is_some() {
return Err(de::Error::duplicate_field("net"));
}
net = Some(map.next_value()?);
}
}
}
let id = id.ok_or_else(|| de::Error::missing_field("id"))?;
let need_grad = need_grad.ok_or_else(|| de::Error::missing_field("need_grad"))?;
let net = net.ok_or_else(|| de::Error::missing_field("net"))?;
Ok(VarInner::set_inner(id, need_grad, net))
}
fn visit_seq<V>(self, mut seq: V) -> Result<VarInner, V::Error>
where V: SeqAccess<'de>, {
let id = seq.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?;
let need_grad = seq.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?;
let net = seq.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?;
Ok(VarInner::set_inner(id, need_grad, net))
}
}
const FIELDS: [&str; 3] = ["id", "need_grad", "net"];
deserializer.deserialize_struct("Duration", &FIELDS, VarInnerVisitor)
}
}
#[cfg(all(test, feature = "use-serde"))]
mod tests {
use crate::var_inner::VarInner;
use crate::var::Var;
use rand::prelude::*;
#[test]
fn test_serde_var_inner() {
let mut rng = StdRng::seed_from_u64(671);
let n = 10;
let data = Var::normal(&mut rng, &vec![n, 2], 0., 2.);
let result = data.matmul(&Var::new(&vec![2., 3.], &vec![2, 1])).unwrap() + Var::new(&vec![1.], &vec![1]);
let serialized = serde_pickle::to_vec(&*result.inner().borrow(), true).unwrap();
let deserialized: VarInner = serde_pickle::from_slice(&serialized).unwrap();
println!("{:?}", deserialized.dump_net());
}
}
