mct-nightly 2.1.0.20240801.515__py3-none-any.whl → 2.1.0.20240803.442__py3-none-any.whl

{mct_nightly-2.1.0.20240801.515.dist-info → mct_nightly-2.1.0.20240803.442.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.1.0.20240801.515
+Version: 2.1.0.20240803.442
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct_nightly-2.1.0.20240801.515.dist-info → mct_nightly-2.1.0.20240803.442.dist-info}/RECORD

@@ -1,5 +1,5 @@
-model_compression_toolkit/__init__.py,sha256=-L1xPY1BvoKlBh8WD3EKn_XFs0oLG-nuiSLnyOVxbfU,1573
-model_compression_toolkit/constants.py,sha256=9pVleMwnhlM4QwIL2HcEq42I1uF4rlSw63RUjkxOF4w,3923
+model_compression_toolkit/__init__.py,sha256=X3BCGmZUNFVMjlxgn7jbVizQB3gwC83XMkFDfzPYI3c,1573
+model_compression_toolkit/constants.py,sha256=dexmfFCQ6VgoWuFBeM6MZykfgiVVdVxgkiSnpfjN8Dw,4005
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
 model_compression_toolkit/metadata.py,sha256=IyoON37lBv3TI0rZGCP4K5t3oYI4TOmYy-LRXOwHGpE,1136
@@ -31,7 +31,7 @@ model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5
 model_compression_toolkit/core/common/fusion/layer_fusing.py,sha256=lOubqpc18TslhXZijWUJQAa1c3jIB2S-M-5HK78wJPQ,5548
 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=lg5QaBkRbmvM3tGZ0Q34S3m0CbFql3LUv5BaXLe5TG8,37824
-model_compression_toolkit/core/common/graph/base_node.py,sha256=Hwp5QiAa79TD1Y4KM8Uit7SrJ081QRGCooDIkenYuTs,28494
+model_compression_toolkit/core/common/graph/base_node.py,sha256=Tv_whLIy-Da0DWZIycnvZ2cf2Qa1rCwpcH8kTkkhv2s,31415
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=XvzydBSRxgpYdKS-aYVaWtH3FDzJPKGad3bai9wF3BI,3956
 model_compression_toolkit/core/common/graph/graph_matchers.py,sha256=CrDoHYq4iPaflgJWmoJ1K4ziLrRogJvFTVWg8P0UcDU,4744
@@ -69,7 +69,7 @@ model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,s
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=KifDMbm7qkSfvSl6pcZzQ82naIXzeKL6aT-VsvWZYyc,7901
 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=HILF7CIn-GYPvPmTFyvjWLhuLDwSGwdBcAaKFgVYrwk,4745
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=MhmYgsybWJ2dlCwbZjDKJB8QlDHHy--zOBs2DwJB2e0,13820
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=az0XfBPVm1kAfxNCPb0Z-Q05-F-vqnmyRpKm6SBLa6c,13826
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_aggregation_methods.py,sha256=ttc8wPa_9LZansutQ2f1ss-RTzgTv739wy3qsdLzyyk,4217
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_functions_mapping.py,sha256=QhuqaECEGLnYC08iD6-2XXcU7NXbPzYf1sQcjYlGak8,1682
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_methods.py,sha256=WC1EHoNuo_lrzy4NRhGJ1cgmJ2IsFsbmP86mrVO3AVA,21506
@@ -101,24 +101,24 @@ model_compression_toolkit/core/common/quantization/candidate_node_quantization_c
 model_compression_toolkit/core/common/quantization/core_config.py,sha256=KYdyfSmjSL4ye24nKlC_c4_AxYb14qoqaeMnZj4-8kE,2257
 model_compression_toolkit/core/common/quantization/debug_config.py,sha256=HtkMmneN-EmAzgZK4Vp4M8Sqm5QKdrvNyyZMpaVqYzY,1482
 model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py,sha256=fwF4VILaX-u3ZaFd81xjbJuhg8Ef-JX_KfMXW0TPV-I,7136
-model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=QivClAel7O9k1RkM25Kp_bhB7otq0ZKlxDAF0nQIT6Q,26351
+model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=Vk37nN4owenWJVZO-ycPQknwXUqp7v5HKKfdBhlDu1A,26393
 model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=du0VdsxfkOSYaP1EU9gHA5qbXpfQNZL0jXrjk1wBA0U,7106
 model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,sha256=eyosbVdnCwed7oMQ19tqnh0VoyGZ_UAuD_UnNoXyBpo,2210
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=MwIOBZ4BlZSTIOG75PDvlI3JmZ6t8YjPc1VP9Adei60,3847
 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=O4qFJw3nBYUD4cGbO8haGXZ2-piSqoRpDKDD74iXSxw,12417
