ci: update version string in docs

.github/workflows/pypi.yml

@@ -168,7 +168,7 @@ jobs:
           name: wheels
           path: dist
 
-  #  There's a problem with the maturin-action toolchain for arm arch leading to failed builds
+  # TODO: There's a problem with the maturin-action toolchain for arm arch leading to failed builds
   # linux-cross:
   #   runs-on: ubuntu-latest
   #   strategy:
@@ -306,7 +306,7 @@ jobs:
           manylinux: musllinux_1_2
           args: --release --out dist --features python-bindings
 
-      - uses: uraimo/run-on-arch-action@v2.8.1
+      - uses: uraimo/run-on-arch-action@v2.5.0
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '15.6.4'
+release = '15.6.2'
 version = release
 
 

examples/onnx/exp/gen.py

@@ -1,42 +0,0 @@
-from torch import nn
-import torch
-import json
-import numpy as np
-
-
-class MyModel(nn.Module):
-    def __init__(self):
-        super(MyModel, self).__init__()
-
-    def forward(self, x):          
-        m = torch.exp(x)
-        
-        return m 
-
-
-circuit = MyModel()
-
-x = torch.empty(1, 8).uniform_(0, 1)
-
-out = circuit(x)
-
-print(out)
-
-torch.onnx.export(circuit, x, "network.onnx",
-                  export_params=True,        # store the trained parameter weights inside the model file
-                  opset_version=17,          # the ONNX version to export the model to
-                  do_constant_folding=True,  # whether to execute constant folding for optimization
-                  input_names=['input'],   # the model's input names
-                  output_names=['output'],  # the model's output names
-                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
-                                'output': {0: 'batch_size'}})
-
-
-d1 = ((x).detach().numpy()).reshape([-1]).tolist()
-
-data = dict(
-    input_data=[d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/exp/input.json

@@ -1 +0,0 @@
-{"input_data": [[0.5801457762718201, 0.6019012331962585, 0.8695418238639832, 0.17170941829681396, 0.500616729259491, 0.353726327419281, 0.6726185083389282, 0.5936906337738037]]}

examples/onnx/exp/network.onnx

@@ -1,14 +0,0 @@
-pytorch2.2.2:o
-
-inputoutput/Exp"Exp
-main_graphZ!
-input
-

-
-batch_size
-b"
-output
-

-
-batch_size
-B

examples/onnx/general_exp/gen.py

@@ -1,41 +0,0 @@
-from torch import nn
-import torch
-import json
-import numpy as np
-
-
-class MyModel(nn.Module):
-    def __init__(self):
-        super(MyModel, self).__init__()
-
-    def forward(self, x):          
-        m = 10**x
-        return m 
-
-
-circuit = MyModel()
-
-x = torch.empty(1, 8).uniform_(0, 1)
-
-out = circuit(x)
-
-print(out)
-
-torch.onnx.export(circuit, x, "network.onnx",
-                  export_params=True,        # store the trained parameter weights inside the model file
-                  opset_version=17,          # the ONNX version to export the model to
-                  do_constant_folding=True,  # whether to execute constant folding for optimization
-                  input_names=['input'],   # the model's input names
-                  output_names=['output'],  # the model's output names
-                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
-                                'output': {0: 'batch_size'}})
-
-
-d1 = ((x).detach().numpy()).reshape([-1]).tolist()
-
-data = dict(
-    input_data=[d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/general_exp/input.json

@@ -1 +0,0 @@
-{"input_data": [[0.9837989807128906, 0.026381194591522217, 0.3403851389884949, 0.14531707763671875, 0.24652725458145142, 0.7945117354393005, 0.4076554775238037, 0.23064672946929932]]}

src/circuit/ops/layouts.rs

@@ -1,6 +1,5 @@
 use std::{
     collections::{HashMap, HashSet},
-    f64::consts::E,
     ops::Range,
 };
 
@@ -5625,10 +5624,7 @@ pub fn softmax<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
         config,
         region,
         &[sub],
-        &LookupOp::Exp {
-            scale: input_scale,
-            base: E.into(),
-        },
+        &LookupOp::Exp { scale: input_scale },
     )?;
 
     percent(config, region, &[ex.clone()], input_scale, output_scale)

src/circuit/ops/lookup.rs

@@ -19,7 +19,7 @@ pub enum LookupOp {
     PowersOfTwo { scale: utils::F32 },
     Ln { scale: utils::F32 },
     Sigmoid { scale: utils::F32 },
-    Exp { scale: utils::F32, base: utils::F32 },
+    Exp { scale: utils::F32 },
     Cos { scale: utils::F32 },
     ACos { scale: utils::F32 },
     Cosh { scale: utils::F32 },
@@ -55,7 +55,7 @@ impl LookupOp {
             LookupOp::Div { denom } => format!("div_{}", denom),
             LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
             LookupOp::Erf { scale } => format!("erf_{}", scale),
-            LookupOp::Exp { scale, base } => format!("exp_{}_{}", scale, base),
+            LookupOp::Exp { scale } => format!("exp_{}", scale),
             LookupOp::Cos { scale } => format!("cos_{}", scale),
             LookupOp::ACos { scale } => format!("acos_{}", scale),
             LookupOp::Cosh { scale } => format!("cosh_{}", scale),
@@ -99,9 +99,9 @@ impl LookupOp {
                 LookupOp::Erf { scale } => {
                     Ok::<_, TensorError>(tensor::ops::nonlinearities::erffunc(&x, scale.into()))
                 }
-                LookupOp::Exp { scale, base } => Ok::<_, TensorError>(
-                    tensor::ops::nonlinearities::exp(&x, scale.into(), base.into()),
-                ),
+                LookupOp::Exp { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::exp(&x, scale.into()))
+                }
                 LookupOp::Cos { scale } => {
                     Ok::<_, TensorError>(tensor::ops::nonlinearities::cos(&x, scale.into()))
                 }
@@ -165,7 +165,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
             LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
             LookupOp::Sigmoid { scale } => format!("SIGMOID(scale={})", scale),
             LookupOp::Erf { scale } => format!("ERF(scale={})", scale),
-            LookupOp::Exp { scale, base } => format!("EXP(scale={}, base={})", scale, base),
+            LookupOp::Exp { scale } => format!("EXP(scale={})", scale),
             LookupOp::Tan { scale } => format!("TAN(scale={})", scale),
             LookupOp::ATan { scale } => format!("ATAN(scale={})", scale),
             LookupOp::Tanh { scale } => format!("TANH(scale={})", scale),

src/graph/utilities.rs

@@ -279,8 +279,6 @@ pub fn new_op_from_onnx(
     symbol_values: &SymbolValues,
     run_args: &crate::RunArgs,
 ) -> Result<(SupportedOp, Vec<usize>), GraphError> {
-    use std::f64::consts::E;
-
     use tract_onnx::tract_core::ops::array::Trilu;
 
     use crate::circuit::InputType;
@@ -857,7 +855,6 @@ pub fn new_op_from_onnx(
         }
         "Exp" => SupportedOp::Nonlinear(LookupOp::Exp {
             scale: scale_to_multiplier(input_scales[0]).into(),
-            base: E.into(),
         }),
         "Ln" => {
             if run_args.bounded_log_lookup {
@@ -1137,22 +1134,7 @@ pub fn new_op_from_onnx(
                     })
                 }
             } else {
-                if let Some(c) = inputs[0].opkind().get_mutable_constant() {
-                    inputs[0].decrement_use();
-                    deleted_indices.push(0);
-                    if c.raw_values.len() > 1 {
-                        unimplemented!("only support scalar base")
-                    }
-
-                    let base = c.raw_values[0];
-
-                    SupportedOp::Nonlinear(LookupOp::Exp {
-                        scale: scale_to_multiplier(input_scales[1]).into(),
-                        base: base.into(),
-                    })
-                } else {
-                    unimplemented!("only support constant base or pow for now")
-                }
+                unimplemented!("only support constant pow for now")
             }
         }
         "Cube" => SupportedOp::Linear(PolyOp::Pow(3)),

src/tensor/ops.rs

@@ -1664,7 +1664,7 @@ pub mod nonlinearities {
     ///     Some(&[2, 15, 2, 1, 1, 0]),
     ///     &[2, 3],
     /// ).unwrap();
-    /// let result = exp(&x, 1.0,  std::f64::consts::E);
+    /// let result = exp(&x, 1.0);
     /// let expected = Tensor::<IntegerRep>::new(Some(&[7, 3269017, 7, 3, 3, 1]), &[2, 3]).unwrap();
     /// assert_eq!(result, expected);
     ///
@@ -1673,16 +1673,16 @@ pub mod nonlinearities {
     ///    Some(&[37, 12, 41]),
     ///   &[3],
     /// ).unwrap();
-    /// let result = exp(&x, 512.0, std::f64::consts::E);
+    /// let result = exp(&x, 512.0);
     ///
     /// let expected = Tensor::<IntegerRep>::new(Some(&[550, 524, 555]), &[3]).unwrap();
     ///
     /// assert_eq!(result, expected);
     /// ```
-    pub fn exp(a: &Tensor<IntegerRep>, scale_input: f64, base: f64) -> Tensor<IntegerRep> {
+    pub fn exp(a: &Tensor<IntegerRep>, scale_input: f64) -> Tensor<IntegerRep> {
         a.par_enum_map(|_, a_i| {
             let kix = (a_i as f64) / scale_input;
-            let fout = scale_input * base.powf(kix);
+            let fout = scale_input * kix.exp();
             let rounded = fout.round();
             Ok::<_, TensorError>(rounded as IntegerRep)
         })

tests/integration_tests.rs

@@ -205,7 +205,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 98] = [
+    const TESTS: [&str; 96] = [
         "1l_mlp", //0
         "1l_slice",
         "1l_concat",
@@ -306,8 +306,6 @@ mod native_tests {
         "lenet_5",     // 93
         "rsqrt",       // 94
         "log",         // 95
-        "exp",         // 96
-        "general_exp", // 97
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -546,7 +544,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=97 {
+            seq!(N in 0..=95 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]