mct-nightly 2.1.0.20240708.453__py3-none-any.whl → 2.1.0.20240710.440__py3-none-any.whl

{mct_nightly-2.1.0.20240708.453.dist-info → mct_nightly-2.1.0.20240710.440.dist-info}/METADATA

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

{mct_nightly-2.1.0.20240708.453.dist-info → mct_nightly-2.1.0.20240710.440.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=2qX0UAXPLOzyntHHsJZv1L1q9YihCWIXVOiHz9RS_CQ,1573
+model_compression_toolkit/__init__.py,sha256=3GQ9gfo5RfzoWI0wjlyOHA6G4dz31vXoA1cBJdGk3Mw,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
@@ -6,11 +6,11 @@ model_compression_toolkit/metadata.py,sha256=IyoON37lBv3TI0rZGCP4K5t3oYI4TOmYy-L
 model_compression_toolkit/core/__init__.py,sha256=TrRgkWpT1AN2Faw1M_1HXyJkJnbxfn9p-RigDZl7pg0,1982
 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/quantization_prep_runner.py,sha256=K9eJ7VbB_rpeyxX4yEnorOmSxFW3DkvofzxS6QI8Hp8,6454
 model_compression_toolkit/core/runner.py,sha256=4TtOgyNb4cXr52dOlDqYxLm3rnLR6uHPDNoZiEFL9XA,12655
 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=8b6M1GcUR9bDgoxwqyNP8C6KSU9OTQ5hIk20Y74eLPo,20896
+model_compression_toolkit/core/common/framework_implementation.py,sha256=zg2Sznd-uqpN8hy9C22jah_27qPYXNajYx3xMR3AlMw,20938
 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
@@ -44,11 +44,11 @@ model_compression_toolkit/core/common/graph/memory_graph/cut.py,sha256=aPdXJPP5a
 model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256=crV2NCLVO8jx9MlryZBYuJKFe_G9HfM7rUR64fDymlw,17045
 model_compression_toolkit/core/common/graph/memory_graph/memory_element.py,sha256=gRmBEFRmyJsNKezQfiwDwQu1cmbGd2wgKCRTH6iw8mw,3961
 model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py,sha256=gw4av_rzn_3oEAPpD3B7PHZDqnxHMjIESevl6ppPnkk,7175
-model_compression_toolkit/core/common/hessian/__init__.py,sha256=bxPVbkIlHFJMiOgTdWMVCqcD9JKV5kb2bVdWUTeLpj8,1021
-model_compression_toolkit/core/common/hessian/hessian_info_service.py,sha256=0Ziwyzv6H5mIG5ptW6uC_w1gmxZIdffCuK8cg0STmJQ,20731
-model_compression_toolkit/core/common/hessian/hessian_info_utils.py,sha256=JepOjcyX1XyiC1UblqM3zdKv2xuUvU3HKWjlE1Bnq_U,1490
-model_compression_toolkit/core/common/hessian/trace_hessian_calculator.py,sha256=EIV4NVUfvkefqMAFrrjNhQq7cvT3hljHpGz_gpVaFtY,4135
-model_compression_toolkit/core/common/hessian/trace_hessian_request.py,sha256=uvnaYtJRRmj_CfnYAO6oehnhDqdalW0NgETWJvSzCxc,3245
+model_compression_toolkit/core/common/hessian/__init__.py,sha256=6216QgHl7h4DXGn5ForP9Tija-wrBSONNtQ769ikP2s,1025
+model_compression_toolkit/core/common/hessian/hessian_info_service.py,sha256=DHbZqFDuDir1QWN-YkYBzaoGDujgYam1hT2ea6uL3yM,21009
+model_compression_toolkit/core/common/hessian/hessian_info_utils.py,sha256=1axmN0tjJSo_7hUr2d2KMv4y1pBi19cqWSQpi4BbdsA,1458
+model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py,sha256=Pe4uKerx-MeDQPJ7Slr8fvFUHfv02q33w3gbQK5kBKs,4186
+model_compression_toolkit/core/common/hessian/hessian_scores_request.py,sha256=atGJgJBL9uwYRC3t9NnzGgHYxV4XJj4Ai_xPpQH0rhY,3229
 model_compression_toolkit/core/common/matchers/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/matchers/base_graph_filter.py,sha256=mTk54z0mIbFmPOb4h0xfLtLDookcFyNh8H0pIN5js_M,3091
 model_compression_toolkit/core/common/matchers/base_matcher.py,sha256=JCj-NLAXOJa-GcSX-94PVUTWjooQUd0NemiyNg5uKGQ,2210
@@ -62,9 +62,9 @@ model_compression_toolkit/core/common/mixed_precision/configurable_quant_id.py,s
 model_compression_toolkit/core/common/mixed_precision/configurable_quantizer_utils.py,sha256=7dKMi5S0zQZ16m8NWn1XIuoXsKuZUg64G4-uK8-j1PQ,5177
 model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha256=H8qYkJsk88OszUJo-Zde7vTmWiypLTg9KbbzIZ-hhvM,2812
 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=JmHopRNpHjxnoyeqXRVO0t-DdqEOm-jOZI06w5aAl9k,7550
+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=C29Qg3oO5d4lslB7uZh8JwcEgLKqyKox9B1Ss9mZDLQ,27536
+model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=PNGWP0bPkQNP1jCORP6FQgGIr616Kg1YSe_hy-BDg0I,27546
 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
@@ -92,7 +92,7 @@ model_compression_toolkit/core/common/pruning/pruning_section.py,sha256=I4vxh5iP
 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=SA1lqFNWhyXAnEyT_ROd3a-9gDYAgoCusk13US2l_QE,14047
+model_compression_toolkit/core/common/pruning/importance_metrics/lfh_importance_metric.py,sha256=sJGsR8vTs43SV7Wfz929pCwLM-_7aXUyO5nBUig9K9s,14055
 model_compression_toolkit/core/common/pruning/mask/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
 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
@@ -109,12 +109,12 @@ model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha
 model_compression_toolkit/core/common/quantization/quantize_node.py,sha256=cdzGNWfT4MRogIU8ehs0tr3lVjnzAI-jeoS9b4TwVBo,2854
 model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=O4qFJw3nBYUD4cGbO8haGXZ2-piSqoRpDKDD74iXSxw,12417
 model_compression_toolkit/core/common/quantization/quantization_params_generation/__init__.py,sha256=eCDGwsWYLU6z7qbEVb4TozMW_nd5VEP_iCJ6PcvyEPw,1486
-model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=4XH-qSo-zG7XkVTx1J0DFNHEklLOhkhxXeEWnXNJ7z8,23602
+model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=Fd_gxr5js-mqEwucaRR1CQAZ1W_wna19L1gAPeOzxRQ,23610
 model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=t0XSwjfOxcq2Sj2PGzccntz1GGv2eqVn9oR3OI0t9wo,8533
 model_compression_toolkit/core/common/quantization/quantization_params_generation/outlier_filter.py,sha256=9gnfJV89jpGwAx8ImJ5E9NjCv3lDtbyulP4OtgWb62M,1772
 model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py,sha256=HfnhQ4MxGpb95gOWXD1vnroTxxjFt9VFd4jIdo-rvAQ,10623
 model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py,sha256=noEdvGiyyW7acgQ2OFWLedCODibTGYJifC9qo8YIU5U,4558
-model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_computation.py,sha256=JS1nhQUMBVBtEjXbevFbbzHsXM0QLKVTG_3DRhdTAa0,8643
+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/symmetric_selection.py,sha256=4TP41wPYC0azIzFxUt-lNlKUPIIXQeE4H1SYHkON75k,11875
@@ -150,7 +150,7 @@ 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=bRH39d4lW7Ngm8xi7v9JQd9gNfGlB_lb-bolbzTYUcc,29881
+model_compression_toolkit/core/keras/keras_implementation.py,sha256=qrmFzs749gVCEanw-paEsbM50zECtMV8qDMxKFTmyj0,29906
 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
@@ -184,9 +184,9 @@ model_compression_toolkit/core/keras/graph_substitutions/substitutions/softmax_s
 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=4eJKq_Fx4mm_VuBDeeti0fTcUk1lL2yjebxCugJhvrA,8871
-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=Xogd90kPZPvKbplZQv5B77Dq_m4aW5-bL6Jxh33VZWs,12213
+model_compression_toolkit/core/keras/hessian/activation_hessian_scores_calculator_keras.py,sha256=p0eM-EO5ltXYjSkd7B3h9BWBcuRZvjxEcA8WaNvdyqc,8901
+model_compression_toolkit/core/keras/hessian/hessian_scores_calculator_keras.py,sha256=Cep-bQEwLyqLYfLxM0ByOQd_oAIT-uXjr3dFUd8T9CY,3954
+model_compression_toolkit/core/keras/hessian/weights_hessian_scores_calculator_keras.py,sha256=970C-8J4HtUalNWvZAKlWFZVfw5r6SBdt5RQU_mZ7M0,12261
 model_compression_toolkit/core/keras/mixed_precision/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py,sha256=aW8wR13fK6P6xzbU9XGU60IO1yYzXSo_Hk4qeq486kg,5137
 model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quantizer.py,sha256=Ziydik2j-LvNBXP3TSfUD6rEezPAikzQGib0_IXkmGM,6729
@@ -213,7 +213,7 @@ model_compression_toolkit/core/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKW
 model_compression_toolkit/core/pytorch/constants.py,sha256=AguUnAsNlj41gwuKIP_7nos3FcJHsIAjewLXSQdrDQM,2624
 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=7CFt1Y3fiDaKkEVvlDd76ZmucCuVp6OZNQwwqJezKbU,27547
+model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=XL_RZcfnb_ZY2jdCjOxxz7SbRBzMokbOWsTuYOSjyRU,27569
 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=OT_mrNEJqPgWLdtQuivKMQVjtJY49cmoIVvbRhANl1w,3004
@@ -249,9 +249,9 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/transfo
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/virtual_activation_weights_composition.py,sha256=WmEa8Xjji-_tIbthDxlLAGSr69nWk-YKcHNaVqLa7sg,1375
 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=eDiTiKVvH5NBgUFV6oBe7QeowJRo6tOQbcXx9t9k2S0,8522
-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=-B446KhtZHPU_5Ixtm9v_v-3qDQ05NoIj2iyq5DlgR4,8460
+model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py,sha256=xc_-utc9_Hq915X02VbT8zXxGqxE4fFz6dhiiZwU3ok,8578
+model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py,sha256=vXluX-awgavv7DGihG9HrlvLhak8qIHy837PPTOd4jg,3471
+model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py,sha256=C4-7naBQUh8TN6fEwkyKY6rlY_nvHSAmCnWT4iMBs8E,8497
 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
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py,sha256=KVZTKCYzJqqzF5nFEiuGMv_sNeVuBTxhmxWMFacKOxE,6337
@@ -332,17 +332,17 @@ model_compression_toolkit/exporter/model_wrapper/pytorch/builder/__init__.py,sha
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=YT9IVdpKaJbAW3msYRoQNIgqRSEVwSarRy6qlWCrBfk,5389
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py,sha256=4sN5z-6BXrTE5Dp2FX_jKO9ty5iZ2r4RM7XvXtDVLSI,9348
 model_compression_toolkit/gptq/__init__.py,sha256=YKg-tMj9D4Yd0xW9VRD5EN1J5JrmlRbNEF2fOSgodqA,1228
-model_compression_toolkit/gptq/runner.py,sha256=PQoLK3WhdRuUwZMd1VbtA7KZ9c-zWig_0ShmTtvJSHY,5970
+model_compression_toolkit/gptq/runner.py,sha256=La12JTYjWyJW0YW4Al4TP1_Xi4JWBCEKw6FR_JQsxe0,5982
 model_compression_toolkit/gptq/common/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/gptq/common/gptq_config.py,sha256=U-NiVEedkOsVaFq-iXU2Xcqp99Rgf0f2I3oANdVMhMY,5672
 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=efnwgKSGk9wtnirlLR48Q1KtZuXoGcrHoPUYq_9YKxc,16394
+model_compression_toolkit/gptq/common/gptq_training.py,sha256=nI_XVa7WbfCcbgHMFgnPtnD77m5ezAB306z7VE0XFvU,16527
 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
-model_compression_toolkit/gptq/keras/gptq_training.py,sha256=RAUZvve-kUMTfXY-aXQWEM4IejaeVedrKejBNrO6szI,19156
+model_compression_toolkit/gptq/keras/gptq_training.py,sha256=NXTNsVrO9DTh0uvc8V7rFaM0fYg2OA18ZrYd-cKZ7Z4,19159
 model_compression_toolkit/gptq/keras/graph_info.py,sha256=MKIfrRTRH3zCuxCR1g9ZVIFyuSSr0e0sDybqh4LDM7E,4672
 model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=SjmBTuSwki4JTPVhxvJMFK9uAsmEm2c6VV11NnM6eEo,15117
 model_compression_toolkit/gptq/keras/quantizer/__init__.py,sha256=-DK1CDXvlsnEbki4lukZLpl6Xrbo91_jcqxXlG5Eg6Q,963
@@ -359,7 +359,7 @@ model_compression_toolkit/gptq/keras/quantizer/ste_rounding/symmetric_ste.py,sha
 model_compression_toolkit/gptq/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/gptq/pytorch/gptq_loss.py,sha256=kDuWw-6zh17wZpYWh4Xa94rpoodf82DksgjQCnL7nBc,2719
 model_compression_toolkit/gptq/pytorch/gptq_pytorch_implementation.py,sha256=tECPTavxn8EEwgLaP2zvxdJH6Vg9jC0YOIMJ7857Sdc,1268
-model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=2pe_caivE7Fr9zCvmZENKbFTS6AUFbSjHN-TODEhbSY,16631
+model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=-daninmlPGfKsBNPB2C3gT6rK0G5YeyJsuOLA0JlfBU,16633
 model_compression_toolkit/gptq/pytorch/graph_info.py,sha256=4mVM-VvnBaA64ACVdOe6wTGHdMSa2UTLIUe7nACLcdo,4008
 model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=jcvRKBuMkrerNE8oWIJFp802pyFO0dnA-4hRnclKbWE,13569
 model_compression_toolkit/gptq/pytorch/quantizer/__init__.py,sha256=ZHNHo1yzye44m9_ht4UUZfTpK01RiVR3Tr74-vtnOGI,968
@@ -400,7 +400,7 @@ model_compression_toolkit/qat/keras/quantizer/ste_rounding/__init__.py,sha256=cc
 model_compression_toolkit/qat/keras/quantizer/ste_rounding/symmetric_ste.py,sha256=I4KlaGv17k71IyjuSG9M0OlXlD5P0pfvKa6oCyRQ5FE,13517
 model_compression_toolkit/qat/keras/quantizer/ste_rounding/uniform_ste.py,sha256=EED6LfqhX_OhDRJ9e4GwbpgNC9vq7hoXyJS2VPvG2qc,10789
 model_compression_toolkit/qat/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=23qsgnXk-U5nYMucqDI9iZVj5sKXMdMf9ceQWd8nfqA,13374
+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/quantization_builder.py,sha256=sFWGu76PZ9dSRf3L0uZI6YwLIs0biBND1tl76I1piBQ,5721
@@ -517,8 +517,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.20240708.453.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.1.0.20240708.453.dist-info/METADATA,sha256=xCeSsgvXFic6elnMsxAglgpYw2XPx-drzNM2ZFYwtKo,19719
-mct_nightly-2.1.0.20240708.453.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mct_nightly-2.1.0.20240708.453.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.1.0.20240708.453.dist-info/RECORD,,
+mct_nightly-2.1.0.20240710.440.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.1.0.20240710.440.dist-info/METADATA,sha256=MHsFULGCUhQiOAsGEFxkud6ktNEV5C_KQSlzCVbHCSE,19719
+mct_nightly-2.1.0.20240710.440.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+mct_nightly-2.1.0.20240710.440.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.1.0.20240710.440.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.20240708.000453"
+__version__ = "2.1.0.20240710.000440"

model_compression_toolkit/core/common/framework_implementation.py

@@ -24,7 +24,7 @@ from model_compression_toolkit.core.common import BaseNode
 from model_compression_toolkit.core.common.collectors.statistics_collector import BaseStatsCollector
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_graph import Graph
-from model_compression_toolkit.core.common.hessian import TraceHessianRequest, HessianInfoService
+from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
 from model_compression_toolkit.core.common.node_prior_info import NodePriorInfo
@@ -49,23 +49,23 @@ class FrameworkImplementation(ABC):
         raise NotImplemented(f'{self.__class__.__name__} did not supply a constants module.')  # pragma: no cover
 
     @abstractmethod
-    def get_trace_hessian_calculator(self,
-                                     graph: Graph,
-                                     input_images: List[Any],
-                                     trace_hessian_request: TraceHessianRequest,
-                                     num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
+    def get_hessian_scores_calculator(self,
+                                      graph: Graph,
+                                      input_images: List[Any],
+                                      hessian_scores_request: HessianScoresRequest,
+                                      num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
         """
-        Get framework trace hessian approximations calculator based on the trace hessian request.
+        Get framework hessian-approximation scores calculator based on the hessian scores request.
         Args:
             input_images: Images to use for computation.
             graph: Float graph to compute the approximation of its different nodes.
-            trace_hessian_request: TraceHessianRequest to search for the desired calculator.
-            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian trace.
+            hessian_scores_request: HessianScoresRequest to search for the desired calculator.
+            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian-approximation scores.
 
-        Returns: TraceHessianCalculator to use for the trace hessian approximation computation for this request.
+        Returns: HessianScoresCalculator to use for the hessian approximation scores computation for this request.
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
-                             f'framework\'s get_trace_hessian_calculator method.')  # pragma: no cover
+                             f'framework\'s get_hessian_scores_calculator method.')  # pragma: no cover
 
     @abstractmethod
     def to_numpy(self, tensor: Any) -> np.ndarray:
@@ -310,7 +310,7 @@ class FrameworkImplementation(ABC):
             representative_data_gen: Dataset to use for retrieving images for the models inputs.
             fw_info: FrameworkInfo object with information about the specific framework's model.
             disable_activation_for_metric: Whether to disable activation quantization when computing the MP metric.
-            hessian_info_service: HessianInfoService to fetch Hessian traces approximations.
+            hessian_info_service: HessianInfoService to fetch information based on Hessian-approximation.
 
         Returns:
             A function that computes the metric.

model_compression_toolkit/core/common/hessian/__init__.py

@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-from model_compression_toolkit.core.common.hessian.trace_hessian_request import TraceHessianRequest, HessianMode, HessianInfoGranularity
+from model_compression_toolkit.core.common.hessian.hessian_scores_request import HessianScoresRequest, HessianMode, HessianScoresGranularity
 from model_compression_toolkit.core.common.hessian.hessian_info_service import HessianInfoService
 import model_compression_toolkit.core.common.hessian.hessian_info_utils as hessian_utils

model_compression_toolkit/core/common/hessian/hessian_info_service.py

@@ -19,24 +19,24 @@ from tqdm import tqdm
 from typing import Callable, List, Dict, Any, Tuple
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
-from model_compression_toolkit.core.common.hessian.trace_hessian_request import TraceHessianRequest, \
-    HessianInfoGranularity, HessianMode
+from model_compression_toolkit.core.common.hessian.hessian_scores_request import HessianScoresRequest, \
+    HessianScoresGranularity, HessianMode
 from model_compression_toolkit.logger import Logger
 
 
 class HessianInfoService:
     """
-    A service to manage, store, and compute approximation of the Hessian-based information.
+    A service to manage, store, and compute information based on the Hessian matrix approximation.
 
-    This class provides functionalities to compute approximation based on the Hessian matrix based
-    on the different parameters (such as number of iterations for approximating the info)
+    This class provides functionalities to compute information based on the Hessian matrix approximation
+    based on the different parameters (such as number of iterations for approximating the scores)
     and input images (using representative_dataset_gen).
     It also offers cache management capabilities for efficient computation and retrieval.
 
     Note:
     - The Hessian provides valuable information about the curvature of the loss function.
     - Computation can be computationally heavy and time-consuming.
-    - The computed trace is an approximation.
+    - The computed information is based on Hessian approximation (and not the precise Hessian matrix).
     """
 
     def __init__(self,
@@ -49,7 +49,7 @@ class HessianInfoService:
         Args:
             graph: Float graph.
             representative_dataset_gen: A callable that provides a dataset for sampling.
-            fw_impl: Framework-specific implementation for trace Hessian approximation computation.
+            fw_impl: Framework-specific implementation for Hessian approximation scores computation.
         """
         self.graph = graph
 
@@ -58,7 +58,7 @@ class HessianInfoService:
         self.fw_impl = fw_impl
         self.num_iterations_for_approximation = num_iterations_for_approximation
 
-        self.trace_hessian_request_to_score_list = {}
+        self.hessian_scores_request_to_scores_list = {}
 
     def _sample_batch_representative_dataset(self,
                                              representative_dataset: Any,
@@ -142,11 +142,11 @@ class HessianInfoService:
 
     def _clear_saved_hessian_info(self):
         """Clears the saved info approximations."""
-        self.trace_hessian_request_to_score_list={}
+        self.hessian_scores_request_to_scores_list={}
 
-    def count_saved_info_of_request(self, hessian_request: TraceHessianRequest) -> Dict:
+    def count_saved_scores_of_request(self, hessian_request: HessianScoresRequest) -> Dict:
         """
-        Counts the saved approximations of Hessian info (traces, for now) for a specific request.
+        Counts the saved approximations of Hessian scores for a specific request.
         If some approximations were computed for this request before, the amount of approximations (per image)
         will be returned. If not, zero is returned.
 
@@ -166,55 +166,58 @@ class HessianInfoService:
                 Logger.critical(f"Expecting the Hessian request to include only non-reused nodes at this point, "
                                 f"but found node {n.name} with 'reuse' status.")
             # Check if the request for this node is in the saved info and store its count, otherwise store 0
-            per_node_counter[n] = len(self.trace_hessian_request_to_score_list.get(hessian_request, []))
+            per_node_counter[n] = len(self.hessian_scores_request_to_scores_list.get(hessian_request, []))
 
         return per_node_counter
 
-    def compute(self, trace_hessian_request: TraceHessianRequest, representative_dataset_gen, num_hessian_samples: int,
+    def compute(self,
+                hessian_scores_request: HessianScoresRequest,
+                representative_dataset_gen,
+                num_hessian_samples: int,
                 last_iter_remain_samples: List[List[np.ndarray]] = None):
         """
-        Computes an approximation of the trace of the Hessian based on the
+        Computes scores based on the Hessian matrix approximation according to the
         provided request configuration and stores it in the cache.
 
         Args:
-            trace_hessian_request: Configuration for which to compute the approximation.
+            hessian_scores_request: Configuration for which to compute the approximation.
             representative_dataset_gen: A callable that provides a dataset for sampling.
             num_hessian_samples: Number of requested samples to compute batch Hessian approximation scores.
             last_iter_remain_samples: A list of input samples (for each input layer) with remaining samples from
             previous iterations.
         """
-        Logger.debug(f"Computing Hessian-trace approximation for nodes {trace_hessian_request.target_nodes}.")
+        Logger.debug(f"Computing Hessian-scores approximations for nodes {hessian_scores_request.target_nodes}.")
 
         images, next_iter_remain_samples = representative_dataset_gen(num_hessian_samples=num_hessian_samples,
                                                                       last_iter_remain_samples=last_iter_remain_samples)
 
         # Compute and store the computed approximation in the saved info
         topo_sorted_nodes_names = [x.name for x in self.graph.get_topo_sorted_nodes()]
-        trace_hessian_request.target_nodes.sort(key=lambda x: topo_sorted_nodes_names.index(x.name))
+        hessian_scores_request.target_nodes.sort(key=lambda x: topo_sorted_nodes_names.index(x.name))
 
-        # Get the framework-specific calculator for trace Hessian approximation
-        fw_hessian_calculator = self.fw_impl.get_trace_hessian_calculator(graph=self.graph,
-                                                                          input_images=images,
-                                                                          trace_hessian_request=trace_hessian_request,
-                                                                          num_iterations_for_approximation=self.num_iterations_for_approximation)
+        # Get the framework-specific calculator Hessian-approximation scores
+        fw_hessian_calculator = self.fw_impl.get_hessian_scores_calculator(graph=self.graph,
+                                                                           input_images=images,
+                                                                           hessian_scores_request=hessian_scores_request,
+                                                                           num_iterations_for_approximation=self.num_iterations_for_approximation)
 
-        trace_hessian = fw_hessian_calculator.compute()
+        hessian_scores = fw_hessian_calculator.compute()
 
-        for node, hessian in zip(trace_hessian_request.target_nodes, trace_hessian):
-            single_node_request = self._construct_single_node_request(trace_hessian_request.mode,
-                                                                      trace_hessian_request.granularity,
+        for node, hessian in zip(hessian_scores_request.target_nodes, hessian_scores):
+            single_node_request = self._construct_single_node_request(hessian_scores_request.mode,
+                                                                      hessian_scores_request.granularity,
                                                                       node)
 
             # The hessian for each node is expected to be a tensor where the first axis represents the number of
             # images in the batch on which the approximation was computed.
             # We collect the results as a list of a result for images, which is combined across batches.
-            # After conversion, trace_hessian_request_to_score_list for a request of a single node should be a list of
+            # After conversion, hessian_scores_request_to_scores_list for a request of a single node should be a list of
             # results of all images, where each result is a tensor of the shape depending on the granularity.
-            if single_node_request in self.trace_hessian_request_to_score_list:
-                self.trace_hessian_request_to_score_list[single_node_request] += (
+            if single_node_request in self.hessian_scores_request_to_scores_list:
+                self.hessian_scores_request_to_scores_list[single_node_request] += (
                     self._convert_tensor_to_list_of_appx_results(hessian))
             else:
-                self.trace_hessian_request_to_score_list[single_node_request] = (
+                self.hessian_scores_request_to_scores_list[single_node_request] = (
                     self._convert_tensor_to_list_of_appx_results(hessian))
 
         # In case that we are required to return a number of scores that is larger that the computation batch size
@@ -226,15 +229,15 @@ class HessianInfoService:
         and len(next_iter_remain_samples[0]) > 0 else None
 
     def fetch_hessian(self,
-                      trace_hessian_request: TraceHessianRequest,
+                      hessian_scores_request: HessianScoresRequest,
                       required_size: int,
                       batch_size: int = 1) -> List[List[np.ndarray]]:
         """
-        Fetches the computed approximations of the trace of the Hessian for the given 
+        Fetches the computed approximations of the Hessian-based scores for the given
         request and required size.
 
         Args:
-            trace_hessian_request: Configuration for which to fetch the approximation.
+            hessian_scores_request: Configuration for which to fetch the approximation.
             required_size: Number of approximations required.
             batch_size: The Hessian computation batch size.
 
@@ -245,28 +248,28 @@ class HessianInfoService:
             OC for per-output-channel when the requested node has OC output-channels, etc.)
         """
 
-        if len(trace_hessian_request.target_nodes) == 0:
+        if len(hessian_scores_request.target_nodes) == 0:
             return []
 
         if required_size == 0:
-            return [[] for _ in trace_hessian_request.target_nodes]
+            return [[] for _ in hessian_scores_request.target_nodes]
 
-        Logger.info(f"\nEnsuring {required_size} Hessian-trace approximation for nodes "
-                    f"{trace_hessian_request.target_nodes}.")
+        Logger.info(f"\nEnsuring {required_size} Hessian-approximation scores for nodes "
+                    f"{hessian_scores_request.target_nodes}.")
 
         # Replace node in reused target nodes with a representing node from the 'reuse group'.
-        for n in trace_hessian_request.target_nodes:
+        for n in hessian_scores_request.target_nodes:
             if n.reuse_group:
                 rep_node = self._get_representing_of_reuse_group(n)
-                trace_hessian_request.target_nodes.remove(n)
-                if rep_node not in trace_hessian_request.target_nodes:
-                    trace_hessian_request.target_nodes.append(rep_node)
+                hessian_scores_request.target_nodes.remove(n)
+                if rep_node not in hessian_scores_request.target_nodes:
+                    hessian_scores_request.target_nodes.append(rep_node)
 
         # Ensure the saved info has the required number of approximations
-        self._populate_saved_info_to_size(trace_hessian_request, required_size, batch_size)
+        self._populate_saved_info_to_size(hessian_scores_request, required_size, batch_size)
 
         # Return the saved approximations for the given request
-        return self._collect_saved_hessians_for_request(trace_hessian_request, required_size)
+        return self._collect_saved_hessians_for_request(hessian_scores_request, required_size)
 
     def _get_representing_of_reuse_group(self, node) -> Any:
         """
@@ -286,20 +289,20 @@ class HessianInfoService:
         return father_nodes[0]
 
     def _populate_saved_info_to_size(self,
-                                     trace_hessian_request: TraceHessianRequest,
+                                     hessian_scores_request: HessianScoresRequest,
                                      required_size: int,
                                      batch_size: int = 1):
         """
-        Ensures that the saved info has the required size of trace Hessian approximations for the given request.
+        Ensures that the saved info has the required size of Hessian approximation scores for the given request.
 
         Args:
-            trace_hessian_request: Configuration for which to ensure the saved info size.
-            required_size: Required number of trace Hessian approximations.
+            hessian_scores_request: Configuration of the request to ensure the saved info size.
+            required_size: Required number of Hessian-approximation scores.
             batch_size: The Hessian computation batch size.
         """
 
         # Get the current number of saved approximations for each node in the request
-        current_existing_hessians = self.count_saved_info_of_request(trace_hessian_request)
+        current_existing_hessians = self.count_saved_scores_of_request(hessian_scores_request)
 
         # Compute the required number of approximations to meet the required size.
         # Since we allow batch and multi-nodes computation, we take the node with the maximal number of missing
@@ -308,9 +311,9 @@ class HessianInfoService:
         max_remaining_hessians = required_size - min_exist_hessians
 
         Logger.info(
-            f"Running Hessian approximation computation for {len(trace_hessian_request.target_nodes)} nodes.\n "
-            f"The node with minimal existing Hessian-trace approximations has {min_exist_hessians} "
-            f"approximations computed.\n"
+            f"Running Hessian approximation computation for {len(hessian_scores_request.target_nodes)} nodes.\n "
+            f"The node with minimal existing Hessian-approximation scores has {min_exist_hessians} "
+            f"approximated scores computed.\n"
             f"{max_remaining_hessians} approximations left to compute...")
 
         hessian_representative_dataset = partial(self._sample_batch_representative_dataset,
@@ -325,30 +328,31 @@ class HessianInfoService:
             pbar.update(1)
             size_to_compute = min(max_remaining_hessians, batch_size)
             next_iter_remaining_samples = (
-                self.compute(trace_hessian_request, hessian_representative_dataset, size_to_compute,
+                self.compute(hessian_scores_request, hessian_representative_dataset, size_to_compute,
                              last_iter_remain_samples=next_iter_remaining_samples))
             max_remaining_hessians -= size_to_compute
 
-    def _collect_saved_hessians_for_request(self, trace_hessian_request: TraceHessianRequest, required_size: int
-                                            ) -> List[List[np.ndarray]]:
+    def _collect_saved_hessians_for_request(self,
+                                            hessian_scores_request: HessianScoresRequest,
+                                            required_size: int) -> List[List[np.ndarray]]:
         """
         Collects Hessian approximation for the nodes in the given request.
 
         Args:
-            trace_hessian_request: Configuration for which to fetch the approximation.
-            required_size: Required number of trace Hessian approximations.
+            hessian_scores_request: Configuration for which to fetch the approximation.
+            required_size: Required number of Hessian-approximation scores.
 
         Returns: A list with List of computed Hessian approximation (a tensor for each score) for each node
         in the request.
 
         """
         collected_results = []
-        for node in trace_hessian_request.target_nodes:
-            single_node_request = self._construct_single_node_request(trace_hessian_request.mode,
-                                                                      trace_hessian_request.granularity,
+        for node in hessian_scores_request.target_nodes:
+            single_node_request = self._construct_single_node_request(hessian_scores_request.mode,
+                                                                      hessian_scores_request.granularity,
                                                                       node)
 
-            res_for_node = self.trace_hessian_request_to_score_list.get(single_node_request)
+            res_for_node = self.hessian_scores_request_to_scores_list.get(single_node_request)
             if res_for_node is None:  # pragma: no cover
                 Logger.critical(f"Couldn't find saved Hessian approximations for node {node.name}.")
             if len(res_for_node) < required_size:  # pragma: no cover
@@ -362,22 +366,23 @@ class HessianInfoService:
         return collected_results
 
     @staticmethod
-    def _construct_single_node_request(mode: HessianMode, granularity: HessianInfoGranularity, target_nodes: List
-                                       ) -> TraceHessianRequest:
+    def _construct_single_node_request(mode: HessianMode,
+                                       granularity: HessianScoresGranularity,
+                                       target_nodes: List) -> HessianScoresRequest:
         """
         Constructs a Hessian request with for a single node. Used for retrieving and maintaining cached results.
 
         Args:
-            mode (HessianMode): Mode of Hessian's trace approximation (w.r.t weights or activations).
-            granularity (HessianInfoGranularity): Granularity level for the approximation.
-            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's trace approximation is targeted.
+            mode (HessianMode): Mode of Hessian's approximation (w.r.t weights or activations).
+            granularity (HessianScoresGranularity): Granularity level for the approximation.
+            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's approximation scores is targeted.
 
-        Returns: A TraceHessianRequest with the given details for the requested node.
+        Returns: A HessianScoresRequest with the given details for the requested node.
 
         """
-        return TraceHessianRequest(mode,
-                                   granularity,
-                                   target_nodes=[target_nodes])
+        return HessianScoresRequest(mode,
+                                    granularity,
+                                    target_nodes=[target_nodes])
 
     @staticmethod
     def _convert_tensor_to_list_of_appx_results(t: Any) -> List:

model_compression_toolkit/core/common/hessian/hessian_info_utils.py

@@ -19,7 +19,7 @@ from model_compression_toolkit.constants import EPS
 
 def normalize_scores(hessian_approximations: List) -> List[np.ndarray]:
     """
-    Normalize Hessian information approximations by dividing the trace Hessian approximations value by the sum of all
+    Normalize Hessian scores approximations by dividing their value by the sum of all
     other values.
 
     Args: