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

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

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

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

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=sHb21l7q6uqdrtwQFDGXqUI66hhGFmew2OkJQTS7eZc,1573
+model_compression_toolkit/__init__.py,sha256=-L1xPY1BvoKlBh8WD3EKn_XFs0oLG-nuiSLnyOVxbfU,1573
 model_compression_toolkit/constants.py,sha256=9pVleMwnhlM4QwIL2HcEq42I1uF4rlSw63RUjkxOF4w,3923
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -7,10 +7,10 @@ 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=K9eJ7VbB_rpeyxX4yEnorOmSxFW3DkvofzxS6QI8Hp8,6454
-model_compression_toolkit/core/runner.py,sha256=4TtOgyNb4cXr52dOlDqYxLm3rnLR6uHPDNoZiEFL9XA,12655
+model_compression_toolkit/core/runner.py,sha256=JvX0Ht164BOKIsPPxp6z-Nlk1Vlhlg7wKBl6lc2yIaQ,12675
 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=zg2Sznd-uqpN8hy9C22jah_27qPYXNajYx3xMR3AlMw,20938
+model_compression_toolkit/core/common/framework_implementation.py,sha256=kSg2f7wS7e2EyvX6y0eKfNTTFvVFVrB8lvldJvcPvN8,20724
 model_compression_toolkit/core/common/framework_info.py,sha256=1ZMMGS9ip-kSflqkartyNRt9aQ5ub1WepuTRcTy-YSQ,6337
 model_compression_toolkit/core/common/memory_computation.py,sha256=ixoSpV5ZYZGyzhre3kQcvR2sNA8KBsPZ3lgbkDnw9Cs,1205
 model_compression_toolkit/core/common/model_builder_mode.py,sha256=jll9-59OPaE3ug7Y9-lLyV99_FoNHxkGZMgcm0Vkpss,1324
@@ -30,8 +30,8 @@ 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=lmIw0srKiwCvz7KWqfwKTxyQHDy3s6rWMIXzFAa1UMo,38326
-model_compression_toolkit/core/common/graph/base_node.py,sha256=Hqv5lsEYT2uz5FYAX44Rsps_Ax73_kVoXy_DNaXIddU,29448
+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/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
@@ -64,7 +64,7 @@ model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha2
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=rppRZJdSCQGiZsd93QxoUIhj51eETvQbuI5JiC2TUeA,4963
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=pk8HRoShDhiUprBC4m1AFQv1SacS4hOrj0MRdbq-5gY,7556
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=TTTux4YiOnQqt-2h7Y38959XaDwNZc0eufLMx_yws5U,37578
-model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=PNGWP0bPkQNP1jCORP6FQgGIr616Kg1YSe_hy-BDg0I,27546
+model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=QdxFQ0JxsrcSfk5LlUU_3oZpEK7bYwKelGzEHh0mnJY,27558
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=P8QtKgFXtt5b2RoubzI5OGlCfbEfZsAirjyrkFzK26A,2846
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=KifDMbm7qkSfvSl6pcZzQ82naIXzeKL6aT-VsvWZYyc,7901
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
@@ -97,11 +97,11 @@ model_compression_toolkit/core/common/pruning/mask/__init__.py,sha256=huHoBUcKNB
 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/candidate_node_quantization_config.py,sha256=yU-Cr6S4wOSkDk57iH2NVe-WII0whOhLryejkomCOt4,4940
 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=u0JkdRqBXG0RvvYyLyvYknEVtB2-gxpqUJnUw3loLmE,26851
+model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=QivClAel7O9k1RkM25Kp_bhB7otq0ZKlxDAF0nQIT6Q,26351
 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
@@ -116,12 +116,12 @@ model_compression_toolkit/core/common/quantization/quantization_params_generatio
 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/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_weights_computation.py,sha256=zSNda0jN8cP41m6g5TOv5WvATwIhV8z6AVM1Es6rq1s,4419
+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/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=CCFhi5LUIcHCCIzDyORvm0FDZLknrctdNwNlPphOQgI,14245
+model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py,sha256=iEoWUPFQMcvZXHtLMe2_7L7IK25XcKiY6-d1_gArZs0,11880
 model_compression_toolkit/core/common/quantization/quantizers/uniform_quantizers.py,sha256=wXExWHf5-0He7L4bpvFpKlx7FG4u3DAfNZiXPpOs_SQ,5521
 model_compression_toolkit/core/common/statistics_correction/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/statistics_correction/apply_bias_correction_to_graph.py,sha256=xSWVDOODgbN0k4mjJWWtpawilOsqdm4O7Uw2hbA75EA,4669
@@ -150,13 +150,13 @@ model_compression_toolkit/core/keras/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7V
 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=HcHplb7IcnOTyK2p6uhp3OVG4-RV3RDo9C_4evaIzkQ,4981
-model_compression_toolkit/core/keras/keras_implementation.py,sha256=qrmFzs749gVCEanw-paEsbM50zECtMV8qDMxKFTmyj0,29906
+model_compression_toolkit/core/keras/keras_implementation.py,sha256=hzNC6wz1gtL2EqmRCMCQYl8AqIDJPu6rdOX6nvPgjCM,30193
 model_compression_toolkit/core/keras/keras_model_validation.py,sha256=1wNV2clFdC9BzIELRLSO2uKf0xqjLqlkTJudwtCeaJk,1722
 model_compression_toolkit/core/keras/keras_node_prior_info.py,sha256=HUmzEXDQ8LGX7uOYSRiLZ2TNbYxLX9J9IeAa6QYlifg,3927
 model_compression_toolkit/core/keras/resource_utilization_data_facade.py,sha256=Xmk2ZL5CaYdb7iG62HdtZ1F64vap7ffnrsuR3e3G5hc,4851
-model_compression_toolkit/core/keras/tf_tensor_numpy.py,sha256=moMFP7hOagAbd09bWa2AX5uxN7XOJqLB-mV3mA30kLQ,2651
+model_compression_toolkit/core/keras/tf_tensor_numpy.py,sha256=AJMPD_cAwf7nzTlLMf_Y1kofXkh_xm8Ji7J6yDpbAKc,2691
 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/factory_model_builder.py,sha256=UIQgOOdexycrSKombTMJVvTthR7MlrCihoqM8Kg-rnE,2293
 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=XFSSaET4oPWB_cx-Q_c9pDJfWyQ1qXT9JXBl5FJCTa4,18137