+model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=9Y4eVDWCXFvCaXy2gbb-1880sp52M8wqH0M3KgAw8rM,12834
 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=Fd_gxr5js-mqEwucaRR1CQAZ1W_wna19L1gAPeOzxRQ,23610
-model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=t0XSwjfOxcq2Sj2PGzccntz1GGv2eqVn9oR3OI0t9wo,8533
+model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=RL-PklAjGyC-26anSt8fU07a6pB_LBQFQy9o4e9giN0,8739
 model_compression_toolkit/core/common/quantization/quantization_params_generation/outlier_filter.py,sha256=9gnfJV89jpGwAx8ImJ5E9NjCv3lDtbyulP4OtgWb62M,1772
-model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py,sha256=HfnhQ4MxGpb95gOWXD1vnroTxxjFt9VFd4jIdo-rvAQ,10623
-model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py,sha256=noEdvGiyyW7acgQ2OFWLedCODibTGYJifC9qo8YIU5U,4558
+model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py,sha256=y-mEST-0fVbyLiprQu7elOQawSc70TkVdpPsL7o1BmM,11197
+model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py,sha256=I-2CT8KtQr6KSJ11D94nPma8tIedm5mP1jEqA0xjdao,4594
 model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_computation.py,sha256=oME8T6Slgl1SJNpXV4oY3UhuX0YmKYbcWDsLiCYq7oE,8651
-model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_search.py,sha256=o2XNY_0pUUyId02TUVQBtkux_i40NCcnzuobSeQLy3E,42863
+model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_search.py,sha256=Nv_b3DECVjQnlrUet2kbuSvSKVnxcc-gf2zhFb2jSZk,43482
 model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_weights_computation.py,sha256=UI-NW9K-yA6qxtk3Uin1wKmo59FNy0LUnySpxodgeEs,3796
-model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py,sha256=4TP41wPYC0azIzFxUt-lNlKUPIIXQeE4H1SYHkON75k,11875
-model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py,sha256=E83BU4wZEOY-Q-HTo04ABftv22Y6fWEdNYkGA-MZLMU,10494
+model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py,sha256=iPukBikpzuJhKfwnnBgyJ71HhaDIpSoTUuYsjt4rR7w,12587
+model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py,sha256=St2wmWOxsFMP2e8gOy6Gf-L-2x-IiskMD_lOyE4jwiI,10860
 model_compression_toolkit/core/common/quantization/quantizers/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/common/quantization/quantizers/lut_kmeans_quantizer.py,sha256=P0x_y18LypBxP2tV9OWizheYfILqvaMC8RwHo04sUpQ,2761
 model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py,sha256=iEoWUPFQMcvZXHtLMe2_7L7IK25XcKiY6-d1_gArZs0,11880
@@ -138,7 +138,7 @@ model_compression_toolkit/core/common/substitutions/linear_collapsing_substituti
 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=cyy4qnlD-v1Gou62oHNDsf1hWLWkYfcjVv1otFrUltY,29865
+model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=AqQ0cTMz0d1qziQD5uUeYJON0wfXKvRIADuonF8Hobs,29969
 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=aXzUOJfgKPfQpEGfiIun26fgfCqazBG1mBpzoc4Ezxs,3477
 model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=h85L2VlDOqbLd-N98wA3SdYWiblBgSsPceNuLanJd70,4737
@@ -421,7 +421,7 @@ model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=YhROB
 model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py,sha256=bD2xE101rRw7pGarGiBzYraeFF7FUnzyWtAVzwu5JT4,1724
 model_compression_toolkit/target_platform_capabilities/target_platform/current_tp_model.py,sha256=1Glr4qKDJfdk5TwM5fzZ12XzgbpQFioDOxb475905gk,2013
 model_compression_toolkit/target_platform_capabilities/target_platform/fusing.py,sha256=f3xBAI6ivPvEj4lw8cAvTKdIbs7CRdLAa_0LvhGw3Dg,3924
-model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py,sha256=AJfW-uGrXZToaPa8BiyuBv38T7yV_RRrGIHr4Ji946I,15178
+model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py,sha256=w7VBBgvhiOcHjn_OcrWnER8LPa1uhIIYaMEROLFF1xA,16441
 model_compression_toolkit/target_platform_capabilities/target_platform/operators.py,sha256=rRmrmPBY4rxCWVpEc6FxeOPUFh8MkfwgQsqD82U9a7w,3108
 model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py,sha256=mU4djXodftvTqJnFH6-9ISuY1uECjj1xi6SijJWpiRg,9477
 model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model_component.py,sha256=TDbNQwmF7Id-FoIQZlR7ZOcz_nRb4XKBmDihAgKT0u8,1392
@@ -435,48 +435,52 @@ model_compression_toolkit/target_platform_capabilities/target_platform/targetpla
 model_compression_toolkit/target_platform_capabilities/tpc_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 model_compression_toolkit/target_platform_capabilities/tpc_models/get_target_platform_capabilities.py,sha256=-jCL-meZWFBF-Dp9wBYTX_14SKmyyUJE-BZ2IQDJIAk,3336
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py,sha256=mjPFr6Z-PLzqQta8mW7dK31mbbBZsJo4MdpJQmxlSt4,4640
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py,sha256=KOSrFJAheWk360kU4UKQRVOaM0xIUaVdEdnU6b3t7Ww,5046
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/latest/__init__.py,sha256=F5RG4MnuAwKcNXbfVbPFLQu30-lNax-7knqu20B6udQ,1522
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/__init__.py,sha256=1mMOREEMoNHu_KTMGDp4crN61opKWX6aFn1DrDLvqcc,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py,sha256=S-GwMI-JiuPpbtOdd6TSOEjiUFiIs6M2RAiJNJ3O950,10883
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py,sha256=XF5djXt1kOz6pAKStNlcRfSESLZZAjKikF0Pdoq3MUY,10973
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tpc_keras.py,sha256=bPBWxopMUHFgiaJjaAfoompwShvfH2wHAouN56PQn0A,6484
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tpc_pytorch.py,sha256=iCBfBmIRozoeGVPC3MjZpVyp-Nx4fC94_PKILC82K-Y,5731
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_lut/__init__.py,sha256=vFDyiMymNZSRCdTgAyWn4A-tZD3vzze_PTLBSF2OYe8,721
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_lut/tp_model.py,sha256=InFx2Uh6dG30U9YIvVH_1jb34r1wJw7ms3J295lRKvM,10619
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_lut/tp_model.py,sha256=ptqH5KGE5XJ35rYXb7zWyfP9Zbfq-Qa35IKyq0E1hrw,10709
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_lut/tpc_keras.py,sha256=bU74t-ZIkIptXuNaPI_YIC5w9TX6nDgJUpJwxHAPOSI,6493
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_lut/tpc_pytorch.py,sha256=09fbd5vEnSQDWfCkMRtYZYy7kIYiWkXDcH_dT1cAmoY,5739
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_pot/__init__.py,sha256=NUuczImqUxzdfflqSdqkeAN8aCU6Tuiu6U0Fnj9Tzmw,721
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_pot/tp_model.py,sha256=o1KloA8WPw1MbtZ-4p-kxQuroBAL67z77dPpliZyH9o,10369
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_pot/tp_model.py,sha256=zx39TEVxMwBYWa7CaUVi3kPxIIC_ID8pnamibkCQer4,10459
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_pot/tpc_keras.py,sha256=NkAGCZbSgXYeRAiJRzt19h2cxkrVQJaHu8-2jHZLOYg,6505
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1_pot/tpc_pytorch.py,sha256=X853xDEF-3rcPoqxbrlYN28vvW3buSdM36c_eN_LKx8,5758
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2/__init__.py,sha256=vKWAoQ2KkhuptS5HZB50zHG6KY8wHpHTxPugw_nGCRo,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2/tp_model.py,sha256=uMGN6TbyRMSGL01_i4M3z6eeI8PqC4qYZSTEACpo9io,10958
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2/tp_model.py,sha256=0-_lLUqQAvl19ySSeDp40hLmD7GYuQmmnAHHoE_e1Us,11048
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2/tpc_keras.py,sha256=U5lYwk6vJkRt5fo5v_1_h5POTwf9zfia1XQ_cDoOZAI,6587
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2/tpc_pytorch.py,sha256=jAyTXhcChO124odtWC3bYKRH4ZyqLPkKQluJFOoyPIM,5726
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/__init__.py,sha256=wUk4Xsg7jpxOWYjq2K3WUwLcI185p_sVPK-ttG0ydhA,721
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tp_model.py,sha256=dmi2lCT0dw6RnWVw73tcnqgsVSgINSWaIWfgZhEli4Q,10691
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tp_model.py,sha256=VTK3dC5-_Ps2AsoQwfAg9ATVTlz6yUvrXYX02jc7X0U,10781
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tpc_keras.py,sha256=6PVKQKGpJpM2B1qvmf6fID_-MACaSQZkaL_9J_fj2SQ,6595
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tpc_pytorch.py,sha256=dFQjzFlLDwoUqKNP1at1fS1N1WJadSSasRyzHl6vaB8,5733
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/__init__.py,sha256=gAeebYCKyIXH9-Qwze7FwvTihudzAHk_Qsg94fQbkjQ,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tp_model.py,sha256=edMH4lM7Bq7FaPAFZLU5UMX-bWSWiaaAIXnQE7lZ7rI,11844
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tp_model.py,sha256=ku_hfhd_VaqyC3yjQEiG6dJN-V6ADSBGF-YBpB5I54w,11934
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_keras.py,sha256=T5YMv-RzgYlzBaagnMO7WnKgbZ7PrOvm29Nn4vUhCHI,6587
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_pytorch.py,sha256=HRo0W5l4IJesr_np4ZhXoMk_xfdiV53LgamquQIryJA,5800
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/__init__.py,sha256=C2kwyDE1-rtukkbNSoKRv9q8Nt2GOCaBbl0BdOr3goA,721
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tp_model.py,sha256=HoGjDwoSx2Y4dQua5v1qzzlnSl_HfDMK6bGWuZhPOzQ,11577
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tp_model.py,sha256=8SHk1Ws9nLU9mDq6YV4pxDgeIH3n6NfKrRZk_Zv-JIk,11667
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_keras.py,sha256=LvqUkvpJKXBb9QETcHsmp9OGDwl9KWr457deag8GVuM,6595
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_pytorch.py,sha256=nP05jqvh6uaj30a3W7zEkJfKtqfP0Nz5bobwRqbYrdM,5807
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/__init__.py,sha256=tHTUvsaerSfbe22pU0kIDauPpFD7Pq5EmZytVIDkHz4,717
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tp_model.py,sha256=Wi_pLHFcY3p_HlooT7e0uLE1wUpp4LsbfI2DN445tu8,12731
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_keras.py,sha256=VSPTv6pt6OX8Zpjdit5GK9WattHpKAi4sVByBzTwsgw,6626
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_pytorch.py,sha256=HRU8CRkmzfsvzw9AwhiB33HyRnR5oXxw__hD2OqfmN8,5800
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/target_platform_capabilities.py,sha256=7KVcuz0LfngRKOsfcvBysxGVb9fqgoAO6MVTl1CmB5c,2082
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/latest/__init__.py,sha256=UUvUCcTots_sehdRnDfgkaE8WPQ7dPbeuhDF4Qy2nzw,1510
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/__init__.py,sha256=t4JKsPcor-7KSCKzIwuaBv0NLNwfhuewAQGlDl6iBeo,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tp_model.py,sha256=InHTtUwHxh8KeC430SX9gP17hUvXJ-REGCXIUCQBVhI,8106
+model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tp_model.py,sha256=czKvlJaa1tRllQSlzFBeyJF4u3ktwJG3LT0NUDK9yVg,8196
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tpc_keras.py,sha256=h_hePXCggG2qktLuoNAOE1XNtc0qEwMyky7om1c8eC8,4483
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tpc_pytorch.py,sha256=65WJPRCjliXEUL4AjZRxcyVS3y7KHTMDdkqy6D95kRw,3814
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/target_platform_capabilities.py,sha256=Go0RJ1KcKoynCUSwGhxA1nsYsMmZEFSrxiL59iyE6LA,2077
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/latest/__init__.py,sha256=sK9PnyB2R9g0rqHr_9vyUFX7wSyrZe7x9yqYUlbaiqo,1505
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/__init__.py,sha256=t4JKsPcor-7KSCKzIwuaBv0NLNwfhuewAQGlDl6iBeo,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tp_model.py,sha256=PSoSEgn2Gprc3TpLyl2BCcn7tYW0KrFN-CXM7l8dwOo,9864
+model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tp_model.py,sha256=7Qn5PPAMm9-NNQq2SDJqXABW0dqOzjyGYB1LZFf4l3k,9954
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc_keras.py,sha256=-4vNf2Q6c_rgaac19AFO8hG4ANaPfgNPf0kN44mL6TQ,6830
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc_pytorch.py,sha256=YVJJvqGPBdkKnug99p9bjqtbfecDXZKIB2iWVCe7RUY,5960
 model_compression_toolkit/trainable_infrastructure/__init__.py,sha256=DwWh0lXiLNNzqHHNEy-Py6_5OtseNGJDGNV3SYm8rYQ,1224
