fix: patch large batch ex (#763)

examples/onnx/lstm_large/input.json

@@ -0,0 +1,13 @@
+{
+  "input_data": [
+    [
+      0.8894134163856506,
+      0.8894201517105103
+    ]
+  ],
+  "output_data": [
+    [
+      0.8436377
+    ]
+  ]
+}

src/commands.rs

@@ -444,7 +444,7 @@ pub enum Commands {
         disable_selector_compression: bool,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     /// Aggregates proofs :)
     Aggregate {
@@ -479,7 +479,7 @@ pub enum Commands {
         split_proofs: bool,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     /// Compiles a circuit from onnx to a simplified graph (einsum + other ops) and parameters as sets of field elements
     CompileCircuit {
@@ -726,7 +726,7 @@ pub enum Commands {
         logrows: u32,
         /// commitment
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that is generated by ezkl

src/execute.rs

@@ -339,7 +339,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             split_proofs,
             disable_selector_compression,
-            commitment,
+            commitment.into(),
         ),
         Commands::Aggregate {
             proof_path,
@@ -360,7 +360,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             check_mode,
             split_proofs,
-            commitment,
+            commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::Verify {
@@ -384,7 +384,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             reduced_srs,
-            commitment,
+            commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         #[cfg(not(target_arch = "wasm32"))]
@@ -586,7 +586,7 @@ pub(crate) async fn get_srs_cmd(
     } else if let Some(settings_p) = settings_path {
         if settings_p.exists() {
             let settings = GraphSettings::load(&settings_p)?;
-            settings.run_args.commitment
+            settings.run_args.commitment.into()
         } else {
             return Err(err_string.into());
         }
@@ -666,21 +666,17 @@ pub(crate) async fn gen_witness(
 
     // if any of the settings have kzg visibility then we need to load the srs
 
+    let commitment: Commitments = settings.run_args.commitment.into();
+
     let start_time = Instant::now();
     let witness = if settings.module_requires_polycommit() {
-        if get_srs_path(
-            settings.run_args.logrows,
-            srs_path.clone(),
-            settings.run_args.commitment,
-        )
-        .exists()
-        {
-            match settings.run_args.commitment {
+        if get_srs_path(settings.run_args.logrows, srs_path.clone(), commitment).exists() {
+            match Commitments::from(settings.run_args.commitment) {
                 Commitments::KZG => {
                     let srs: ParamsKZG<Bn256> = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                         srs_path.clone(),
                         settings.run_args.logrows,
-                        settings.run_args.commitment,
+                        commitment,
                     )?;
                     circuit.forward::<KZGCommitmentScheme<_>>(
                         &mut input,
@@ -694,7 +690,7 @@ pub(crate) async fn gen_witness(
                         load_params_prover::<IPACommitmentScheme<G1Affine>>(
                             srs_path.clone(),
                             settings.run_args.logrows,
-                            settings.run_args.commitment,
+                            commitment,
                         )?;
                     circuit.forward::<IPACommitmentScheme<_>>(
                         &mut input,
@@ -1303,17 +1299,19 @@ pub(crate) fn create_evm_verifier(
     render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let circuit_settings = GraphSettings::load(&settings_path)?;
+
+    let settings = GraphSettings::load(&settings_path)?;
+    let commitment: Commitments = settings.run_args.commitment.into();
     let params = load_params_verifier::<KZGCommitmentScheme<Bn256>>(
         srs_path,
-        circuit_settings.run_args.logrows,
-        circuit_settings.run_args.commitment,
+        settings.run_args.logrows,
+        commitment,
     )?;
 
-    let num_instance = circuit_settings.total_instances();
+    let num_instance = settings.total_instances();
     let num_instance: usize = num_instance.iter().sum::<usize>();
 
-    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, circuit_settings)?;
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
 
     let generator = halo2_solidity_verifier::SolidityGenerator::new(
@@ -1347,17 +1345,18 @@ pub(crate) fn create_evm_vk(
     abi_path: PathBuf,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let circuit_settings = GraphSettings::load(&settings_path)?;
+    let settings = GraphSettings::load(&settings_path)?;
+    let commitment: Commitments = settings.run_args.commitment.into();
     let params = load_params_verifier::<KZGCommitmentScheme<Bn256>>(
         srs_path,
-        circuit_settings.run_args.logrows,
-        circuit_settings.run_args.commitment,
+        settings.run_args.logrows,
+        commitment,
     )?;
 
-    let num_instance = circuit_settings.total_instances();
+    let num_instance = settings.total_instances();
     let num_instance: usize = num_instance.iter().sum::<usize>();
 
-    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, circuit_settings)?;
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
 
     let generator = halo2_solidity_verifier::SolidityGenerator::new(
@@ -1626,8 +1625,9 @@ pub(crate) fn setup(
     }
 
     let logrows = circuit.settings().run_args.logrows;
+    let commitment: Commitments = circuit.settings().run_args.commitment.into();
 
-    let pk = match circuit.settings().run_args.commitment {
+    let pk = match commitment {
         Commitments::KZG => {
             let params = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                 srs_path,
@@ -1736,7 +1736,8 @@ pub(crate) fn prove(
     let transcript: TranscriptType = proof_type.into();
     let proof_split_commits: Option<ProofSplitCommit> = data.into();
 
-    let commitment = circuit_settings.run_args.commitment;
+    let commitment = circuit_settings.run_args.commitment.into();
+    let logrows = circuit_settings.run_args.logrows;
     // creates and verifies the proof
     let mut snark = match commitment {
         Commitments::KZG => {
@@ -1745,7 +1746,7 @@ pub(crate) fn prove(
 
             let params = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                 srs_path,
-                circuit_settings.run_args.logrows,
+                logrows,
                 Commitments::KZG,
             )?;
             match strategy {
@@ -2187,8 +2188,9 @@ pub(crate) fn verify(
     let circuit_settings = GraphSettings::load(&settings_path)?;
 
     let logrows = circuit_settings.run_args.logrows;
+    let commitment = circuit_settings.run_args.commitment.into();
 
-    match circuit_settings.run_args.commitment {
+    match commitment {
         Commitments::KZG => {
             let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
             let params: ParamsKZG<Bn256> = if reduced_srs {

src/graph/model.rs

@@ -803,13 +803,18 @@ impl Model {
                     let input_state_idx = input_state_idx(&input_mappings);
 
                     let mut output_mappings = vec![];
-                    for mapping in b.output_mapping.iter() {
+                    for (i, mapping) in b.output_mapping.iter().enumerate() {
                         let mut mappings = vec![];
                         if let Some(outlet) = mapping.last_value_slot {
                             mappings.push(OutputMapping::Single {
                                 outlet,
                                 is_state: mapping.state,
                             });
+                        } else if mapping.state {
+                            mappings.push(OutputMapping::Single {
+                                outlet: i,
+                                is_state: mapping.state,
+                            });
                         }
                         if let Some(last) = mapping.scan {
                             mappings.push(OutputMapping::Stacked {
@@ -818,6 +823,7 @@ impl Model {
                                 is_state: false,
                             });
                         }
+
                         output_mappings.push(mappings);
                     }
 
@@ -1264,8 +1270,8 @@ impl Model {
                     let num_iter = number_of_iterations(&input_mappings, input_dims.collect());
 
                     debug!(
-                        "{} iteration(s) in a subgraph with inputs {:?} and sources {:?}",
-                        num_iter, inputs, model.graph.inputs
+                        "{} iteration(s) in a subgraph with inputs {:?}, sources {:?}, and outputs {:?}",
+                        num_iter, inputs, model.graph.inputs, model.graph.outputs
                     );
 
                     let mut full_results: Vec<ValTensor<Fp>> = vec![];
@@ -1297,6 +1303,7 @@ impl Model {
                         let res = model.layout_nodes(config, region, &mut subgraph_results)?;
 
                         let mut outlets = BTreeMap::new();
+                        let mut stacked_outlets = BTreeMap::new();
 
                         for (mappings, outlet_res) in output_mappings.iter().zip(res) {
                             for mapping in mappings {
@@ -1309,25 +1316,42 @@ impl Model {
                                             let stacked_res = full_results[*outlet]
                                                 .clone()
                                                 .concat_axis(outlet_res.clone(), axis)?;
-
-                                            outlets.insert(outlet, stacked_res);
-                                        } else {
-                                            outlets.insert(outlet, outlet_res.clone());
+                                            stacked_outlets.insert(outlet, stacked_res);
                                         }
+                                        outlets.insert(outlet, outlet_res.clone());
                                     }
                                 }
                             }
                         }
 
-                        full_results = outlets.into_values().collect_vec();
+                        // now extend with stacked elements
+                        let mut pre_stacked_outlets = outlets.clone();
+                        pre_stacked_outlets.extend(stacked_outlets);
+
+                        let outlets = outlets.into_values().collect_vec();
+
+                        full_results = pre_stacked_outlets.into_values().collect_vec();
 
                         let output_states = output_state_idx(output_mappings);
                         let input_states = input_state_idx(&input_mappings);
 
-                        assert_eq!(input_states.len(), output_states.len());
+                        assert_eq!(
+                            input_states.len(),
+                            output_states.len(),
+                            "input and output states must be the same length, got {:?} and {:?}",
+                            input_mappings,
+                            output_mappings
+                        );
 
                         for (input_idx, output_idx) in input_states.iter().zip(output_states) {
-                            values[*input_idx] = full_results[output_idx].clone();
+                            assert_eq!(
+                                values[*input_idx].dims(),
+                                outlets[output_idx].dims(),
+                                "input and output dims must be the same, got {:?} and {:?}",
+                                values[*input_idx].dims(),
+                                outlets[output_idx].dims()
+                            );
+                            values[*input_idx] = outlets[output_idx].clone();
                         }
                     }
 

src/lib.rs

@@ -114,6 +114,12 @@ pub enum Commitments {
     IPA,
 }
 
+impl From<Option<Commitments>> for Commitments {
+    fn from(value: Option<Commitments>) -> Self {
+        value.unwrap_or(Commitments::KZG)
+    }
+}
+
 impl FromStr for Commitments {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -214,7 +220,7 @@ pub struct RunArgs {
     pub check_mode: CheckMode,
     /// commitment scheme
     #[arg(long, default_value = "kzg")]
-    pub commitment: Commitments,
+    pub commitment: Option<Commitments>,
 }
 
 impl Default for RunArgs {
@@ -234,7 +240,7 @@ impl Default for RunArgs {
             div_rebasing: false,
             rebase_frac_zero_constants: false,
             check_mode: CheckMode::UNSAFE,
-            commitment: Commitments::KZG,
+            commitment: None,
         }
     }
 }

src/python.rs

@@ -197,7 +197,7 @@ impl From<PyRunArgs> for RunArgs {
             div_rebasing: py_run_args.div_rebasing,
             rebase_frac_zero_constants: py_run_args.rebase_frac_zero_constants,
             check_mode: py_run_args.check_mode,
-            commitment: py_run_args.commitment.into(),
+            commitment: Some(py_run_args.commitment.into()),
         }
     }
 }
@@ -234,6 +234,16 @@ pub enum PyCommitments {
     IPA,
 }
 
+impl From<Option<Commitments>> for PyCommitments {
+    fn from(commitment: Option<Commitments>) -> Self {
+        match commitment {
+            Some(Commitments::KZG) => PyCommitments::KZG,
+            Some(Commitments::IPA) => PyCommitments::IPA,
+            None => PyCommitments::KZG,
+        }
+    }
+}
+
 impl From<PyCommitments> for Commitments {
     fn from(py_commitments: PyCommitments) -> Self {
         match py_commitments {

src/tensor/val.rs

@@ -1,3 +1,5 @@
+use core::{iter::FilterMap, slice::Iter};
+
 use crate::circuit::region::ConstantsMap;
 
 use super::{
@@ -450,10 +452,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     /// Returns the number of constants in the [ValTensor].
     pub fn create_constants_map_iterator(
         &self,
-    ) -> core::iter::FilterMap<
-        core::slice::Iter<'_, ValType<F>>,
-        fn(&ValType<F>) -> Option<(F, ValType<F>)>,
-    > {
+    ) -> FilterMap<Iter<'_, ValType<F>>, fn(&ValType<F>) -> Option<(F, ValType<F>)>> {
         match self {
             ValTensor::Value { inner, .. } => inner.iter().filter_map(|x| {
                 if let ValType::Constant(v) = x {

src/wasm.rs

@@ -337,8 +337,10 @@ pub fn verify(
 
     let orig_n = 1 << circuit_settings.run_args.logrows;
 
+    let commitment = circuit_settings.run_args.commitment.into();
+
     let mut reader = std::io::BufReader::new(&srs[..]);
-    let result = match circuit_settings.run_args.commitment {
+    let result = match commitment {
         Commitments::KZG => {
             let params: ParamsKZG<Bn256> =
                 halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)
@@ -521,8 +523,9 @@ pub fn prove(
 
     // read in kzg params
     let mut reader = std::io::BufReader::new(&srs[..]);
+    let commitment = circuit.settings().run_args.commitment.into();
     // creates and verifies the proof
-    let proof = match circuit.settings().run_args.commitment {
+    let proof = match commitment {
         Commitments::KZG => {
             let params: ParamsKZG<Bn256> =
                 halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)

tests/integration_tests.rs

@@ -122,7 +122,7 @@ mod native_tests {
         let settings: GraphSettings = serde_json::from_str(&settings).unwrap();
         let logrows = settings.run_args.logrows;
 
-        download_srs(logrows, settings.run_args.commitment);
+        download_srs(logrows, settings.run_args.commitment.into());
     }
 
     fn mv_test_(test_dir: &str, test: &str) {
@@ -200,7 +200,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 91] = [
+    const TESTS: [&str; 92] = [
         "1l_mlp", //0
         "1l_slice",
         "1l_concat",
@@ -296,6 +296,7 @@ mod native_tests {
         "reducel1",
         "reducel2", // 89
         "1l_lppool",
+        "lstm_large", // 91
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -534,7 +535,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=90 {
+            seq!(N in 0..=91 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]
@@ -622,7 +623,7 @@ mod native_tests {
             #(#[test_case(TESTS[N])])*
             fn mock_large_batch_public_outputs_(test: &str) {
                 // currently variable output rank is not supported in ONNX
-                if test != "gather_nd" {
+                if test != "gather_nd" && test != "lstm_large" {
                     crate::native_tests::init_binary();
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
@@ -1970,7 +1971,7 @@ mod native_tests {
             .expect("failed to parse settings file");
 
         // get_srs for the graph_settings_num_instances
-        download_srs(1, graph_settings.run_args.commitment);
+        download_srs(1, graph_settings.run_args.commitment.into());
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([

tests/wasm/settings.json

@@ -24,8 +24,7 @@
         "param_visibility": "Private",
         "div_rebasing": false,
         "rebase_frac_zero_constants": false,
-        "check_mode": "UNSAFE",
-        "commitment": "KZG"
+        "check_mode": "UNSAFE"
     },
     "num_rows": 16,
     "total_dynamic_col_size": 0,