tract 0.21.2.dev0__tar.gz → 0.21.2.dev1__tar.gz

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tract
-Version: 0.21.2.dev0
+Version: 0.21.2.dev1
 Summary: Python bindings for tract, a neural network inference engine
 Author: Mathieu Poumeyrol, Sonos, and tract contributors
 Author-email: mathieu@poumeyrol.fr

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/pyproject.toml

@@ -1,12 +1,11 @@
 [build-system]
 requires = [
-    "setuptools>=68<69",
-    "setuptools_rust>=1.6<1.7",
-    "wheel>=0.41<0.42",
-    "toml>=0.10<0.11"
+    "setuptools >=68, <69",
+    "setuptools_rust >=1.6, <1.7",
+    "wheel >=0.41, <0.42",
+    "toml >=0.10, <0.11"
 ]
 
-
 [tool.cibuildwheel]
 environment = "PATH=$PATH:$HOME/.cargo/bin"
 test-requires = "pytest"

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/api/ffi/src/lib.rs

@@ -23,7 +23,7 @@ pub enum TRACT_RESULT {
 }
 
 thread_local! {
-    pub(crate) static LAST_ERROR: RefCell<Option<CString>> = RefCell::new(None);
+    pub(crate) static LAST_ERROR: RefCell<Option<CString>> = const { RefCell::new(None) };
 }
 
 fn wrap<F: FnOnce() -> anyhow::Result<()>>(func: F) -> TRACT_RESULT {

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/cli/src/main.rs

@@ -235,6 +235,11 @@ fn main() -> tract_core::anyhow::Result<()> {
                 .takes_value(true)
                 .help("Save intermediary values as a npz file"),
         )
+        .arg(
+            Arg::new("check-f16-overflow")
+                .long("check-f16-overflow")
+                .help("Check for f16 overflow in all outputs"),
+        )
         .arg(
             Arg::new("assert-sane-floats")
                 .long("assert-sane-floats")

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/cli/src/run.rs

@@ -147,6 +147,7 @@ fn run_regular(
     sub_matches: &clap::ArgMatches,
 ) -> TractResult<TVec<Vec<TValue>>> {
     let steps = sub_matches.is_present("steps");
+    let check_f16_overflow = sub_matches.is_present("check-f16-overflow");
     let assert_sane_floats = sub_matches.is_present("assert-sane-floats");
     let mut npz = if let Some(npz) = sub_matches.value_of("save-steps") {
         let npz = std::fs::File::create(npz).with_context(|| format!("Creating {npz}"))?;
@@ -210,6 +211,15 @@ fn run_regular(
                             npz_add_tensor(npz, name, t)?;
                         }
                     }
+                    if check_f16_overflow {
+                        for (ix, o) in r.iter().enumerate() {
+                            if let Ok(f32s) = o.as_slice::<f32>() {
+                                if f32s.iter().any(|f| f.abs() > f16::MAX.to_f32()) {
+                                    warn!("{node}, output {ix} overflows f16");
+                                }
+                            }
+                        }
+                    }
                     if assert_sane_floats {
                         for (ix, o) in r.iter().enumerate() {
                             if node.op_is::<Im2Col>() || node.op_is::<MatMatMulPack>() {

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/floats.rs

@@ -4,6 +4,7 @@ use crate::internal::translator::Translate;
 use crate::internal::*;
 use crate::ops::array::{Pad, PadMode};
 use crate::ops::einsum::EinSum;
+use crate::ops::cast::Cast;
 use crate::ops::konst::Const;
 use crate::ops::scan::Scan;
 use crate::ops::source::TypedSource;
@@ -39,6 +40,12 @@ impl<T1: Datum + Float, T2: Datum + Float>
             Box::new(TypedSource::new(fact_float_precision_conversion::<T1, T2>(&source.fact)))
         } else if let Some(konst) = node.op_as::<Const>() {
             Box::new(Const(tensor_float_precision_conversion::<T1, T2>(&konst.0)))
+        } else if let Some(cast) = node.op_as::<Cast>() {
+            if cast.to == T1::datum_type() {
+                Box::new(Cast { to: T2::datum_type() })
+            } else {
+                node.op.clone()
+            }
         } else if let Some(op) = node.op_as::<Scan>() {
             let body = FloatPrecisionTranslator::<T1, T2>::default().translate_model(&op.body)?;
             Box::new(Scan { body, ..op.clone() })

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/ops/binary.rs

@@ -4,11 +4,12 @@ use std::fmt;
 use tract_data::itertools::izip;
 
 pub fn wire_cast(
-    prefix: &str,
+    prefix: impl AsRef<str>,
     target: &mut TypedModel,
     inputs: &[OutletId],
     operating_datum_type: DatumType,
 ) -> TractResult<TVec<OutletId>> {
+    let prefix = prefix.as_ref();
     let mut wires = tvec!();
     for (ix, mut wire) in inputs.iter().copied().enumerate() {
         if target.outlet_fact(wire)?.datum_type != operating_datum_type {
@@ -30,7 +31,7 @@ pub fn wire_rank_broadcast(
 ) -> TractResult<TVec<OutletId>> {
     let facts = inputs
         .iter()
-        .map(|o| target.outlet_fact(*o).map(|ok| ok.clone()))
+        .map(|o| target.outlet_fact(*o).cloned())
         .collect::<TractResult<TVec<_>>>()?;
     let max_rank = facts.iter().map(|f| f.rank()).max().unwrap();
     let mut wires = tvec!();

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/ops/nn/mod.rs

@@ -3,7 +3,7 @@ mod reduce;
 mod softmax;
 
 pub use self::data_formats::{BaseDataShape, DataFormat, DataShape, SymDataShape};
-pub use self::reduce::{Reduce, Reducer};
+pub use self::reduce::{Reduce, Reducer, expand_mean_of_squares};
 pub use self::softmax::{Softmax, SoftmaxExp};
 
 pub use crate::internal::*;

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/ops/nn/reduce.rs

@@ -1,5 +1,9 @@
 use crate::internal::Axis;
 use crate::internal::*;
+use crate::ops::binary::{wire_cast, wire_with_rank_broadcast, TypedBinOp};
+use crate::ops::cast::cast;
+use crate::ops::element_wise::ElementWiseOp;
+use crate::ops::math::{div, mul, square, Mul, Square};
 use std::convert::TryFrom;
 use std::mem::transmute;
 use tract_data::internal::ClampCast;
@@ -50,6 +54,7 @@ pub enum Reducer {
     Min,
     Prod,
     Sum,
+    MeanOfSquares,
 }
 
 impl Reducer {
@@ -90,6 +95,7 @@ impl Reducer {
                         ))
                     }
                 }
+                MeanOfSquares => self.mean_of_squares(axes, input)?,
             };
             if input.datum_type().is_quantized()
                 && input.datum_type().unquantized() == t.datum_type().unquantized()
@@ -177,6 +183,16 @@ impl Reducer {
         }
         output.unwrap().into_tensor()
     }
+
+    fn mean_of_squares(&self, axis: &[usize], input: &Tensor) -> TractResult<Tensor> {
+        let dt = input.datum_type();
+        let mut input = input.cast_to::<f32>()?.into_owned();
+        input.as_slice_mut::<f32>()?.iter_mut().for_each(|x| *x = *x * *x);
+        let mut output = unsafe { self.sum::<f32>(axis, &input) };
+        let norm = output.len() as f32 / input.len() as f32;
+        output.as_slice_mut::<f32>()?.iter_mut().for_each(|x| *x *= norm);
+        Ok(output.cast_to_dt(dt)?.into_owned())
+    }
 }
 
 fn argmax_t<T>(v: ArrayViewD<T>, last: bool) -> i64
@@ -298,6 +314,51 @@ impl TypedOp for Reduce {
         Ok(tvec!(dt.fact(shape)))
     }
 
+    fn declutter(
+        &self,
+        model: &TypedModel,
+        node: &TypedNode,
+    ) -> TractResult<Option<TypedModelPatch>> {
+        if self.reducer == Reducer::Sum {
+            let Some(prec) = model.single_prec(node.id)? else { return Ok(None) };
+            let Some(prec_ew) = prec.op_as::<ElementWiseOp>() else { return Ok(None) };
+            if !prec_ew.0.is::<Square>() {
+                return Ok(None);
+            }
+            if node.outputs.len() != 1 || node.outputs[0].successors.len() != 1 {
+                return Ok(None);
+            }
+            let our_inlet = node.outputs[0].successors[0];
+            let succ = model.node(our_inlet.node);
+            let Some(succ_bin) = succ.op_as::<TypedBinOp>() else { return Ok(None) };
+            if !succ_bin.0.is::<Mul>() {
+                return Ok(None);
+            }
+            let other = succ.inputs[1 - our_inlet.slot];
+            let Some(other_konst) = model.outlet_fact(other)?.uniform.as_ref() else {
+                return Ok(None);
+            };
+            let norm: TDim = self.axes.iter().map(|&ax| &prec.outputs[0].fact.shape[ax]).product();
+            let Some(norm) = norm.as_i64() else { return Ok(None) };
+            if norm == 0 {
+                return Ok(None);
+            }
+            let norm = tensor0((norm as f32).recip());
+            if other_konst.close_enough(&norm, Approximation::Close).is_ok() {
+                let mut patch = TypedModelPatch::default();
+                let wire = patch.tap_model(model, prec.inputs[0])?;
+                let wire = patch.wire_node(
+                    &node.name,
+                    Reduce::new(self.axes.clone(), Reducer::MeanOfSquares),
+                    &[wire],
+                )?[0];
+                patch.shunt_outside(model, succ.id.into(), wire)?;
+                return Ok(Some(patch));
+            }
+        }
+        Ok(None)
+    }
+
     fn axes_mapping(
         &self,
         inputs: &[&TypedFact],
@@ -346,3 +407,46 @@ impl TypedOp for Reduce {
 
     as_op!();
 }
+
+pub fn expand_mean_of_squares(
+    _ctx: &(),
+    model: &TypedModel,
+    node: &TypedNode,
+    name: &str,
+    op: &Reduce,
+) -> TractResult<Option<TypedModelPatch>> {
+    if op.reducer == Reducer::MeanOfSquares {
+        let mut patch = TypedModelPatch::default();
+        let mut wire = tvec!(patch.tap_model(model, node.inputs[0])?);
+        let dt = model.outlet_fact(node.inputs[0])?.datum_type;
+        if dt != f32::datum_type() {
+            wire = patch.wire_node(format!("{name}.to_f32"), cast(f32::datum_type()), &wire)?;
+        }
+        wire = patch.wire_node(format!("{name}.sqr"), square(), &wire)?;
+        let input_size = patch.outlet_fact(wire[0])?.shape.volume();
+        let input_size = patch.add_const(format!("{name}.input_size"), tensor0(input_size))?;
+        wire = patch.wire_node(
+            format!("{name}.sum"),
+            Reduce::new(op.axes.clone(), Reducer::Sum),
+            &wire,
+        )?;
+        let output_size = patch.outlet_fact(wire[0])?.shape.volume();
+        let output_size = patch.add_const(format!("{name}.output_size"), tensor0(output_size))?;
+        let norm = wire_cast(
+            format!("{name}.norm"),
+            &mut patch,
+            &[output_size, input_size],
+            f32::datum_type(),
+        )?;
+        let norm = patch.wire_node(format!("{name}.norm"), div(), &norm)?[0];
+        wire =
+            wire_with_rank_broadcast(format!("{name}.card"), &mut patch, mul(), &[wire[0], norm])?;
+        if dt != f32::datum_type() {
+            wire = patch.wire_node(format!("{name}.from_f32"), cast(dt), &wire)?;
+        }
+        patch.shunt_outside(model, node.id.into(), wire[0])?;
+        Ok(Some(patch))
+    } else {
+        Ok(None)
+    }
+}

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/ops/submodel.rs

@@ -16,9 +16,9 @@ impl SubmodelOp {
     pub fn new(model: Box<dyn InnerModel>, label: &str) -> TractResult<Self> {
         Ok(Self { model, label: label.to_string(), decluttered: false, codegen: false })
     }
-    
+
     pub fn iteration_count(&self, _inputs: &[&TypedFact]) -> Option<TDim> {
-        None 
+        None
     }
 
     pub fn model(&self) -> &TypedModel {
@@ -121,7 +121,7 @@ impl InnerModel for TypedModel {
         let facts = self
             .output_outlets()?
             .iter()
-            .map(|outlet| self.outlet_fact(*outlet).map(|c| c.clone()))
+            .map(|outlet| self.outlet_fact(*outlet).cloned())
             .collect::<TractResult<TVec<_>>>()?;
         Ok(facts)
     }
@@ -154,7 +154,6 @@ impl InnerModel for TypedModel {
     }
 }
 
-
 pub type TypedModelOpState = TypedSimpleState<TypedModel, Arc<TypedSimplePlan<TypedModel>>>;
 
 impl OpState for TypedModelOpState {
@@ -169,7 +168,8 @@ impl OpState for TypedModelOpState {
     }
 }
 
-pub type FrozenSubmodelOpState = TypedFrozenSimpleState<TypedModel, Arc<TypedSimplePlan<TypedModel>>>;
+pub type FrozenSubmodelOpState =
+    TypedFrozenSimpleState<TypedModel, Arc<TypedSimplePlan<TypedModel>>>;
 
 impl FrozenOpState for FrozenSubmodelOpState {
     fn unfreeze(&self) -> Box<dyn OpState> {

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/core/src/plan.rs

@@ -553,7 +553,7 @@ where
         None => node.op().eval(input),
     }
     .with_context(|| format!("Evaluating {node}"));
-    // eprintln!(" ==> {}", r.as_ref().unwrap()[0].dump(true)?);
+     // eprintln!(" ==> {}", r.as_ref().unwrap()[0].dump(true)?);
     r
 }
 

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/data/src/lib.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::len_zero)]
 #![allow(clippy::missing_safety_doc)]
-#[macro_use]
+
 pub extern crate itertools;
 
 #[macro_use]

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/data/src/tensor.rs

@@ -1283,7 +1283,7 @@ impl Tensor {
     /// Access the data as a scalar, after a cast.
     pub fn cast_to_scalar<D: Datum + Copy>(&self) -> anyhow::Result<D> {
         let casted = self.cast_to::<D>()?;
-        casted.to_scalar::<D>().map(|&x| x)
+        casted.to_scalar::<D>().copied()
     }
 
     /// Access the nth element of the tensor, returned as a 0-rank Tensor

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/deny.toml

@@ -1,4 +1,6 @@
+
 # add whatever else we support.
+[graph]
 targets = [
     { triple = "x86_64-unknown-linux-gnu" },
     { triple = "x86_64-unknown-linux-musl" },
@@ -16,8 +18,8 @@ targets = [
 ]
 
 [advisories]
-vulnerability = "deny"
-unmaintained = "warn"
+version = 2
+git-fetch-with-cli = true
 yanked = "deny"
 ignore = [
 	"RUSTSEC-2021-0145", # in atty, only impacts benches (through criterion) or pytorch example
@@ -33,7 +35,6 @@ deny = [
 
 # Skip some multiple-versions checks, until they can be fixed.
 skip = [
-    { name = "bitflags", version="<2" },
     { name = "itertools", version="<0.12.1" },
     { name = "regex-syntax", version="<8" },
     { name = "syn", version="<2" },
@@ -46,7 +47,6 @@ allow-git = [
 
 [licenses]
 allow = [
-    "BSD-3-Clause",                   # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
     "Apache-2.0",                     # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
     "MIT",                            # https://tldrlegal.com/license/mit-license
     "Unicode-DFS-2016"                # https://spdx.org/licenses/Unicode-DFS-2016.html 

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/harness/pre-optimized-graphes/mdl-en-2019-Q3-librispeech/expected

@@ -142,11 +142,11 @@ graph network(input) -> (output) {
   i"tdnn1.affine.output" = add(i"tdnn1.affine.output.einsum", i"tdnn1.affine.output.bias.reshape");
   i"tdnn1.relu.output.low.cst" = [[[0.0]]];
   i"tdnn1.relu.output.low" = max(i"tdnn1.affine.output", i"tdnn1.relu.output.low.cst");
-  i"tdnn1.renorm.reduced.sq" = square(i"tdnn1.relu.output.low");
-  i"tdnn1.renorm.reduced.sum" = sum_reduce(i"tdnn1.renorm.reduced.sq", axes = [1]);
-  i"tdnn1.renorm.scaled-recip" = [[[0.00390625]]];
-  i"tdnn1.renorm.scaled" = mul(i"tdnn1.renorm.reduced.sum", i"tdnn1.renorm.scaled-recip");
-  i"tdnn1.renorm.output-recip" = rsqrt(i"tdnn1.renorm.scaled");
+  i"tdnn1.renorm.reduced.sum.sqr" = square(i"tdnn1.relu.output.low");
+  i"tdnn1.renorm.reduced.sum.sum" = sum_reduce(i"tdnn1.renorm.reduced.sum.sqr", axes = [1]);
+  i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2" = [[[0.00390625]]];
+  i"tdnn1.renorm.reduced.sum.card" = mul(i"tdnn1.renorm.reduced.sum.sum", i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2");
+  i"tdnn1.renorm.output-recip" = rsqrt(i"tdnn1.renorm.reduced.sum.card");
   i"tdnn1.renorm.output" = mul(i"tdnn1.relu.output.low", i"tdnn1.renorm.output-recip");
   i"tdnn2.affine.output.delay" = tract_pulse_delay(i"tdnn1.renorm.output", axis = 2, delay = 0, overlap = 2);
   i"tdnn2.affine.kernel.0" = variable<scalar>(label = "tdnn2.affine.kernel.0", shape = [256, 256, 3]);
@@ -154,20 +154,20 @@ graph network(input) -> (output) {
   i"tdnn2.affine.output_conv" = conv(i"tdnn2.affine.output.delay", i"tdnn2.affine.kernel.0", i"tdnn2.affine.bias.0", dilation = [1], stride = [1], border = "constant", groups = 1, padding = [(0, 0)]);
   i"tdnn2.affine.output" = i"tdnn2.affine.output_conv";
   i"tdnn2.relu.output.low" = max(i"tdnn2.affine.output", i"tdnn1.relu.output.low.cst");
-  i"tdnn2.renorm.reduced.sq" = square(i"tdnn2.relu.output.low");
-  i"tdnn2.renorm.reduced.sum" = sum_reduce(i"tdnn2.renorm.reduced.sq", axes = [1]);
-  i"tdnn2.renorm.scaled" = mul(i"tdnn2.renorm.reduced.sum", i"tdnn1.renorm.scaled-recip");
-  i"tdnn2.renorm.output-recip" = rsqrt(i"tdnn2.renorm.scaled");
+  i"tdnn2.renorm.reduced.sum.sqr" = square(i"tdnn2.relu.output.low");
+  i"tdnn2.renorm.reduced.sum.sum" = sum_reduce(i"tdnn2.renorm.reduced.sum.sqr", axes = [1]);
+  i"tdnn2.renorm.reduced.sum.card" = mul(i"tdnn2.renorm.reduced.sum.sum", i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2");
+  i"tdnn2.renorm.output-recip" = rsqrt(i"tdnn2.renorm.reduced.sum.card");
   i"tdnn2.renorm.output" = mul(i"tdnn2.relu.output.low", i"tdnn2.renorm.output-recip");
   i"tdnn3.affine.kernel.0" = variable<scalar>(label = "tdnn3.affine.kernel.0", shape = [256, 256, 3]);
   i"tdnn3.affine.bias.0" = variable<scalar>(label = "tdnn3.affine.bias.0", shape = [256]);
   i"tdnn3.affine.output_conv" = conv(i"tdnn2.renorm.output", i"tdnn3.affine.kernel.0", i"tdnn3.affine.bias.0", dilation = [1], stride = [3], border = "constant", groups = 1, padding = [(0, 0)]);
   i"tdnn3.affine.output" = i"tdnn3.affine.output_conv";
   i"tdnn3.relu.output.low" = max(i"tdnn3.affine.output", i"tdnn1.relu.output.low.cst");
-  i"tdnn3.renorm.reduced.sq" = square(i"tdnn3.relu.output.low");
-  i"tdnn3.renorm.reduced.sum" = sum_reduce(i"tdnn3.renorm.reduced.sq", axes = [1]);
-  i"tdnn3.renorm.scaled" = mul(i"tdnn3.renorm.reduced.sum", i"tdnn1.renorm.scaled-recip");
-  i"tdnn3.renorm.output-recip" = rsqrt(i"tdnn3.renorm.scaled");
+  i"tdnn3.renorm.reduced.sum.sqr" = square(i"tdnn3.relu.output.low");
+  i"tdnn3.renorm.reduced.sum.sum" = sum_reduce(i"tdnn3.renorm.reduced.sum.sqr", axes = [1]);
+  i"tdnn3.renorm.reduced.sum.card" = mul(i"tdnn3.renorm.reduced.sum.sum", i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2");
+  i"tdnn3.renorm.output-recip" = rsqrt(i"tdnn3.renorm.reduced.sum.card");
   i"tdnn3.renorm.output" = mul(i"tdnn3.relu.output.low", i"tdnn3.renorm.output-recip");
   i"fastlstm1.c_final.extracted.fastlstm1.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0" = variable<scalar>(label = "fastlstm1.c_final.extracted.fastlstm1.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0", shape = [1, 256, 256]);
   i"fastlstm1.c_final.extracted.fastlstm1.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256" = matmul(i"tdnn3.renorm.output", i"fastlstm1.c_final.extracted.fastlstm1.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0", transposeA = true, transposeB = false);
@@ -217,10 +217,10 @@ graph network(input) -> (output) {
   i"tdnn4.affine.output_conv" = conv(i"tdnn4.affine.output.delay", i"tdnn4.affine.kernel.0", i"tdnn4.affine.bias.0", dilation = [1], stride = [1], border = "constant", groups = 1, padding = [(0, 0)]);
   i"tdnn4.affine.output" = i"tdnn4.affine.output_conv";
   i"tdnn4.relu.output.low" = max(i"tdnn4.affine.output", i"tdnn1.relu.output.low.cst");
-  i"tdnn4.renorm.reduced.sq" = square(i"tdnn4.relu.output.low");
-  i"tdnn4.renorm.reduced.sum" = sum_reduce(i"tdnn4.renorm.reduced.sq", axes = [1]);
-  i"tdnn4.renorm.scaled" = mul(i"tdnn4.renorm.reduced.sum", i"tdnn1.renorm.scaled-recip");
-  i"tdnn4.renorm.output-recip" = rsqrt(i"tdnn4.renorm.scaled");
+  i"tdnn4.renorm.reduced.sum.sqr" = square(i"tdnn4.relu.output.low");
+  i"tdnn4.renorm.reduced.sum.sum" = sum_reduce(i"tdnn4.renorm.reduced.sum.sqr", axes = [1]);
+  i"tdnn4.renorm.reduced.sum.card" = mul(i"tdnn4.renorm.reduced.sum.sum", i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2");
+  i"tdnn4.renorm.output-recip" = rsqrt(i"tdnn4.renorm.reduced.sum.card");
   i"tdnn4.renorm.output" = mul(i"tdnn4.relu.output.low", i"tdnn4.renorm.output-recip");
   i"tdnn5.affine.output.delay" = tract_pulse_delay(i"tdnn4.renorm.output", axis = 2, delay = 0, overlap = 2);
   i"tdnn5.affine.kernel.0" = variable<scalar>(label = "tdnn5.affine.kernel.0", shape = [256, 256, 3]);
@@ -228,10 +228,10 @@ graph network(input) -> (output) {
   i"tdnn5.affine.output_conv" = conv(i"tdnn5.affine.output.delay", i"tdnn5.affine.kernel.0", i"tdnn5.affine.bias.0", dilation = [1], stride = [1], border = "constant", groups = 1, padding = [(0, 0)]);
   i"tdnn5.affine.output" = i"tdnn5.affine.output_conv";
   i"tdnn5.relu.output.low" = max(i"tdnn5.affine.output", i"tdnn1.relu.output.low.cst");
-  i"tdnn5.renorm.reduced.sq" = square(i"tdnn5.relu.output.low");
-  i"tdnn5.renorm.reduced.sum" = sum_reduce(i"tdnn5.renorm.reduced.sq", axes = [1]);
-  i"tdnn5.renorm.scaled" = mul(i"tdnn5.renorm.reduced.sum", i"tdnn1.renorm.scaled-recip");
-  i"tdnn5.renorm.output-recip" = rsqrt(i"tdnn5.renorm.scaled");
+  i"tdnn5.renorm.reduced.sum.sqr" = square(i"tdnn5.relu.output.low");
+  i"tdnn5.renorm.reduced.sum.sum" = sum_reduce(i"tdnn5.renorm.reduced.sum.sqr", axes = [1]);
+  i"tdnn5.renorm.reduced.sum.card" = mul(i"tdnn5.renorm.reduced.sum.sum", i"tdnn1.renorm.reduced.sum.card.fix-rank-1-2");
+  i"tdnn5.renorm.output-recip" = rsqrt(i"tdnn5.renorm.reduced.sum.card");
   i"tdnn5.renorm.output" = mul(i"tdnn5.relu.output.low", i"tdnn5.renorm.output-recip");
   i"fastlstm2.c_final.extracted.fastlstm2.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0" = variable<scalar>(label = "fastlstm2.c_final.extracted.fastlstm2.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0", shape = [1, 256, 256]);
   i"fastlstm2.c_final.extracted.fastlstm2.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256" = matmul(i"tdnn5.renorm.output", i"fastlstm2.c_final.extracted.fastlstm2.four_parts.W.concat-einsum-k.0..256.split-over-1.0..256.fix_b.0", transposeA = true, transposeB = false);

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/hir/src/ops/array/concat.rs

@@ -71,7 +71,7 @@ impl Expansion for Concat {
     ) -> TractResult<TVec<OutletId>> {
         let facts = inputs
             .iter()
-            .map(|i| target.outlet_fact(*i).map(|x| x.clone()))
+            .map(|i| target.outlet_fact(*i).cloned())
             .collect::<TractResult<TVec<_>>>()?;
 
         let super_type = if let Some(super_type) =

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/hir/src/ops/nn/reduce.rs

@@ -211,7 +211,7 @@ impl Expansion for Reduce {
         inputs: &[OutletId],
     ) -> TractResult<TVec<OutletId>> {
         let mut wire = inputs[0];
-        let fact = target.outlet_fact(wire)?;
+        let fact = target.outlet_fact(wire)?.clone();
         let mut axes = self.resolve_axes(fact.rank())?;
         axes.sort();
         if fact.datum_type == TDim::datum_type() {
@@ -222,6 +222,13 @@ impl Expansion for Reduce {
             )?[0];
         }
         wire = self.reducer.wire(axes.clone(), name, target, wire).context("wiring reducer")?;
+        if fact.datum_type == TDim::datum_type() {
+            wire = target.wire_node(
+                format!("{name}.cast_to_tdim"),
+                tract_core::ops::cast::cast(TDim::datum_type()),
+                &[wire],
+            )?[0];
+        }
         if !self.keep_dims {
             for axis in axes.into_iter().rev() {
                 wire = target.wire_node(

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/nnef/src/ser.rs

@@ -24,6 +24,7 @@ pub fn rewrite_model(model: &mut TypedModel) -> TractResult<()> {
             "rewrite_consistent_quantized_conv",
             crate::ops::nnef::ser::rewrite_consistent_quantized_conv,
         )
+        .with_rule_for("expand_mean_of_square", tract_core::ops::nn::expand_mean_of_squares)
         .rewrite(&(), model)
 }
 
@@ -363,7 +364,8 @@ impl<'a> IntoAst<'a> {
                     Self::dump_rec_tensor(&tensor.to_array_view::<f32>()?, |f| numeric(f)).into()
                 );
             } else if have_tract_core && tensor.datum_type() == DatumType::F16 {
-                let array = Self::dump_rec_tensor(&tensor.to_array_view::<f16>()?, |f| numeric(f)).into();
+                let array =
+                    Self::dump_rec_tensor(&tensor.to_array_view::<f16>()?, |f| numeric(f)).into();
                 return Ok(invocation("tract_core_cast", &[array], &[("to", string("f16"))]));
             } else if have_tract_core && tensor.datum_type().is_integer() {
                 if let Ok(value) = tensor.cast_to::<i64>() {

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/pulse/src/model.rs

@@ -127,7 +127,11 @@ impl SpecialOps<PulsedFact, Box<dyn PulsedOp>> for PulsedModel {
     }
 }
 
-struct Pulsifier(Symbol, TDim, Arc<RwLock<HashMap<TypeId, crate::ops::OpPulsifier>>>);
+struct Pulsifier(
+    Symbol,
+    TDim,
+    #[allow(dead_code)] Arc<RwLock<HashMap<TypeId, crate::ops::OpPulsifier>>>,
+);
 
 impl std::fmt::Debug for Pulsifier {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

{tract-0.21.2.dev0 → tract-0.21.2.dev1}/rust-workspace/pulse/src/ops/array/concat.rs

@@ -1,7 +1,6 @@
-use std::ops::Range;
-
 use crate::internal::*;
 use tract_core::ops::array::TypedConcat;
+use tract_pulse_opl::concat::overwrite_part_of_pulse;
 use tract_pulse_opl::ops::Delay;
 use tract_pulse_opl::tract_core::trivial_op_state_freeeze;
 
@@ -175,81 +174,3 @@ impl OpState for PulsedSameAxisConcatState {
         Ok(tvec!(data.into_tvalue()))
     }
 }
-
-pub fn overwrite_part_of_pulse(
-    axis: usize,
-    pulse_data: &mut Tensor,
-    current_pos: usize,
-    const_data: &Tensor,
-    const_offset: usize,
-) -> TractResult<()> {
-    let pulse = pulse_data.shape()[axis];
-    let const_length = const_data.shape()[axis];
-    let const_range = const_offset..const_offset + const_length;
-    let pulse_range = current_pos..current_pos + pulse;
-
-    match range_in_range(&pulse_range, &const_range) {
-        RangeInRange::Before(_) | RangeInRange::After(_) => (),
-        RangeInRange::Begin(offset) => {
-            // ----[<----->HHH]HH----
-            pulse_data.assign_slice(offset..pulse, const_data, 0..pulse - offset, axis)?;
-        }
-        RangeInRange::Contain(offset) => {
-            // ----[<----->HHHHHHH-]---
-            pulse_data.assign_slice(
-                offset..offset + const_length,
-                const_data,
-                0..const_length,
-                axis,
-            )?;
-        }
-        RangeInRange::Inside(offset) => {
-            // ----------<H>[HH]HH----
-            pulse_data.assign_slice(0..pulse, const_data, offset..offset + pulse, axis)?;
-        }
-        RangeInRange::End(offset) => {
-            // --------<HHH>[HHHH-]---
-            pulse_data.assign_slice(
-                0..const_length - offset,
-                const_data,
-                offset..const_length,
-                axis,
-            )?;
-        }
-    }
-    Ok(())
-}
-
-#[derive(Copy, Clone, Debug)]
-enum RangeInRange {
-    /// ----[--]<-->HHHH----
-    Before(usize),
-    /// ----[<----->HHH]HH----
-    Begin(usize),
-    /// ----[<----->HHHHHHH-]---
-    Contain(usize),
-    /// ----------<H>[HH]HH----
-    Inside(usize),
-    /// --------<HHH>[HHHH-]---
-    End(usize),
-    /// --------HHHHHHH<->[--]---
-    After(usize),
-}
-
-fn range_in_range(needle: &Range<usize>, haystack: &Range<usize>) -> RangeInRange {
-    if needle.end <= haystack.start {
-        RangeInRange::Before(haystack.start - needle.end)
-    } else if needle.start < haystack.start {
-        if needle.end < haystack.end {
-            RangeInRange::Begin(haystack.start - needle.start)
-        } else {
-            RangeInRange::Contain(haystack.start - needle.start)
-        }
-    } else if needle.start >= haystack.end {
-        RangeInRange::After(needle.start - haystack.end)
-    } else if needle.end > haystack.end {
-        RangeInRange::End(needle.start - haystack.start)
-    } else {
-        RangeInRange::Inside(needle.start - haystack.start)
-    }
-}