@@ -521,8 +525,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=yrZNVRm2IRU7r7R-hjS2lOQ6wvEEvbeunvf2jKoWjXk,3277
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=eyMoXt5o5EnMr6d-rpCwQdX5mAiYiymvbgKv4tf7-a0,4576
-mct_nightly-2.1.0.20240801.515.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.1.0.20240801.515.dist-info/METADATA,sha256=pry-813t-qxDBgTyO7RCAsGWfQbNwdOMVUs5r7Hdf_s,19719
-mct_nightly-2.1.0.20240801.515.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mct_nightly-2.1.0.20240801.515.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.1.0.20240801.515.dist-info/RECORD,,
+mct_nightly-2.1.0.20240803.442.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.1.0.20240803.442.dist-info/METADATA,sha256=RKnrVIjHC3DybeqKgWlBfXJKJz5c6z_GPTqahkwBy6s,19719
+mct_nightly-2.1.0.20240803.442.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+mct_nightly-2.1.0.20240803.442.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.1.0.20240803.442.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.1.0.20240801.000515"
+__version__ = "2.1.0.20240803.000442"

model_compression_toolkit/constants.py

@@ -69,7 +69,8 @@ FLOAT_BITWIDTH = 32
 # that are shared among different candidates:
 WEIGHTS_NBITS_ATTRIBUTE = 'weights_n_bits'
 CORRECTED_BIAS_ATTRIBUTE = 'corrected_bias'