@@ -213,12 +213,12 @@ model_compression_toolkit/core/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKW
 model_compression_toolkit/core/pytorch/constants.py,sha256=YwD_joIF0vK8UG2vW1NVvg36pCNWA0vHOXjAgy_XWn0,2794
 model_compression_toolkit/core/pytorch/default_framework_info.py,sha256=r1XyzUFvrjGcJHQM5ETLsMZIG2yHCr9HMjqf0ti9inw,4175
 model_compression_toolkit/core/pytorch/pytorch_device_config.py,sha256=S25cuw10AW3SEN_fRAGRcG_I3wdvvQx1ehSJzPnn-UI,4404
-model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=XL_RZcfnb_ZY2jdCjOxxz7SbRBzMokbOWsTuYOSjyRU,27569
+model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=xmcJyU-rkIDX1a_X9LILzf2Ko2z_4I4xnlHkezKH-2w,27669
 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
 model_compression_toolkit/core/pytorch/utils.py,sha256=GE7T8q93I5C4As0iOias_dk9HpOvXM1N6---dJlyD60,3863
 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/factory_model_builder.py,sha256=bwppTPRs6gL96nm7qPiKrNcBj4Krr0yEsOWjRF0aXmQ,2339
 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=BBHBfTqeWm7L3iDyPBpk0jxvj-rBg1QWI23imkjfIl0,1467
 model_compression_toolkit/core/pytorch/back2framework/mixed_precision_model_builder.py,sha256=D7lU1r9Uq_7fdNuKk2BMF8ho5GrsY-8gyGN6yYoHaVg,15060
@@ -262,7 +262,7 @@ model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py,sha256=D8
 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=ESL8k7RLZogTyG_oTTFDmm4RauZvx2gU-UvnOnEsH6Q,15948
-model_compression_toolkit/core/pytorch/reader/node_holders.py,sha256=TaolORuwBZEddWe-q0Mg79Nmswz-Sq3-9-4o8UxFQ50,1028
+model_compression_toolkit/core/pytorch/reader/node_holders.py,sha256=7XNc7-l1MZPJGcOESvtAwfIMxrU6kvt3YjF5B7qOqK4,1048
 model_compression_toolkit/core/pytorch/reader/reader.py,sha256=GEJE0QX8XJFWbYCkbRBtzttZtmmuoACLx8gw9KyAQCE,6015
 model_compression_toolkit/core/pytorch/statistics_correction/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/statistics_correction/apply_second_moment_correction.py,sha256=VgU24J3jf7QComHH7jonOXSkg6mO4TOch3uFkOthZvM,3261
@@ -326,7 +326,7 @@ model_compression_toolkit/exporter/model_wrapper/__init__.py,sha256=7CF2zvpTrIEm
 model_compression_toolkit/exporter/model_wrapper/fw_agnostic/__init__.py,sha256=pKAdbTCFM_2BrZXUtTIw0ouKotrWwUDF_hP3rPwCM2k,696
 model_compression_toolkit/exporter/model_wrapper/fw_agnostic/get_inferable_quantizers.py,sha256=Bd3QhAR__YC9Xmobd5qHv9ofh_rPn_eTFV0sXizcBnY,2297
 model_compression_toolkit/exporter/model_wrapper/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py,sha256=YffgbVYJG5LKeIsW84Pi7NqzQcvJMeQRnAKQCCmIL6c,3776
+model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py,sha256=llQJ8yY4buSMNue_UnEhGhT5lHpXU7iMqWwCrUt6L08,3816
 model_compression_toolkit/exporter/model_wrapper/keras/builder/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/exporter/model_wrapper/keras/builder/fully_quantized_model_builder.py,sha256=T2wgd7b86cpA5Ffq5eVCb8YlmnJ7vDxtmFeRkZtpLZc,5422
 model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py,sha256=uL6tJWC4s2IWUy8GJVwtMWpwZZioRRztfKyPJHo14xI,9442
@@ -342,7 +342,7 @@ model_compression_toolkit/gptq/common/gptq_config.py,sha256=U-NiVEedkOsVaFq-iXU2
 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=nI_XVa7WbfCcbgHMFgnPtnD77m5ezAB306z7VE0XFvU,16527
+model_compression_toolkit/gptq/common/gptq_training.py,sha256=CtSpjG27BQ3rLPGWeBnZYYiGnMREpdBd6dx7SQf_wDk,14965
 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
@@ -394,7 +394,7 @@ model_compression_toolkit/qat/common/qat_config.py,sha256=zoq0Vb74vCY7WlWD8JH_KP
 model_compression_toolkit/qat/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/qat/keras/quantization_facade.py,sha256=AXwY6p1XFjPUzal_r_c1_su5Ji3ARtVTZYYWpDPZ09k,17026
 model_compression_toolkit/qat/keras/quantizer/__init__.py,sha256=zmYyCa25_KLCSUCGUDRslh3RCIjcRMxc_oXa54Aui-4,996
-model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py,sha256=TIFdLEeUUTH-ZKoqfbqmL8rq2iuFCwb8CZ61rIJDOIM,2065
+model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py,sha256=0CB5M68zjPXv4yJZ-DzaYP9yYYWX_8J2gJLunxupOAM,2085
 model_compression_toolkit/qat/keras/quantizer/quant_utils.py,sha256=cBULOgWUodcBO1lHevZggdTevuDYI6tQceV86U2x6DA,2543
 model_compression_toolkit/qat/keras/quantizer/quantization_builder.py,sha256=HD0JIOiqnrpqj5qk6RyzuCsSGZsDUVohdCYSePmJBNQ,5872
 model_compression_toolkit/qat/keras/quantizer/lsq/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
@@ -406,7 +406,7 @@ model_compression_toolkit/qat/keras/quantizer/ste_rounding/uniform_ste.py,sha256
 model_compression_toolkit/qat/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=pRy2B5OsaLi33p4hozjr0rzAooT8Gic3_qxTl66J900,13375
 model_compression_toolkit/qat/pytorch/quantizer/__init__.py,sha256=xYa4C8pr9cG1f3mQQcBXO_u3IdJN-zl7leZxuXDs86w,1003
-model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_quantizer.py,sha256=soxP4moJxQaziq5ccP3Du34fSIVSFyZq6hD8YuaDn88,2187
+model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_quantizer.py,sha256=2I_WcINn63lpT3mN_skXNL4Rfbm955_wzhYHaiwH2q4,2207
 model_compression_toolkit/qat/pytorch/quantizer/quantization_builder.py,sha256=sFWGu76PZ9dSRf3L0uZI6YwLIs0biBND1tl76I1piBQ,5721
 model_compression_toolkit/qat/pytorch/quantizer/quantizer_utils.py,sha256=nO7IrDRo5b9Asf21WJacE4vf5voD3UzF_oGjBoGusD4,5335
 model_compression_toolkit/qat/pytorch/quantizer/lsq/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
@@ -421,9 +421,9 @@ 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=tpy19ZwFCqPWCFtTc76K_kv2dEzFqojdsnWhYxjdDUA,15015
+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/operators.py,sha256=rRmrmPBY4rxCWVpEc6FxeOPUFh8MkfwgQsqD82U9a7w,3108
-model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py,sha256=55EQyP4McJBwsw9_l9eseEZ-V2ygQfdRXjjJLF6HdIM,9482
+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
 model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/__init__.py,sha256=WCP1wfFZgM4eFm-pPeUinr5R_aSx5qwfSQqLZCXUNBA,1513
 model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attribute_filter.py,sha256=jfhszvuD2Fyy6W2KjlLzXBQKFzTqGAaDZeFVr4-ONQw,8776
@@ -521,8 +521,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.20240730.436.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.1.0.20240730.436.dist-info/METADATA,sha256=A8w_lgs16pLb6T44oV5i9FLLn3UDt0dn5wS3jB0B6sI,19719
-mct_nightly-2.1.0.20240730.436.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mct_nightly-2.1.0.20240730.436.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.1.0.20240730.436.dist-info/RECORD,,
+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,,

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.20240730.000436"
+__version__ = "2.1.0.20240801.000515"

model_compression_toolkit/core/common/framework_implementation.py

@@ -348,24 +348,20 @@ class FrameworkImplementation(ABC):
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
                              f'framework\'s count_node_for_mixed_precision_interest_points method.')  # pragma: no cover
 
-    def get_mp_node_distance_fn(self, layer_class: type,
-                             framework_attrs: Dict[str, Any],
-                             compute_distance_fn: Callable = None,
-                             axis: int = None,
-                             norm_mse: bool = False) -> Callable:
+    def get_mp_node_distance_fn(self, n: BaseNode,
+                                compute_distance_fn: Callable = None,
+                                norm_mse: bool = False) -> Tuple[Callable, int]:
         """
         A mapping between layers' types and a distance function for computing the distance between
         two tensors in mixed precision (for loss computation purposes). Returns a specific function if node of specific types is
         given, or a default (normalized MSE) function otherwise.
 
         Args:
-            layer_class: Class path of a model's layer.
-            framework_attrs: Framework attributes the layer had which the graph node holds.
+            n: Node to choose distance function for.
             compute_distance_fn: An optional distance function to use globally for all nodes.
-            axis: The axis on which the operation is preformed (if specified).
             norm_mse: whether to normalize mse distance function.
 
-        Returns: A distance function between two tensors.
+        Returns: A distance function between two tensors and a axis on which the distance is computed (if exists).
         """
 
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '

model_compression_toolkit/core/common/graph/base_graph.py

@@ -440,7 +440,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         output_nodes = [ot.node for ot in self.get_outputs()]  # get output nodes from namedtuples
         if node_to_remove in output_nodes:  # If node is in the graph's outputs, the outputs should be updated
-            if new_graph_outputs is None:
+            if new_graph_outputs is None:  # pragma: no cover
                 Logger.critical(
                     f"{node_to_remove.name} is among the graph outputs; however, it cannot be removed without providing a new output.")  # pragma: no cover
             self.set_outputs(new_graph_outputs)
@@ -506,28 +506,6 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             output_edges.sort(key=lambda e: getattr(e, sort_by_attr))
         return output_edges
 
-    def get_memory(self) -> float:
-        """
-
-        Returns: Total memory consumption of the graph in bytes.
-
-        """
-        memory = 0
-        for n in self.nodes:
-            memory += n.get_memory_bytes(self.fw_info)
-        return memory
-
-    def get_float_memory(self) -> float:
-        """
-
-        Returns: Total memory consumption of the float graph in bytes.
-
-        """
-        memory = 0
-        for n in self.nodes:
-            memory += n.get_float_memory_bytes(self.fw_info)
-        return memory
-
     def get_configurable_sorted_nodes_names(self,
                                             fw_info: FrameworkInfo,
                                             include_reused_nodes: bool = False) -> List[str]:

model_compression_toolkit/core/common/graph/base_node.py

@@ -297,18 +297,6 @@ class BaseNode:
 
         return memory
 
-    def get_float_memory_bytes(self, fw_info) -> float:
-        """
-        Compute the number of bytes the node's memory requires.
-
-        Args:
-            fw_info: Framework info to decide which attributes should be quantized.
-
-        Returns: Number of bytes the node's memory requires when in floating point (32 bit).
-
-        """
-        q_params, f_params = self.get_num_parameters(fw_info)
-        return (f_params + q_params) * FP32_BYTES_PER_PARAMETER
 
     def get_unified_weights_candidates_dict(self, fw_info) -> Dict[str, Any]:
         """
@@ -436,20 +424,6 @@ class BaseNode:
 
         return sum([np.prod([x for x in output_shape if x is not None]) for output_shape in output_shapes])
 
-    def get_total_input_params(self) -> float:
-        """
-        Calculates the total parameters in the node's input tensors.
-
-        Returns: Input size (i.e., total number of parameters).
-        """
-
-        input_shapes = self.input_shape if isinstance(self.input_shape, List) else [self.input_shape]
-
-        # remove batch size (first element) from input shape
-        input_shapes = [s[1:] for s in input_shapes]
-
-        return sum([np.prod([x for x in input_shape if x is not None]) for input_shape in input_shapes])
-
     def find_min_candidates_indices(self) -> List[int]:
         """
         Returns a list with potential minimal candidates.
