mct-nightly 2.3.0.20250408.522__py3-none-any.whl → 2.3.0.20250410.526__py3-none-any.whl

{mct_nightly-2.3.0.20250408.522.dist-info → mct_nightly-2.3.0.20250410.526.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250408.522
+Version: 2.3.0.20250410.526
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,6 +22,7 @@ Requires-Dist: scipy
 Requires-Dist: protobuf
 Requires-Dist: mct-quantizers-nightly
 Requires-Dist: pydantic<2.0
+Requires-Dist: sony-custom-layers-dev==0.4.0.dev6
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

{mct_nightly-2.3.0.20250408.522.dist-info → mct_nightly-2.3.0.20250410.526.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mct_nightly-2.3.0.20250408.522.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=Nxtw-bh_Op7j74mOVtyUSxB8W47zj0_P8k7LJLmHpwU,1557
+mct_nightly-2.3.0.20250410.526.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=hH7K5n9ZDkBMIcujI3umeAh3pUxoyxZu2pWu83zoGgk,1557
 model_compression_toolkit/constants.py,sha256=2ltuH-gdaLZoZV4CPUgKjC3S9ojz2z4OTVdenyVEypU,3912
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
 model_compression_toolkit/metadata.py,sha256=x_Bk4VpzILdsFax6--CZ3X18qUTP28sbF_AhoQW8dNc,4003
-model_compression_toolkit/verify_packages.py,sha256=TlS-K1EP-QsghqWUW7SDPkAJiUf7ryw4tvhFDe6rCUk,1405
+model_compression_toolkit/verify_packages.py,sha256=l0neIRr8q_QwxmuiTI4vyCMDISDedK0EihjEQUe66tE,1319
 model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZG1FUxxJlAV8L8,2096
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=C6eUTd-fcgxk0LUbt51gFZwmyDDDEB8-9Q4kr9ujYvI,11555
@@ -12,7 +12,7 @@ model_compression_toolkit/core/quantization_prep_runner.py,sha256=DPevqQ8brkdut8
 model_compression_toolkit/core/runner.py,sha256=_r6cieb7Ur2BeHQK5XxTZHogjyA0utybvIVbH06CBHY,13056
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
-model_compression_toolkit/core/common/framework_implementation.py,sha256=s3yiqnbWkwfnAB1sSal_KAuqVg27rLhAJ2O8LHUbSHE,22494
+model_compression_toolkit/core/common/framework_implementation.py,sha256=L88uv_sfYM_56FSmxXP--emjv01_lk7IPqOI7QBZEt0,22939
 model_compression_toolkit/core/common/framework_info.py,sha256=RWeZfQOPiBroU2v4AeZoquVunNtZ4UORjOr2aRAPu8o,6279
 model_compression_toolkit/core/common/memory_computation.py,sha256=ixoSpV5ZYZGyzhre3kQcvR2sNA8KBsPZ3lgbkDnw9Cs,1205
 model_compression_toolkit/core/common/model_builder_mode.py,sha256=jll9-59OPaE3ug7Y9-lLyV99_FoNHxkGZMgcm0Vkpss,1324
@@ -31,11 +31,11 @@ model_compression_toolkit/core/common/collectors/min_max_per_channel_collector.p
 model_compression_toolkit/core/common/collectors/statistics_collector.py,sha256=psijsQZefwjMDH8SU5E18n65HiGtQilPhKr1hhzZX-I,8268
 model_compression_toolkit/core/common/collectors/weighted_histogram_collector.py,sha256=zp3dE7YTqWmkD5QWdRhsl9zD8W6Lr96G1Wjw1g2D3T0,4894
 model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
-model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=LfzVS9B6r2KCwf8rcCUdepEQhWkt287SoXfwoudpfFo,15496
+model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=W8qZejLwbm-lkvNF3GepNL3ypO10vFRxOxbq-o_rt_I,15479
 model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=F0AaAUBpJ9JjHMB5H2LD9pdwTSWJK-Kqm9dQmGHX1Jo,7368
 model_compression_toolkit/core/common/graph/__init__.py,sha256=Xr-Lt_qXMdrCnnOaUS_OJP_3iTTGfPCLf8_vSrQgCs0,773
-model_compression_toolkit/core/common/graph/base_graph.py,sha256=hedhjVula5rPv0vN0CLBDtPYM8SH3cM6FAL62aFfF7U,41767
-model_compression_toolkit/core/common/graph/base_node.py,sha256=CJu8_r80MGVnYmlAUGOGKGRsD9xShMyaRNb3VMeRC0s,34523
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=3OhaMHW01okwFY4mSy0ERFCJk8AZPDs8bCKAmjvmJEI,41893
+model_compression_toolkit/core/common/graph/base_node.py,sha256=Yl6GdjnP_Rt9w1lQUm00CJI0JUAffQF7wr6mur_YfbA,34124
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=GH5wStmw8SoAj5IdT_-ItN1Meo_P5NUTt_5bgJC4fak,3935
 model_compression_toolkit/core/common/graph/graph_matchers.py,sha256=CrDoHYq4iPaflgJWmoJ1K4ziLrRogJvFTVWg8P0UcDU,4744
@@ -51,7 +51,7 @@ model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py,sha256=
 model_compression_toolkit/core/common/hessian/__init__.py,sha256=E7LK3K_1AwMCQokanNc1JODMwUKNOKmwXQiGQ7GO10I,1033
 model_compression_toolkit/core/common/hessian/hessian_info_service.py,sha256=8NDC_WLe3ZnY_v3e_Vz_lseF22lrbvhFmArihpeWfuI,14291
 model_compression_toolkit/core/common/hessian/hessian_info_utils.py,sha256=1axmN0tjJSo_7hUr2d2KMv4y1pBi19cqWSQpi4BbdsA,1458
-model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py,sha256=NHC2WQcTK4MLOuKlmELR8XoDTt_h8KwvpNy2o94azrI,4238
+model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py,sha256=wqKPfAJgXiV7zD2DufbOU5HcOLi-44Fv9PWdVgFMGaw,4354
 model_compression_toolkit/core/common/hessian/hessian_scores_request.py,sha256=ZNdwDzW7QF2A-w1Ye4P2xn5erTQnoTXk5z_b17HDGH4,3391
 model_compression_toolkit/core/common/matchers/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/matchers/base_graph_filter.py,sha256=mTk54z0mIbFmPOb4h0xfLtLDookcFyNh8H0pIN5js_M,3091
@@ -70,12 +70,12 @@ model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantizati
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=2Pp4hiYvGW2I9YhloDxQNT0sZRg3TDp9CXObloF8IFU,4971
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=GGrp7QngrWvWtPN8cQnL4IEbNwcVRc-hAUqfnxjjMmk,5998
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=NBzzhkVI407S9cIiw7t7nsP3MrkOdSnweKQdPBXb8to,38180
-model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=gsigifJ-ykWNafF4t7UMEC_-nd6YPERAk1_z0kT-Y88,27172
+model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=4bkM8pYKvk18cxHbx973Dz6qWrNT0MRm44cuk__qVaI,27297
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=P8QtKgFXtt5b2RoubzI5OGlCfbEfZsAirjyrkFzK26A,2846
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=fk7PWiZ6Na5O_Z_dymk_UfDCTqW_X_4EROU7DZknQnc,9444
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=PKkhc5q8pEPnNLXwo3U56EOCfYnPXIvPs0LlCGZOoKU,4426
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=MP4Q5lThvEIhfa1iBajQQM3nCUNgK-2yseqQQ8Rgiog,40624
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=cjFnpDvxZDE4K2sgt26DhosA2XqhxHDs0eW5Qe7AwAQ,40668
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=QQwtl08DiDxUOQGpYPnek_RlZjWm1Ky7tL2ESHXMK78,4050
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=TaK5NqVdmygsHw9_x5JsJ-BPvlbKA9cRyTno1R8gbnU,7269
@@ -104,15 +104,15 @@ model_compression_toolkit/core/common/quantization/__init__.py,sha256=sw7LOPN1bM
 model_compression_toolkit/core/common/quantization/bit_width_config.py,sha256=0HA3CIZW-ZrA55ra-yJXRvAYnoR8i1SjpbnMDKcWYNQ,12819
 model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=lyWPvnoX8BmulhLKR20r5gT2_Yan7P40d8EcgDhErPk,4905
 model_compression_toolkit/core/common/quantization/core_config.py,sha256=yxCzWqldcHoe8GGxrH0tp99bhrc5jDT7SgZftnMUUBE,2374
-model_compression_toolkit/core/common/quantization/debug_config.py,sha256=zJP2W9apUPX9RstpPWWK71wr9xJsg7j-s7lGV4_bQdc,1510
+model_compression_toolkit/core/common/quantization/debug_config.py,sha256=uH45Uq3Tp9FIyMynex_WY2_y-Kv8LuPw2XXZydnpW5A,1649
 model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py,sha256=n2A8pO7_DMMae4o69U0I00iW6mzeRlRfKHDxlQUBBuI,7204
-model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=tAVQlDp7Zt9xncFFU39JCjDBarACRwz-Do_-6pUGMB0,28530
+model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=gL3XUm85FBLvtF60jmWkPxITOBw7cs66scNtC7QHW-M,29471
 model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=UkSVW7d1OF_Px9gAjsqqK65aYhIBFWaBO-_IH6_AFfg,4403
 model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,sha256=HfBkSiRTOf9mNF-TNQHTCCs3xSg66F20no0O6vl5v1Y,2154
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=7eG7dl1TcbdnHwgmvyjarxLs0o6Lw_9VAjXAm4rsiBk,3791
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha256=N005MSvx8UypVpa7XrxNrB2G732n2wHj3RmLyjTgd3I,2728
 model_compression_toolkit/core/common/quantization/quantize_node.py,sha256=cdzGNWfT4MRogIU8ehs0tr3lVjnzAI-jeoS9b4TwVBo,2854
-model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=u0pVJawyUTgatn2L8qMNBac2Cut3HSPZSytBGDuBB0k,21341
+model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=3jyOBaRFwoZQsiyB1nF7ayox1XSo6jf2fDc9V30wKkg,21431
 model_compression_toolkit/core/common/quantization/quantization_params_generation/__init__.py,sha256=eCDGwsWYLU6z7qbEVb4TozMW_nd5VEP_iCJ6PcvyEPw,1486
 model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=_m-XkEMJMHf0gYwVIXAoHVjdRa2NXt_gYdwBlw76ZR8,24031
 model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=RL-PklAjGyC-26anSt8fU07a6pB_LBQFQy9o4e9giN0,8739
@@ -132,20 +132,20 @@ model_compression_toolkit/core/common/statistics_correction/__init__.py,sha256=s
 model_compression_toolkit/core/common/statistics_correction/apply_activation_bias_correction_to_graph.py,sha256=b05ZwQ2CwG0Q-yqs9A1uHfP8o17aGEZFCeJNP1p4IWk,4450
 model_compression_toolkit/core/common/statistics_correction/apply_bias_correction_to_graph.py,sha256=b5clhUWGoDaQLn2pDCeYkV0FomVebcKS8pMXtQTTzIg,4679
 model_compression_toolkit/core/common/statistics_correction/apply_second_moment_correction_to_graph.py,sha256=C_nwhhitTd1pCto0nHZPn3fjIMOeDD7VIciumTR3s6k,5641
-model_compression_toolkit/core/common/statistics_correction/compute_activation_bias_correction_of_graph.py,sha256=ov9-WYktWKqRquibwyARR81QVT9TfPWAoTTfnKOQSd0,9273
+model_compression_toolkit/core/common/statistics_correction/compute_activation_bias_correction_of_graph.py,sha256=F8kK8yoYCGeTdXUsHGcM3T2tRdjSlcWg3UToGtovNOs,9196
 model_compression_toolkit/core/common/statistics_correction/compute_bias_correction_of_graph.py,sha256=LaGhYES7HgIDf9Bi2KAG_mBzAWuum0J6AGmAFPC8wwo,10478
 model_compression_toolkit/core/common/statistics_correction/statistics_correction.py,sha256=E0ZA4edimJwpHh9twI5gafcoJ9fX5F1JX2QUOkUOKEw,6250
 model_compression_toolkit/core/common/substitutions/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/substitutions/apply_substitutions.py,sha256=k-bifmakHIYZeZS-4T1QpZ1Et6AwAijMRgAKs7hmMKc,1390
 model_compression_toolkit/core/common/substitutions/batchnorm_folding.py,sha256=wLlTT7sqUffKHwOrMG2VV5SktQkkP54l8taW1Fq0mh0,13392
-model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,sha256=1389z4NbTKIHYGr-FB-fV1YP1Gcfta0tOu60DwfNVlI,8452
+model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,sha256=kz1Xg2OMNXyRbCW3K-wfZpbv6jmLShJjHYUoziOUNv4,8496
 model_compression_toolkit/core/common/substitutions/batchnorm_refusing.py,sha256=dWJpVfomF4Ppeeor3VzS23TXHyBm85QI7snyLOYP_ko,9972
 model_compression_toolkit/core/common/substitutions/linear_collapsing.py,sha256=iEtzbWCDXP6EDkTZCtREQ0rpMxhQ2kM9zlcP_0KLq9I,12367
 model_compression_toolkit/core/common/substitutions/linear_collapsing_substitution.py,sha256=uoauhmncQqUBNvD-qCLIXsIbl_IzrbxSKdxiMig-5W4,2406
 model_compression_toolkit/core/common/substitutions/remove_identity.py,sha256=TKU1TIU52UIkVnl0EZvWnDhLV9nIVZ4hqi-w1i4NXMk,2637
 model_compression_toolkit/core/common/substitutions/residual_collapsing.py,sha256=N82mso5j3EJQlKt9EMHjjEJ67FmdGQeCfN8U5grOFXo,4830
 model_compression_toolkit/core/common/substitutions/scale_equalization.py,sha256=p57u25qdW2pimxzGwgMXEBV4S-LzXuTVAlIM7830WfU,10966
-model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=oiiN16OqDrax4FPP5VeyTz0rhb0-eZJACKznTBlKkio,30013
+model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=1utreR5CkJYwaJS1LOCQi_EYkedsnxXzyJCnJ-ZeqQ0,30057
 model_compression_toolkit/core/common/substitutions/softmax_shift.py,sha256=R-0ZqhYAuZLEFWHvB2UTPm52L6gWHGdRdEnwGxKSeGI,2625
 model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py,sha256=w43dRmaG96a8SNECgghxoFCTSoZ-vUb33dXGm2PbomE,4251
 model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=gt07lXRUvYunJKiwv_w20zfXhcplSW4oT2C1dqiNNXc,4719
@@ -158,7 +158,7 @@ model_compression_toolkit/core/keras/constants.py,sha256=dh4elQWt6Q6NYRht5k5RiiO
 model_compression_toolkit/core/keras/custom_layer_validation.py,sha256=f-b14wuiIgitBe7d0MmofYhDCTO3IhwJgwrh-Hq_t_U,1192
 model_compression_toolkit/core/keras/data_util.py,sha256=jm54o-SlI1DJ-sEvRuX9OyLN68tEt0VxcqrdIjR98Ag,8366
 model_compression_toolkit/core/keras/default_framework_info.py,sha256=IGEHKH3IcmpRfyHuEBJTpEXu2-TDFfqQzpm8kHuj8QY,4974
-model_compression_toolkit/core/keras/keras_implementation.py,sha256=e9cVe_TJ_6h4OPgnAVX9T9wgvNDdGh5y_4Hprxa6Ths,32104
+model_compression_toolkit/core/keras/keras_implementation.py,sha256=_15BrSGTRSSp_8ayuo2x-hdKanew1xuIPSumP46IGSA,32545
 model_compression_toolkit/core/keras/keras_model_validation.py,sha256=1wNV2clFdC9BzIELRLSO2uKf0xqjLqlkTJudwtCeaJk,1722
 model_compression_toolkit/core/keras/keras_node_prior_info.py,sha256=HUmzEXDQ8LGX7uOYSRiLZ2TNbYxLX9J9IeAa6QYlifg,3927
 model_compression_toolkit/core/keras/resource_utilization_data_facade.py,sha256=XBCmUrHy_fNQCfSjnXCpwuEtc7cda4hXySuiIzhFGqc,5696
@@ -198,7 +198,7 @@ model_compression_toolkit/core/keras/hessian/activation_hessian_scores_calculato
 model_compression_toolkit/core/keras/hessian/hessian_scores_calculator_keras.py,sha256=1o7X9GXSfpEmuB5ee2AaBQ2sN2xzX4-smbrq_0qOGRU,4454
 model_compression_toolkit/core/keras/hessian/weights_hessian_scores_calculator_keras.py,sha256=Rl6NNGkHMV0ioEM5bbM4XX7yHDqG6mMp4ifN2VQBDxE,12168
 model_compression_toolkit/core/keras/mixed_precision/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
-model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py,sha256=aW8wR13fK6P6xzbU9XGU60IO1yYzXSo_Hk4qeq486kg,5137
+model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py,sha256=WFwPtCcXR3qY86OML_jyzasvdd2DGhy4-GveAGpDOt0,5075
 model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quantizer.py,sha256=38Lvwux9L35oT6muck6_FH7nDdH2N8_kuGDMj4-QNpE,6647
 model_compression_toolkit/core/keras/pruning/__init__.py,sha256=3Lkr37Exk9u8811hw8hVqkGcbTQGcLjd3LLuLC3fa_E,698
 model_compression_toolkit/core/keras/pruning/pruning_keras_implementation.py,sha256=EJkblZ4OAjI5l29GKsUraam5Jn58Sogld47_rFFyr3k,12777
@@ -224,10 +224,10 @@ model_compression_toolkit/core/pytorch/constants.py,sha256=Sg0hkUaMe88mI2_pd3Kqh
 model_compression_toolkit/core/pytorch/data_util.py,sha256=YYbT135HhlTt0q6XdD2JX7AS_L92f_uV2rWq2hsJOCA,6325
 model_compression_toolkit/core/pytorch/default_framework_info.py,sha256=NLdmiig5a2EBxutJeDHjp8px4g_2EKt3zmntmK-NrT4,4309
 model_compression_toolkit/core/pytorch/pytorch_device_config.py,sha256=S25cuw10AW3SEN_fRAGRcG_I3wdvvQx1ehSJzPnn-UI,4404
-model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=QBCKYimTbHGFmXGz84Ioni5C9qKntp9FMEBLMUrIKkY,30771
+model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=c_QFo4e7t6b21CDakGhjVpqy5aXFxxqkdJ-s54HEOfs,31207
 model_compression_toolkit/core/pytorch/pytorch_node_prior_info.py,sha256=2LDQ7qupglHQ7o1Am7LWdfYVacfQnl-aW2N6l9det1w,3264
 model_compression_toolkit/core/pytorch/resource_utilization_data_facade.py,sha256=aIHl-dTAC4ISnWSKLD99c-1W3827vfRGyLjMBib-l3s,5618
-model_compression_toolkit/core/pytorch/utils.py,sha256=7VbgcLwtQvdEEc_AJgSOQ3U3KRKCICFPaBirN1fIQxg,3940
+model_compression_toolkit/core/pytorch/utils.py,sha256=xNVE7YMtHupLEimIJcxmfcMGM4XKB9I1v0-K8lDeLB8,3936
 model_compression_toolkit/core/pytorch/back2framework/__init__.py,sha256=H_WixgN0elVWf3exgGYsi58imPoYDj5eYPeh6x4yfug,813
 model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py,sha256=bwppTPRs6gL96nm7qPiKrNcBj4Krr0yEsOWjRF0aXmQ,2339
 model_compression_toolkit/core/pytorch/back2framework/float_model_builder.py,sha256=tLrlUyYhxVKVjkad1ZAtbRra0HedB3iVfIkZ_dYnQ-4,3419
@@ -257,7 +257,7 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/remove_
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/reshape_with_static_shapes.py,sha256=hAZXzrEinHa-dJHLj39Hy_9Q-13QyO95rtYVSLrhvT8,4915
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/residual_collapsing.py,sha256=DcJEIkGvBdIMOelNIwaJUZ5UsAHiGnDJPR20I464vWo,2929
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scale_equalization.py,sha256=XFtU9yuBmoZlX0f0mS6otMPWMk-RcWs94XdvvTNhW8Y,3303
-model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scaled_dot_product_attention.py,sha256=WG7MyYTP5JhMZHYxj4PB-7TTuvUDjFQScG4_Ce1mQDY,12476
+model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scaled_dot_product_attention.py,sha256=D1hxN3pZ5-_FLJSS30ZJUo-v8TqUWFcMjhMijFa9aSo,12407
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/shift_negative_activation.py,sha256=3WCLvPyx7tVkM0rwYhYq-gntCzW9R_DcImR1ucKlPac,10772
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/softmax_shift.py,sha256=05lV4pIL3hJkZl4JQPV4wk_EFD0eYLG5b8cdzvZk4P8,1588
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/transform_function_call_method.py,sha256=EC9Dvp-_UlpDWnipnf8ds65wh_Y-T8pXAFIwRScWpiY,2044
@@ -268,7 +268,7 @@ model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calcula
 model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py,sha256=8f_XlM8ZFVQPNGr1iECr1hv8QusYDrNU_vTkLQZE9RU,2477
 model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py,sha256=UzWxWDbr8koKZatEcPn8RCb0Zjm_7fKTvIGb98sp18k,8487
 model_compression_toolkit/core/pytorch/mixed_precision/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
-model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py,sha256=aEjqqj96iK_G_ebXEiJ8kcHLJWs9NFUevSJTipLux1s,4815
+model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py,sha256=mcY_KOQgABIqGIMh0x6mNxaKp7SFNbkEIYavR2X7SQ4,4754
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py,sha256=zp1Xp75IDf9LN5YGO2UzeDbms_6ICQ_pSE1ORQr-SA8,6281
 model_compression_toolkit/core/pytorch/pruning/__init__.py,sha256=RAe8mgIr1V8dRIQtLf_dSG5zTUCKuQzxyybYx1dzEAs,697
 model_compression_toolkit/core/pytorch/pruning/pruning_pytorch_implementation.py,sha256=VfEEVwWEXKpVlZFnr7N6mvEjcpq85ROLg05ZvXfD1Pg,14764
@@ -278,7 +278,7 @@ model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py,sha256=uyeBtN
 model_compression_toolkit/core/pytorch/reader/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/reader/graph_builders.py,sha256=ZASzWbYYojFYIx-ynqMTkg6mCpTrJg2oWYT-xXki4Mw,19763
 model_compression_toolkit/core/pytorch/reader/node_holders.py,sha256=7XNc7-l1MZPJGcOESvtAwfIMxrU6kvt3YjF5B7qOqK4,1048
-model_compression_toolkit/core/pytorch/reader/reader.py,sha256=Me6nqJpmQBg13dXYiUsmfYr148BYySBZqxHRDba5Tuk,6228
+model_compression_toolkit/core/pytorch/reader/reader.py,sha256=OKlSkGXI-5fKULPEcBnGM6dxwUlWGQEq7ZWdUIhovMU,7440
 model_compression_toolkit/core/pytorch/statistics_correction/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/statistics_correction/apply_second_moment_correction.py,sha256=VgU24J3jf7QComHH7jonOXSkg6mO4TOch3uFkOthZvM,3261
 model_compression_toolkit/core/pytorch/statistics_correction/pytorch_compute_activation_bias_correction_of_graph.py,sha256=N-9QaEaQYUsIoya9Lc0ZDoMZ0fkiT2gFpOd4zXHKP34,3096
@@ -366,7 +366,7 @@ model_compression_toolkit/gptq/keras/gptq_keras_implementation.py,sha256=axBwnCS
 model_compression_toolkit/gptq/keras/gptq_loss.py,sha256=2hzWzsbuVd5XcL85NM57YeOyHxRY0qMArKn8NvQ1UWw,7643
 model_compression_toolkit/gptq/keras/gptq_training.py,sha256=km9tcuugOkRvprGXQZrsq_GPtA3-7Du_-rnbR_Gyups,23228
 model_compression_toolkit/gptq/keras/graph_info.py,sha256=zwoeHX67nJJ5-zYLjzvMXS9TLsy9BsizARbZiDVjVSA,4473
-model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=onQSR1YPjQ6IZdqzeeqFMs3IeBT-nWLbI0yXuOkdpKs,18827
+model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=-goXDz-ACJ4QQH55XTA5n4eGVRXcYAWtqJ4dq6tWq1o,18927
 model_compression_toolkit/gptq/keras/quantizer/__init__.py,sha256=-DK1CDXvlsnEbki4lukZLpl6Xrbo91_jcqxXlG5Eg6Q,963
 model_compression_toolkit/gptq/keras/quantizer/base_keras_gptq_quantizer.py,sha256=Rbl9urzkmACvVxICSEyJ02qFOBxWK0UQWtysFJzBVZw,4899
 model_compression_toolkit/gptq/keras/quantizer/quant_utils.py,sha256=Vt7Qb8i4JsE4sFtcjpfM4FTXTtfV1t6SwfoNH8a_Iaw,5055
@@ -382,7 +382,7 @@ model_compression_toolkit/gptq/pytorch/gptq_loss.py,sha256=_07Zx_43bnNokwR5S8phI
 model_compression_toolkit/gptq/pytorch/gptq_pytorch_implementation.py,sha256=tECPTavxn8EEwgLaP2zvxdJH6Vg9jC0YOIMJ7857Sdc,1268
 model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=WtehnyiYXdUXf8-uNpV0mdsalF7YF7eKnL7tcFrzZoE,19549
 model_compression_toolkit/gptq/pytorch/graph_info.py,sha256=4mVM-VvnBaA64ACVdOe6wTGHdMSa2UTLIUe7nACLcdo,4008
-model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=ciBrdTZqTNFw-5RleEAM6o5GJq5zNhym2GmAmf6U0_I,17179
+model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=V_T3EbFiHO3SkN0kvppsEB9IFW8Q68_GMtUf3xjHnXU,17445
 model_compression_toolkit/gptq/pytorch/quantizer/__init__.py,sha256=ZHNHo1yzye44m9_ht4UUZfTpK01RiVR3Tr74-vtnOGI,968
 model_compression_toolkit/gptq/pytorch/quantizer/base_pytorch_gptq_quantizer.py,sha256=fKg-PNOhGBiL-4eySS9Fyw0GkA76Pq8jT_HbJuJ8iZU,4143
 model_compression_toolkit/gptq/pytorch/quantizer/quant_utils.py,sha256=OocYYRqvl7rZ37QT0hTzfJnWGiNCPskg7cziTlR7TRk,3893
@@ -401,9 +401,9 @@ model_compression_toolkit/pruning/pytorch/pruning_facade.py,sha256=FmUQvT0T247Xa
 model_compression_toolkit/ptq/__init__.py,sha256=Z_hkmTh7aLFei1DJKV0oNVUbrv_Q_0CTw-qD85Xf8UM,904
 model_compression_toolkit/ptq/runner.py,sha256=_c1dSjlPPpsx59Vbg1buhG9bZq__OORz1VlPkwjJzoc,2552
 model_compression_toolkit/ptq/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/ptq/keras/quantization_facade.py,sha256=f8sa46eUNHmeaVs3huhZv14DHm5j1X-VInCYdI7nXAY,11567
+model_compression_toolkit/ptq/keras/quantization_facade.py,sha256=QAQ7Pegk26fARDQg2ZNzcYY8aYKmb2hnUY8FiAdcuy0,11824
 model_compression_toolkit/ptq/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/ptq/pytorch/quantization_facade.py,sha256=p5FwojKaybYdsOUVI7qBNa7R8Nge3EXdu38Jf2jHr84,10021
+model_compression_toolkit/ptq/pytorch/quantization_facade.py,sha256=Du3CBhp7HXam-GSkv9VPcBoaIBydKjdXsnhFjsemT3E,10282
 model_compression_toolkit/qat/__init__.py,sha256=AaC4KBha4jDW_tyg2SOxZaKh_idIz0gZtDK3_zxs64E,1241
 model_compression_toolkit/qat/common/__init__.py,sha256=6tLZ4R4pYP6QVztLVQC_jik2nES3l4uhML0qUxZrezk,829
 model_compression_toolkit/qat/common/qat_config.py,sha256=xtfVSoyELGXynHNrw86dB9FU3Inu0zwehc3wLrh7JvY,2918
@@ -441,8 +441,8 @@ model_compression_toolkit/target_platform_capabilities/schema/v1.py,sha256=4CGpW
 model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=yg0ZrsaqaS69lmDvxRrz636CRARzx_eZbokTMVHNEXc,4555
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/__init__.py,sha256=XjNws3zoiJkeH4ixKqrLA5xBvpv5rq31qX7wYQjNpZM,1447
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2fw.py,sha256=HJ8uc3PFfyxg-WpVXPBg4mGaox8Z9bRqtQNbRfIyAk4,3745
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=mxc3DBbUi-HDFgSx8Nmnyxr8SIdbx8lmtcRMsQl1BLE,7578
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=8spnpqxVUv8WF9-PTukOLvJAFiNi01wNowUVIDqSj5I,6321
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=Ehwpd_sL6zxmJFpJugOdN9uNxNX05nijvOCilNfHnFs,7162
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=RY7STxTqYG1umFJEbWFRuGXk32eGi1iYuDFKgyVFo-8,6408
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attribute_filter.py,sha256=jfhszvuD2Fyy6W2KjlLzXBQKFzTqGAaDZeFVr4-ONQw,8776
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/current_tpc.py,sha256=_kFG0USYa6yzvLsi82_Vusv_KR8Hi7J1u680pPXECuo,2192
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py,sha256=UKzckLYLdBcFAptyKnVMwpPpfRkmF0SK1Kl0g0eGjQA,9710
@@ -527,7 +527,7 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.3.0.20250408.522.dist-info/METADATA,sha256=2MJ3qHYwl3E_RVRhIodPb36F7-YSbYHo-rcmjqOYblE,27098
-mct_nightly-2.3.0.20250408.522.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mct_nightly-2.3.0.20250408.522.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250408.522.dist-info/RECORD,,
+mct_nightly-2.3.0.20250410.526.dist-info/METADATA,sha256=lnLhgKNdIybbtKdxLN61inSjhX0CQulfk_9gDUF387o,27148
+mct_nightly-2.3.0.20250410.526.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mct_nightly-2.3.0.20250410.526.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250410.526.dist-info/RECORD,,

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.3.0.20250408.000522"
+__version__ = "2.3.0.20250410.000526"

model_compression_toolkit/core/common/framework_implementation.py

@@ -93,6 +93,17 @@ class FrameworkImplementation(ABC):
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
                              f'framework\'s to_tensor method.')  # pragma: no cover
 
+    @abstractmethod
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
+                             f'framework\'s is_tuple_of_tensors method.')  # pragma: no cover
+
+
     @abstractmethod
     def model_reader(self,
                      model: Any,

model_compression_toolkit/core/common/fusion/fusing_info.py

@@ -150,7 +150,6 @@ class FusingInfo:
         """
         return self.fusing_data
 
-
     @staticmethod
     def generate_fused_op_id(nodes: List['BaseNode']) -> str:
         """
@@ -166,7 +165,7 @@ class FusingInfo:
         id = FUSED_OP_ID_PREFIX + '_'.join([node.name for node in nodes])
         return id
 
-    def validate(self, graph) -> None:
+    def validate(self, graph: 'Graph') -> None:
         """
         Validate that the fusing information is consistent with the given graph and generation logic.
 
@@ -267,7 +266,7 @@ class FusingInfoGenerator:
     def __init__(self, fusing_patterns):
         self._fusing_patterns = fusing_patterns
 
-    def generate_fusing_info(self, graph) -> FusingInfo:
+    def generate_fusing_info(self, graph: 'Graph') -> FusingInfo:
         """
         Generate fusing information based on the graph and fusing patterns.
 
@@ -289,7 +288,7 @@ class FusingInfoGenerator:
             return FusingInfo(fusing_patterns=self._fusing_patterns)
 
         # Find max fusion
-        max_layers_fusing = 0 if len(self._fusing_patterns) == 0 else max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
+        max_layers_fusing = max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
 
         # Travel along the graph to find layers for fusing
         nodes = graph.get_topo_sorted_nodes()
@@ -331,7 +330,7 @@ def get_valid_fusing_patterns_for_node(fusing_patterns: List[List[Any]],
     Returns only the fusing patterns where a specific layer (at index idx) matches the given node — either by type or filter params.
 
     Args:
-        fusing_patterns: supported fusings
+        fusing_patterns: supported fusing patterns
         node: node to decide if it can be a part of fusion
         idx: index of layer in the fusion
 

model_compression_toolkit/core/common/graph/base_graph.py

@@ -33,6 +33,7 @@ from model_compression_toolkit.core.common.collectors.statistics_collector impor
 from model_compression_toolkit.core.common.collectors.statistics_collector import scale_statistics, shift_statistics
 from model_compression_toolkit.core.common.pruning.pruning_section import PruningSection
 from model_compression_toolkit.core.common.user_info import UserInformation
+from model_compression_toolkit.core.common.quantization.node_quantization_config import ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
@@ -920,7 +921,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         nodes_to_disable = [node for nodes in self.fusing_info.get_all_fused_operations().values() for node in nodes[:-1]]
         for node in nodes_to_disable:
             for qc in node.candidates_quantization_cfg:
-                qc.activation_quantization_cfg.enable_activation_quantization = False
+                qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.FLN_QUANT
 
     def validate(self):
         """

model_compression_toolkit/core/common/graph/base_node.py

@@ -20,7 +20,8 @@ import numpy as np
 
 from model_compression_toolkit.constants import WEIGHTS_NBITS_ATTRIBUTE, CORRECTED_BIAS_ATTRIBUTE, \
     ACTIVATION_N_BITS_ATTRIBUTE, FP32_BYTES_PER_PARAMETER
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions, \
     OpQuantizationConfig
@@ -116,33 +117,28 @@ class BaseNode:
         """
         return any(isinstance(key, int) for key in self.weights.keys())
 
+    def _is_single_quant_mode(self, q_mode: ActivationQuantizationMode) -> bool:
+        """ Check whether all candidates have the same unique quantization mode, and if it is 'q_mode'. """
+
+        if self.final_activation_quantization_cfg:
+            # if we have a final configuration, then we only care to check if it enables activation quantization.
+            return self.final_activation_quantization_cfg.quant_mode == q_mode
+
+        q_modes = {qc.activation_quantization_cfg.quant_mode for qc in self.candidates_quantization_cfg}
+        assert len(q_modes) == 1
+        return q_modes.pop() == q_mode
+
     def is_activation_quantization_enabled(self) -> bool:
         """
-
         Returns: Whether node activation quantization is enabled or not.
-
         """
-        if self.final_activation_quantization_cfg:
-            # if we have a final configuration, then we only care to check if it enables activation quantization
-            return self.final_activation_quantization_cfg.enable_activation_quantization
-
-        for qc in self.candidates_quantization_cfg:
-            assert self.candidates_quantization_cfg[0].activation_quantization_cfg.enable_activation_quantization == \
-                   qc.activation_quantization_cfg.enable_activation_quantization
-        return self.candidates_quantization_cfg[0].activation_quantization_cfg.enable_activation_quantization
+        return self._is_single_quant_mode(ActivationQuantizationMode.QUANT)
 
     def is_quantization_preserving(self) -> bool:
         """
         Returns: Whether node activation quantization information is preserved from its inputs.
         """
-        if self.final_activation_quantization_cfg:
-            # if we have a final configuration, then we only care to check if it enables activation quantization.
-            return self.final_activation_quantization_cfg.quantization_preserving
-
-        for qc in self.candidates_quantization_cfg:
-            assert self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving == \
-                   qc.activation_quantization_cfg.quantization_preserving
-        return self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving
+        return self._is_single_quant_mode(ActivationQuantizationMode.PRESERVE_QUANT)
 
     def is_weights_quantization_enabled(self, attr_name: str) -> bool:
         """

model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py

@@ -72,8 +72,7 @@ class HessianScoresCalculator(ABC):
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement compute method.')  # pragma: no cover
 
-    @staticmethod
-    def unfold_tensors_list(tensors_to_unfold: Any) -> List[Any]:
+    def unfold_tensors_list(self, tensors_to_unfold: Any) -> List[Any]:
         """
         Unfold (flatten) a nested tensors list.
         Given a mixed list of single tensors and nested tensor lists,
@@ -85,6 +84,9 @@ class HessianScoresCalculator(ABC):
         """
         unfold_tensors = []
         for tensor in tensors_to_unfold:
+            if self.fw_impl.is_tuple_of_tensors(tensor):
+                tensor = list(tensor)  # converts named tuple to list
+
             if isinstance(tensor, List):
                 unfold_tensors += tensor
             else:

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -31,7 +31,7 @@ from model_compression_toolkit.core.common.graph.virtual_activation_weights_node
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     RUTarget, ResourceUtilization
 from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
-    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig
+    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig, ActivationQuantizationMode
 from model_compression_toolkit.core.common.substitutions.virtual_activation_weights_composition import \
     get_input_activation_if_composable
 
@@ -710,7 +710,7 @@ class ResourceUtilizationCalculator:
         """
         if act_qc:
             assert bitwidth_mode == BitwidthMode.QCustom
-            return act_qc.activation_n_bits if act_qc.enable_activation_quantization else FLOAT_BITWIDTH
+            return act_qc.activation_n_bits if act_qc.quant_mode == ActivationQuantizationMode.QUANT else FLOAT_BITWIDTH
 
         if bitwidth_mode == BitwidthMode.Float or not (n.is_activation_quantization_enabled() or
                                                        n.is_quantization_preserving()):

model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py

@@ -20,6 +20,7 @@ from typing import Callable, Any, List, Tuple
 from model_compression_toolkit.constants import AXIS
 from model_compression_toolkit.core import FrameworkInfo, MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common import Graph, BaseNode
+from model_compression_toolkit.core.common.quantization.node_quantization_config import ActivationQuantizationMode
 from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.similarity_analyzer import compute_kl_divergence
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
@@ -207,7 +208,7 @@ class SensitivityEvaluation:
         if self.disable_activation_for_metric:
             for n in evaluation_graph.get_topo_sorted_nodes():
                 for c in n.candidates_quantization_cfg:
-                    c.activation_quantization_cfg.enable_activation_quantization = False
+                    c.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
 
         model_mp, _, conf_node2layers = self.fw_impl.model_builder(evaluation_graph,
                                                                    mode=ModelBuilderMode.MIXEDPRECISION,

model_compression_toolkit/core/common/quantization/debug_config.py

@@ -29,8 +29,10 @@ class DebugConfig:
          enabled) or not. Can be used to pinpoint problematic layers in the quantization process.
         network_editor (List[EditRule]): A list of rules and actions to edit the network for quantization.
         simulate_scheduler (bool): Simulate scheduler behavior to compute operators' order and cuts.
+        bypass (bool): A flag to enable MCT bypass, which skips MCT runner and returns the input model unchanged.
     """
 
     analyze_similarity: bool = False
     network_editor: List[EditRule] = field(default_factory=list)
     simulate_scheduler: bool = False
+    bypass: bool = False

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -15,7 +15,7 @@
 
 
 from typing import Callable, Any, List, Tuple, Union, Dict, TYPE_CHECKING
-
+from enum import Enum, auto
 import numpy as np
 
 from model_compression_toolkit.core.common.quantization.quantization_fn_selection import get_weights_quantization_fn
@@ -40,6 +40,14 @@ if TYPE_CHECKING:
 ##########################################
 
 
+class ActivationQuantizationMode(Enum):
+    """ An enum defining the output activation quantization mode of  a node. """
+    QUANT = auto()
+    FLN_QUANT = auto()
+    PRESERVE_QUANT = auto()
+    NO_QUANT = auto()
+
+
 class BaseNodeQuantizationConfig(object):
     """
     Base class for node quantization configuration
@@ -100,8 +108,14 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.activation_n_bits = op_cfg.activation_n_bits
         self.relu_bound_to_power_of_2 = qc.relu_bound_to_power_of_2
         self.activation_bias_correction_term = None
-        self.enable_activation_quantization = op_cfg.enable_activation_quantization
-        self.quantization_preserving = op_cfg.quantization_preserving
+        if op_cfg.enable_activation_quantization and op_cfg.quantization_preserving:
+            raise ValueError("An OpQuantizationConfig can't have both enable_activation_quantization and quantization_preserving enabled.")
+        if op_cfg.enable_activation_quantization:
+            self.quant_mode = ActivationQuantizationMode.QUANT
+        elif op_cfg.quantization_preserving:
+            self.quant_mode = ActivationQuantizationMode.PRESERVE_QUANT
+        else:
+            self.quant_mode = ActivationQuantizationMode.NO_QUANT
         self.signedness = op_cfg.signedness
         self.activation_channel_equalization = qc.activation_channel_equalization
         self.input_scaling = qc.input_scaling
@@ -113,6 +127,17 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.shift_negative_threshold_recalculation = qc.shift_negative_threshold_recalculation
         self.concat_threshold_update = qc.concat_threshold_update
 
+    @property
+    def enable_activation_quantization(self):
+        return self.quant_mode == ActivationQuantizationMode.QUANT
+
+    @property
+    def quantization_preserving(self):
+        return self.quant_mode == ActivationQuantizationMode.PRESERVE_QUANT
+
+    def fln_quantization(self):
+        return self.quant_mode == ActivationQuantizationMode.FLN_QUANT
+
     def quantize_node_output(self,
                              tensors: Any) -> Any:
         """
@@ -181,7 +206,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
             activation_params: Dictionary that contains weight quantization params.
 
         """
-        assert self.enable_activation_quantization
+        assert self.quant_mode == ActivationQuantizationMode.QUANT
         for param_name, param_value in activation_params.items():
             self.activation_quantization_params[param_name] = param_value
 
@@ -203,7 +228,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                self.activation_error_method == other.activation_error_method and \
                self.activation_quantization_method == other.activation_quantization_method and \
                self.activation_n_bits == other.activation_n_bits and \
-               self.enable_activation_quantization == other.enable_activation_quantization and \
+               self.quant_mode == other.quant_mode and \
                self.activation_channel_equalization == other.activation_channel_equalization and \
                self.input_scaling == other.input_scaling and \
                self.min_threshold == other.min_threshold and \
@@ -219,7 +244,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                      self.activation_error_method,
                      self.activation_quantization_method,
                      self.activation_n_bits,
-                     self.enable_activation_quantization,
+                     self.quant_mode,
                      self.activation_channel_equalization,
                      self.input_scaling,
                      self.min_threshold,

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -25,7 +25,8 @@ from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeActivationQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeActivationQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, \
     QuantizationErrorMethod
 from model_compression_toolkit.core.common.quantization.quantization_params_fn_selection import \
@@ -191,8 +192,9 @@ def set_quantization_configs_to_node(node: BaseNode,
     node.sort_node_candidates(fw_info)
 
     for candidate_qc in node.candidates_quantization_cfg:
-        candidate_qc.activation_quantization_cfg.enable_activation_quantization = \
-            candidate_qc.activation_quantization_cfg.enable_activation_quantization and node.get_has_activation()
+        if candidate_qc.activation_quantization_cfg.quant_mode == ActivationQuantizationMode.QUANT and \
+                not node.get_has_activation():
+            candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
 
 
 def create_node_activation_qc(qc: QuantizationConfig,

model_compression_toolkit/core/common/statistics_correction/compute_activation_bias_correction_of_graph.py

@@ -45,8 +45,7 @@ def get_previous_node_with_activation_quantization(linear_node: BaseNode,
     activation_quantization_config = prev_node.final_activation_quantization_cfg
 
     # Search for node with activation quantization
-    if (activation_quantization_config.enable_activation_quantization and
-            not activation_quantization_config.quantization_preserving):
+    if activation_quantization_config.enable_activation_quantization:
         return prev_node
     else:
         return get_previous_node_with_activation_quantization(prev_node, graph)

model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py

@@ -22,7 +22,8 @@ import numpy as np
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
@@ -127,7 +128,7 @@ class BatchNormalizationReconstruction(common.BaseSubstitution):
         bn_node.candidates_quantization_cfg = copy.deepcopy(source_node.candidates_quantization_cfg)
 
         for qc in bn_node.candidates_quantization_cfg:
-            qc.activation_quantization_cfg.enable_activation_quantization = False
+            qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
             for attr in bn_node.get_node_weights_attributes():
                 if qc.weights_quantization_cfg.has_attribute_config(attr):
                     # we only create a BN layer to collect statistics, so we don't need to quantize anything,

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -17,7 +17,8 @@ import numpy as np
 from typing import List, Tuple, Any, Callable
 
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common import FrameworkInfo, Graph, BaseNode
 from model_compression_toolkit.constants import THRESHOLD, SIGNED, SHIFT_NEGATIVE_NON_LINEAR_NUM_BITS
@@ -363,7 +364,7 @@ def shift_negative_function(graph: Graph,
                                          mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
         for candidate_qc in pad_node.candidates_quantization_cfg:
-            candidate_qc.activation_quantization_cfg.enable_activation_quantization = False
+            candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
             for attr in pad_node.get_node_weights_attributes():
                 candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
 

model_compression_toolkit/core/keras/keras_implementation.py

@@ -159,6 +159,19 @@ class KerasImplementation(FrameworkImplementation):
         """
         return to_tf_tensor(tensor)
 
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        if not isinstance(obj, tuple):
+            return False
+        for item in obj:
+            if not isinstance(item, tf.Tensor):
+                return False
+        return True
+
     def model_builder(self,
                       graph: Graph,
                       mode: ModelBuilderMode,
@@ -454,7 +467,7 @@ class KerasImplementation(FrameworkImplementation):
             return True
 
         return any([node.is_match_type(_type) for _type in [Conv2D, DepthwiseConv2D, Conv2DTranspose, Dense,
-                                                            Concatenate, tf.concat, Add, tf.add]])
+                                                            Concatenate, tf.concat, Add, tf.add, tf.stack]])
 
     def get_mp_node_distance_fn(self, n: BaseNode,
                                 compute_distance_fn: Callable = None,

model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py

@@ -64,8 +64,7 @@ class ConfigurableActivationQuantizer(BaseKerasInferableQuantizer):
         verify_candidates_descending_order(self.node_q_cfg, kernel_attr)
 
         for qc in node_q_cfg:
-            if qc.activation_quantization_cfg.enable_activation_quantization != \
-                    node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
+            if qc.activation_quantization_cfg.quant_mode != node_q_cfg[0].activation_quantization_cfg.quant_mode:
                 Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         self.activation_quantizers = init_activation_quantizers(self.node_q_cfg)

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scaled_dot_product_attention.py

@@ -198,7 +198,6 @@ class ScaledDotProductDecomposition(BaseSubstitution):
         :param attention_node: the node to replace
         :return: A graph after the substitution
         """
-        print("In scale_dot_product_attention substitution@@@@@@@@")
         input_nodes = self._get_attention_input_nodes(graph, attention_node)
         q_node, k_node, v_node = input_nodes["q"], input_nodes["k"], input_nodes["v"]
         transpose_k_node = self._get_transpose_k_node(attention_node.name, k_node)

model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py

@@ -63,8 +63,7 @@ class ConfigurableActivationQuantizer(BasePyTorchInferableQuantizer):
         verify_candidates_descending_order(self.node_q_cfg, kernel_attr)
 
         for qc in self.node_q_cfg:
-            if qc.activation_quantization_cfg.enable_activation_quantization != \
-                   self.node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
+            if qc.activation_quantization_cfg.quant_mode != self.node_q_cfg[0].activation_quantization_cfg.quant_mode:
                 Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         # Setting layer's activation

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -15,12 +15,12 @@
 import operator
 from copy import deepcopy
 from functools import partial
-from typing import List, Any, Tuple, Callable, Type, Dict, Generator
+from typing import List, Any, Tuple, Callable, Generator
 
 import numpy as np
 import torch
 from mct_quantizers import PytorchQuantizationWrapper, PytorchActivationQuantizationHolder
-from torch import sigmoid, softmax, add, cat, argmax, concat, concatenate
+from torch import sigmoid, softmax, add, cat, argmax, concat, concatenate, stack
 from torch.nn import Conv2d, ConvTranspose2d, Linear
 from torch.nn import Module, Sigmoid, Softmax
 
@@ -144,6 +144,19 @@ class PytorchImplementation(FrameworkImplementation):
         """
         return to_torch_tensor(tensor)
 
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        if not isinstance(obj, tuple):
+            return False
+        for item in obj:
+            if not isinstance(item, torch.Tensor):
+                return False
+        return True
+
     def model_reader(self,
                      module: Module,
                      representative_data_gen: Callable) -> Graph:
@@ -449,7 +462,7 @@ class PytorchImplementation(FrameworkImplementation):
 
         return any(node.is_match_type(_type) for _type in [Conv2d, Linear, ConvTranspose2d, Sigmoid, sigmoid, Softmax,
                                                            softmax, operator.add, add, cat, concat, concatenate,
-                                                           operator.concat])
+                                                           operator.concat, stack])
 
     def get_mp_node_distance_fn(self, n: BaseNode,
                                 compute_distance_fn: Callable = None,

model_compression_toolkit/core/pytorch/reader/reader.py

@@ -13,19 +13,40 @@
 # limitations under the License.
 # ==============================================================================
 
-
-import logging
-from typing import Callable, Dict
-
-import numpy as np
 import torch
-from torch.fx import symbolic_trace
+import logging
+from typing import Callable, Dict, Union, Any
 from torch.fx.passes.shape_prop import ShapeProp
+from torch.fx import Tracer, GraphModule, symbolic_trace
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.pytorch.reader.graph_builders import edges_builder, nodes_builder
 from model_compression_toolkit.core.pytorch.utils import set_model
+from sony_custom_layers.pytorch import CustomLayer
+
+
+def _trace_model(root: Union[torch.nn.Module, Callable[..., Any]]) -> GraphModule:
+    """
+    Given an ``nn.Module`` or function instance ``root``, this function will return a ``GraphModule``
+    constructed by recording operations seen while tracing through ``root``.
+    This function replaces torch.fx.symbolic_trace in order to handle custom layers tracing - treating them as graph
+    leafs.
+    :param root: Module or function to be traced and converted into a Graph representation.
+    :return: GraphModule: a Module created from the recorded operations from ``root``.
+    """
+
+    class MCTTracer(Tracer):
+        def is_leaf_module(self, m: torch.nn.Module, module_qualified_name: str) -> bool:
+            if isinstance(m, CustomLayer):
+                return True
+            return super().is_leaf_module(m, module_qualified_name)
+
+    tracer = MCTTracer()
+    graph = tracer.trace(root)
+    # handling the possibility that the model (root) might be a torch.nn.Module or a function
+    model_name = (root.__class__.__name__ if isinstance(root, torch.nn.Module) else root.__name__)
+    return GraphModule(tracer.root, graph, model_name)
 
 
 def generate_module_dict(model: torch.nn.Module) -> Dict:
@@ -87,7 +108,7 @@ def fx_graph_module_generation(pytorch_model: torch.nn.Module,
     set_model(pytorch_model)
 
     try:
-        symbolic_traced = symbolic_trace(pytorch_model)
+        symbolic_traced = _trace_model(pytorch_model)
     except torch.fx.proxy.TraceError as e:
         Logger.critical(f'Error parsing model with torch.fx\n'
                         f'fx error: {e}')

model_compression_toolkit/core/pytorch/utils.py

@@ -15,7 +15,7 @@
 import torch
 from torch import Tensor
 import numpy as np
-from typing import Union, Sequence, Optional, List, Tuple
+from typing import Union, Optional, List, Tuple, Any
 
 from model_compression_toolkit.core.pytorch.constants import MAX_FLOAT16, MIN_FLOAT16
 from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
@@ -112,4 +112,4 @@ def clip_inf_values_float16(tensor: Tensor) -> Tensor:
     # Replace inf values with max float16 value
     tensor[inf_mask] = MAX_FLOAT16 * torch.sign(tensor[inf_mask])
 
-    return tensor
+    return tensor

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 import copy
 
-from typing import Callable, Tuple, Union
+from typing import Callable, Tuple, Union, Optional
 from packaging import version
 
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
@@ -158,7 +158,7 @@ if FOUND_TF:
                                                   target_resource_utilization: ResourceUtilization = None,
                                                   core_config: CoreConfig = CoreConfig(),
                                                   target_platform_capabilities: Union[TargetPlatformCapabilities, str]
-                                                  = DEFAULT_KERAS_TPC) -> Tuple[Model, UserInformation]:
+                                                  = DEFAULT_KERAS_TPC) -> Tuple[Model, Optional[UserInformation]]:
         """
         Quantize a trained Keras model using post-training quantization. The model is quantized using a
         symmetric constraint quantization thresholds (power of two).
@@ -230,6 +230,10 @@ if FOUND_TF:
             >>> quantized_model, quantization_info = mct.gptq.keras_gradient_post_training_quantization(model, repr_datagen, gptq_config, target_resource_utilization=ru, core_config=config)
 
         """
+
+        if core_config.debug_config.bypass:
+            return in_model, None
+
         KerasModelValidation(model=in_model,
                              fw_info=DEFAULT_KERAS_INFO).validate()
 

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 import copy
-from typing import Callable, Union
+from typing import Callable, Union, Optional, Tuple
 
 from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE, PYTORCH, GPTQ_HESSIAN_NUM_SAMPLES
 from model_compression_toolkit.core import CoreConfig
@@ -22,6 +22,7 @@ from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quant
     MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     ResourceUtilization
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.gptq.common.gptq_config import (
@@ -147,7 +148,8 @@ if FOUND_TORCH:
                                                     core_config: CoreConfig = CoreConfig(),
                                                     gptq_config: GradientPTQConfig = None,
                                                     gptq_representative_data_gen: Callable = None,
-                                                    target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC):
+                                                    target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC
+                                                    ) -> Tuple[Module, Optional[UserInformation]]:
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
@@ -206,6 +208,9 @@ if FOUND_TORCH:
 
         """
 
+        if core_config.debug_config.bypass:
+            return model, None
+
         if core_config.is_mixed_precision_enabled:    # pragma: no cover
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "

model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -14,11 +14,12 @@
 # ==============================================================================
 import copy
 
-from typing import Callable
+from typing import Callable, Tuple, Optional
 
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.analyzer import analyzer_model_quantization
 from model_compression_toolkit.core.common.quantization.quantize_graph_weights import quantize_graph_weights
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW
@@ -52,7 +53,8 @@ if FOUND_TF:
                                          representative_data_gen: Callable,
                                          target_resource_utilization: ResourceUtilization = None,
                                          core_config: CoreConfig = CoreConfig(),
-                                         target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
+                                         target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC
+                                         ) -> Tuple[Model, Optional[UserInformation]]:
         """
          Quantize a trained Keras model using post-training quantization. The model is quantized using a
          symmetric constraint quantization thresholds (power of two).
@@ -123,6 +125,9 @@ if FOUND_TF:
 
          """
 
+        if core_config.debug_config.bypass:
+            return in_model, None
+
         fw_info = DEFAULT_KERAS_INFO
 
         KerasModelValidation(model=in_model,

model_compression_toolkit/ptq/pytorch/quantization_facade.py

@@ -14,8 +14,9 @@
 # ==============================================================================
 import copy
 
-from typing import Callable, Union
+from typing import Callable, Union, Tuple, Optional
 
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH
@@ -49,7 +50,8 @@ if FOUND_TORCH:
                                            representative_data_gen: Callable,
                                            target_resource_utilization: ResourceUtilization = None,
                                            core_config: CoreConfig = CoreConfig(),
-                                           target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC):
+                                           target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC
+                                           ) -> Tuple[Module, Optional[UserInformation]]:
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
@@ -97,6 +99,9 @@ if FOUND_TORCH:
 
         """
 
+        if core_config.debug_config.bypass:
+            return in_module, None
+
         fw_info = DEFAULT_PYTORCH_INFO
 
         if core_config.is_mixed_precision_enabled:

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py

@@ -19,10 +19,8 @@ from packaging import version
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2fw import \
     AttachTpcToFramework
-from model_compression_toolkit.verify_packages import FOUND_SONY_CUSTOM_LAYERS
 
-if FOUND_SONY_CUSTOM_LAYERS:
-    from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
+from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
 
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
@@ -102,15 +100,9 @@ class AttachTpcToKeras(AttachTpcToFramework):
             OperatorSetNames.LOG_SOFTMAX: [tf.nn.log_softmax],
             OperatorSetNames.ADD_BIAS: [tf.nn.bias_add],
             OperatorSetNames.L2NORM: [tf.math.l2_normalize],
+            OperatorSetNames.SSD_POST_PROCESS: [SSDPostProcess]
         }
 
-        if FOUND_SONY_CUSTOM_LAYERS:
-            self._opset2layer[OperatorSetNames.SSD_POST_PROCESS] = [SSDPostProcess]
-        else:
-            # If Custom layers is not installed then we don't want the user to fail, but just ignore custom layers
-            # in the initialized framework TPC
-            self._opset2layer[OperatorSetNames.SSD_POST_PROCESS] = []
-
         self._opset2attr_mapping = {
             OperatorSetNames.CONV: {
                 KERNEL_ATTR: DefaultDict(default_value=KERAS_KERNEL),

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -32,6 +32,7 @@ from model_compression_toolkit.target_platform_capabilities.targetplatform2frame
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2fw import \
     AttachTpcToFramework
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attribute_filter import Eq
+from sony_custom_layers.pytorch import MulticlassNMS, MulticlassNMSWithIndices
 
 
 class AttachTpcToPytorch(AttachTpcToFramework):
@@ -97,7 +98,7 @@ class AttachTpcToPytorch(AttachTpcToFramework):
             OperatorSetNames.L2NORM: [LayerFilterParams(torch.nn.functional.normalize,
                                                         Eq('p', 2) | Eq('p', None))],
             OperatorSetNames.SSD_POST_PROCESS: [],  # no such operator in pytorch
-            OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION: [],  # no such operator in pytorch
+            OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION: [MulticlassNMS, MulticlassNMSWithIndices],
         }
 
         pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),

model_compression_toolkit/verify_packages.py

@@ -30,4 +30,3 @@ FOUND_TORCH = importlib.util.find_spec("torch") is not None
 FOUND_TORCHVISION = importlib.util.find_spec("torchvision") is not None
 FOUND_ONNX = importlib.util.find_spec("onnx") is not None
 FOUND_ONNXRUNTIME = importlib.util.find_spec("onnxruntime") is not None
-FOUND_SONY_CUSTOM_LAYERS = importlib.util.find_spec('sony_custom_layers') is not None