-ACTIVATION_NBITS_ATTRIBUTE = 'activation_n_bits'
+ACTIVATION_N_BITS_ATTRIBUTE = 'activation_n_bits'
+SUPPORTED_INPUT_ACTIVATION_NBITS_ATTRIBUTE = 'supported_input_activation_n_bits'
 
 # Quantization Parameters Iterative Search Defaults:
 SYMMETRIC_TENSOR_N_ITER = 40

model_compression_toolkit/core/common/graph/base_node.py

@@ -19,11 +19,11 @@ from typing import Dict, Any, Tuple, List, Type, Union
 import numpy as np
 
 from model_compression_toolkit.constants import WEIGHTS_NBITS_ATTRIBUTE, CORRECTED_BIAS_ATTRIBUTE, \
-    ACTIVATION_NBITS_ATTRIBUTE, FP32_BYTES_PER_PARAMETER
+    ACTIVATION_N_BITS_ATTRIBUTE, FP32_BYTES_PER_PARAMETER
 from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationConfigOptions, \
-    TargetPlatformCapabilities, LayerFilterParams
+    TargetPlatformCapabilities, LayerFilterParams, OpQuantizationConfig
 
 
 class BaseNode:
@@ -297,7 +297,6 @@ class BaseNode:
 
         return memory
 
-
     def get_unified_weights_candidates_dict(self, fw_info) -> Dict[str, Any]:
         """
         In Mixed-Precision, a node's kernel can have multiple candidates for weights quantization configuration.
@@ -343,7 +342,7 @@ class BaseNode:
         Returns: A dictionary containing information from node's activation quantization configuration candidates.
 
         """
-        shared_attributes = [ACTIVATION_NBITS_ATTRIBUTE]
+        shared_attributes = [ACTIVATION_N_BITS_ATTRIBUTE]
         attr = dict()
         if self.is_activation_quantization_enabled():
             attr = copy.deepcopy(self.candidates_quantization_cfg[0].activation_quantization_cfg.__dict__)
@@ -539,7 +538,7 @@ class BaseNode:
         to the mappings from layers/LayerFilterParams to the OperatorsSet in the TargetPlatformModel.
 
         Args:
-            tpc: TPC to extract the QuantizationConfigOptions for the node
+            tpc: TPC to extract the QuantizationConfigOptions for the node.
 
         Returns:
             QuantizationConfigOptions of the node.
@@ -559,6 +558,52 @@ class BaseNode:
             return matching_qcos[0]
         return tpc.tp_model.default_qco
 