@@ -644,10 +618,10 @@ class BaseNode:
         if len(simd_list) > 1:
             Logger.warning(f"More than one pruning SIMD option is available."
                            f" Min SIMD is used: {min(simd_list)}")
-        if len(simd_list) == 0:
+        if len(simd_list) == 0:  # pragma: no cover
             Logger.critical(f"No SIMD option is available for {self}")
         _simd = min(simd_list)
-        if _simd <= 0 or int(_simd) != _simd:
+        if _simd <= 0 or int(_simd) != _simd:  # pragma: no cover
             Logger.critical(f"SIMD is expected to be a non-positive integer but found: {_simd}")
         return _simd
 

model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py

@@ -77,7 +77,8 @@ class SensitivityEvaluation:
         self.disable_activation_for_metric = disable_activation_for_metric
         if self.quant_config.use_hessian_based_scores:
             if not isinstance(hessian_info_service, HessianInfoService):
-                Logger.critical(f"When using Hessian-based approximations for sensitivity evaluation, a valid HessianInfoService object is required; found {type(hessian_info_service)}.")
+                Logger.critical(
+                    f"When using Hessian-based approximations for sensitivity evaluation, a valid HessianInfoService object is required; found {type(hessian_info_service)}.")
             self.hessian_info_service = hessian_info_service
 
         self.sorted_configurable_nodes_names = graph.get_configurable_sorted_nodes_names(self.fw_info)
@@ -94,7 +95,8 @@ class SensitivityEvaluation:
         self.ips_distance_fns, self.ips_axis = self._init_metric_points_lists(self.interest_points, use_normalized_mse)
 
         self.output_points = get_output_nodes_for_metric(graph)
-        self.out_ps_distance_fns, self.out_ps_axis = self._init_metric_points_lists(self.output_points, use_normalized_mse)
+        self.out_ps_distance_fns, self.out_ps_axis = self._init_metric_points_lists(self.output_points,
+                                                                                    use_normalized_mse)
 
         # Setting lists with relative position of the interest points
         # and output points in the list of all mp model activation tensors
@@ -130,7 +132,8 @@ class SensitivityEvaluation:
             self.interest_points_hessians = self._compute_hessian_based_scores()
             self.quant_config.distance_weighting_method = lambda d: self.interest_points_hessians
 
-    def _init_metric_points_lists(self, points: List[BaseNode], norm_mse: bool = False) -> Tuple[List[Callable], List[int]]:
+    def _init_metric_points_lists(self, points: List[BaseNode], norm_mse: bool = False) -> Tuple[
+        List[Callable], List[int]]:
         """
         Initiates required lists for future use when computing the sensitivity metric.
         Each point on which the metric is computed uses a dedicated distance function based on its type.
@@ -146,16 +149,12 @@ class SensitivityEvaluation:
         distance_fns_list = []
         axis_list = []
         for n in points:
-            axis = n.framework_attr.get(AXIS) if not isinstance(n, FunctionalNode) else n.op_call_kwargs.get(AXIS)
-            distance_fn = self.fw_impl.get_mp_node_distance_fn(
-                layer_class=n.layer_class,
-                framework_attrs=n.framework_attr,
-                compute_distance_fn=self.quant_config.compute_distance_fn,
-                axis=axis,
-                norm_mse=norm_mse)
+            distance_fn, axis = self.fw_impl.get_mp_node_distance_fn(n,
+                                                                     compute_distance_fn=self.quant_config.compute_distance_fn,
+                                                                     norm_mse=norm_mse)
             distance_fns_list.append(distance_fn)
             # Axis is needed only for KL Divergence calculation, otherwise we use per-tensor computation
-            axis_list.append(axis if distance_fn==compute_kl_divergence else None)
+            axis_list.append(axis if distance_fn == compute_kl_divergence else None)
         return distance_fns_list, axis_list
 
     def compute_metric(self,
@@ -300,7 +299,8 @@ class SensitivityEvaluation:
         node_name = sorted_configurable_nodes_names[node_idx_to_configure]
         layers_to_config = self.conf_node2layers.get(node_name, None)
         if layers_to_config is None:
-            Logger.critical(f"Matching layers for node {node_name} not found in the mixed precision model configuration.")  # pragma: no cover
+            Logger.critical(
+                f"Matching layers for node {node_name} not found in the mixed precision model configuration.")  # pragma: no cover
 
         for current_layer in layers_to_config:
             self.set_layer_to_bitwidth(current_layer, mp_model_configuration[node_idx_to_configure])

model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py

@@ -58,7 +58,7 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
         if activation_quantization_cfg is not None:
             self.activation_quantization_cfg = activation_quantization_cfg
         else:
-            if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):
+            if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):  # pragma: no cover
                 Logger.critical(
                     "Missing required arguments to initialize a node activation quantization configuration. "
                     "Ensure QuantizationConfig, OpQuantizationConfig, activation quantization function, "
@@ -72,7 +72,7 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
         if weights_quantization_cfg is not None:
             self.weights_quantization_cfg = weights_quantization_cfg
         else:
-            if any(v is None for v in (qc, op_cfg, node_attrs_list)):
+            if any(v is None for v in (qc, op_cfg, node_attrs_list)):  # pragma: no cover
                 Logger.critical("Missing required arguments to initialize a node weights quantization configuration. "
                                 "Ensure QuantizationConfig, OpQuantizationConfig, weights quantization function, "
                                 "parameters function, and weights attribute quantization config are provided.")

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -178,20 +178,6 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         for param_name, param_value in activation_params.items():
             self.activation_quantization_params[param_name] = param_value
 
-    def has_activation_quantization_params(self) -> bool:
-        """
-
-        Returns: Whether NodeQuantizationConfig has a activation quantization params or not.
-
-        """
-        return len(self.activation_quantization_params) > 0
-
-    def no_quantization(self) -> bool:
-        """
-        Returns: Whether NodeQuantizationConfig does not have activation params.
-        """
-        return (not self.has_activation_quantization_params())
-
     def __eq__(self, other: Any) -> bool:
         """
         Compares the object to another object to find if they are equal.
