mct-nightly 2.0.0.20240506.443__py3-none-any.whl → 2.0.0.20240508.359__py3-none-any.whl

{mct_nightly-2.0.0.20240506.443.dist-info → mct_nightly-2.0.0.20240508.359.dist-info}/METADATA

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

{mct_nightly-2.0.0.20240506.443.dist-info → mct_nightly-2.0.0.20240508.359.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=BrVKSiAXwatjO95aqg8ejMXp_m2yitqzH7vl2sEqVSw,1573
+model_compression_toolkit/__init__.py,sha256=Gb8O8uP4Dp5A0QbdMvIwsAR-LBOTUvfvcH2tA6SOPyg,1573
 model_compression_toolkit/constants.py,sha256=yIJyJ-e1WrDeKD9kG15qkqfYnoj7J1J2CxnJDt008ik,3756
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -7,7 +7,7 @@ model_compression_toolkit/core/__init__.py,sha256=TrRgkWpT1AN2Faw1M_1HXyJkJnbxfn
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=kM70wmNG3yMFiGQc0uO0wn9j4ZbSWxUEykpxDK55doc,10567
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=0ga95vh_ZXO79r8FB26L5GIZKHkG98wq1hMsNH1bIeU,6453
-model_compression_toolkit/core/runner.py,sha256=E_gXj95Az3C3swsv7v1zeKZx25keWjnD30uhI7ONZkY,12028
+model_compression_toolkit/core/runner.py,sha256=yref5I8eUo2A4hAmc4bOQOj6lUZRDQjLQR_5lJCjXiQ,12696
 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=pOT9ZmRFL9FY92uUtigrO3sbWGiyVDhHAM1fbA4b5yo,20752
@@ -30,7 +30,7 @@ model_compression_toolkit/core/common/collectors/statistics_collector.py,sha256=
 model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 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=VKw50YwgGfyA7sdtEeU9qaSDnN31p4fHX1JVx7wNF9c,38265
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=lmIw0srKiwCvz7KWqfwKTxyQHDy3s6rWMIXzFAa1UMo,38326
 model_compression_toolkit/core/common/graph/base_node.py,sha256=IaHrvgtUZvPshhUjS4j2lqIP22Mlny82BQZaL2iVJew,29079
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=71_4TrCdqR_r0mtgxmAyqI05iP5YoQQGeSmDgynuzTw,3902
@@ -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=mk4nSP3cJ-k_aKIyPW0zoAgoe_hHXXQcCygicWBBOjw,7922
+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/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=TUGv_4j9-WUWZceoqLdObH_61tAQnHIRyquxm09x9wI,21473
@@ -84,26 +84,26 @@ model_compression_toolkit/core/common/pruning/channels_grouping.py,sha256=4jsr1x
 model_compression_toolkit/core/common/pruning/greedy_mask_calculator.py,sha256=cKcSkrQkTFm6Ns7Uq9IXWEMDPQfr9Ew9RvZXmr4p4cM,7928
 model_compression_toolkit/core/common/pruning/memory_calculator.py,sha256=doSxL7JnvcuxaANjE2fiG_yiRShLwDBtqNXnQyDtZ50,19523
 model_compression_toolkit/core/common/pruning/prune_graph.py,sha256=Sykf7m49krzINy_Sx9UBU_WF_WctewHArDQ4oFXVQUY,3323
-model_compression_toolkit/core/common/pruning/pruner.py,sha256=70x4eY-1efrDeev10esdCx5c6fFCGwqSV6U0rzPNZiE,7516
+model_compression_toolkit/core/common/pruning/pruner.py,sha256=SIlO1A97MGhX-oBn5618zciUqVlZkQfTs873GF4MLxk,7536
 model_compression_toolkit/core/common/pruning/pruning_config.py,sha256=fbqERt11FGVeuqPVA6nVbgGDh6Ox9mpEKdxVJT8eG4I,3681
 model_compression_toolkit/core/common/pruning/pruning_framework_implementation.py,sha256=H2gnCv-lyRLXapDy71QHA3JkLYTQT1ni23nGTYErsZo,6734
-model_compression_toolkit/core/common/pruning/pruning_info.py,sha256=nT1aA1eYnai3SdGkBGjpvPgvsko7zf_4w2oiNYE2G7M,3781
+model_compression_toolkit/core/common/pruning/pruning_info.py,sha256=qI1kXcoQR9D_GgzjKQ_EoML94VtAxxIF1LGnHWXtl24,3801
 model_compression_toolkit/core/common/pruning/pruning_section.py,sha256=I4vxh5iPKWs8yji-q4TVmaa6bcfLwT3ZhB2x8F8cJkU,5721
 model_compression_toolkit/core/common/pruning/importance_metrics/__init__.py,sha256=3Lkr37Exk9u8811hw8hVqkGcbTQGcLjd3LLuLC3fa_E,698
 model_compression_toolkit/core/common/pruning/importance_metrics/base_importance_metric.py,sha256=qMAtLWs5fjbSco8nhbig5TkuacdhnDW7cy3avMHRGX4,1988
 model_compression_toolkit/core/common/pruning/importance_metrics/importance_metric_factory.py,sha256=E-fKuRfrNYlN3nNcRAbnkJkFNwClvyrL_Js1qDPxIKA,1999
 model_compression_toolkit/core/common/pruning/importance_metrics/lfh_importance_metric.py,sha256=2WwX1omrMAYOsXCesP35g1p_8M6JviEUTkaSNaMIuaI,14027
 model_compression_toolkit/core/common/pruning/mask/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
-model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py,sha256=PdIfl3AMoCATfShimQjsJUszmeIO6eTtpp7B1ZZIc64,5111
-model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py,sha256=h85ZM6N-tDhJB8EWXwHDBVEDnrIHt0fQfFguqqyOfTU,5958
+model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py,sha256=APY8BsM9B7ZxVCH6n1xs9fSCTB_A9ou9gHrCQl1DOdI,5131
+model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py,sha256=4ohJrJHNzZk5uMnZEYkwLx2TDGzkh5kRhLGNVYNC6dc,5978
 model_compression_toolkit/core/common/quantization/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=8RfAaVITnYpWQUvFnDDzLOteBtc5bN6JOzdyb-l768U,4900
 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=q5e1XRIZc2APtdHRW_8bucoFqxaoc0srKWMUgYJ6dAM,26723
-model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=Y76BZ-X2vE_PXeM9r7D93VsFnbC_evoHhN7zYuvFdzw,7041
-model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,sha256=T1nVWdRJfBQ_iuMQYQSIkjfkR-2n3lAOKGAz_rUZZN0,2190
+model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=0XFJwHbuUjT_C20XB0Omumd6PSQqYj5fnsYHRx78AaU,26733
+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
@@ -135,7 +135,7 @@ model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,
 model_compression_toolkit/core/common/substitutions/batchnorm_refusing.py,sha256=YqLKiO5gFBEvI6noAWeMME1JHaYUaGFMglVFg8AqGjc,10028
 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=VUWjc9Wo_nwSX3JTyAtrG5mprV90DwaQopAuvND30nQ,2353
+model_compression_toolkit/core/common/substitutions/remove_identity.py,sha256=TKU1TIU52UIkVnl0EZvWnDhLV9nIVZ4hqi-w1i4NXMk,2637
 model_compression_toolkit/core/common/substitutions/residual_collapsing.py,sha256=doErjlMq-uSObYMSjA6IywSHb3Hz3QCc0HKU68ccrQ4,4767
 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
@@ -149,43 +149,43 @@ model_compression_toolkit/core/common/visualization/tensorboard_writer.py,sha256
 model_compression_toolkit/core/keras/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/keras/constants.py,sha256=Uv3c0UdW55pIVQNW_1HQlgl-dHXREkltOLyzp8G1mTQ,3163
 model_compression_toolkit/core/keras/custom_layer_validation.py,sha256=f-b14wuiIgitBe7d0MmofYhDCTO3IhwJgwrh-Hq_t_U,1192
-model_compression_toolkit/core/keras/default_framework_info.py,sha256=Ha4HTHuiw_KTS5Po1Xnv6GyK9eprpDhYWf-eooS62Ys,4961
-model_compression_toolkit/core/keras/keras_implementation.py,sha256=04vZfpSzDq8jwUlsT88FXp4ngTnTIxKVdIxiYWAwmbg,29673
+model_compression_toolkit/core/keras/default_framework_info.py,sha256=HcHplb7IcnOTyK2p6uhp3OVG4-RV3RDo9C_4evaIzkQ,4981
+model_compression_toolkit/core/keras/keras_implementation.py,sha256=CijrPTyh28Up9-_YYrGNxaflLMAK5CzbXMraAGnX6l4,29716
 model_compression_toolkit/core/keras/keras_model_validation.py,sha256=1wNV2clFdC9BzIELRLSO2uKf0xqjLqlkTJudwtCeaJk,1722
-model_compression_toolkit/core/keras/keras_node_prior_info.py,sha256=TIqazcbeoMxZgneQ-i24myCPyBpy_RJ7GcDxxWHbb4U,3907
+model_compression_toolkit/core/keras/keras_node_prior_info.py,sha256=HUmzEXDQ8LGX7uOYSRiLZ2TNbYxLX9J9IeAa6QYlifg,3927
 model_compression_toolkit/core/keras/resource_utilization_data_facade.py,sha256=Xmk2ZL5CaYdb7iG62HdtZ1F64vap7ffnrsuR3e3G5hc,4851
 model_compression_toolkit/core/keras/tf_tensor_numpy.py,sha256=moMFP7hOagAbd09bWa2AX5uxN7XOJqLB-mV3mA30kLQ,2651
 model_compression_toolkit/core/keras/back2framework/__init__.py,sha256=rhIiXg_nBgUZ-baE3M6SzCuQbcnq4iebY1jtJBvKHOM,808
 model_compression_toolkit/core/keras/back2framework/factory_model_builder.py,sha256=urpfyHvIzD08QzPBWusVBT_dKZ8ZUf1I1zIQNb4qe5Y,2233
 model_compression_toolkit/core/keras/back2framework/float_model_builder.py,sha256=9SFHhX-JnkB8PvYIIHRYlReBDI_RkZY9LditzW_ElLk,2444
 model_compression_toolkit/core/keras/back2framework/instance_builder.py,sha256=fBj13c6zkVoWX4JJG18_uXPptiEJqXClE_zFbaFB6Q8,4517
-model_compression_toolkit/core/keras/back2framework/keras_model_builder.py,sha256=7xEasszjyqbkv5UJuBfEr2kxRPtcrdNP26ivELoIVI4,16227
-model_compression_toolkit/core/keras/back2framework/mixed_precision_model_builder.py,sha256=psJzQJ_Hv_wyHuXZotN5dopwoKIu87-xnaILfINWXf0,15567
+model_compression_toolkit/core/keras/back2framework/keras_model_builder.py,sha256=KXA5rik1cvCSgIbybPfX3tsMlzoILDboVONGyqzXGh0,16290
+model_compression_toolkit/core/keras/back2framework/mixed_precision_model_builder.py,sha256=ygIS1WIiftF1VC3oGhc8N6j7MryKtWgEg8nr50p7f4U,15587
 model_compression_toolkit/core/keras/back2framework/quantized_model_builder.py,sha256=5wFb4nx_F0Wu4c8pLf6n6OzxOHtpOJ6_3mQsNSXIudU,2481
 model_compression_toolkit/core/keras/graph_substitutions/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
-model_compression_toolkit/core/keras/graph_substitutions/substitutions/activation_decomposition.py,sha256=3FVqVfEeEve8vRejmMex079HZDnoRsF21kNY53ZjIM8,5140
+model_compression_toolkit/core/keras/graph_substitutions/substitutions/activation_decomposition.py,sha256=Hs96qwrwhMqnMrjALN-jtsGiuiEU2ZtE6BmC1DoMV-Y,5160
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_folding.py,sha256=Oe2QNsU49rp6qW1jUuOG_fKrE3DqXXDmVWN0fiyWo4c,8207
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_reconstruction.py,sha256=GR1a3mCZpNUu4WxixJXF_aSm57phAdxaRoHecNx3hxw,3168
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/batchnorm_refusing.py,sha256=5df_xGfXkqNub4xVRnCWQvSohWqdv12axjJ6edVU2H0,2478
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/concat_threshold_update.py,sha256=Hl4LEQ_bw_Vpmf3ZqHujYUqVdvTNsPlEMvr9dZhwg2U,2806
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/dwconv_to_conv.py,sha256=R3U7cjc2E0zheMem16GHygp5jZFGSaomkNOTxTjcAgw,5794
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/input_scaling.py,sha256=V6hp67CkS_A3WqdsjLjs0ETtdZAOo4P9mhy4aT7W5FE,5940
-model_compression_toolkit/core/keras/graph_substitutions/substitutions/linear_collapsing.py,sha256=CjBbw20BcD9NFBftc9d28TYLmBI9wUzjfZ33c22hgHU,8157
+model_compression_toolkit/core/keras/graph_substitutions/substitutions/linear_collapsing.py,sha256=i5kdo6-GJe5j4ZVoBp9irLLqqS_H24izrUvda17laf0,8177
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/matmul_substitution.py,sha256=kjwlKtm5yhNgWVVcW6mN-hn7enwAnn_8-TUZvxZBiQs,4112
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/multi_head_attention_decomposition.py,sha256=l9PUREBf4aRwWILiybdteveeUbh7js-i-hLt8Ma0e4c,26771
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/relu_bound_to_power_of_2.py,sha256=IdKOg6AWZWMcmDbOuNdxetS5_zTarXIIffdYL7JTdvk,3872
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/remove_identity.py,sha256=z2J2Xk7b_w_fEgJmK87lwwBmEoAZpGxPmsBrR24IkZs,2035
-model_compression_toolkit/core/keras/graph_substitutions/substitutions/residual_collapsing.py,sha256=MdRl2CLF_EsjHcpqa_kzgD7gKZI1kM4E1qDLarCH9Cw,3188
+model_compression_toolkit/core/keras/graph_substitutions/substitutions/residual_collapsing.py,sha256=jhOLZDQ4_6-x6JHGsyzboX-CdtF3N-BkZjm2YwBsW4I,3208
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/scale_equalization.py,sha256=ryes9y1ie-vjBGso2TeO4EXxVk69Ew3iSAhshPz1Ou4,5542
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/separableconv_decomposition.py,sha256=TEaHlIbXj_ZjIdT5TmAICD3WLD3u_7g0fLWQcNzTJuM,7941
-model_compression_toolkit/core/keras/graph_substitutions/substitutions/shift_negative_activation.py,sha256=JCK--hQMKzbx4MOQZBPZqK015JWZELUO5YdA30IU4bI,11149
+model_compression_toolkit/core/keras/graph_substitutions/substitutions/shift_negative_activation.py,sha256=13ejpU2z7c5O2w0Iy_uz3HaBbXVYrsQpEqt0nKErVvg,11169
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/softmax_shift.py,sha256=Qk5seDALj_th9dHJehY7ynZjvFjVfCv_mJ1enA5hX0c,1623
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/virtual_activation_weights_composition.py,sha256=wH9ocMLL725-uUPU-zCxdd8NwT5nyd0ZShmI7iuTwF8,1462
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/weights_activation_split.py,sha256=rjIheZW7LbSPv9bzMSmC8wl6UUxaTkd4J2IHinObT-Y,1814
 model_compression_toolkit/core/keras/hessian/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
 model_compression_toolkit/core/keras/hessian/activation_trace_hessian_calculator_keras.py,sha256=IBrHt4NfZwsoz_UHaXhfWVTQ8ihDNy1Ca88oBPtytHU,9656
-model_compression_toolkit/core/keras/hessian/trace_hessian_calculator_keras.py,sha256=2TGEz6APP6iEGGzH82c5ba8mrMsfPuCTGkfS_GLm8vQ,3913
+model_compression_toolkit/core/keras/hessian/trace_hessian_calculator_keras.py,sha256=hRfAjgZakDaIMuERmTVjJSa_Ww6FmEudYPO9R7SuYuQ,3914
 model_compression_toolkit/core/keras/hessian/weights_trace_hessian_calculator_keras.py,sha256=ZXiN6D1kW5a_-02wk_YgjBEiKkNpz_cajP6842ysGAc,10525
 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
@@ -194,10 +194,10 @@ model_compression_toolkit/core/keras/pruning/__init__.py,sha256=3Lkr37Exk9u8811h
 model_compression_toolkit/core/keras/pruning/pruning_keras_implementation.py,sha256=EJkblZ4OAjI5l29GKsUraam5Jn58Sogld47_rFFyr3k,12777
 model_compression_toolkit/core/keras/quantizer/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/keras/quantizer/base_quantizer.py,sha256=eMRjAUU189-AVwNGMlV0M-ZlL48ZYmILzutheUT00xU,1628
-model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py,sha256=ymBSCN7IeJnS305fpVO866WJxW456yV8cZAD4kMD308,6274
+model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py,sha256=vfKwU0AfRH2KztmMF5bxcaBlGdnTePPGZsUqOHzED-U,6854
 model_compression_toolkit/core/keras/quantizer/lut_fake_quant.py,sha256=Up3-sbuAcaJ6kfe7Sz3XN6iiJ9hlxzOMncLCFEXJFjk,4475
 model_compression_toolkit/core/keras/reader/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
-model_compression_toolkit/core/keras/reader/common.py,sha256=lVy_dRfIfx4mrijdh8HO9HAx4Jq7QyLY9VGB6dxwDx8,2518
+model_compression_toolkit/core/keras/reader/common.py,sha256=eZWjBcvTDUX7fCWmy1OAH4lYLFTh59_UQ_nP_Gjp4yw,2594
 model_compression_toolkit/core/keras/reader/connectivity_handler.py,sha256=AgF6qXZOJMeXvc-pBnGY23BJz7wPBx2aTYxHiO8efec,11303
 model_compression_toolkit/core/keras/reader/node_builder.py,sha256=URmE3lM9CskS-9a3TuqfReLdHh36Dti08RL8qxzrBjc,10471
 model_compression_toolkit/core/keras/reader/reader.py,sha256=wS9UQ2wJKnkZYe9JHwQp7ygDr6CRlzrxmIyLDv1Qz6U,8109
@@ -212,7 +212,7 @@ model_compression_toolkit/core/keras/visualization/__init__.py,sha256=mjbqLD-KcG
 model_compression_toolkit/core/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/constants.py,sha256=NI-J7REuxn06oEIHsmJ4GqtNC3TbV8xlkJjt5Ar-c4U,2626
 model_compression_toolkit/core/pytorch/default_framework_info.py,sha256=r1XyzUFvrjGcJHQM5ETLsMZIG2yHCr9HMjqf0ti9inw,4175
-model_compression_toolkit/core/pytorch/pytorch_device_config.py,sha256=IoMvTch5awAEPvB6Tg6ANhFGXvfSgv7JLsUBlxpMwk4,4330
+model_compression_toolkit/core/pytorch/pytorch_device_config.py,sha256=S25cuw10AW3SEN_fRAGRcG_I3wdvvQx1ehSJzPnn-UI,4404
 model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=sEtlxpWdt0rzuTN3R0bNCC_l75Xy7rIBMUWY7LuhYKI,27351
 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=E6ifk1HdO60k4IRH2EFBzAYWtwUlrGqJoQ66nknpHoQ,4983
@@ -220,9 +220,9 @@ model_compression_toolkit/core/pytorch/utils.py,sha256=dRPiteBg2dBNsHwZyYzXiCIAj
 model_compression_toolkit/core/pytorch/back2framework/__init__.py,sha256=H_WixgN0elVWf3exgGYsi58imPoYDj5eYPeh6x4yfug,813
 model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py,sha256=DwNO8WO3JiMawKGKDhlrwCoCjMSBIw5BMbsFFF7eDS4,2279
 model_compression_toolkit/core/pytorch/back2framework/float_model_builder.py,sha256=tLrlUyYhxVKVjkad1ZAtbRra0HedB3iVfIkZ_dYnQ-4,3419
-model_compression_toolkit/core/pytorch/back2framework/instance_builder.py,sha256=BxX0e6kKoV29UNT-Yee28f7rXID5_KBz1RiSDYo2Vjk,1848
+model_compression_toolkit/core/pytorch/back2framework/instance_builder.py,sha256=d7U_8VKGjQjbmvcUKRKsD80woWu_0gh6LXg1NhZNTjY,1348
 model_compression_toolkit/core/pytorch/back2framework/mixed_precision_model_builder.py,sha256=D7lU1r9Uq_7fdNuKk2BMF8ho5GrsY-8gyGN6yYoHaVg,15060
-model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py,sha256=i0U4EQfaTbbBHMrv9oJHJ5ltybfGTGz17KETnNpci3k,18299
+model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py,sha256=11pUQUxtBM1gCxipEaXn-8A9dVI5rgRiSoFa9i_nw58,18281
 model_compression_toolkit/core/pytorch/back2framework/quantized_model_builder.py,sha256=qZNNOlNTTV4ZKPG3q5GDXkIVTPUEr8dvxAS_YiMORmg,3456
 model_compression_toolkit/core/pytorch/back2framework/quantization_wrapper/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/core/pytorch/back2framework/quantization_wrapper/quantized_layer_wrapper.py,sha256=q2JDw10NKng50ee2i9faGzWZ-IydnR2aOMGSn9RoZmc,5773
@@ -236,13 +236,13 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/concat_
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/const_holder_conv.py,sha256=Fs2YQBD4KJV-pGLOMqm-p485bfq2JDYgCzFroRljCoM,3933
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_batch_norm.py,sha256=iX8bLHtw2osP42-peNLTRmbpX3cUxdGsAbEfw7NLpx0,3935
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_layer_norm.py,sha256=zKSgtVw_P9fUvdq4e7P9yaLDPG_vZ0cecM9sVPtm1ns,3799
-model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/linear_collapsing.py,sha256=8KtuyqKgu7VTk6zffTmIteZ5Eq90ffPXgYWqca0NZj0,5829
+model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/linear_collapsing.py,sha256=CXSMASpc_Zed3BJ2CsER69zKxE6ncFvvKQWDO1JxKYI,5849
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/multi_head_attention_decomposition.py,sha256=VNg-VgzCxSyqy2J3neEPl6U0SPO8UIVU_T47bGhz4FE,38459
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/permute_call_method.py,sha256=EMCviyFyJFLEKuAUz3rZHLfB9MAU1kywSBL2XQNzLlg,1953
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/relu_bound_to_power_of_2.py,sha256=q1a3HieQtaOmWG2WGXp6GHYAvxa3CZ9dJUx9dqMAsS8,5695
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/remove_identity.py,sha256=joHjwiUxccypMHkTy46rI91VyapLn9yJ2YRo5ISnOH4,1987
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/reshape_with_static_shapes.py,sha256=jOqlelGhADEZiYUEyYj9oJZ5YLXx8jWNUlVTG6Td79Y,4919
-model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/residual_collapsing.py,sha256=flHJU-hSvih3bi8c24SYArqN00UnOVImu8HZBZAzzVo,2909
+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/shift_negative_activation.py,sha256=lOPl5zDU3FoR9WmlxO04Pfi65MimK0gmnuHzQJodQdY,10668
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/softmax_shift.py,sha256=05lV4pIL3hJkZl4JQPV4wk_EFD0eYLG5b8cdzvZk4P8,1588
@@ -250,7 +250,7 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/virtual
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/weights_activation_split.py,sha256=tp78axmUQc0Zpj3KwVmV0PGYHvCf7sAW_sRmXXw7gsY,1616
 model_compression_toolkit/core/pytorch/hessian/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
 model_compression_toolkit/core/pytorch/hessian/activation_trace_hessian_calculator_pytorch.py,sha256=9yD0zAcERmZkwzUJkTMq_rZp9bIUCIPSsB4HE-53MFo,8147
-model_compression_toolkit/core/pytorch/hessian/trace_hessian_calculator_pytorch.py,sha256=BBZjM71V9YwlCMe380D7VQoBzXxHQpiPLvNIemyH-3g,3425
+model_compression_toolkit/core/pytorch/hessian/trace_hessian_calculator_pytorch.py,sha256=Gat9aobUOQEWGt02x30vVm04mdi3gchdz2Bmmw5p91w,3445
 model_compression_toolkit/core/pytorch/hessian/weights_trace_hessian_calculator_pytorch.py,sha256=ODktCLPovOgrvYGHKtSD8es5p2BxMC--9t7fkp04tyo,6974
 model_compression_toolkit/core/pytorch/mixed_precision/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py,sha256=-6oep2WJ85-JmIxZa-e2AmBpbORoKe4Xdduz2ZidwvM,4871
@@ -258,7 +258,7 @@ model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quan
 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
 model_compression_toolkit/core/pytorch/quantizer/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
-model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py,sha256=rox-f5wbRyxU1UHeHyaoIDXB9r9fCXm1dPN4FVwHqTc,6464
+model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py,sha256=D8_CEuFqKAhbUgKaRw7Jlxo0zlqgPTMu6CIIIM4LfS0,7045
 model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py,sha256=uyeBtNokyDUikk-YkDP_mN_2DX0J5oPm3kSfdSUT2Ck,4420
 model_compression_toolkit/core/pytorch/reader/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/reader/graph_builders.py,sha256=8EieykOysQEMoHZQTLZv9yfkg0dkoFwRtlR3I0rlshg,12626
@@ -273,8 +273,8 @@ model_compression_toolkit/data_generation/common/data_generation.py,sha256=fccGG
 model_compression_toolkit/data_generation/common/data_generation_config.py,sha256=ynyNaT2x2d23bYSrO2sRItM2ZsjGD0K0fM71FlibiJQ,4564
 model_compression_toolkit/data_generation/common/enums.py,sha256=OGnvtEGFbP5l4V3-1l32zzVQwTb1vGJhTVF0kOkYZK4,3584
 model_compression_toolkit/data_generation/common/image_pipeline.py,sha256=WwyeoIvgmcxKnuOX-_Hl_0APET4M26f5x-prhUB3qvU,2149
-model_compression_toolkit/data_generation/common/model_info_exctractors.py,sha256=EspXpsimTuGIpF6Pg4OMixZ4z7Zg778aYioMOE30hmo,6046
-model_compression_toolkit/data_generation/common/optimization_utils.py,sha256=8wCU-bCLabDIUayG3eyapdD8pTE6x0RYG5o3rfha7XE,19572
+model_compression_toolkit/data_generation/common/model_info_exctractors.py,sha256=kz3w4h4fO4R2N5IgLvSkqDUwjhH4S-I3n3_pK2hQ_uo,6200
+model_compression_toolkit/data_generation/common/optimization_utils.py,sha256=Q_yG8T8HQxfTKjVmN7bLm4M4y-5WrMeGQ_h5RnurSmg,19761
 model_compression_toolkit/data_generation/keras/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
 model_compression_toolkit/data_generation/keras/constants.py,sha256=uy3eU24ykygIrjIvwOMj3j5euBeN2PwWiEFPOkJJ7ss,1088
 model_compression_toolkit/data_generation/keras/image_pipeline.py,sha256=_Qezq67huKmmNsxdFBBrTY-VaGR-paFzDH80dDuRnug,7623
@@ -338,7 +338,7 @@ model_compression_toolkit/gptq/common/gptq_config.py,sha256=6xP99B-lK1bwGv3Adqxn
 model_compression_toolkit/gptq/common/gptq_constants.py,sha256=QSm6laLkIV0LYmU0BLtmKp3Fi3SqDfbncFQWOGA1cGU,611
 model_compression_toolkit/gptq/common/gptq_framework_implementation.py,sha256=n3mSf4J92kFjekzyGyrJULylI-8Jf5OVWJ5AFoVnEx0,1266
 model_compression_toolkit/gptq/common/gptq_graph.py,sha256=-bL5HhPcKqV8nj4dZPXc5QmQJbFBel6etrioikP0tEo,3039
-model_compression_toolkit/gptq/common/gptq_training.py,sha256=rLA1xlOO-6gWfmc2dLWr1E8dRvTE76vkUYA5eH-MMTA,17705
+model_compression_toolkit/gptq/common/gptq_training.py,sha256=v_R24lW74XpAISK9D3P4U-xYyeWbH7obAdqo3f-WCis,16093
 model_compression_toolkit/gptq/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/gptq/keras/gptq_keras_implementation.py,sha256=axBwnCSjq5xk-xGymOwSOqjp39It-CVtGcCTRTf0E_4,1248
 model_compression_toolkit/gptq/keras/gptq_loss.py,sha256=rbRkF15MYd6nq4G49kcjb_dPTa-XNq9cTkrb93mXawo,6241
@@ -476,15 +476,15 @@ model_compression_toolkit/trainable_infrastructure/common/get_quantizers.py,sha2
 model_compression_toolkit/trainable_infrastructure/common/quant_utils.py,sha256=zdiew1jwR7tUKm9XWlHnAPxIZsAdKqbzzC2vH02j5wA,1505
 model_compression_toolkit/trainable_infrastructure/common/trainable_quantizer_config.py,sha256=My5Wz34jPOyh8z33OTpKnOobRB0cpO_Qgmtsd5lizHo,4791
 model_compression_toolkit/trainable_infrastructure/keras/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
-model_compression_toolkit/trainable_infrastructure/keras/base_keras_quantizer.py,sha256=-Lrp9tW4WDfgjTgSRYGSCQaQZullhFvdVcJiVRS5Is0,4148
+model_compression_toolkit/trainable_infrastructure/keras/base_keras_quantizer.py,sha256=HYJxTS_z1xBL5GzA3vQzYWMSPZW29cR3hvhvoBi-BaE,3996
 model_compression_toolkit/trainable_infrastructure/keras/config_serialization.py,sha256=txdWXdZoHazg-3MDPb9P-oXRM92LRn2G_8woEplwKaI,4360
 model_compression_toolkit/trainable_infrastructure/keras/load_model.py,sha256=-g-php71ezRZg1viD1MjMQ-GEyBua-PVd5XoSBvwzpc,3656
 model_compression_toolkit/trainable_infrastructure/keras/quantize_wrapper.py,sha256=ZdYRQaBtKbckwodcN2yfVx4Bc6LrcoUG-kDKc7mW12U,5468
 model_compression_toolkit/trainable_infrastructure/keras/quantizer_utils.py,sha256=MVwXNymmFRB2NXIBx4e2mdJ1RfoHxRPYRgjb1MQP5kY,1797
 model_compression_toolkit/trainable_infrastructure/pytorch/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
-model_compression_toolkit/trainable_infrastructure/pytorch/base_pytorch_quantizer.py,sha256=7bbzqJN8ZAycVDvZr_5xC-niTAR5df8f03Kooev_pfg,3047
-mct_nightly-2.0.0.20240506.443.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.0.0.20240506.443.dist-info/METADATA,sha256=Y_3b2WsIezUyVrXvoTElmbtMIJvdQU7u6TfGRyPPtN0,18795
-mct_nightly-2.0.0.20240506.443.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mct_nightly-2.0.0.20240506.443.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.0.0.20240506.443.dist-info/RECORD,,
+model_compression_toolkit/trainable_infrastructure/pytorch/base_pytorch_quantizer.py,sha256=MxylaVFPgN7zBiRBy6WV610EA4scLgRJFbMucKvvNDU,2896
+mct_nightly-2.0.0.20240508.359.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.0.0.20240508.359.dist-info/METADATA,sha256=7DNTJcz_t4DjzI_GkV1hLDACyfk5b67MTnSiNmyDMys,18795
+mct_nightly-2.0.0.20240508.359.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+mct_nightly-2.0.0.20240508.359.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.0.0.20240508.359.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.0.0.20240506.000443"
+__version__ = "2.0.0.20240508.000359"

model_compression_toolkit/core/common/graph/base_graph.py

@@ -414,7 +414,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         """
         if new_node is None:
-            Logger.critical("Cannot replace input node with a None value; new input node is required.")
+            Logger.critical("Cannot replace input node with a None value; new input node is required.")  # pragma: no cover
 
         graph_inputs = self.get_inputs()
         new_graph_inputs = copy(graph_inputs)
@@ -828,12 +828,12 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         """
         if not fw_impl.is_node_entry_node(entry_node):
-            Logger.critical(f"Node {entry_node} is not a valid entry node for creating a pruning section")
+            Logger.critical(f"Node {entry_node} is not a valid entry node for creating a pruning section")  # pragma: no cover
 
         intermediate_nodes, exit_node = self._find_intermediate_and_exit_nodes(entry_node, fw_impl)
 
         if not fw_impl.is_node_exit_node(exit_node, entry_node, self.fw_info):
-            Logger.critical(f"Node {exit_node} is not a valid exit node for the pruning section starting with {entry_node}.")
+            Logger.critical(f"Node {exit_node} is not a valid exit node for the pruning section starting with {entry_node}.")   # pragma: no cover
 
         return PruningSection(entry_node=entry_node,
                               intermediate_nodes=intermediate_nodes,

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

@@ -13,15 +13,16 @@
 # limitations under the License.
 # ==============================================================================
 import numpy as np
-from typing import Callable, Any
+from typing import Callable, Any, Dict, Tuple
 
-from model_compression_toolkit.constants import FLOAT_BITWIDTH
+from model_compression_toolkit.constants import FLOAT_BITWIDTH, BITS_TO_BYTES
 from model_compression_toolkit.core import FrameworkInfo, ResourceUtilization, CoreConfig
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.graph.edge import EDGE_SINK_INDEX
 from model_compression_toolkit.core.graph_prep_runner import graph_preparation_runner
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities, \
+    QuantizationConfigOptions
 
 
 def compute_resource_utilization_data(in_model: Any,
@@ -29,10 +30,13 @@ def compute_resource_utilization_data(in_model: Any,
                                       core_config: CoreConfig,
                                       tpc: TargetPlatformCapabilities,
                                       fw_info: FrameworkInfo,
-                                      fw_impl: FrameworkImplementation) -> ResourceUtilization:
+                                      fw_impl: FrameworkImplementation,
+                                      transformed_graph: Graph = None,
+                                      mixed_precision_enable: bool = True) -> ResourceUtilization:
     """
     Compute Resource Utilization information that can be relevant for defining target ResourceUtilization for mixed precision search.
-    Calculates maximal activation tensor, sum of weights' parameters and total (sum of both).
+    Calculates maximal activation tensor size, the sum of the model's weight parameters and the total memory combining both weights
+    and maximal activation tensor size.
 
     Args:
         in_model:  Model to build graph from (the model that intended to be quantized).
@@ -42,27 +46,35 @@ def compute_resource_utilization_data(in_model: Any,
                                               the attached framework operator's information.
         fw_info: Information needed for quantization about the specific framework.
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+        transformed_graph: An internal graph representation of the input model. Defaults to None.
+                            If no graph is provided, a graph will be constructed using the specified model.
+        mixed_precision_enable: Indicates if mixed precision is enabled, defaults to True.
+                                If disabled, computes resource utilization using base quantization
+                                configurations across all layers.
+
+    Returns:
+        ResourceUtilization: An object encapsulating the calculated resource utilization computations.
 
-    Returns: A ResourceUtilization object with the results.
 
     """
 
     # We assume that the resource_utilization_data API is used to compute the model resource utilization for
     # mixed precision scenario, so we run graph preparation under the assumption of enabled mixed precision.
-    transformed_graph = graph_preparation_runner(in_model,
-                                                 representative_data_gen,
-                                                 core_config.quantization_config,
-                                                 fw_info,
-                                                 fw_impl,
-                                                 tpc,
-                                                 mixed_precision_enable=True)
+    if transformed_graph is None:
+        transformed_graph = graph_preparation_runner(in_model,
+                                                     representative_data_gen,
+                                                     core_config.quantization_config,
+                                                     fw_info,
+                                                     fw_impl,
+                                                     tpc,
+                                                     mixed_precision_enable=mixed_precision_enable)
 
     # Compute parameters sum
-    weights_params = compute_nodes_weights_params(graph=transformed_graph, fw_info=fw_info)
+    weights_memory_bytes, weights_params = compute_nodes_weights_params(graph=transformed_graph, fw_info=fw_info)
     total_weights_params = 0 if len(weights_params) == 0 else sum(weights_params)
 
     # Compute max activation tensor
-    activation_output_sizes = compute_activation_output_sizes(graph=transformed_graph)
+    activation_output_sizes_bytes, activation_output_sizes = compute_activation_output_sizes(graph=transformed_graph)
     max_activation_tensor_size = 0 if len(activation_output_sizes) == 0 else max(activation_output_sizes)
 
     # Compute total memory utilization - parameters sum + max activation tensor
@@ -78,20 +90,23 @@ def compute_resource_utilization_data(in_model: Any,
                                bops=bops_count)
 
 
-def compute_nodes_weights_params(graph: Graph, fw_info: FrameworkInfo) -> np.ndarray:
+def compute_nodes_weights_params(graph: Graph, fw_info: FrameworkInfo) -> Tuple[np.ndarray, np.ndarray]:
     """
-    Computes a vector with the respective weights' parameters size for each node.
+    Calculates the memory usage in bytes and the number of weight parameters for each node within a graph.
+    Memory calculations are based on the maximum bit-width used for quantization per node.
 
     Args:
-        graph: Finalized Graph object.
-        fw_info: FrameworkInfo object about the specific framework
-            (e.g., attributes of different layers' weights to quantize).
-
-    Returns: A vector of node's weights memory sizes.
-
+        graph: A finalized Graph object, representing the model structure.
+        fw_info: FrameworkInfo object containing details about the specific framework's
+                 quantization attributes for different layers' weights.
+
+    Returns:
+        A tuple containing two arrays:
+            - The first array represents the memory in bytes for each node's weights when quantized at the maximal bit-width.
+            - The second array represents the total number of weight parameters for each node.
     """
-
     weights_params = []
+    weights_memory_bytes = []
     for n in graph.nodes:
         # TODO: when enabling multiple attribute quantization by default (currently,
         #  only kernel quantization is enabled) we should include other attributes memory in the sum of all
@@ -100,7 +115,9 @@ def compute_nodes_weights_params(graph: Graph, fw_info: FrameworkInfo) -> np.nda
         kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
         if kernel_attr is not None and not n.reuse:
             kernel_candidates = n.get_all_weights_attr_candidates(kernel_attr)
+
             if len(kernel_candidates) > 0 and any([c.enable_weights_quantization for c in kernel_candidates]):
+                max_weight_bits = max([kc.weights_n_bits for kc in kernel_candidates])
                 node_num_weights_params = 0
                 for attr in fw_info.get_kernel_op_attributes(n.type):
                     if attr is not None:
@@ -108,28 +125,41 @@ def compute_nodes_weights_params(graph: Graph, fw_info: FrameworkInfo) -> np.nda
 
                 weights_params.append(node_num_weights_params)
 
-    return np.array(weights_params)
+                # multiply num params by num bits and divide by BITS_TO_BYTES to convert from bits to bytes
+                weights_memory_bytes.append(node_num_weights_params * max_weight_bits / BITS_TO_BYTES)
 
+    return np.array(weights_memory_bytes), np.array(weights_params)
 
-def compute_activation_output_sizes(graph: Graph) -> np.ndarray:
+def compute_activation_output_sizes(graph: Graph) -> Tuple[np.ndarray, np.ndarray]:
     """
-    Computes a vector with the respective output tensor size for each node.
+    Computes an array of the respective output tensor size and an array of the output tensor size in bytes for
+    each node.
 
     Args:
-        graph: Finalized Graph object.
+        graph: A finalized Graph object, representing the model structure.
+
+    Returns:
+    A tuple containing two arrays:
+        - The first array represents the size of each node's activation output tensor size in bytes,
+          calculated using the maximal bit-width for quantization.
+        - The second array represents the size of each node's activation output tensor size.
 
-    Returns: A vector of node's activation output size.
 
     """
 
     activation_outputs = []
-    # Go over all nodes that have configurable activation.
+    activation_outputs_bytes = []
     for n in graph.nodes:
+        # Go over all nodes that have configurable activation.
         if n.has_activation_quantization_enabled_candidate():
+            # Fetch maximum bits required for quantizing activations
+            max_activation_bits = max([qc.activation_quantization_cfg.activation_n_bits for qc in n.candidates_quantization_cfg])
             node_output_size = n.get_total_output_params()
             activation_outputs.append(node_output_size)
+            # Calculate activation size in bytes and append to list
+            activation_outputs_bytes.append(node_output_size * max_activation_bits / BITS_TO_BYTES)
 
-    return np.array(activation_outputs)
+    return np.array(activation_outputs_bytes), np.array(activation_outputs)
 
 
 def compute_total_bops(graph: Graph, fw_info: FrameworkInfo, fw_impl: FrameworkImplementation) -> np.ndarray:
@@ -162,3 +192,56 @@ def compute_total_bops(graph: Graph, fw_info: FrameworkInfo, fw_impl: FrameworkI
             bops.append(node_bops)
 
     return np.array(bops)
+
+
+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:
+    """
+    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,
+    the target maximum size of an activation tensor is less than the available memory,
+    and the target number of BOPs is less than the available BOPs.
+    If any of these conditions are met, the function returns True. Otherwise, it returns False.
+
+    Args:
+        in_model: The model to be evaluated.
+        target_resource_utilization: The resource utilization of the target device.
+        representative_data_gen: A function that generates representative data for the model.
+        core_config: CoreConfig containing parameters of how the model should be quantized.
+        tpc: TargetPlatformCapabilities object that models the inference target platform and
+                                              the attached framework operator's information.
+        fw_info: Information needed for quantization about the specific framework.
+        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+
+    Returns: A boolean indicating if mixed precision is needed.
+    """
+    is_mixed_precision = False
+    transformed_graph = graph_preparation_runner(in_model,
+                                                 representative_data_gen,
+                                                 core_config.quantization_config,
+                                                 fw_info,
+                                                 fw_impl,
+                                                 tpc,
+                                                 mixed_precision_enable=False)
+    # Compute max weights memory in bytes
+    weights_memory_by_layer_bytes, _ = compute_nodes_weights_params(transformed_graph, fw_info)
+    total_weights_memory_bytes = 0 if len(weights_memory_by_layer_bytes) == 0 else sum(weights_memory_by_layer_bytes)
+
+    # Compute max activation tensor in bytes
+    activation_output_sizes_bytes, _ = compute_activation_output_sizes(transformed_graph)
+    max_activation_tensor_size_bytes = 0 if len(activation_output_sizes_bytes) == 0 else max(activation_output_sizes_bytes)
+
+    # Compute BOPS utilization - total count of bit-operations for all configurable layers with kernel
+    bops_count = compute_total_bops(graph=transformed_graph, fw_info=fw_info, fw_impl=fw_impl)
+    bops_count = np.inf if len(bops_count) == 0 else sum(bops_count)
+
+    is_mixed_precision |= target_resource_utilization.weights_memory < total_weights_memory_bytes
+    is_mixed_precision |= target_resource_utilization.activation_memory < max_activation_tensor_size_bytes
+    is_mixed_precision |= target_resource_utilization.total_memory < total_weights_memory_bytes + max_activation_tensor_size_bytes
+    is_mixed_precision |= target_resource_utilization.bops < bops_count
+    return is_mixed_precision

model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py

@@ -73,7 +73,7 @@ class PerChannelMask:
             mask_indicator: The new value to set in the mask (either PRUNED or REMAINED).
         """
         if mask_indicator not in [MaskIndicator.PRUNED, MaskIndicator.REMAINED]:
-            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")
+            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")  # pragma: no cover
         self._mask[node][channel_idx] = mask_indicator.value
 
     def has_pruned_channel(self) -> bool:

model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py

@@ -79,7 +79,7 @@ class PerSIMDGroupMask:
             mask_indicator: The new value to set in the mask (either PRUNED or REMAINED).
         """
         if mask_indicator not in [MaskIndicator.PRUNED, MaskIndicator.REMAINED]:
-            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")
+            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")  # pragma: no cover
 
         # Update the SIMD group mask and corresponding per-channel mask
         self._mask_simd[node][group_index] = mask_indicator.value

model_compression_toolkit/core/common/pruning/pruner.py

@@ -92,7 +92,7 @@ class Pruner:
             mask_calculator.compute_mask()
             self.per_oc_mask = mask_calculator.get_mask()
         else:
-            Logger.critical("Only GREEDY ChannelsFilteringStrategy is currently supported.")
+            Logger.critical("Only GREEDY ChannelsFilteringStrategy is currently supported.")  # pragma: no cover
 
         Logger.info("Start pruning graph...")
         _pruned_graph = build_pruned_graph(self.float_graph,

model_compression_toolkit/core/common/pruning/pruning_info.py

@@ -76,7 +76,7 @@ def unroll_simd_scores_to_per_channel_scores(simd_scores: Dict[BaseNode, np.ndar
     """
     if simd_scores is None or simd_groups_indices is None:
         Logger.critical(f"Failed to find scores and indices to create unrolled scores for pruning information."
-                        f" Scores: {simd_scores}, Group indices: {simd_groups_indices}.")
+                        f" Scores: {simd_scores}, Group indices: {simd_groups_indices}.")  # pragma: no cover
     _scores = {}
     for node, groups_indices in simd_groups_indices.items():
         node_scores = simd_scores[node]

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -65,10 +65,8 @@ class BaseNodeQuantizationConfig(object):
         """
         Returns: String to display a NodeQuantizationConfig object.
         """
-        repr_str = ''
-        for k, v in self.__dict__.items():
-            repr_str += f'{k}: {v}\n'
-        return repr_str
+        # Used for debugging, thus no cover.
+        return ''.join(f'{k}: {v}\n' for k, v in self.__dict__.items())  # pragma: no cover
 
 
 class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):

model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -124,7 +124,8 @@ class QuantizationConfig:
         self.concat_threshold_update = concat_threshold_update
 
     def __repr__(self):
-        return str(self.__dict__)
+        # Used for debugging, thus no cover.
+        return str(self.__dict__)  # pragma: no cover
 
 
 # Default quantization configuration the library use.

model_compression_toolkit/core/common/quantization/quantization_fn_selection.py

@@ -44,6 +44,6 @@ def get_weights_quantization_fn(weights_quantization_method: QuantizationMethod)
         quantizer_fn = lut_kmeans_quantizer
     else:
         Logger.critical(
-            f"No quantizer function found for the specified quantization method: {weights_quantization_method}")
+            f"No quantizer function found for the specified quantization method: {weights_quantization_method}")  # pragma: no cover
 
     return quantizer_fn

model_compression_toolkit/core/common/substitutions/remove_identity.py

@@ -15,6 +15,7 @@
 
 from model_compression_toolkit.core.common.graph.base_graph import Graph, OutTensor
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
+from model_compression_toolkit.logger import Logger
 
 
 def remove_identity_node(graph: Graph,
@@ -36,7 +37,9 @@ def remove_identity_node(graph: Graph,
 
     # Ensure there is exactly one predecessor; otherwise, do nothing.
     if len(prev_identity_nodes) != 1:
-        return graph
+        # We do not expect to get here.
+        Logger.error(f"Identity node {node} have {len(prev_identity_nodes)} inputs, while expected to have one. Skipping remove identity substitution.") # pragma: no cover
+        return graph  # pragma: no cover
 
     graph_outputs = graph.get_outputs()
     for i, g_out in enumerate(graph_outputs):

model_compression_toolkit/core/keras/back2framework/keras_model_builder.py

@@ -25,9 +25,9 @@ if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers.core import TFOpLambda
     from keras.src.engine.base_layer import TensorFlowOpLayer, Layer
 else:
-    from keras import Input
-    from keras.layers.core import TFOpLambda
-    from keras.engine.base_layer import TensorFlowOpLayer, Layer
+    from keras import Input   # pragma: no cover
+    from keras.layers.core import TFOpLambda   # pragma: no cover
+    from keras.engine.base_layer import TensorFlowOpLayer, Layer   # pragma: no cover
 
 from typing import Any, Dict, List, Tuple, Callable
 from tensorflow.python.util.object_identity import Reference as TFReference

model_compression_toolkit/core/keras/back2framework/mixed_precision_model_builder.py

@@ -19,7 +19,7 @@ import tensorflow as tf
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.engine.base_layer import Layer
 else:
-    from keras.engine.base_layer import Layer
+    from keras.engine.base_layer import Layer  # pragma: no cover
 
 from keras.models import Model
 from mct_quantizers import KerasQuantizationWrapper, KerasActivationQuantizationHolder, QuantizationTarget

model_compression_toolkit/core/keras/default_framework_info.py

@@ -22,7 +22,7 @@ from packaging import version
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Conv2DTranspose, Softmax, ELU
 else:
-    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Conv2DTranspose, Softmax, ELU
+    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Conv2DTranspose, Softmax, ELU  # pragma: no cover
 
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo

model_compression_toolkit/core/keras/graph_substitutions/substitutions/activation_decomposition.py

@@ -66,7 +66,7 @@ class ActivationDecomposition(common.BaseSubstitution):
         if ACTIVATION not in op2d_node.framework_attr:
             Logger.warning(f'Op2d node {op2d_node.name} of type {op2d_node.type} is missing an "{ACTIVATION}"'
                            f' attribute -> Skipping substitution ActivationDecomposition')  # pragma: no cover
-            return graph
+            return graph  # pragma: no cover
 
         activation_node_name = op2d_node.name + '_post_activation'
 

model_compression_toolkit/core/keras/graph_substitutions/substitutions/linear_collapsing.py

@@ -104,7 +104,7 @@ def conv2d_collapsing_fn(first_node: BaseNode,
 
         return kernel_collapsed, bias_collapsed
     else:
-        Logger.critical(f"Layer collapsing unsupported for combination: {first_node.type} and {second_node.type}.")
+        Logger.critical(f"Layer collapsing unsupported for combination: {first_node.type} and {second_node.type}.")  # pragma: no cover
 
 
 def keras_linear_collapsing() -> Conv2DCollapsing:

model_compression_toolkit/core/keras/graph_substitutions/substitutions/residual_collapsing.py

@@ -62,7 +62,7 @@ def residual_collapsing_fn(first_node: BaseNode,
 
         return kernel
     else:
-        Logger.critical(f"Residual collapsing is unsupported for {first_node.type} node types.")
+        Logger.critical(f"Residual collapsing is unsupported for {first_node.type} node types.")  # pragma: no cover
 
 
 def keras_residual_collapsing() -> ResidualCollapsing:

model_compression_toolkit/core/keras/graph_substitutions/substitutions/shift_negative_activation.py

@@ -22,7 +22,7 @@ import tensorflow as tf
 from tensorflow.python.keras.layers.core import TFOpLambda
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers import Activation, Conv2D, Dense, DepthwiseConv2D, ZeroPadding2D, Reshape, \
-        GlobalAveragePooling2D, Dropout, ReLU, PReLU, ELU
+        GlobalAveragePooling2D, Dropout, ReLU, PReLU, ELU  # pragma: no cover
 else:
     from tensorflow.keras.layers import Activation, Conv2D, Dense, DepthwiseConv2D, ZeroPadding2D, Reshape, \
         GlobalAveragePooling2D, Dropout, ReLU, PReLU, ELU

model_compression_toolkit/core/keras/hessian/trace_hessian_calculator_keras.py

@@ -74,6 +74,6 @@ class TraceHessianCalculatorKeras(TraceHessianCalculator):
         concat_axis_dim = [o.shape[0] for o in _r_tensors]
         if not all(d == concat_axis_dim[0] for d in concat_axis_dim):
             Logger.critical(
-                "Unable to concatenate tensors for gradient calculation due to mismatched shapes along the first axis.")# pragma: no cover
+                "Unable to concatenate tensors for gradient calculation due to mismatched shapes along the first axis.") # pragma: no cover
 
         return tf.concat(_r_tensors, axis=1)

model_compression_toolkit/core/keras/keras_implementation.py

@@ -51,13 +51,11 @@ from model_compression_toolkit.core.keras.statistics_correction.apply_second_mom
 from packaging import version
 
 if version.parse(tf.__version__) >= version.parse("2.13"):
-    from keras.src.layers import Dense, Activation, Conv2D, DepthwiseConv2D, Conv2DTranspose, \
-        Concatenate, Add
+    from keras.src.layers import Dense, Activation, Conv2D, DepthwiseConv2D, Conv2DTranspose, Concatenate, Add
     from keras.src.layers.core import TFOpLambda
 else:
-    from keras.layers import Dense, Activation, Conv2D, DepthwiseConv2D, Conv2DTranspose, \
-        Concatenate, Add
-    from keras.layers.core import TFOpLambda
+    from keras.layers import Dense, Activation, Conv2D, DepthwiseConv2D, Conv2DTranspose, Concatenate, Add   # pragma: no cover
+    from keras.layers.core import TFOpLambda   # pragma: no cover
 
 from model_compression_toolkit.core import QuantizationConfig, FrameworkInfo, CoreConfig, MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core import common
@@ -489,7 +487,7 @@ class KerasImplementation(FrameworkImplementation):
                                                       fw_impl=self,
                                                       num_iterations_for_approximation=num_iterations_for_approximation)
         else:
-            Logger.critical(f"Unsupported Hessian mode for Keras: {trace_hessian_request.mode}.")
+            Logger.critical(f"Unsupported Hessian mode for Keras: {trace_hessian_request.mode}.")   # pragma: no cover
 
     def is_output_node_compatible_for_hessian_score_computation(self,
                                                                 node: BaseNode) -> Any:

model_compression_toolkit/core/keras/keras_node_prior_info.py

@@ -6,7 +6,7 @@ from packaging import version
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers import Activation, ReLU, BatchNormalization
 else:
-    from keras.layers import Activation, ReLU, BatchNormalization
+    from keras.layers import Activation, ReLU, BatchNormalization  # pragma: no cover
 
 from model_compression_toolkit.core import FrameworkInfo
 from model_compression_toolkit.core.common import BaseNode

model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py

@@ -24,6 +24,17 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX
 from model_compression_toolkit.core.common.quantization.quantizers.uniform_quantizers import threshold_is_power_of_two
 
+################################################################
+################################################################
+# TODO:
+#  These quantizer functions are for internal use. They are currently
+#  used in some features like MP for activation and SNC (where
+#  inference in the framework is needed).
+#  It may worth considering removing these functions and use
+#  activation inferable quantizers in those features like we do
+#  in GPTQ.
+################################################################
+################################################################
 
 def quantizer_min_max_calculator(threshold: np.ndarray,
                                  num_bits: int,

model_compression_toolkit/core/keras/reader/common.py

@@ -24,10 +24,10 @@ if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.engine.functional import Functional
     from keras.src.engine.sequential import Sequential
 else:
-    from keras.engine.input_layer import InputLayer
-    from keras.engine.node import Node as KerasNode
-    from keras.engine.functional import Functional
-    from keras.engine.sequential import Sequential
+    from keras.engine.input_layer import InputLayer # pragma: no cover
+    from keras.engine.node import Node as KerasNode # pragma: no cover
+    from keras.engine.functional import Functional # pragma: no cover
+    from keras.engine.sequential import Sequential # pragma: no cover
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.graph.base_node import BaseNode

model_compression_toolkit/core/pytorch/back2framework/instance_builder.py

@@ -38,18 +38,3 @@ def node_builder(n: BaseNode) -> Module:
     return node_instance
 
 
-# todo: remove. It is not used anymore
-def identity_wrapper(node: BaseNode,
-                     module: Module,
-                     include_activation_quantizers: bool):
-    """
-    A function which takes a computational graph node and a pytorch module and return an identity wrapping which return the layer itself
-    Args:
-        node: A node of mct graph.
-        layer: A pytorch module
-        include_activation_quantizers: bool flag.
-    Returns: pytorch module
-    """
-    return module
-
-

model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py

@@ -27,7 +27,7 @@ from model_compression_toolkit.core.common.back2framework.base_model_builder imp
 from model_compression_toolkit.core.common.graph.edge import EDGE_SINK_INDEX
 from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.user_info import UserInformation
-from model_compression_toolkit.core.pytorch.back2framework.instance_builder import node_builder, identity_wrapper
+from model_compression_toolkit.core.pytorch.back2framework.instance_builder import node_builder
 from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
 from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
 from model_compression_toolkit.core.pytorch.reader.node_holders import DummyPlaceHolder

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

@@ -101,7 +101,7 @@ def conv2d_collapsing_fn(first_node: BaseNode,
 
         return kernel_collapsed, bias_collapsed
     else:
-        Logger.critical(f"Layer collapsing is not supported for the combination of {first_node.type} and {second_node.type}.")
+        Logger.critical(f"Layer collapsing is not supported for the combination of {first_node.type} and {second_node.type}.")  # pragma: no cover
 
 
 def pytorch_linear_collapsing() -> Conv2DCollapsing:

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

@@ -58,7 +58,7 @@ def residual_collapsing_fn(first_node: BaseNode,
             kernel[i, i, idxH, idxW] += 1
         return kernel
     else:
-        Logger.critical(f"Residual collapsing not supported for node type: {first_node.type}")
+        Logger.critical(f"Residual collapsing not supported for node type: {first_node.type}")  # pragma: no cover
 
 
 def pytorch_residual_collapsing() -> ResidualCollapsing:

model_compression_toolkit/core/pytorch/hessian/trace_hessian_calculator_pytorch.py

@@ -65,6 +65,6 @@ class TraceHessianCalculatorPytorch(TraceHessianCalculator):
         concat_axis_dim = [o.shape[0] for o in _r_tensors]
         if not all(d == concat_axis_dim[0] for d in concat_axis_dim):
             Logger.critical(
-                "Unable to concatenate tensors for gradient calculation due to mismatched shapes along the first axis.")
+                "Unable to concatenate tensors for gradient calculation due to mismatched shapes along the first axis.")  # pragma: no cover
 
         return torch.concat(_r_tensors, dim=1)

model_compression_toolkit/core/pytorch/pytorch_device_config.py

@@ -87,13 +87,16 @@ class DeviceManager:
                 device_index = int(device_name.split(':')[1])
                 if device_index >= torch.cuda.device_count():
                     return False, f"CUDA device index {device_index} out of range. Number of valid devices: {torch.cuda.device_count()}"
-            except IndexError:
+            except Exception:
                 # Handle cases where the device name is incorrectly formatted
                 return False, "Invalid CUDA device format. Use 'cuda' or 'cuda:x' where x is the device index."
 
             return True, "Valid device"
 
-        return True, "Valid device"
+        if CPU in device_name:
+            return True, "Valid device"
+
+        return False, "Invalid device"
 
 
 

model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py

@@ -20,6 +20,18 @@ from model_compression_toolkit.core.common.quantization.quantizers.uniform_quant
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import fix_range_to_include_zero
 
 
+################################################################
+################################################################
+# TODO:
+#  These quantizer functions are for internal use. They are currently
+#  used in some features like MP for activation and SNC (where
+#  inference in the framework is needed).
+#  It may worth considering removing these functions and use
+#  activation inferable quantizers in those features like we do
+#  in GPTQ.
+################################################################
+################################################################
+
 def get_symmetric_quantization_range_and_scale(activation_is_signed: bool,
                                                activation_n_bits: int,
                                                activation_threshold: float):

model_compression_toolkit/core/runner.py

@@ -20,6 +20,8 @@ import numpy as np
 
 from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common.hessian.hessian_info_service import HessianInfoService
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_data import \
+    requires_mixed_precision
 from model_compression_toolkit.core.graph_prep_runner import graph_preparation_runner
 from model_compression_toolkit.core.quantization_prep_runner import quantization_preparation_runner
 from model_compression_toolkit.logger import Logger
@@ -89,7 +91,16 @@ def core_runner(in_model: Any,
         if core_config.mixed_precision_config is None:
             Logger.critical("Provided an initialized target_resource_utilization, that means that mixed precision quantization is "
                             "enabled, but the provided MixedPrecisionQuantizationConfig is None.")
-        core_config.mixed_precision_config.set_mixed_precision_enable()
+        # Determine whether to use mixed precision or single precision based on target_resource_utilization.
+        if requires_mixed_precision(in_model,
+                                    target_resource_utilization,
+                                    representative_data_gen,
+                                    core_config,
+                                    tpc,
+                                    fw_info,
+                                    fw_impl):
+            core_config.mixed_precision_config.set_mixed_precision_enable()
+            Logger.info('Mixed precision enabled.')
 
     graph = graph_preparation_runner(in_model,
                                      representative_data_gen,

model_compression_toolkit/data_generation/common/model_info_exctractors.py

@@ -35,8 +35,7 @@ class OriginalBNStatsHolder:
         """
         self.bn_params = self.get_bn_params(model, bn_layer_types)
         if self.get_num_bn_layers() == 0:
-            Logger.critical(
-                f'Data generation requires a model with at least one BatchNorm layer.')
+            Logger.critical(f'Data generation requires a model with at least one BatchNorm layer.')
 
     def get_bn_layer_names(self) -> List[str]:
         """
@@ -105,7 +104,7 @@ class OriginalBNStatsHolder:
         Returns:
             dict: Dictionary mapping batch normalization layer names to their parameters.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
 
 class ActivationExtractor:
@@ -123,7 +122,7 @@ class ActivationExtractor:
             model (Any): The model.
             layer_types_to_extract_inputs (List): Tuple or list of layer types.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def get_layer_input_activation(self, layer_name: str) -> Any:
@@ -136,7 +135,7 @@ class ActivationExtractor:
         Returns:
             Any: Input activation tensor of the layer.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def get_output_layer_input_activation(self) -> List:
@@ -146,7 +145,7 @@ class ActivationExtractor:
         Returns:
             Any: Input activation tensors of all the output layers that are Linear or Conv2d.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def get_last_linear_layers_weights(self) -> List:
@@ -156,7 +155,7 @@ class ActivationExtractor:
         Returns:
             List: Weight tensors of all the last linear layers.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     def get_num_extractor_layers(self) -> int:
         """
@@ -175,21 +174,21 @@ class ActivationExtractor:
         Returns:
             List: A list of layer names for which to extract input activations.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def clear(self):
         """
         Clear the stored activation tensors.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def remove(self):
         """
         Remove the hooks from the model.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover
 
     @abstractmethod
     def run_model(self, inputs: Any) -> Any:
@@ -202,4 +201,4 @@ class ActivationExtractor:
         Returns:
             Any: Output tensor.
         """
-        raise NotImplemented
+        raise NotImplemented # pragma: no cover

model_compression_toolkit/data_generation/common/optimization_utils.py

@@ -159,7 +159,7 @@ class ImagesOptimizationHandler:
         Returns:
             Tuple[Any, Any]: the averaged activation statistics on all the batches for the specified layer.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def compute_bn_loss(self,
                         input_imgs: Any,
@@ -245,7 +245,7 @@ class ImagesOptimizationHandler:
             loss (Any): The loss value.
             i_ter (int): The current iteration.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     @abstractmethod
     def zero_grad(self, batch_index: int):
@@ -255,7 +255,7 @@ class ImagesOptimizationHandler:
         Args:
             batch_index (int): Index of the batch.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     @abstractmethod
     def get_finalized_images(self) -> list:
@@ -265,7 +265,7 @@ class ImagesOptimizationHandler:
         Returns:
             list: a list of the generated images.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
 
 class BatchOptimizationHolder:
@@ -291,7 +291,7 @@ class BatchOptimizationHolder:
             scheduler (Any): scheduler responsible for adjusting the learning rate of the optimizer over time.
             initial_lr (float): the initial learning rate used by the optimizer.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def get_images(self) -> Any:
         """Returns the stored images"""
@@ -344,7 +344,7 @@ class AllImagesStatsHolder:
         Returns:
             list: List of batches stats holders.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def update_batch_stats(self,
                            batch_index: int,
@@ -442,7 +442,7 @@ class BatchStatsHolder:
         Returns:
             Any: the variance for the specified layer.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def get_std(self, bn_layer_name: str) -> Any:
         """
@@ -454,7 +454,7 @@ class BatchStatsHolder:
         Returns:
             Any: the variance for the specified layer.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def update_layer_stats(self,
                            bn_layer_name: str,
@@ -483,7 +483,7 @@ class BatchStatsHolder:
             activation_extractor (ActivationExtractor): the activation extractor object.
             to_differentiate (bool): a flag indicating whether to differentiate or not.
         """
-        raise NotImplemented
+        raise NotImplemented   # pragma: no cover
 
     def clear(self):
         """Clear the statistics."""

model_compression_toolkit/gptq/common/gptq_training.py

@@ -76,7 +76,7 @@ class GPTQTrainer(ABC):
         if self.gptq_config.use_hessian_based_weights:
             if not isinstance(hessian_info_service, HessianInfoService):
                 Logger.critical(f"When using Hessian-based approximations for sensitivity evaluation, "
-                                f"an 'HessianInfoService' object must be provided, but received: {hessian_info_service}.")
+                                f"an 'HessianInfoService' object must be provided, but received: {hessian_info_service}.")   # pragma: no cover
             self.hessian_service = hessian_info_service
 
     def get_optimizer_with_param(self,
@@ -238,47 +238,12 @@ class GPTQTrainer(ABC):
             trace_approx: Trace approximation to validate.
         """
         if not isinstance(trace_approx, list):
-            Logger.critical(f"Trace approximation was expected to be a list but is of type: {type(trace_approx)}.")
+            Logger.critical(f"Trace approximation was expected to be a list but is of type: {type(trace_approx)}.")   # pragma: no cover
         if len(trace_approx) != 1:
             Logger.critical(f"Trace approximation was expected to have a length of 1 "
                             f"(for computations with granularity set to 'HessianInfoGranularity.PER_TENSOR') "
                             f"but has a length of {len(trace_approx)}."
-            )
-
-    @staticmethod
-    def _generate_images_batch(representative_data_gen: Callable, num_samples_for_loss: int) -> np.ndarray:
-        """
-        Construct batches of image samples for inference.
-
-        Args:
-            representative_data_gen: A callable method to retrieve images from Dataset.
-            num_samples_for_loss: Num of total images for evaluation.
-
-        Returns: A tensor of images batches
-        """
-        # First, select images to use for all measurements.
-        samples_count = 0  # Number of images we used so far to compute the distance matrix.
-        images = []
-        for inference_batch_input in representative_data_gen():
-            if samples_count >= num_samples_for_loss:
-                break
-            num_images = inference_batch_input[0].shape[0]
-
-            # If we sampled more images than we should,
-            # we take only a subset of these images and use only them.
-            if num_images > num_samples_for_loss - samples_count:
-                inference_batch_input = [x[:num_samples_for_loss - samples_count] for x in inference_batch_input]
-                assert num_samples_for_loss - samples_count == inference_batch_input[0].shape[0]
-                num_images = num_samples_for_loss - samples_count
-
-            images.append(inference_batch_input[0])
-            samples_count += num_images
-        else:
-            if samples_count < num_samples_for_loss:
-                Logger.warning(f'Not enough images in representative dataset to generate {num_samples_for_loss} data points, '
-                               f'only {samples_count} were generated')
-
-        return np.concatenate(images, axis=0)
+            )   # pragma: no cover
 
 
     @abstractmethod

model_compression_toolkit/trainable_infrastructure/keras/base_keras_quantizer.py

@@ -82,9 +82,6 @@ if FOUND_TF:
 
 else:
     class BaseKerasTrainableQuantizer(BaseTrainableQuantizer):
-        def __init__(self,
-                     quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):
-
-            super().__init__(quantization_config)
+        def __init__(self, *args, **kwargs):
             Logger.critical("Tensorflow must be installed to use BaseKerasTrainableQuantizer. "
                             "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/trainable_infrastructure/pytorch/base_pytorch_quantizer.py

@@ -57,9 +57,7 @@ if FOUND_TORCH:
 
 else:
     class BasePytorchTrainableQuantizer(BaseTrainableQuantizer):
-        def __init__(self,
-                     quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):
-            super().__init__(quantization_config)
+        def __init__(self, *args, **kwargs):
             Logger.critical("PyTorch must be installed to use 'BasePytorchTrainableQuantizer'. "
                             "The 'torch' package is missing.")  # pragma: no cover