+    def filter_node_qco_by_graph(self, tpc: TargetPlatformCapabilities,
+                                 next_nodes: List, node_qc_options: QuantizationConfigOptions
+                                 ) -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]:
+        """
+        Filter quantization config options that don't match the graph.
+        A node may have several quantization config options with 'activation_n_bits' values, and
+        the next nodes in the graph may support different bit-width as input activation. This function
+        filters out quantization config that don't comply to these attributes.
+
+        Args:
+            tpc: TPC to extract the QuantizationConfigOptions for the next nodes.
+            next_nodes: Output nodes of current node.
+            node_qc_options: Node's QuantizationConfigOptions.
+
+        Returns:
+
+        """
+        # Filter quantization config options that don't match the graph.
+        _base_config = node_qc_options.base_config
+        _node_qc_options = node_qc_options.quantization_config_list
+        if len(next_nodes):
+            next_nodes_qc_options = [_node.get_qco(tpc) for _node in next_nodes]
+            next_nodes_supported_input_bitwidth = min([op_cfg.max_input_activation_n_bits
+                                                       for qc_opts in next_nodes_qc_options
+                                                       for op_cfg in qc_opts.quantization_config_list])
+
+            # Filter node's QC options that match next nodes input bit-width.
+            _node_qc_options = [_option for _option in _node_qc_options
+                                if _option.activation_n_bits <= next_nodes_supported_input_bitwidth]
+            if len(_node_qc_options) == 0:
+                Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+
+            # Verify base config match
+            if any([node_qc_options.base_config.activation_n_bits > qc_opt.base_config.max_input_activation_n_bits
+                    for qc_opt in next_nodes_qc_options]):
+                # base_config activation bits doesn't match next node supported input bit-width -> replace with
+                # a qco from quantization_config_list with maximum activation bit-width.
+                if len(_node_qc_options) > 0:
+                    output_act_bitwidth = {qco.activation_n_bits: i for i, qco in enumerate(_node_qc_options)}
+                    _base_config = _node_qc_options[output_act_bitwidth[max(output_act_bitwidth)]]
+                    Logger.warning(f"Node {self} base quantization config changed to match Graph and TPC configuration.\nCause: {self} -> {next_nodes}.")
+                else:
+                    Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+
+        return _base_config, _node_qc_options
+
     def is_match_type(self, _type: Type) -> bool:
         """
         Check if input type matches the node type, either in instance type or in type name.

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

@@ -195,12 +195,12 @@ def compute_total_bops(graph: Graph, fw_info: FrameworkInfo, fw_impl: FrameworkI
 
 
 def requires_mixed_precision(in_model: Any,
-                            target_resource_utilization: ResourceUtilization,
-                            representative_data_gen: Callable,
-                            core_config: CoreConfig,
-                            tpc: TargetPlatformCapabilities,
-                            fw_info: FrameworkInfo,
-                            fw_impl: FrameworkImplementation) -> bool:
+                             target_resource_utilization: ResourceUtilization,
+                             representative_data_gen: Callable,
+                             core_config: CoreConfig,
+                             tpc: TargetPlatformCapabilities,
+                             fw_info: FrameworkInfo,
+                             fw_impl: FrameworkImplementation) -> bool:
     """
     The function checks whether the model requires mixed precision to meet the requested target resource utilization.
     This is determined by whether the target memory usage of the weights is less than the available memory,

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -96,6 +96,7 @@ 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.enable_activation_quantization = op_cfg.enable_activation_quantization
+        self.is_signed = op_cfg.is_signed
         self.activation_channel_equalization = qc.activation_channel_equalization
         self.input_scaling = qc.input_scaling
         self.min_threshold = qc.min_threshold

model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py

@@ -19,7 +19,7 @@ from sklearn.cluster import KMeans
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
 from model_compression_toolkit.constants import LUT_VALUES, MIN_THRESHOLD, SCALE_PER_CHANNEL, \
-    LUT_VALUES_BITWIDTH, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+    LUT_VALUES_BITWIDTH, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import \
     max_power_of_two, int_quantization_with_threshold
@@ -110,7 +110,8 @@ def lut_kmeans_histogram(bins: np.ndarray,
                          constrained: bool = True,
                          n_iter: int = 20,
                          min_threshold: float = MIN_THRESHOLD,
-                         quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> Dict:
+                         quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                         is_signed: bool = None) -> Dict:
     """
     Finds quantization cluster points for non-uniform activation quantization.
     The quantizer first finds the closest power-of-two number to the max value of the given histogram,
@@ -129,6 +130,7 @@ def lut_kmeans_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small.
         quant_error_method: an error function to optimize the parameters' selection accordingly (not used for this method).
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         A dictionary containing the cluster assignments according to the k-means algorithm and
@@ -148,9 +150,9 @@ def lut_kmeans_histogram(bins: np.ndarray,
     tensor_max = np.max(bins_with_values)
     threshold = max_power_of_two(tensor_max, min_threshold)
 
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     tensor_for_kmeans = int_quantization_with_threshold(data=bins, threshold=threshold, n_bits=LUT_VALUES_BITWIDTH, signed=signed)
     kmeans.fit(tensor_for_kmeans.reshape(-1, 1), sample_weight=np.insert(counts, 0, 0))
 
     return {LUT_VALUES: np.float32(np.round(kmeans.cluster_centers_)),
-            THRESHOLD: threshold}
+            THRESHOLD: threshold, SIGNED: signed}

model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.qparams_search import \
     qparams_selection_tensor_search, qparams_selection_histogram_search
@@ -105,7 +105,8 @@ def power_of_two_selection_histogram(bins: np.ndarray,
                                      constrained: bool = True,
                                      n_iter: int = 20,
                                      min_threshold: float = MIN_THRESHOLD,
-                                     quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                     quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                     is_signed: bool = None) -> Dict:
     """
     Compute the power of two threshold based on the provided QuantizationErrorMethod to quantize a histogram.
     Different search is applied, depends on the value of the selected QuantizationErrorMethod.
