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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
use crate::internal::*;
use crate::model::*;
use crate::ops;
use crate::ops::invariants;
use crate::plan::{SimplePlan, SimpleState};
use crate::TractResult;
pub type TypedModel = Graph<TypedFact, Box<dyn TypedOp>>;
pub type TypedNode = Node<TypedFact, Box<dyn TypedOp>>;
pub type TypedModelPatch = ModelPatch<TypedFact, Box<dyn TypedOp>>;
pub type TypedSimplePlan<M> = SimplePlan<TypedFact, Box<dyn TypedOp>, M>;
pub type TypedRunnableModel<M> = RunnableModel<TypedFact, Box<dyn TypedOp>, M>;
pub type TypedSimpleState<M, P> = SimpleState<TypedFact, Box<dyn TypedOp>, M, P>;
pub type RunnableModel<F, O, M> = SimplePlan<F, O, M>;
impl SpecialOps<TypedFact, Box<dyn TypedOp>> for TypedModel {
fn is_source(op: &Box<dyn TypedOp>) -> bool {
op.as_op().downcast_ref::<ops::source::TypedSource>().is_some()
}
fn create_dummy(&self) -> Box<dyn TypedOp> {
Box::new(crate::ops::dummy::Dummy::new())
}
fn create_source(&self, fact: TypedFact) -> Box<dyn TypedOp> {
Box::new(crate::ops::source::TypedSource::new(fact))
}
fn wire_node(
&mut self,
name: impl Into<String>,
op: impl Into<Box<dyn TypedOp>>,
inputs: &[OutletId],
) -> TractResult<TVec<OutletId>> {
let op = op.into();
let name = name.into();
let output_facts = {
let input_facts =
inputs.iter().map(|o| self.outlet_fact(*o)).collect::<TractResult<TVec<_>>>()?;
if input_facts.iter().all(|f| f.konst.is_some()) && op.is_stateless() {
let tensors =
input_facts.iter().map(|f| f.konst.clone().unwrap()).collect::<TVec<_>>();
let outputs = op.eval(tensors)?;
outputs.into_iter().map(|t| TypedFact::from(t)).collect()
} else {
op.output_facts(&*input_facts)
.with_context(|| format!("wiring {} ({:?})", name, op))?
}
};
let id = self.add_node(name, op, output_facts)?;
inputs
.iter()
.enumerate()
.try_for_each(|(ix, i)| self.add_edge(*i, InletId::new(id, ix)))?;
Ok(self.node(id).outputs.iter().enumerate().map(|(ix, _)| OutletId::new(id, ix)).collect())
}
}
impl TypedModel {
pub fn signature(&self) -> u64 {
use std::hash::Hasher;
let mut hasher = std::collections::hash_map::DefaultHasher::new();
self.hash(&mut hasher);
hasher.finish()
}
pub fn into_optimized(self) -> TractResult<TypedModel> {
self.declutter()?.optimize()
}
#[cfg(all(debug_assertions, feature = "paranoid_assertions"))]
pub fn check_consistent_facts(&self) -> TractResult<()> {
for node_id in &self.eval_order()? {
let input_facts = self.node_input_facts(*node_id)?;
let node = &self.nodes[*node_id];
if node.id != *node_id {
bail!("Node at position {} has id {}", node_id, node.id);
}
let output_facts = node.op.output_facts(&input_facts)?;
if node.outputs.len() != output_facts.len() {
bail!(
"Inconsistent model, node output count mismatch. Op says {}, node says {}. {}",
output_facts.len(),
node.outputs.len(),
node
);
}
if node
.outputs
.iter()
.map(|o| &o.fact)
.zip(output_facts.iter())
.any(|(a, b)| a.datum_type != b.datum_type || a.shape != b.shape)
{
bail!(
"Inconsistent model, node output types mismatch. Op says: {:?}, node says: {:?}. {} with inputs {:?}",
output_facts, node.outputs.iter().map(|o| &o.fact).collect::<Vec<_>>(), node, input_facts)
}
}
for node in &self.nodes {
for (ix, output) in node.outputs.iter().enumerate() {
output.fact.consistent().with_context(|| {
format!("Inconsistent fact {:?}: {:?}", OutletId::new(node.id, ix), output.fact)
})?
}
}
Ok(())
}
pub fn declutter(&self) -> TractResult<TypedModel> {
crate::optim::Optimizer::declutter().optimize(&self)
}
pub fn concretize_dims(&self, values: &SymbolValues) -> TractResult<TypedModel> {
use crate::model::translator::Translate;
impl Translate<TypedFact, Box<dyn TypedOp>, TypedFact, Box<dyn TypedOp>> for SymbolValues {
fn translate_node(
&self,
source: &TypedModel,
node: &TypedNode,
target: &mut TypedModel,
mapping: &HashMap<OutletId, OutletId>,
) -> TractResult<TVec<OutletId>> {
node.op.concretize_dims(source, node, target, mapping, self)
}
}
values.translate_model(&self)
}
pub fn optimize(self) -> TractResult<TypedModel> {
crate::optim::Optimizer::codegen().optimize(&self)
}
pub fn invariants(&self) -> TractResult<invariants::Invariants> {
invariants::for_model(self)
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test() {
fn is_sync<T: Sync>() {}
is_sync::<TypedModel>();
}
}