@@ -203,7 +189,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
 
         """
         if not isinstance(other, NodeActivationQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.activation_quantization_fn == other.activation_quantization_fn and \
                self.activation_quantization_params_fn == other.activation_quantization_params_fn and \
@@ -340,14 +326,6 @@ class WeightsAttrQuantizationConfig:
         else:
             self.set_weights_quantization_param({})
 
-    def has_weights_quantization_params(self) -> bool:
-        """
-
-        Returns: Whether NodeQuantizationConfig has weights quantization params or not.
-
-        """
-        return len(self.weights_quantization_params) > 0
-
     def __eq__(self, other: Any) -> bool:
         """
         Compares the object to another object to find if they are equal.
@@ -359,7 +337,7 @@ class WeightsAttrQuantizationConfig:
 
         """
         if not isinstance(other, WeightsAttrQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.weights_quantization_fn == other.weights_quantization_fn and \
                self.weights_quantization_params_fn == other.weights_quantization_params_fn and \
@@ -419,11 +397,11 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # In Tensorflow, the attribute name is composed of the framework attribute name and the layer name,
                 # therefore, we need to look for the attribute in the op_cfg that is contained in the node attribute's name.
                 attrs_included_in_name = {k: v for k, v in op_cfg.attr_weights_configs_mapping.items() if k in attr}
-                if len(attrs_included_in_name) > 1:
-                    Logger.error(f"Found multiple attribute in TPC OpConfig that are contained "
-                                 f"in the attribute name '{attr}'."
-                                 f"Please fix the TPC attribute names mapping such that each operator's attribute would "
-                                 f"have a unique matching name.")
+                if len(attrs_included_in_name) > 1:  # pragma: no cover
+                    Logger.critical(f"Found multiple attribute in TPC OpConfig that are contained "
+                                    f"in the attribute name '{attr}'."
+                                    f"Please fix the TPC attribute names mapping such that each operator's attribute would "
+                                    f"have a unique matching name.")
                 if len(attrs_included_in_name) == 0:
                     attr_cfg = op_cfg.default_weight_attr_config
                 else:
@@ -446,8 +424,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
         Returns: An attribute quantization configuration.
 
         """
-        if attr_name is None:
-            Logger.error("Got 'None' attribute name for retrieving weights attribute quantization configuration.")
+        if attr_name is None:  # pragma: no cover
+            Logger.critical("Got 'None' attribute name for retrieving weights attribute quantization configuration.")
 
         if isinstance(attr_name, int):
             # this is a positional attribute
@@ -463,8 +441,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # If no attribute with the exact name then an error would be thrown
                 attr_cfg = self.attributes_config_mapping.get(attr_name)
 
-        if attr_cfg is None:
-            Logger.error(f"Weight attribute '{attr_name}' config could not be found.")
+        if attr_cfg is None:  # pragma: no cover
+            Logger.critical(f"Weight attribute '{attr_name}' config could not be found.")
 
         return attr_cfg
 
@@ -519,8 +497,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                            f"{list(attrs_with_name.keys())}.")
         return attrs_with_name
 