@@ -121,6 +122,7 @@ def power_of_two_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (used only for kl threshold selection).
         quant_error_method: an error function to optimize the parameters' selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Power of two threshold to quantize the histogram a power of 2 manner.
@@ -128,17 +130,20 @@ def power_of_two_selection_histogram(bins: np.ndarray,
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         tensor_max = np.max(np.abs(bins)[1:][counts > 0])
         threshold = max_power_of_two(tensor_max, min_threshold)
+        # Resolve is_signed in case it is None.
+        signed = (bins<0).any() if is_signed is None else is_signed
     else:
         error_function = get_threshold_selection_histogram_error_function(QuantizationMethod.POWER_OF_TWO,
                                                                           quant_error_method, p)
-        threshold = qparams_selection_histogram_search(error_function,
-                                                       bins,
-                                                       counts,
-                                                       n_bits,
-                                                       constrained=constrained,
-                                                       n_iter=n_iter,
-                                                       min_threshold=min_threshold)
-    return {THRESHOLD: threshold}
+        threshold, signed = qparams_selection_histogram_search(error_function,
+                                                               bins,
+                                                               counts,
+                                                               n_bits,
+                                                               constrained=constrained,
+                                                               n_iter=n_iter,
+                                                               min_threshold=min_threshold,
+                                                               is_signed=is_signed)
+    return {THRESHOLD: threshold, SIGNED: signed}
 
 
 def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
@@ -151,7 +156,8 @@ def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
                                                n_iter: int = 20,
                                                min_threshold: float = MIN_THRESHOLD,
                                                quant_error_method: qc.QuantizationErrorMethod =
-                                               qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                               qc.QuantizationErrorMethod.NOCLIPPING,
+                                               is_signed: bool = None) -> Dict:
     """
     Gets a threshold between min and max numbers.
     If computed threshold is less than min_threshold, min_threshold is returned.
@@ -168,4 +174,5 @@ def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
                                             constrained,
                                             n_iter,
                                             min_threshold=min_threshold,
-                                            quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
+                                            quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                            is_signed=is_signed)

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 import numpy as np
-from typing import Dict
+from typing import Dict, Union
 
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.collectors.statistics_collector import BaseStatsCollector
@@ -25,7 +25,7 @@ from model_compression_toolkit.core.common.quantization.node_quantization_config
 
 def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConfig,
                             nodes_prior_info: NodePriorInfo,
-                            out_stats_container: BaseStatsCollector) -> Dict[str, float]:
+                            out_stats_container: BaseStatsCollector) -> Dict[str, Union[np.ndarray, float, bool]]:
     """
     Compute the activations params for a given node in a graph according to a params function.
 
@@ -49,7 +49,9 @@ def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConf
                                                                     bins_counts)
     min_value, max_value = out_stats_container.get_min_max_values()
 
-    if nodes_prior_info.is_output_bounded():
+    if activation_quant_cfg.is_signed is not None:
+        signed = activation_quant_cfg.is_signed
+    elif nodes_prior_info.is_output_bounded():
         signed = min_value < 0
     else:
         signed = np.any(bins_values[:-1][bins_counts > 0] < 0)
@@ -65,14 +67,12 @@ def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConf
             activation_quant_cfg.activation_quantization_params_fn = \
                 quantization_params_generation.uniform_no_clipping_selection_min_max
 
