Bump ndarray from 0.15.3 to 0.16

Cargo.toml

@@ -151,8 +151,8 @@ log = "0.4.14"
 maplit = "1.0.2"
 memmap2 = "0.9"
 metal = { version = "0.27.0", features = ["mps"] }
-ndarray = "0.15.3"
-ndarray-npy = { version = "0.8.0", features = [ "compressed_npz" ] }
+ndarray = "0.16"
+ndarray-npy = { version = "0.9.1", features = [ "compressed_npz" ] }
 nom = "7.0.0"
 nu-ansi-term = "0.46"
 num-complex = "0.4.0"

core/src/ops/array/gather_nd.rs

@@ -35,19 +35,19 @@ impl GatherNd {
  let remaining = indices.shape().iter().skip(batch_dims).rev().skip(1).product();
  let indices_shape_op = tvec!(batch_size, remaining, n);
  let reshaped_indices: ArrayViewD<i32> =
- indices.view().into_shape(&*indices_shape_op).unwrap();
+ indices.view().into_shape_with_order(&*indices_shape_op).unwrap();
 
  let mut data_shape_op: TVec<usize> =
  data.shape().iter().skip(batch_dims).copied().collect();
  data_shape_op.insert(0, batch_size);
  let reshaped_data =
- data.to_array_view_unchecked::<T>().into_shape(&*data_shape_op).unwrap();
+ data.to_array_view_unchecked::<T>().into_shape_with_order(&*data_shape_op).unwrap();
 
  let mut output_shape_op: TVec<usize> =
  data.shape().iter().skip(n + batch_dims).copied().collect();
  output_shape_op.insert(0, batch_size * remaining);
  let mut output =
- output.to_array_view_mut_unchecked::<T>().into_shape(&*output_shape_op).unwrap();
+ output.to_array_view_mut_unchecked::<T>().into_shape_with_order(&*output_shape_op).unwrap();
 
  for b in 0..batch_size {
  let mut i = reshaped_data.view();

core/src/ops/einsum/eval.rs

@@ -131,7 +131,7 @@ pub fn eval_q(expr: &AxesMapping, qp: DatumType, inputs: TVec<TValue>) -> TractR
  } else {
  let mut bias_shape = tvec!(1; output.ndim());
  bias_shape[expr.axis((InOut::In(2), 0))?.outputs[0][0]] = bias.len();
- let bias = bias.to_array_view::<i32>()?.into_shape(&*bias_shape)?;
+ let bias = bias.to_array_view::<i32>()?.into_shape_with_order(&*bias_shape)?;
  output = output + bias;
  }
 

data/src/tensor/litteral.rs

@@ -3,27 +3,24 @@ use crate::datum::Datum;
 use ndarray::*;
 use std::sync::Arc;
 
-pub fn arr4<A, V, U, T>(xs: &[V]) -> Array4<A>
+pub fn arr4<A, const N: usize, const M: usize, const T: usize>(xs: &[[[[A;T];M];N]]) -> Array4<A>
 where
- V: FixedInitializer<Elem = U> + Clone,
- U: FixedInitializer<Elem = T> + Clone,
- T: FixedInitializer<Elem = A> + Clone,
  A: Clone,
 {
  use ndarray::*;
  let xs = xs.to_vec();
- let dim = Ix4(xs.len(), V::len(), U::len(), T::len());
+ let dim = Ix4(xs.len(), N, M, T);
  let len = xs.len();
  let cap = xs.capacity();
- let expand_len = len * V::len() * U::len() * T::len();
+ let expand_len = len * N * M * T;
  let ptr = Box::into_raw(xs.into_boxed_slice());
  unsafe {
  let v = if ::std::mem::size_of::<A>() == 0 {
  Vec::from_raw_parts(ptr as *mut A, expand_len, expand_len)
- } else if V::len() == 0 || U::len() == 0 || T::len() == 0 {
+ } else if N == 0 || M == 0 || T == 0 {
  Vec::new()
  } else {
- let expand_cap = cap * V::len() * U::len() * T::len();
+ let expand_cap = cap * N * M * T;
  Vec::from_raw_parts(ptr as *mut A, expand_len, expand_cap)
  };
  ArrayBase::from_shape_vec_unchecked(dim, v)
@@ -38,26 +35,17 @@ pub fn tensor1<A: Datum>(xs: &[A]) -> Tensor {
  Tensor::from(arr1(xs))
 }
 
-pub fn tensor2<A: Datum, T>(xs: &[T]) -> Tensor
-where
- T: FixedInitializer<Elem = A> + Clone,
+pub fn tensor2<A: Datum, const N: usize>(xs: &[[A;N]]) -> Tensor
 {
  Tensor::from(arr2(xs))
 }
 
-pub fn tensor3<A: Datum, T, U>(xs: &[U]) -> Tensor
-where
- U: FixedInitializer<Elem = T> + Clone,
- T: FixedInitializer<Elem = A> + Clone,
+pub fn tensor3<A: Datum, const N: usize, const M: usize>(xs: &[[[A;M];N]]) -> Tensor
 {
  Tensor::from(arr3(xs))
 }
 
-pub fn tensor4<A: Datum, T, U, V>(xs: &[V]) -> Tensor
-where
- V: FixedInitializer<Elem = U> + Clone,
- U: FixedInitializer<Elem = T> + Clone,
- T: FixedInitializer<Elem = A> + Clone,
+pub fn tensor4<A: Datum, const N: usize, const M: usize, const T: usize>(xs: &[[[[A;T];M];N]]) -> Tensor
 {
  Tensor::from(arr4(xs))
 }
@@ -70,26 +58,17 @@ pub fn rctensor1<A: Datum>(xs: &[A]) -> Arc<Tensor> {
  Arc::new(Tensor::from(arr1(xs)))
 }
 
-pub fn rctensor2<A: Datum, T>(xs: &[T]) -> Arc<Tensor>
-where
- T: FixedInitializer<Elem = A> + Clone,
+pub fn rctensor2<A: Datum, const N: usize>(xs: &[[A;N]]) -> Arc<Tensor>
 {
  Arc::new(Tensor::from(arr2(xs)))
 }
 
-pub fn rctensor3<A: Datum, T, U>(xs: &[U]) -> Arc<Tensor>
-where
- U: FixedInitializer<Elem = T> + Clone,
- T: FixedInitializer<Elem = A> + Clone,
+pub fn rctensor3<A: Datum, const N: usize, const M: usize>(xs: &[[[A;M];N]]) -> Arc<Tensor>
 {
  Arc::new(Tensor::from(arr3(xs)))
 }
 
-pub fn rctensor4<A: Datum, T, U, V>(xs: &[V]) -> Arc<Tensor>
-where
- V: FixedInitializer<Elem = U> + Clone,
- U: FixedInitializer<Elem = T> + Clone,
- T: FixedInitializer<Elem = A> + Clone,
+pub fn rctensor4<A: Datum, const N: usize, const M: usize, const T: usize>(xs: &[[[[A;T];M];N]]) -> Arc<Tensor>
 {
  Arc::new(Tensor::from(arr4(xs)))
 }

harness/core-proptest-pulse/src/delay_plus_downsample.rs

@@ -15,7 +15,7 @@ struct DelayPlusDownsampleProblem {
 }
 
 fn t(n: usize) -> ArrayD<f32> {
- arr1(&(0..n).map(|x| x as f32).collect_vec()).into_shape(vec![1, n, 1]).unwrap()
+ arr1(&(0..n).map(|x| x as f32).collect_vec()).into_shape_with_order(vec![1, n, 1]).unwrap()
 }
 
 impl Arbitrary for DelayPlusDownsampleProblem {

harness/core-proptest-pulse/src/delay_plus_pool.rs

@@ -60,7 +60,7 @@ impl DelayPlusPoolProblem {
  );
  let pool = model.wire_node("pool", MaxPool::new(pool_spec, None), &crop).unwrap();
  model.set_output_outlets(&pool).unwrap();
- let input = arr1(&self.input).into_shape((1, self.input.len(), 1)).unwrap().into_dyn();
+ let input = arr1(&self.input).into_shape_with_order((1, self.input.len(), 1)).unwrap().into_dyn();
  proptest_regular_against_pulse(model, self.pulse as _, input, 1)
  }
 }

harness/lstm-proptest-onnx-vs-tf/src/lib.rs

@@ -4,6 +4,7 @@ use proptest::prelude::*;
 
 use tract_hir::internal::*;
 use tract_ndarray::prelude::*;
+use tract_ndarray::Order;
 use tract_onnx::prelude::*;
 use tract_onnx::tract_hir;
 
@@ -39,9 +40,11 @@ impl LstmProblem {
  .slice_axis_mut(Axis(0), (s * icfo..s * (icfo + 1)).into())
  .assign(&self.b_icfo.slice_axis(Axis(0), (s * iofc..s * (iofc + 1)).into()));
  }
- let w_iofc = w_iofc.t().into_shape((1, 4 * s, s))?.to_owned();
- let r_iofc = r_iofc.t().into_shape((1, 4 * s, s))?.to_owned();
- let b_iofc = b_iofc.into_shape((1, 8 * s))?;
+ // let (shape, order) = w_iofc.t().into_shape_and_order();
+
+ let w_iofc = w_iofc.t().into_shape_with_order(((1, 4 * s, s), Order::ColumnMajor))?.to_owned();
+ let r_iofc = r_iofc.t().into_shape_with_order(((1, 4 * s, s), Order::ColumnMajor))?.to_owned();
+ let b_iofc = b_iofc.into_shape_with_order(((1, 8 * s), Order::ColumnMajor))?;
 
  let x = model.add_source("x", self.x.datum_type().fact(self.x.shape()).into())?;
  let op = tract_onnx::ops::rec::common::CommonRec {
@@ -190,7 +193,7 @@ impl LstmProblem {
  let plan = SimplePlan::new(model)?;
  let mut state = SimpleState::new(plan)?;
  let y = state.run(tvec!(self.x.clone()))?.remove(0).into_tensor().into_array::<f32>()?;
- let y = y.into_shape((self.length, self.batch_size, self.cell_size)).unwrap();
+ let y = y.into_shape_with_order((self.length, self.batch_size, self.cell_size)).unwrap();
  Ok(y.into_tvalue())
  }
 

harness/tf-moz-deepspeech/src/lib.rs

@@ -39,7 +39,7 @@ fn parse_tensor<T: Datum + FromStr>(s: &str) -> TractResult<Tensor> {
  let shape = &shape[1..shape.len() - 1];
  let shape: Vec<usize> = shape.split(',').map(|s| s.parse().unwrap()).collect();
  Ok(tract_ndarray::Array1::from(tokens.filter_map(|s| s.parse::<T>().ok()).collect::<Vec<_>>())
- .into_shape(shape)?
+ .into_shape_with_order(shape)?
  .into())
 }
 

linalg/src/frame/mmm/pack.rs

@@ -555,7 +555,7 @@ mod test {
  self.mn_range.clone(),
  )
  };
- output.into_array::<u32>().unwrap().into_shape((panels, panel_len)).unwrap()
+ output.into_array::<u32>().unwrap().into_shape_with_order((panels, panel_len)).unwrap()
  }
 
  fn reference(&self) -> Array2<u32> {

linalg/tests/virtual_im2col.rs

@@ -231,7 +231,7 @@ impl EagerIm2colSpec {
  [kh, kw, ci, h, w],
  |(kh, kw, ci, h, w)| *input.at([ci, h + kh, w + kw]).unwrap(),
  )
- .into_shape([k, n])
+ .into_shape_with_order([k, n])
  .unwrap();
  Box::new(EagerIm2col { im2col: im2col.into_tensor(), packer: self.packer.clone(), k })
  }

onnx/src/ops/nn/batch_norm.rs

@@ -23,10 +23,10 @@ impl BatchNorm {
  T: Datum + tract_num_traits::Float,
  f32: AsPrimitive<T>,
  {
- let scale = scale.to_array_view::<T>()?.into_shape((c_dim,))?;
- let beta = beta.to_array_view::<T>()?.into_shape((c_dim,))?;
- let mean = mean.to_array_view::<T>()?.into_shape((c_dim,))?;
- let var = var.to_array_view::<T>()?.into_shape((c_dim,))?;
+ let scale = scale.to_array_view::<T>()?.into_shape_with_order((c_dim,))?;
+ let beta = beta.to_array_view::<T>()?.into_shape_with_order((c_dim,))?;
+ let mean = mean.to_array_view::<T>()?.into_shape_with_order((c_dim,))?;
+ let var = var.to_array_view::<T>()?.into_shape_with_order((c_dim,))?;
 
  let denominator = var.mapv(|x| (x + self.epsilon.as_()).sqrt());
 

tensorflow/src/conform/tf.rs

@@ -106,7 +106,7 @@ impl From<Tensor> for TensorHolder {
 
 fn tensor_to_array<T: ::tensorflow::TensorType>(tensor: &tf::Tensor<T>) -> TractResult<ArrayD<T>> {
  let shape: Vec<usize> = tensor.dims().iter().map(|d| *d as _).collect();
- Ok(Array::from(tensor.into_iter().cloned().collect::<Vec<_>>()).into_shape(shape)?)
+ Ok(Array::from(tensor.into_iter().cloned().collect::<Vec<_>>()).into_shape_with_order(shape)?)
 }
 
 impl Tensorflow {

tensorflow/src/ops/nn/conv2d.rs

@@ -24,7 +24,7 @@ mod tests {
 
  fn mk(sizes: &[usize]) -> Tensor {
  Array::range(1f32, sizes.iter().product::<usize>() as f32 + 1.0, 1.0)
- .into_shape(sizes)
+ .into_shape_with_order(sizes)
  .unwrap()
  .into()
  }

tensorflow/src/ops/nn/s2b/mod.rs

@@ -82,7 +82,7 @@ fn batch_to_space<T: Copy + Datum + Zero>(
  let batches = data.shape()[0] / block_size;
  unflatten_blocked_shape.push(batches);
  unflatten_blocked_shape.extend(&data.shape()[1..]);
- let data = data.into_shape(&*unflatten_blocked_shape)?;
+ let data = data.into_shape_with_order(&*unflatten_blocked_shape)?;
  let mut permuted_axes = vec![block_shape.len()];
  let mut padded_shape = vec![batches];
  for i in 0..block_shape.shape()[0] {

tensorflow/tests/ops_nn_conv2d.rs

@@ -54,11 +54,11 @@ fn img_and_ker() -> BoxedStrategy<(Tensor, Tensor, (usize, usize))> {
  .prop_map(|(img_shape, ker_shape, img, ker, strides)| {
  (
  tract_ndarray::Array::from(img.into_iter().map(|i| i as f32).collect::<Vec<_>>())
- .into_shape(img_shape)
+ .into_shape_with_order(img_shape)
  .unwrap()
  .into(),
  tract_ndarray::Array::from(ker.into_iter().map(|i| i as f32).collect::<Vec<_>>())
- .into_shape(ker_shape)
+ .into_shape_with_order(ker_shape)
  .unwrap()
  .into(),
  strides,

tensorflow/tests/ops_nn_dwconv2d.rs

@@ -52,10 +52,10 @@ fn img_and_ker() -> BoxedStrategy<(Array4<f32>, Array4<f32>, usize)> {
  .prop_map(|(img_shape, ker_shape, img, ker, stride)| {
  (
  Array::from(img.into_iter().map(|i| i as f32).collect::<Vec<_>>())
- .into_shape(img_shape)
+ .into_shape_with_order(img_shape)
  .unwrap(),
  Array::from(ker.into_iter().map(|i| i as f32).collect::<Vec<_>>())
- .into_shape(ker_shape)
+ .into_shape_with_order(ker_shape)
  .unwrap(),
  stride,
  )

tensorflow/tests/ops_nn_pools.rs

@@ -32,7 +32,7 @@ fn img_and_pool() -> BoxedStrategy<(Array4<f32>, (usize, usize), String, usize)>
  )
  })
  .prop_map(|(img_shape, k, img, padding, stride)| {
- (Array::from(img).into_shape(img_shape).unwrap(), k, padding, stride)
+ (Array::from(img).into_shape_with_order(img_shape).unwrap(), k, padding, stride)
  })
  .boxed()
 }

test-rt/suite-unit/src/conv_f32.rs

@@ -154,7 +154,7 @@ impl ConvProblem {
  if let Some(bias) = &self.bias {
  let mut shape = vec![1; out.ndim()];
  shape[shape_out.c_axis()] = bias.len();
- out += &bias.clone().into_shape(shape).unwrap();
+ out += &bias.clone().into_shape_with_order(shape).unwrap();
  }
  out
  }

test-rt/suite-unit/src/conv_q.rs

@@ -189,7 +189,7 @@ impl QConvProblem {
  if let Some(bias) = &self.bias {
  let mut shape = vec![1; temp.ndim()];
  shape[shape_out.c_axis()] = bias.len();
- temp += &bias.clone().into_shape(shape).unwrap();
+ temp += &bias.clone().into_shape_with_order(shape).unwrap();
  }
  let cdt = self.output_dt();
  temp.axis_iter_mut(Axis(shape_out.c_axis())).zip(k_scale).for_each(

test-rt/suite-unit/src/deconv.rs

@@ -204,7 +204,7 @@ impl DeconvProblem {
  if let Some(b) = &self.bias {
  let mut bias_shape = tvec!(1; output_shape.rank());
  bias_shape[output_shape.c_axis()] = co;
- let b = b.clone().into_shape(&*bias_shape)?;
+ let b = b.clone().into_shape_with_order(&*bias_shape)?;
  output += &b;
  }
  let co_per_group = co / self.group;
@@ -599,7 +599,7 @@ pub fn suite() -> TractResult<TestSuite> {
  padding: PaddingSpec::Valid,
  input: arr4(&[[[[0.0, 0.0, 0.0, 1.0]]]]).into_dyn(),
  kernel: arr1(&[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0])
- .into_shape(vec![2, 2, 1, 2, 1])
+ .into_shape_with_order(vec![2, 2, 1, 2, 1])
  .unwrap()
  .into_dyn(),
  bias: None,