-    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any, attr_name: str = None,
-                              *args: List[Any], **kwargs: Dict[str, Any]):
+    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any,
+                              attr_name: Union[str, int] = None, *args: List[Any], **kwargs: Dict[str, Any]):
         """
         This method overrides the parent class set_quant_config_attr to enable setting a specific weights
         attribute config parameter.
@@ -546,8 +524,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 else:
                     Logger.warning(f"Parameter {config_parameter_name} could not be found in the node quantization config of "
                                    f"weights attribute {attr_name} and was not updated!")
-            else:
-                Logger.error(f"Weights attribute {attr_name} could not be found to set parameter {config_parameter_name}.")
+            else:  # pragma: no cover
+                Logger.critical(f"Weights attribute {attr_name} could not be found to set parameter {config_parameter_name}.")
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -560,7 +538,7 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
 
         """
         if not isinstance(other, NodeWeightsQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.min_threshold == other.min_threshold and \
             self.simd_size == other.simd_size and \

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

@@ -22,10 +22,7 @@ from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
     WeightsAttrQuantizationConfig
-
-# If the quantization config does not contain kernel channel mapping or the weights
-# quantization is not per-channel, we use a dummy channel mapping.
-dummy_channel_mapping = DefaultDict(default_value=(None, None))
+from model_compression_toolkit.logger import Logger
 
 
 def get_weights_qparams(weights_attr_values: np.ndarray,
@@ -64,29 +61,10 @@ def get_weights_qparams(weights_attr_values: np.ndarray,
             node=node,
             hessian_info_service=hessian_info_service,
             num_hessian_samples=num_hessian_samples)
-    else:
+    else:  # pragma: no cover
+        Logger.error(f"Requested weights quantization parameters computation for node {node.name} without providing a "
+                     f"weights_quantization_params_fn."
+                     f"Returning an empty dictionary since no quantization parameters were computed.")
         weights_params = {}
 
     return weights_params, output_channels_axis
-
-
-def _get_kernel_channels_mapping(fw_info:FrameworkInfo,
-                                use_dummy: bool) -> DefaultDict:
-    """
-    Get a kernel channel mapping from the framework info, or use dummy mapping (which returns a
-    tuple of Nones) if use_use_dummy is True.
-
-    Args:
-        fw_info: Framework info which contains a kernel channels mapping.
-        use_dummy: Whether to use a dummy mapping or not.
-
-    Returns:
-        Kernel channels mapping.
-    """
-
-    # Set a kernel channels mapping
-    if use_dummy:  # If kernel mapping is missing, we use a dummy channels mapping
-        kernel_channels_mapping = dummy_channel_mapping
-    else:
-        kernel_channels_mapping = fw_info.kernel_channels_mapping
-    return kernel_channels_mapping

model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py

@@ -60,33 +60,6 @@ def calculate_delta(threshold: np.ndarray,
     return threshold / (2 ** (n_bits - int(signed)))
 
 
-def calculate_min_max_values(threshold: np.ndarray,
-                             n_bits: int = 8,
-                             signed: bool = False) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Compute the min/max values of a quantization range according to the threshold,
-    number of bits and whether its signed or unsigned.
-
-    Args:
-        threshold: Threshold of quantization range to compute its min/max values.
-        n_bits: Number of bits used in the quantization.
-        signed: Whether the quantization range is signed or not.
-
-    Returns:
-        Min/max values of quantization range.
-    """
-
-    delta = calculate_delta(threshold,
-                            n_bits=n_bits,
-                            signed=signed)
-
-    # If unsigned: min=0, otherwise its -threshold
-    min_value = int(signed) * -threshold
-    max_value = threshold - delta
-
-    return min_value, max_value
-
-
 def quantize_tensor(tensor_data: np.ndarray,
                     threshold: np.ndarray,
                     n_bits: int,
@@ -238,7 +211,7 @@ def get_tensor_max(tensor_data: np.ndarray,
 
     """
     if n_bits < 1:
-        Logger.critical(f"Parameter n_bits must be positive; however 'n_bits'={n_bits} was provided.")
+        Logger.critical(f"Parameter n_bits must be positive; however 'n_bits'={n_bits} was provided.")  # pragma: no cover
     if is_uniform_quantization:
         expansion_factor = 1.0
     elif n_bits == 1:
@@ -337,40 +310,3 @@ def get_output_shape(tensor_shape, channel_axis):
 
     """
     return [-1 if i is channel_axis else 1 for i in range(len(tensor_shape))]
-
-
-def get_range_bounds(tensor_min, tensor_max):
-    """
-    Gets bounds on the quantization range limits for the minimization process.
-    Calculates the bounds in a way that would leave a gap between the possible optimized values
-    and the tensor min-max values.
-
-    Args:
-        tensor_min: min value of a tensor.
-        tensor_max: max value of a tensor.
-
-    Returns: An array with (lbound, ubound) pairs on the quantization range limit values.
-
-    """
-    # choosing bounds that have some gap from the original tensor min/max values.
-    l_bound = tensor_min / 2 if tensor_min > 0 else tensor_min * 2
-    u_bound = tensor_max * 2 if tensor_max > 0 else tensor_min / 2
-    return [(l_bound, u_bound), (l_bound, u_bound)]
-
-
-def get_threshold_bounds(min_threshold, max_threshold):
-    """
-    Gets bounds on the threshold for the minimization process.
-    Calculates the bounds in a way that would leave a gap between the possible optimized threshold
-    and the tensor max values. We use min_threshold as lower-bound to prevent the selected threshold
-    from being zero or negative.
-
-    Args:
-        min_threshold: minimal threshold to use if threshold is too small (not used for this method).
-        max_threshold: maximal threshold to be used in quantization.
-
-    Returns: An array with a pair of (lbound, ubound) on the quantization threshold limit values.
-
-    """
-    max_threshold = max(min_threshold, max_threshold)
-    return [(min_threshold, 2 * max_threshold)]

model_compression_toolkit/core/keras/back2framework/factory_model_builder.py

@@ -37,10 +37,10 @@ def get_keras_model_builder(mode: ModelBuilderMode) -> type:
         Keras model builder for the given mode.
     """
 
-    if not isinstance(mode, ModelBuilderMode):
+    if not isinstance(mode, ModelBuilderMode):  # pragma: no cover
         Logger.critical(f"Expected a ModelBuilderMode type for 'mode', but received {type(mode)} instead.")
-    if mode is None:
+    if mode is None:  # pragma: no cover
         Logger.critical(f"get_keras_model_builder received 'mode' is None")
-    if mode not in keras_model_builders.keys():
+    if mode not in keras_model_builders.keys():  # pragma: no cover
         Logger.critical(f"'mode' {mode} is not recognized in the Keras model builders factory.")
     return keras_model_builders.get(mode)

model_compression_toolkit/core/keras/keras_implementation.py

@@ -21,6 +21,7 @@ from mct_quantizers import KerasQuantizationWrapper, KerasActivationQuantization
 from tensorflow.keras.models import Model
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
+from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianMode, HessianInfoService
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.remove_identity import RemoveIdentity
 from model_compression_toolkit.core.keras.hessian.activation_hessian_scores_calculator_keras import \
@@ -421,44 +422,47 @@ class KerasImplementation(FrameworkImplementation):
 
         return False
 
-    def get_mp_node_distance_fn(self, layer_class: type,
-                             framework_attrs: Dict[str, Any],
-                             compute_distance_fn: Callable = None,
-                             axis: int = None,
-                             norm_mse: bool = False) -> Callable:
+    def get_mp_node_distance_fn(self, n: BaseNode,
+                                compute_distance_fn: Callable = None,
+                                norm_mse: bool = False) -> Tuple[Callable, int]:
         """
         A mapping between layers' types and a distance function for computing the distance between
         two tensors in mixed precision (for loss computation purposes). Returns a specific function if node of specific types is
         given, or a default (normalized MSE) function otherwise.
 
         Args:
-            layer_class: Class path of a model's layer.
-            framework_attrs: Framework attributes the layer had which the graph node holds.
+            n: Node to choose distance function for.
             compute_distance_fn: An optional distance function to use globally for all nodes.
-            axis: The axis on which the operation is preformed (if specified).
             norm_mse: whether to normalize mse distance function.
 
-        Returns: A distance function between two tensors.
+        Returns: A distance function between two tensors and a axis on which the distance is computed (if exists).
         """
 
+        axis = n.framework_attr.get(keras_constants.AXIS) \
+            if not isinstance(n, FunctionalNode) else n.op_call_kwargs.get(keras_constants.AXIS)
+
+        layer_class = n.layer_class
+        framework_attrs = n.framework_attr
+
         if compute_distance_fn is not None:
-            return compute_distance_fn
+            return compute_distance_fn, axis
 
         if layer_class == Activation:
             node_type_name = framework_attrs[ACTIVATION]
             if node_type_name == SOFTMAX and axis is not None:
-                return compute_kl_divergence
+                return compute_kl_divergence, axis
             elif node_type_name == SIGMOID:
-                return compute_cs
+                return compute_cs, axis
         elif axis is not None and (layer_class == tf.nn.softmax or layer_class == tf.keras.layers.Softmax
                                    or (layer_class == TFOpLambda and
                                        SOFTMAX in framework_attrs[keras_constants.FUNCTION])):
-            return compute_kl_divergence
-        elif layer_class == tf.nn.sigmoid:
-            return compute_cs
+            return compute_kl_divergence, axis
+        elif layer_class == tf.nn.sigmoid or (layer_class == TFOpLambda and
+                                              SIGMOID in framework_attrs[keras_constants.FUNCTION]):
+            return compute_cs, axis
         elif layer_class == Dense:
-            return compute_cs
-        return partial(compute_mse, norm=norm_mse)
+            return compute_cs, axis
+        return partial(compute_mse, norm=norm_mse), axis
 
     def get_hessian_scores_calculator(self,
                                       graph: Graph,

model_compression_toolkit/core/keras/tf_tensor_numpy.py

@@ -36,7 +36,7 @@ def to_tf_tensor(tensor):
         return (to_tf_tensor(t) for t in tensor)
     elif isinstance(tensor, np.ndarray):
         return tf.convert_to_tensor(tensor.astype(np.float32))
-    else:
+    else:  # pragma: no cover
         Logger.critical(f'Unsupported type for conversion to TF tensor: {type(tensor)}.')
 
 
@@ -69,5 +69,5 @@ def tf_tensor_to_numpy(tensor: Union[List, Tuple, np.ndarray, tf.Tensor, float],
         return np.array([np_tensor]) if np.isscalar(np_tensor) else np_tensor
     elif isinstance(tensor, float):
         return np.array([tensor])
-    else:
+    else:  # pragma: no cover
         Logger.critical(f'Unsupported type for conversion to Numpy array: {type(tensor)}.')

model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py

@@ -37,10 +37,10 @@ def get_pytorch_model_builder(mode: ModelBuilderMode) -> type:
         PyTorch model builder for the given mode.
     """
 
-    if not isinstance(mode, ModelBuilderMode):
+    if not isinstance(mode, ModelBuilderMode):  # pragma: no cover
         Logger.critical(f"Expected a ModelBuilderMode type for 'mode' parameter; received {type(mode)} instead.")
-    if mode is None:
+    if mode is None:  # pragma: no cover
         Logger.critical(f"Received 'mode' parameter is None.")
-    if mode not in pytorch_model_builders.keys():
+    if mode not in pytorch_model_builders.keys():  # pragma: no cover
         Logger.critical(f"'mode' parameter {mode} is not supported by the PyTorch model builders factory.")
     return pytorch_model_builders.get(mode)

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -30,6 +30,7 @@ from model_compression_toolkit.core import QuantizationConfig, FrameworkInfo, Co
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common import Graph, BaseNode
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianMode, HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
 from model_compression_toolkit.core.common.mixed_precision.set_layer_to_bitwidth import set_layer_to_bitwidth
@@ -403,36 +404,36 @@ class PytorchImplementation(FrameworkImplementation):
             return True
         return False
 
-    def get_mp_node_distance_fn(self, layer_class: type,
-                             framework_attrs: Dict[str, Any],
-                             compute_distance_fn: Callable = None,
-                             axis: int = None,
-                             norm_mse: bool = False) -> Callable:
+    def get_mp_node_distance_fn(self, n: BaseNode,
+                                compute_distance_fn: Callable = None,
+                                norm_mse: bool = False) -> Tuple[Callable, int]:
         """
         A mapping between layers' types and a distance function for computing the distance between
         two tensors in mixed precision (for loss computation purposes). Returns a specific function if node of specific types is
         given, or a default (normalized MSE) function otherwise.
 
         Args:
-            layer_class: Class path of a model's layer.
-            framework_attrs: Framework attributes the layer had which the graph node holds.
+            n: Node to choose distance function for.
             compute_distance_fn: An optional distance function to use globally for all nodes.
-            axis: The axis on which the operation is preformed (if specified).
             norm_mse: whether to normalize mse distance function.
 
-        Returns: A distance function between two tensors.
+        Returns: A distance function between two tensors and a axis on which the distance is computed (if exists).
         """
+        axis = n.framework_attr.get(pytorch_constants.DIM) if not (
+            isinstance(n, FunctionalNode)) else n.op_call_kwargs.get(pytorch_constants.DIM)
+
+        layer_class = n.layer_class
 
         if compute_distance_fn is not None:
-            return compute_distance_fn
+            return compute_distance_fn, axis
 
         elif layer_class in [Softmax, softmax] and axis is not None:
-            return compute_kl_divergence
+            return compute_kl_divergence, axis
         elif layer_class in [Sigmoid, sigmoid]:
-            return compute_cs
+            return compute_cs, axis
         elif layer_class == Linear:
-            return compute_cs
-        return partial(compute_mse, norm=norm_mse)
+            return compute_cs, axis
+        return partial(compute_mse, norm=norm_mse), axis
 
     def is_output_node_compatible_for_hessian_score_computation(self,
                                                                 node: BaseNode) -> bool:

model_compression_toolkit/core/pytorch/reader/node_holders.py

@@ -25,7 +25,7 @@ class DummyPlaceHolder(torch.nn.Module):
     """
 
     def __name__(self):
-        return PLACEHOLDER
+        return PLACEHOLDER  # pragma: no cover
 
     def forward(self, x):
         return x

model_compression_toolkit/core/runner.py

@@ -222,5 +222,6 @@ def _set_final_resource_utilization(graph: Graph,
 
     final_ru = ResourceUtilization()
     final_ru.set_resource_utilization_by_target(final_ru_dict)
+    print(final_ru)
     graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config

model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py

@@ -24,7 +24,7 @@ if FOUND_TF:
     if version.parse(tf.__version__) >= version.parse("2.13"):
         from keras.src.engine.base_layer import Layer
         from keras.src.engine.input_layer import InputLayer
-    else:
+    else:  # pragma: no cover
         from keras.engine.base_layer import Layer
         from keras.engine.input_layer import InputLayer
 
@@ -57,7 +57,7 @@ if FOUND_TF:
                     f'KerasQuantizationWrapper must have a weights_quantizers but has a '
                     f'{type(layer.weights_quantizers)} object') # pragma: no cover
 
-            if len(layer.weights_quantizers) == 0:
+            if len(layer.weights_quantizers) == 0:  # pragma: no cover
                 Logger.critical(f'KerasQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers. If layer is not quantized it should be a Keras layer.')
 
             for _, weights_quantizer in layer.weights_quantizers.items():

model_compression_toolkit/gptq/common/gptq_training.py

@@ -219,41 +219,6 @@ class GPTQTrainer(ABC):
 
         return hessian_approx_score_by_image
 
-    def _get_approximations_by_interest_point(self, approximations: Dict, image_idx: int) -> List:
-        """
-        Retrieves hessian approximations for a specific image index.
-
-        Args:
-            approximations (Dict): Hessian approximations.
-            image_idx (int): Image index.
-
-        Returns:
-            List: Hessian approximations for the given image index.
-        """
-        approx_by_interest_point = []
-        for target_node in self.compare_points:
-            hessian_approx_scores = approximations[target_node][image_idx]
-            self._validate_scores_approximation(hessian_approx_scores)
-            approx_by_interest_point.append(hessian_approx_scores[0])
-        return approx_by_interest_point
-
-    @staticmethod
-    def _validate_scores_approximation(hessian_approx_scores: List):
-        """
-        Validates the structure and length of the Hessian-approximation scores.
-
-        Args:
-            hessian_approx_scores: Scores to validate.
-        """
-        if not isinstance(hessian_approx_scores, list):
-            Logger.critical(f"Scores approximation was expected to be a list but is of type: {type(hessian_approx_scores)}.")   # pragma: no cover
-        if len(hessian_approx_scores) != 1:
-            Logger.critical(f"Scores 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(hessian_approx_scores)}."
-            )   # pragma: no cover
-
-
     @abstractmethod
     def build_gptq_model(self):
         """

model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py

@@ -38,7 +38,7 @@ if FOUND_TF:
 
             super().__init__(quantization_config)
 
-else:
+else:  # pragma: no cover
     class BaseKerasQATTrainableQuantizer(BaseKerasTrainableQuantizer):
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):

model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_quantizer.py

@@ -39,7 +39,7 @@ if FOUND_TORCH:
             """
             super().__init__(quantization_config)
 
-else:
+else:  # pragma: no cover
     class BasePytorchQATTrainableQuantizer(BasePytorchTrainableQuantizer):
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):

model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -96,7 +96,7 @@ class AttributeQuantizationConfig:
             Whether this configuration is equal to another object or not.
         """
         if not isinstance(other, AttributeQuantizationConfig):
-            return False
+            return False  # pragma: no cover
         return self.weights_quantization_method == other.weights_quantization_method and \
             self.weights_n_bits == other.weights_n_bits and \
             self.weights_per_channel_threshold == other.weights_per_channel_threshold and \
@@ -152,7 +152,7 @@ class OpQuantizationConfig:
         Returns: Info about the quantization configuration as a dictionary.
 
         """
-        return self.__dict__
+        return self.__dict__  # pragma: no cover
 
     def clone_and_edit(self, attr_to_edit: Dict[str, Dict[str, Any]] = {}, **kwargs):
         """
@@ -188,7 +188,7 @@ class OpQuantizationConfig:
             Whether this configuration is equal to another object or not.
         """
         if not isinstance(other, OpQuantizationConfig):
-            return False
+            return False  # pragma: no cover
         return self.default_weight_attr_config == other.default_weight_attr_config and \
             self.attr_weights_configs_mapping == other.attr_weights_configs_mapping and \
             self.activation_quantization_method == other.activation_quantization_method and \
@@ -279,12 +279,12 @@ class QuantizationConfigOptions:
             if attrs is None:
                 attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
             else:
-                if not isinstance(attrs, List):
+                if not isinstance(attrs, List):  # pragma: no cover
                     Logger.critical(f"Expected a list of attributes but received {type(attrs)}.")
                 attrs_to_update = attrs
 
             for attr in attrs_to_update:
-                if qc.attr_weights_configs_mapping.get(attr) is None:
+                if qc.attr_weights_configs_mapping.get(attr) is None:  # pragma: no cover
                     Logger.critical(f'Editing attributes is only possible for existing attributes in the configuration\'s '
                                     f'weights config mapping; {attr} does not exist in {qc}.')
                 self.__edit_quantization_configuration(qc.attr_weights_configs_mapping[attr], kwargs)
@@ -310,6 +310,7 @@ class QuantizationConfigOptions:
         # If not, add base_config to the list of configurations to update
         cfgs_to_update = [cfg for cfg in qc_options.quantization_config_list]
         if not any(qc_options.base_config is cfg for cfg in cfgs_to_update):
+            # TODO: add test for this case
             cfgs_to_update.append(qc_options.base_config)
 
         for qc in cfgs_to_update:
@@ -319,7 +320,7 @@ class QuantizationConfigOptions:
                 new_attr_mapping = {}
                 for attr in list(qc.attr_weights_configs_mapping.keys()):
                     new_key = layer_attrs_mapping.get(attr)
-                    if new_key is None:
+                    if new_key is None:  # pragma: no cover
                         Logger.critical(f"Attribute \'{attr}\' does not exist in the provided attribute mapping.")
 
                     new_attr_mapping[new_key] = qc.attr_weights_configs_mapping.pop(attr)

model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py

@@ -96,7 +96,7 @@ class TargetPlatformModel(ImmutableClass):
         for op_set in self.operator_set:
             if operators_set_name == op_set.name:
                 return op_set.qc_options
-        return get_default_quantization_config_options()
+        return self.default_qco
 
     def get_default_op_quantization_config(self) -> OpQuantizationConfig:
         """
@@ -158,7 +158,7 @@ class TargetPlatformModel(ImmutableClass):
             self.fusing_patterns.append(tp_model_component)
         elif isinstance(tp_model_component, OperatorsSetBase):
             self.operator_set.append(tp_model_component)
-        else:
+        else:  # pragma: no cover
             Logger.critical(f'Attempted to append an unrecognized TargetPlatformModelComponent of type: {type(tp_model_component)}.')
 
     def __enter__(self):