-    activation_params = activation_quant_cfg.activation_quantization_params_fn(bins_values,
-                                                                               bins_counts,
-                                                                               activation_quant_cfg.l_p_value,
-                                                                               activation_quant_cfg.activation_n_bits,
-                                                                               min_value,
-                                                                               max_value,
-                                                                               min_threshold=activation_quant_cfg.min_threshold,
-                                                                               quant_error_method=activation_quant_cfg.activation_error_method)
-    activation_params.update({SIGNED: signed})
-
-    return activation_params
+    return activation_quant_cfg.activation_quantization_params_fn(bins_values,
+                                                                  bins_counts,
+                                                                  activation_quant_cfg.l_p_value,
+                                                                  activation_quant_cfg.activation_n_bits,
+                                                                  min_value,
+                                                                  max_value,
+                                                                  min_threshold=activation_quant_cfg.min_threshold,
+                                                                  quant_error_method=activation_quant_cfg.activation_error_method,
+                                                                  is_signed=signed)

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_search.py

@@ -107,7 +107,8 @@ def qparams_selection_histogram_search(error_function: Callable,
                                        n_bits: int,
                                        constrained: bool = True,
                                        n_iter: int = 10,
-                                       min_threshold: float = MIN_THRESHOLD):
+                                       min_threshold: float = MIN_THRESHOLD,
+                                       is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     Search for an optimal threshold to quantize a histogram of collected float values.
     The search_methods starts with the constrained no-clipping threshold by the bins' maximal value, and continues with
@@ -123,13 +124,14 @@ def qparams_selection_histogram_search(error_function: Callable,
         constrained: Whether the threshold should be constrained or not.
         n_iter: Number of searching iterations.
         min_threshold: Threshold to return if the computed threshold is smaller that min_threshold.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal constrained threshold to quantize the tensor.
 
     """
 
-    signed = np.any(bins < 0)  # Whether histogram contains negative values or not.
+    signed = (bins < 0).any() if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     tensor_data = np.abs(bins)
     tensor_max = np.max(tensor_data)
     if not constrained:
@@ -150,7 +152,7 @@ def qparams_selection_histogram_search(error_function: Callable,
         error_list.append(error)
 
     # Return the threshold with the minimal error.
-    return np.maximum(threshold_list[np.argmin(error_list)], min_threshold)
+    return np.maximum(threshold_list[np.argmin(error_list)], min_threshold), signed
 
 
 def qparams_symmetric_iterative_minimization(x0: np.ndarray,
@@ -537,7 +539,8 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                  counts: np.ndarray,
                                                  n_bits: int,
                                                  n_iter: int = SYMMETRIC_HISTOGRAM_N_ITER,
-                                                 min_threshold: float = MIN_THRESHOLD):
+                                                 min_threshold: float = MIN_THRESHOLD,
+                                                 is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     search for optimal threshold (per-channel or per-tensor) for symmetric quantization of a histogram,
     using the iterative optimizer method.
@@ -550,12 +553,13 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
         n_bits: Number of bits to quantize the tensor.
         n_iter: Number of searching iterations.
         min_threshold: Threshold to return if the computed threshold is smaller that min_threshold.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimized threshold for quantifying the histogram.
 
     """
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
 
     res = qparams_symmetric_iterative_minimization(x0=get_init_threshold(min_threshold, tensor_max),
                                                    x=bins,
@@ -570,7 +574,7 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                    n_iter=SYMMETRIC_HISTOGRAM_N_ITER,
                                                    dec_freq=SYMMETRIC_HISTOGRAM_DEC_FREQ,
                                                    per_channel=False)
-    return max(min_threshold, res['param'])
+    return max(min_threshold, res['param']), signed
 
 
 def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
@@ -579,7 +583,8 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                     counts: np.ndarray,
                                                     n_bits: int,
                                                     n_iter: int = SYMMETRIC_HISTOGRAM_N_ITER,
-                                                    min_threshold: float = MIN_THRESHOLD):
+                                                    min_threshold: float = MIN_THRESHOLD,
+                                                    is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     Search for optimal threshold (per-channel or per-tensor) for symmetric quantization of a histogram,
     with KL-Divergence loss function (needs a separate search function
@@ -599,7 +604,7 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
         Optimized threshold for quantifying the histogram.
 
     """
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     res = qparams_symmetric_iterative_minimization(x0=get_init_threshold(min_threshold, tensor_max),
                                                    x=bins,
                                                    loss_fn=lambda x, q_x, t:
@@ -617,7 +622,7 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                    n_iter=SYMMETRIC_HISTOGRAM_N_ITER,
                                                    dec_freq=SYMMETRIC_HISTOGRAM_DEC_FREQ,
                                                    per_channel=False)
-    return max(min_threshold, res['param'])
+    return max(min_threshold, res['param']), signed
 
 
 def qparams_uniform_selection_histogram_search(error_function: Callable,