mct-nightly 2.3.0.20250310.500__py3-none-any.whl → 2.3.0.20250313.526__py3-none-any.whl

{mct_nightly-2.3.0.20250310.500.dist-info → mct_nightly-2.3.0.20250313.526.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.3.0.20250310.500
+Version: 2.3.0.20250313.526
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -20,7 +20,7 @@ Requires-Dist: PuLP
 Requires-Dist: matplotlib<3.10.0
 Requires-Dist: scipy
 Requires-Dist: protobuf
-Requires-Dist: mct-quantizers==1.5.2
+Requires-Dist: mct-quantizers-nightly
 Requires-Dist: pydantic<2.0
 Dynamic: classifier
 Dynamic: description

{mct_nightly-2.3.0.20250310.500.dist-info → mct_nightly-2.3.0.20250313.526.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=IvTOp-U0QerJ9UCdyeAzLvpX3qRiOQGbOeGL7ps8zGg,1557
+model_compression_toolkit/__init__.py,sha256=9GncQIw01bNCuq697TP39EeUYSVCocW8hYFq_GlA4NY,1557
 model_compression_toolkit/constants.py,sha256=i_R6uXBfO1ph_X6DNJych2x59SUojfJbn7dNjs_mZnc,3846
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -8,7 +8,7 @@ model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZ
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=CVTjBaci8F6EP3IKDnRMfxkP-Sv8qY8GpkGt6FyII2U,11376
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=DPevqQ8brkdut8K5f5v9g5lbT3r1GSmhLAk3NkL40Fg,6593
-model_compression_toolkit/core/runner.py,sha256=iJpDasfs7wtdAelIRaBPxDbN64phPern1O86QDM2HeY,13706
+model_compression_toolkit/core/runner.py,sha256=qblr8WM6R5v4jip94kBeWHKsjc-FUOteVgMtunGf8lU,13716
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
 model_compression_toolkit/core/common/framework_implementation.py,sha256=s3yiqnbWkwfnAB1sSal_KAuqVg27rLhAJ2O8LHUbSHE,22494
@@ -34,17 +34,17 @@ model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=b41_4rL_Adiza
 model_compression_toolkit/core/common/fusion/layer_fusing.py,sha256=-2fnjyC9q2RPw9st6RxROW-gdtT2mSRz0QZ_Gz1KDz4,5579
 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=0zsiEldkV_wjDoTjaGtL8DOMGEv2yQqhajwEAnFgqR8,37819
-model_compression_toolkit/core/common/graph/base_node.py,sha256=LYiF4Pv0doX9dJhXGBM78Ay40qYDp0gXHd19JwS11Uo,33463
+model_compression_toolkit/core/common/graph/base_node.py,sha256=kZbmAMh5cPAwYzlY8KYa8w0ipL58yApB09-WXQ8plrE,33763
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=GH5wStmw8SoAj5IdT_-ItN1Meo_P5NUTt_5bgJC4fak,3935
 model_compression_toolkit/core/common/graph/graph_matchers.py,sha256=CrDoHYq4iPaflgJWmoJ1K4ziLrRogJvFTVWg8P0UcDU,4744
 model_compression_toolkit/core/common/graph/graph_searches.py,sha256=2oKuW6L8hP-oL0lFO9PhQFt9fEFgVJwpc1u4fHExAtE,5128
-model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py,sha256=3el-A7j1oyoo1_9zq3faQp7IeRsFXFCvnrb3zZFXpU0,9803
+model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py,sha256=gPlGMyC5jdUTQy8jYU_Rz7cPXSH6JhV4Dnwt3-1FAKM,9849
 model_compression_toolkit/core/common/graph/memory_graph/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/core/common/graph/memory_graph/bipartite_graph.py,sha256=X6FK3C3y8ixFRPjC_wm3ClloCX8_06SOdA1TRi7o_LA,3800
 model_compression_toolkit/core/common/graph/memory_graph/compute_graph_max_cut.py,sha256=oyz260JXDbvL8aI-DVtUvLHtLRWC2Yu4SBYlGL68c2Y,3498
-model_compression_toolkit/core/common/graph/memory_graph/cut.py,sha256=7Dfq4TVJIrnencHLJqjhxYKhY7ooUo_ml33WH2IIAgc,2576
-model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256=E8xKMUxtEF0GjztUk-3CmMtivPPBcADnZTUaSN24o6A,17816
+model_compression_toolkit/core/common/graph/memory_graph/cut.py,sha256=ZUGgn-vDA7unzc9UWhK2v_2i5nfdkSG1xOpgpDmziEo,2870
+model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256=1TWLVAOlT8g8q_YyOdjm5cQfiSDZ5EHGQcb509Gnzjg,17895
 model_compression_toolkit/core/common/graph/memory_graph/memory_element.py,sha256=ISD2BvJWj5mB91jrFjG8VQb0oOoLBoita_thCZWzCPI,4238
 model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py,sha256=FCzK4HmX4lWI4qGoGv94wpGv7o6_f5wPBfeBPMerZ18,7752
 model_compression_toolkit/core/common/hessian/__init__.py,sha256=E7LK3K_1AwMCQokanNc1JODMwUKNOKmwXQiGQ7GO10I,1033
@@ -66,15 +66,15 @@ model_compression_toolkit/core/common/mixed_precision/configurable_quantizer_uti
 model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha256=-x8edUyudu1EAEM66AuXPtgayLpzbxoLNubfEbFM5kU,2867
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py,sha256=6pLUEEIqRTVIlCYQC4JIvY55KAvuBHEX8uTOQ-1Ac4Q,3859
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=r1t025_QHshyoop-PZvL7x6UuXaeplCCU3h4VNBhJHo,4309
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=7iJ2YprFvm2Dk9EkXYrwO7-Sf89f537D-KrQP7XhvPs,8889
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=aAuGIzSDKIDiq07nheeWRXLEatzr6Fvoa5ZHv-2BtCI,7130
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=uDX1mEaq7qqWk2FQCfVXUYVlpGWS0OBP0C1CsGCkZYY,32791
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=k7LjEmcvlkiV995DU7S1CrNOllu6qPZrhUUKXcZDIUQ,7538
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=4YH9tsFPOn6rCcedfyocZhZwDLNX5kB1tebu0-nvhyA,7226
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=ItBWNZYOf-Zzi8FaRv1y170wYRXYcR3pJysClOtH8qc,32525
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=gsigifJ-ykWNafF4t7UMEC_-nd6YPERAk1_z0kT-Y88,27172
 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=MQZnBcpBDMd5y6rOunUtH3t41GQH0aBmxVB4muoxNfk,9477
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=T5yVr7lay-6QLuTDBZNI1Ufj02EMBWuY_yHjC8eHx5I,3998
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=DyiE84ECgwtaCATWcisv-7ndmBUbj_TaddZ7GeIjlrU,35307
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=Oj-tVGUyBXtTpxNFQVPja8fFcUOpi6B2PdpNKHkAlbc,39314
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=J7gqUGs4ITo4ufl84A5vACxm670LG6RhQyXkejfpbn8,8834
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=9Hh85pr0VL65umhf9mPnrrssJXwJPAsIkBwCZnfzjHY,17575
@@ -146,8 +146,8 @@ model_compression_toolkit/core/common/substitutions/residual_collapsing.py,sha25
 model_compression_toolkit/core/common/substitutions/scale_equalization.py,sha256=p57u25qdW2pimxzGwgMXEBV4S-LzXuTVAlIM7830WfU,10966
 model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=oiiN16OqDrax4FPP5VeyTz0rhb0-eZJACKznTBlKkio,30013
 model_compression_toolkit/core/common/substitutions/softmax_shift.py,sha256=R-0ZqhYAuZLEFWHvB2UTPm52L6gWHGdRdEnwGxKSeGI,2625
-model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py,sha256=aXzUOJfgKPfQpEGfiIun26fgfCqazBG1mBpzoc4Ezxs,3477
-model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=h85L2VlDOqbLd-N98wA3SdYWiblBgSsPceNuLanJd70,4737
+model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py,sha256=w43dRmaG96a8SNECgghxoFCTSoZ-vUb33dXGm2PbomE,4251
+model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=gt07lXRUvYunJKiwv_w20zfXhcplSW4oT2C1dqiNNXc,4719
 model_compression_toolkit/core/common/visualization/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/common/visualization/final_config_visualizer.py,sha256=6I10jKLesB-RQKaXA75Xgz2wPvylQUrnPtCcQZIynGo,6371
 model_compression_toolkit/core/common/visualization/nn_visualizer.py,sha256=HOq7AObkmEZiDSZXUMJDAEJzUY-fSXUT0AMgwiyH7dg,7388
@@ -219,11 +219,11 @@ model_compression_toolkit/core/keras/statistics_correction/apply_second_moment_c
 model_compression_toolkit/core/keras/statistics_correction/keras_compute_activation_bias_correction_of_graph.py,sha256=lq6yw9r1u0ZGA95JFvzsV-HQax66qAkJBmGeKnG9OrM,3409
 model_compression_toolkit/core/keras/visualization/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
-model_compression_toolkit/core/pytorch/constants.py,sha256=YwD_joIF0vK8UG2vW1NVvg36pCNWA0vHOXjAgy_XWn0,2794
+model_compression_toolkit/core/pytorch/constants.py,sha256=Sg0hkUaMe88mI2_pd3KqhVz5ORnA46S1uq9Tj5qhtHc,2828
 model_compression_toolkit/core/pytorch/data_util.py,sha256=YYbT135HhlTt0q6XdD2JX7AS_L92f_uV2rWq2hsJOCA,6325
 model_compression_toolkit/core/pytorch/default_framework_info.py,sha256=NLdmiig5a2EBxutJeDHjp8px4g_2EKt3zmntmK-NrT4,4309
 model_compression_toolkit/core/pytorch/pytorch_device_config.py,sha256=S25cuw10AW3SEN_fRAGRcG_I3wdvvQx1ehSJzPnn-UI,4404
-model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=ToGadW24_9ajSWc_J8jlARw7OOO5BRt0_HvN1FfijgI,30575
+model_compression_toolkit/core/pytorch/pytorch_implementation.py,sha256=QBCKYimTbHGFmXGz84Ioni5C9qKntp9FMEBLMUrIKkY,30771
 model_compression_toolkit/core/pytorch/pytorch_node_prior_info.py,sha256=2LDQ7qupglHQ7o1Am7LWdfYVacfQnl-aW2N6l9det1w,3264
 model_compression_toolkit/core/pytorch/resource_utilization_data_facade.py,sha256=aIHl-dTAC4ISnWSKLD99c-1W3827vfRGyLjMBib-l3s,5618
 model_compression_toolkit/core/pytorch/utils.py,sha256=7VbgcLwtQvdEEc_AJgSOQ3U3KRKCICFPaBirN1fIQxg,3940
@@ -244,6 +244,7 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/batchno
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/batchnorm_refusing.py,sha256=JDWOaNwYrZG0zTwd3HwoZUM3tKu7zPbzLOrqNQsu8xA,2162
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/concat_threshold_update.py,sha256=SBrR24ZAnWPftLinv4FuIqdBGjfYtfXbYQJN5mgy5V4,2861
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/const_holder_conv.py,sha256=sw3jIOUSvfWUeD8l3rGcUOtC6QuzpMIQm8V3RQAM53Q,4741
+model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/convtranspose_dynamic_padding.py,sha256=N0VQr7hYkj1BN6O91nqiLkV3ZtclLkqlNNJwOEKv62g,3205
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_batch_norm.py,sha256=7GZY7lU3LUUaO5iiccHkUP62PB0QeGAGOZdUSGMkFBY,4450
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_layer_norm.py,sha256=XhiLVcnCc_gF-6mjxbf9C4bYg5YL_GCvDJmcdLkBNAg,4151
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_linear.py,sha256=3-OHYPun5Rt7GITqV3ZekJk59tsuY9ZYSpRpxKsNEVA,3450
@@ -347,7 +348,7 @@ model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer
 model_compression_toolkit/exporter/model_wrapper/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py,sha256=vQUGbCi8_pGoN8DwQ0IblSeN6L9t6Cr0reZNuCbBpkM,3469
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=0sx6PLcnJ42LHKn79Qx1FOH615YBqM9OJMF6S1W6plE,6255
+model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=dpN2Hyb56Wt4INEtBJAOxZeFdhIwdx__WFTmOVkxMLc,6470
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py,sha256=Pl8a8MSZMzNbm5vngujFjCt_iSMbSmKjlcL1DvN9nTM,9292
 model_compression_toolkit/gptq/__init__.py,sha256=pEgkJvmf05KSw70iLDTz_6LI_2Oi5L8sTN0JsEUpnpk,1445
 model_compression_toolkit/gptq/runner.py,sha256=La12JTYjWyJW0YW4Al4TP1_Xi4JWBCEKw6FR_JQsxe0,5982
@@ -428,7 +429,7 @@ model_compression_toolkit/qat/pytorch/quantizer/lsq/uniform_lsq.py,sha256=KefO2Z
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/symmetric_ste.py,sha256=p1JqtBZZVHTV5caR1U0d1t2UcTz0ACNyLcJTBFUEq98,6173
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/uniform_ste.py,sha256=wWehe5R0xVHSm3ruMrUc8RzW5UVAVCMgUTUMPDsvy9g,5487
-model_compression_toolkit/target_platform_capabilities/__init__.py,sha256=9ZcT9JVlYzy8k7MlAXhj086gn6SxlGFsjMvy7ubcnfc,1392
+model_compression_toolkit/target_platform_capabilities/__init__.py,sha256=8RVOriZg-XNjSt53h_4Yum0oRgOe2gp5H45dfG_lZxE,1415
 model_compression_toolkit/target_platform_capabilities/constants.py,sha256=BFSgDwYWU1sZShjoW2S7eH3AI0D4SqDOeOu_sQ971LE,1518
 model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=YhROBiXEIB3TU-bAFrnL3qbAsb1yuWPBAQ_CLOJbYUU,1827
 model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py,sha256=4ydTWWKv_PEOAFok2JtxFNj8rav-0IlqcXKF6lnhHNE,4157
@@ -524,8 +525,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.3.0.20250310.500.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.3.0.20250310.500.dist-info/METADATA,sha256=sONRBJhRO4oeP6vCk6tpSIEekAc8Y8EH-6HfO-a9ZG0,27079
-mct_nightly-2.3.0.20250310.500.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-mct_nightly-2.3.0.20250310.500.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250310.500.dist-info/RECORD,,
+mct_nightly-2.3.0.20250313.526.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.3.0.20250313.526.dist-info/METADATA,sha256=aCFIGI9kNuUGhU8Koa0PDvXhqkHxK05E6a10mBpQAgU,27080
+mct_nightly-2.3.0.20250313.526.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+mct_nightly-2.3.0.20250313.526.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250313.526.dist-info/RECORD,,

model_compression_toolkit/__init__.py

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

model_compression_toolkit/core/common/graph/base_node.py

@@ -167,6 +167,14 @@ class BaseNode:
         """
         return self.is_weights_quantization_enabled(attr_name) and not self.is_all_weights_candidates_equal(attr_name)
 
+    def has_any_configurable_weight(self) -> bool:
+        """
+        Check whether any of the node's weights is configurable.
+        Returns:
+            Whether any of the node's weights is configurable.
+        """
+        return any(self.is_configurable_weight(attr) for attr in self.weights)
+
     def has_configurable_activation(self) -> bool:
         """
         Checks whether the activation has a configurable quantization.

model_compression_toolkit/core/common/graph/memory_graph/cut.py

@@ -12,28 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from dataclasses import dataclass, field
+
 from typing import List, Set
 
 from model_compression_toolkit.core.common import BaseNode
 from model_compression_toolkit.core.common.graph.memory_graph.memory_element import MemoryElements
 
 
+@dataclass(frozen=True)
 class Cut:
     """
     A Cut object that contains a set of ordered nodes and their memory elements.
-    """
 
-    def __init__(self, op_order: List[BaseNode], op_record: Set[BaseNode], mem_elements: MemoryElements):
-        """
-        Args:
-            op_order: A list of the cut's nodes (model layers), ordered by their addition to the cut (first-to-last).
-            op_record: A (unordered) set of the nodes in the cut.
-            mem_elements: MemoryElements object which represents the activation tensors of the cut's nodes.
-        """
-
-        self.op_order = op_order
-        self.op_record = op_record
-        self.mem_elements = mem_elements
+    Args:
+        op_order: A list of the cut's nodes (model layers), ordered by their addition to the cut (first-to-last).
+        op_record: A (unordered) set of the nodes in the cut.
+        mem_elements: MemoryElements object which represents the activation tensors of the cut's nodes.
+    """
+    op_order: List[BaseNode]
+    op_record: Set[BaseNode]
+    mem_elements: MemoryElements
+
+    _sorted_elements_signature: str = field(init=False, default=None)
+
+    @property
+    def sorted_elements_signature(self):
+        if self._sorted_elements_signature is None:
+            object.__setattr__(self, '_sorted_elements_signature',
+                               '_'.join(sorted([e.node_name for e in self.mem_elements.elements])))
+        return self._sorted_elements_signature
 
     def memory_size(self) -> float:
         """

model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py

@@ -232,7 +232,8 @@ class MaxCutAstar:
         max_cut_len = max([len(routes[c]) for c in open_list])
         ordered_cuts_list = sorted(open_list,
                                    key=lambda c: (self.accumulate(costs[c], self.estimate(c, estimate)),
-                                                  max_cut_len - len(routes[c])))
+                                                  max_cut_len - len(routes[c]),
+                                                  c.sorted_elements_signature))
 
         assert len(ordered_cuts_list) > 0
         return ordered_cuts_list[0]

model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py

@@ -24,7 +24,6 @@ import numpy as np
 
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
-from model_compression_toolkit.logger import Logger
 
 
 class VirtualSplitNode(BaseNode):
@@ -73,11 +72,14 @@ class VirtualSplitWeightsNode(VirtualSplitNode):
         super().__init__(origin_node)
 
         self.name = origin_node.name + VIRTUAL_WEIGHTS_SUFFIX
-
-        self.candidates_quantization_cfg = origin_node.get_unique_weights_candidates(kernel_attr)
-        for c in self.candidates_quantization_cfg:
-            c.activation_quantization_cfg.enable_activation_quantization = False
-            c.activation_quantization_cfg.activation_n_bits = FLOAT_BITWIDTH
+        # Virtual weights node is created only to be absorbed into virtual composed node right away.
+        # However, in some cases composition is impossible and virtual weights node can remain in the graph.
+        # In such case it messes up resource utilization computation, specifically activation cuts. In order to minimize
+        # the impact, we preserve the behavior of the original node wrt activation (shape and quantization),
+        # so that prev - virtualW cut is identical to prev-origin_node. Only the cut virtualW-virtualA will be different
+        # from the original graph, so in the worst case the utilization will be higher in virtual graph.
+        # This should guarantee that the utilization of the original graph does not exceed the requested target.
+        self.candidates_quantization_cfg = origin_node.candidates_quantization_cfg
 
 
 class VirtualSplitActivationNode(VirtualSplitNode):
@@ -126,89 +128,68 @@ class VirtualActivationWeightsNode(BaseNode):
     def __init__(self,
                  act_node: BaseNode,
                  weights_node: BaseNode,
-                 name: str,
-                 framework_attr: Dict[str, Any],
-                 input_shape: Tuple[Any],
-                 output_shape: Tuple[Any],
-                 weights: Dict[str, np.ndarray],
-                 layer_class: type,
-                 fw_info: FrameworkInfo,
-                 reuse: bool = False,
-                 reuse_group: str = None,
-                 quantization_attr: Dict[str, Any] = None,
-                 has_activation: bool = True,
-                 **kwargs):
+                 fw_info: FrameworkInfo):
         """
         Init a VirtualActivationWeightsNode object.
 
         Args:
             act_node: The original activation node.
             weights_node: The original weights node.
-            name: Node's name
-            framework_attr: Framework attributes the layer had which the node holds.
-            input_shape: Input tensor shape of the node.
-            output_shape: Input tensor shape of the node.
-            weights: Dictionary from a variable name to the weights with that name in the layer the node represents.
-            layer_class: Class path of the layer this node represents.
-            fw_info: A FrameworkInfo object with framework specific information,
-            reuse: Whether this node was duplicated and represents a reused layer.
-            reuse_group: Name of group of nodes from the same reused layer.
-            quantization_attr: Attributes the node holds regarding how it should be quantized.
-            has_activation: Whether the node has activations that we might want to quantize.
-            **kwargs: Additional arguments that can be passed but are not used (allows to init the object with an
-                existing node's __dict__).
-
+            fw_info: A FrameworkInfo object with framework specific information.
         """
-
+        # Validate weights node
+        kernel_attrs = fw_info.get_kernel_op_attributes(weights_node.type)
+        assert len(kernel_attrs) == 1 and kernel_attrs[0] is not None, 'Expected exactly one kernel attr.'
+        kernel_attr = kernel_attrs[0]
+        conf_weights = [attr for attr in weights_node.weights if weights_node.is_configurable_weight(attr)]
+        if len(conf_weights) > 1 or len(conf_weights) == 1 and not weights_node.is_configurable_weight(kernel_attr):
+            raise NotImplementedError('Only kernel weight can be configurable.')    # pragma: no cover
+
+        weights = weights_node.weights
+        if act_node.weights:
+            assert fw_info.get_kernel_op_attributes(act_node)[0] is None, \
+                f'Node {act_node} with kernel cannot be used as activation for VirtualActivationWeightsNode.'
+            if set(weights_node.weights.keys()).intersection(set(act_node.weights.keys())):
+                raise ValueError('Activation and weight nodes are not expected to have the same weight attribute')    # pragma: no cover
+            if act_node.has_any_configurable_weight():
+                raise NotImplementedError('Node with a configurable weight cannot be used as activation for '
+                                          'VirtualActivationWeightsNode.')    # pragma: no cover
+            # combine weights from activation and weights
+            weights.update(act_node.weights)
+
+        name = f"{VIRTUAL_ACTIVATION_WEIGHTS_NODE_PREFIX}_{act_node.name}_{weights_node.name}"
         super().__init__(name,
-                         framework_attr,
-                         input_shape,
-                         output_shape,
-                         weights,
-                         layer_class,
-                         reuse,
-                         reuse_group,
-                         quantization_attr,
-                         has_activation)
-
-        self.name = f"{VIRTUAL_ACTIVATION_WEIGHTS_NODE_PREFIX}_{act_node.name}_{weights_node.name}"
+                         framework_attr=weights_node.framework_attr,
+                         input_shape=act_node.input_shape,
+                         output_shape=act_node.output_shape,
+                         weights=weights,
+                         layer_class=weights_node.layer_class,
+                         reuse=weights_node.reuse,
+                         reuse_group=weights_node.reuse_group,
+                         quantization_attr=weights_node.quantization_attr,
+                         has_activation=False)
 
         self.original_activation_node = act_node
         self.original_weights_node = weights_node
 
         v_candidates = []
+        weights_candidates_quantization_cfg = weights_node.get_unique_weights_candidates(kernel_attr)
         for c_a in act_node.candidates_quantization_cfg:
-            for c_w in weights_node.candidates_quantization_cfg:
+            for c_w in weights_candidates_quantization_cfg:
                 composed_candidate = CandidateNodeQuantizationConfig(activation_quantization_cfg=c_a.activation_quantization_cfg,
                                                                      weights_quantization_cfg=c_w.weights_quantization_cfg)
+                if act_node.weights:
+                    # add non-kernel weights cfg from activation node to the composed node's weights cfg
+                    composed_candidate.weights_quantization_cfg.attributes_config_mapping.update(
+                        c_a.weights_quantization_cfg.attributes_config_mapping
+                    )
+                    composed_candidate.weights_quantization_cfg.pos_attributes_config_mapping.update(
+                        c_a.weights_quantization_cfg.pos_attributes_config_mapping
+                    )
                 v_candidates.append(composed_candidate)
 
         # sorting the candidates by weights number of bits first and then by activation number of bits (reversed order)
-        kernel_attr = fw_info.get_kernel_op_attributes(self.type)[0]
         v_candidates.sort(key=lambda c: (c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits,
                                          c.activation_quantization_cfg.activation_n_bits), reverse=True)
 
         self.candidates_quantization_cfg = v_candidates
-
-    def get_bops_count(self, fw_impl: Any, fw_info: FrameworkInfo, candidate_idx: int) -> float:
-        """
-        Computes the composed node's (edge) bit-operation count.
-
-        Args:
-            fw_impl: A FrameworkImplementation object with framework specific methods.
-            fw_info: A FrameworkInfo object with framework specific information,
-            candidate_idx: The index of the node's quantization candidate configuration.
-
-        Returns: The BOPS count of the composed node.
-
-        """
-        kernel_attr = fw_info.get_kernel_op_attributes(self.original_weights_node.type)[0]
-        node_mac = fw_impl.get_node_mac_operations(self.original_weights_node, fw_info)
-        candidate = self.candidates_quantization_cfg[candidate_idx]
-        kernel_attr_cfg = candidate.weights_quantization_cfg.get_attr_config(kernel_attr)
-        weights_bit = kernel_attr_cfg.weights_n_bits if \
-            kernel_attr_cfg.enable_weights_quantization else FLOAT_BITWIDTH
-        activation_bit = candidate.activation_quantization_cfg.activation_n_bits if \
-            candidate.activation_quantization_cfg.enable_activation_quantization else FLOAT_BITWIDTH
-        node_bops = weights_bit * activation_bit * node_mac
-        return node_bops

model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py

@@ -19,7 +19,6 @@ import numpy as np
 from model_compression_toolkit.core import FrameworkInfo
 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.virtual_activation_weights_node import VirtualActivationWeightsNode
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     RUTarget
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_calculator import \
@@ -28,9 +27,6 @@ from model_compression_toolkit.core.common.quantization.node_quantization_config
     NodeActivationQuantizationConfig
 
 
-# TODO take into account Virtual nodes. Are candidates defined with respect to virtual or original nodes?
-#  Can we use the virtual graph only for bops and the original graph for everything else?
-
 class MixedPrecisionRUHelper:
     """ Helper class for resource utilization computations for mixed precision optimization. """
 
@@ -65,7 +61,7 @@ class MixedPrecisionRUHelper:
             ru[RUTarget.ACTIVATION] = np.array(list(au.values()))
 
         if RUTarget.BOPS in ru_targets:
-            ru[RUTarget.BOPS] = self._bops_utilization(mp_cfg)
+            ru[RUTarget.BOPS] = self._bops_utilization(act_qcs=act_qcs, w_qcs=w_qcs)
 
         if RUTarget.TOTAL in ru_targets:
             raise ValueError('Total target should be computed based on weights and activations targets.')
@@ -88,8 +84,8 @@ class MixedPrecisionRUHelper:
         """
         mp_nodes = self.graph.get_configurable_sorted_nodes(self.fw_info)
         node_qcs = {n: n.candidates_quantization_cfg[mp_cfg[i]] for i, n in enumerate(mp_nodes)}
-        act_qcs = {n: cfg.activation_quantization_cfg for n, cfg in node_qcs.items()}
-        w_qcs = {n: cfg.weights_quantization_cfg for n, cfg in node_qcs.items()}
+        act_qcs = {n.name: cfg.activation_quantization_cfg for n, cfg in node_qcs.items()}
+        w_qcs = {n.name: cfg.weights_quantization_cfg for n, cfg in node_qcs.items()}
         return act_qcs, w_qcs
 
     def _weights_utilization(self, w_qcs: Optional[Dict[BaseNode, NodeWeightsQuantizationConfig]]) -> Dict[BaseNode, float]:
@@ -137,51 +133,25 @@ class MixedPrecisionRUHelper:
         cuts_util = {c: u.bytes for c, u in cuts_util.items()}
         return cuts_util
 
-    def _bops_utilization(self, mp_cfg: List[int]) -> np.ndarray:
+    def _bops_utilization(self,
+                          act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]],
+                          w_qcs: Optional[Dict[BaseNode, NodeWeightsQuantizationConfig]]) -> np.ndarray:
         """
-        Computes a resource utilization vector with the respective bit-operations (BOPS) count for each configurable node,
-        according to the given mixed-precision configuration of a virtual graph with composed nodes.
+        Computes a resource utilization vector with the respective bit-operations (BOPS) count
+        according to the given mixed-precision configuration.
 
         Args:
-            mp_cfg: A mixed-precision configuration (list of candidates index for each configurable node)
+            act_qcs: nodes activation configuration or None.
+            w_qcs: nodes quantization configuration to compute, or None.
+              Either both are provided, or both are None.
 
         Returns:
             A vector of node's BOPS count.
         """
-        # bops is computed for all nodes, so non-configurable memory is already covered by the computation of
-        # configurable nodes
-        if not mp_cfg:
+        assert [act_qcs, w_qcs].count(None) in [0, 2], 'act_qcs and w_qcs should both be provided or both be None.'
+        if act_qcs is None:
             return np.array([])
 
-        # TODO keeping old implementation for now
-        virtual_bops_nodes = [n for n in self.graph.get_topo_sorted_nodes() if isinstance(n, VirtualActivationWeightsNode)]
-
-        mp_nodes = self.graph.get_configurable_sorted_nodes_names(self.fw_info)
-
-        bops = [n.get_bops_count(self.fw_impl, self.fw_info, candidate_idx=_get_node_cfg_idx(n, mp_cfg, mp_nodes))
-                for n in virtual_bops_nodes]
-
-        return np.array(bops)
-
-
-def _get_node_cfg_idx(node: BaseNode, mp_cfg: List[int], sorted_configurable_nodes_names: List[str]) -> int:
-    """
-    Returns the index of a node's quantization configuration candidate according to the given
-    mixed-precision configuration. If the node is not configurable, then it must have a single configuration,
-    therefore, the index 0 is returned.
-
-    Args:
-        node: A node to get its candidate configuration index.
-        mp_cfg: A mixed-precision configuration (list of candidates index for each configurable node)
-        sorted_configurable_nodes_names: A list of configurable nodes names.
-
-    Returns: An index (integer) of a node's quantization configuration candidate.
-    """
-
-    if node.name in sorted_configurable_nodes_names:
-        node_idx = sorted_configurable_nodes_names.index(node.name)
-        return mp_cfg[node_idx]
-    else:    # pragma: no cover
-        assert len(node.candidates_quantization_cfg) > 0, \
-            "Any node should have at least one candidate configuration."
-        return 0
+        _, detailed_bops = self.ru_calculator.compute_bops(TargetInclusionCriterion.Any, BitwidthMode.QCustom,
+                                                           act_qcs=act_qcs, w_qcs=w_qcs)
+        return np.array(list(detailed_bops.values()))

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -83,6 +83,7 @@ def search_bit_width(graph_to_search_cfg: Graph,
     # Set graph for MP search
     graph = copy.deepcopy(graph_to_search_cfg)  # Copy graph before searching
     if target_resource_utilization.bops_restricted():
+        # TODO: we only need the virtual graph is both activations and weights are configurable
         # Since Bit-operations count target resource utilization is set, we need to reconstruct the graph for the MP search
         graph = substitute(graph, fw_impl.get_substitutions_virtual_weights_activation_coupling())
 

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py

@@ -189,11 +189,9 @@ class MixedPrecisionSearchManager:
 
         """
         act_qcs, w_qcs = self.ru_helper.get_quantization_candidates(config)
-        act_qcs = None if (RUTarget.ACTIVATION not in self.ru_targets_to_compute and RUTarget.TOTAL not in self.ru_targets_to_compute) else act_qcs
-        w_qcs = None if (RUTarget.WEIGHTS not in self.ru_targets_to_compute and RUTarget.TOTAL not in self.ru_targets_to_compute) else w_qcs
         ru = self.ru_helper.ru_calculator.compute_resource_utilization(
             target_criterion=TargetInclusionCriterion.AnyQuantized, bitwidth_mode=BitwidthMode.QCustom, act_qcs=act_qcs,
-            w_qcs=w_qcs, ru_targets=self.ru_targets_to_compute)
+            w_qcs=w_qcs, ru_targets=self.ru_targets_to_compute, allow_unused_qcs=True)
         return ru
 
     def finalize_distance_metric(self, layer_to_metrics_mapping: Dict[int, Dict[int, float]]):

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

@@ -13,24 +13,27 @@
 # limitations under the License.
 # ==============================================================================
 from collections import defaultdict
+
 from copy import deepcopy
 from enum import Enum, auto
 from typing import Dict, NamedTuple, Optional, Tuple, List, Iterable, Union, Literal, Sequence
 
-from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.core import FrameworkInfo
 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.base_node import WeightAttrT
-from model_compression_toolkit.core.common.graph.edge import EDGE_SINK_INDEX
 from model_compression_toolkit.core.common.graph.memory_graph.compute_graph_max_cut import compute_graph_max_cut
 from model_compression_toolkit.core.common.graph.memory_graph.cut import Cut
 from model_compression_toolkit.core.common.graph.memory_graph.memory_graph import MemoryGraph
+from model_compression_toolkit.core.common.graph.virtual_activation_weights_node import VirtualActivationWeightsNode, \
+    VirtualSplitWeightsNode
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     RUTarget, ResourceUtilization
 from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
-    NodeActivationQuantizationConfig
+    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig
+from model_compression_toolkit.core.common.substitutions.virtual_activation_weights_composition import \
+    get_input_activation_if_composable
 
 
 class BitwidthMode(Enum):
@@ -101,6 +104,12 @@ class Utilization(NamedTuple):
         return self.bytes < other.bytes
 
 
+NodeName = str
+ActivationQCfgPerNode = Dict[NodeName, NodeActivationQuantizationConfig]
+WeightsQCfgPerNode = Dict[NodeName, NodeWeightsQuantizationConfig]
+DetailedMem = Dict[Union[BaseNode, Cut], float]
+
+
 class ResourceUtilizationCalculator:
     """ Resource utilization calculator. """
 
@@ -110,6 +119,7 @@ class ResourceUtilizationCalculator:
     }
 
     unexpected_qc_error = 'Custom quantization configuration is not expected for non-custom bit mode.'
+    unexpected_qc_nodes_error = 'Custom quantization configuration contains unexpected node names.'
 
     def __init__(self, graph: Graph, fw_impl: FrameworkImplementation, fw_info: FrameworkInfo):
         self.graph = graph
@@ -121,10 +131,11 @@ class ResourceUtilizationCalculator:
         self._act_tensors_size = {}
         self._params_cnt = {}
         for n in graph.nodes:
-            self._act_tensors_size[n] = n.get_total_output_params()
+            self._act_tensors_size[n.name] = n.get_total_output_params()
             if n.weights:
-                self._params_cnt[n] = {k: v.size for k, v in n.weights.items()}
+                self._params_cnt[n.name] = {k: v.size for k, v in n.weights.items()}
         self._cuts: Optional[Dict[Cut, List[BaseNode]]] = None
+        self._nodes_names = set(n.name for n in graph.nodes)
 
     @property
     def cuts(self) -> Dict[Cut, List[BaseNode]]:
@@ -142,10 +153,12 @@ class ResourceUtilizationCalculator:
     def compute_resource_utilization(self,
                                      target_criterion: TargetInclusionCriterion,
                                      bitwidth_mode: BitwidthMode,
-                                     act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None,
-                                     w_qcs: Optional[Dict[BaseNode, NodeWeightsQuantizationConfig]] = None,
+                                     act_qcs: Optional[ActivationQCfgPerNode] = None,
+                                     w_qcs: Optional[WeightsQCfgPerNode] = None,
                                      ru_targets: Iterable[RUTarget] = None,
-                                     allow_unused_qcs: bool = False) -> ResourceUtilization:
+                                     allow_unused_qcs: bool = False,
+                                     return_detailed=False) \
+            -> Union[ResourceUtilization, Tuple[ResourceUtilization, Dict[RUTarget, DetailedMem]]]:
         """
         Compute network's resource utilization.
 
@@ -161,14 +174,17 @@ class ResourceUtilizationCalculator:
             ru_targets: metrics to include for computation. If None, all metrics are calculated.
             allow_unused_qcs: by default, if custom quantization configs are passed, but are not going to be used for
               any of the requested targets, an error is raised. To disable the validation, pass True.
+            return_detailed: whether to return an additional dictionary with detailed utilization per element.
 
         Returns:
-            Resource utilization object.
+            Resource utilization object, or a tuple of resource utilization object and a dict containing detailed
+            memory utilization per ru target: for weights and bops targets - bytes per node,
+                                              for activations and total targets - bytes per cut.
         """
         ru_targets = set(ru_targets) if ru_targets else set(RUTarget)
 
-        if (w_qcs or act_qcs) and bitwidth_mode != BitwidthMode.QCustom:
-            raise ValueError(self.unexpected_qc_error)
+        self._validate_custom_qcs(act_qcs, bitwidth_mode)
+        self._validate_custom_qcs(w_qcs, bitwidth_mode)
 
         if w_qcs and not {RUTarget.WEIGHTS, RUTarget.TOTAL, RUTarget.BOPS}.intersection(ru_targets):
             if not allow_unused_qcs:
@@ -180,31 +196,46 @@ class ResourceUtilizationCalculator:
                 raise ValueError('Activation configuration passed but no relevant ru_targets requested.')
             act_qcs = None
 
-        w_total, a_total = None, None
+        w_total, w_per_node = None, None
         if {RUTarget.WEIGHTS, RUTarget.TOTAL}.intersection(ru_targets):
-            w_total, *_ = self.compute_weights_utilization(target_criterion, bitwidth_mode, w_qcs)
+            w_total, w_per_node, _ = self.compute_weights_utilization(target_criterion, bitwidth_mode, w_qcs)
 
+        a_total, a_per_cut = None, None
         if {RUTarget.ACTIVATION, RUTarget.TOTAL}.intersection(ru_targets):
-            a_total = self.compute_activations_utilization(target_criterion, bitwidth_mode, act_qcs)
+            a_total, a_per_cut, _ = self.compute_activations_utilization(target_criterion, bitwidth_mode, act_qcs)
 
         ru = ResourceUtilization()
+        detailed = {}
         if RUTarget.WEIGHTS in ru_targets:
             ru.weights_memory = w_total
+            if return_detailed:
+                detailed[RUTarget.WEIGHTS] = {n: u.bytes for n, u in w_per_node.items()}
         if RUTarget.ACTIVATION in ru_targets:
             ru.activation_memory = a_total
+            if return_detailed:
+                detailed[RUTarget.ACTIVATION] = {cut: u.bytes for cut, u in a_per_cut.items()}
         if RUTarget.TOTAL in ru_targets:
             ru.total_memory = w_total + a_total
+            if return_detailed:
+                detailed[RUTarget.TOTAL] = {cut: u.bytes + w_total for cut, u in a_per_cut.items()}
         if RUTarget.BOPS in ru_targets:
-            ru.bops, _ = self.compute_bops(target_criterion, bitwidth_mode, act_qcs=act_qcs, w_qcs=w_qcs)
+            ru.bops, bops_per_node = self.compute_bops(target_criterion, bitwidth_mode, act_qcs=act_qcs, w_qcs=w_qcs)
+            if return_detailed:
+                detailed[RUTarget.BOPS] = bops_per_node
+
+        assert ru.get_restricted_targets() == set(ru_targets), \
+            'Mismatch between the number of requested and computed metrics'
+
+        if return_detailed:
+            return ru, detailed
 
-        assert ru.get_restricted_targets() == set(ru_targets), 'Mismatch between the number of requested and computed metrics'
         return ru
 
     def compute_weights_utilization(self,
                                     target_criterion: TargetInclusionCriterion,
                                     bitwidth_mode: BitwidthMode,
-                                    w_qcs: Optional[Dict[BaseNode, NodeWeightsQuantizationConfig]] = None) \
-            -> Tuple[float, Dict[BaseNode, Utilization], Dict[BaseNode, Dict[str, Utilization]]]:
+                                    w_qcs: Optional[WeightsQCfgPerNode] = None) \
+            -> Tuple[float, Dict[NodeName, Utilization], Dict[NodeName, Dict[str, Utilization]]]:
         """
         Compute graph's weights resource utilization.
 
@@ -220,19 +251,18 @@ class ResourceUtilizationCalculator:
             - Per node total weights utilization. Dict keys are nodes in a topological order.
             - Detailed per node per weight attribute utilization. Dict keys are nodes in a topological order.
         """
-        if w_qcs and bitwidth_mode != BitwidthMode.QCustom:
-            raise ValueError(self.unexpected_qc_error)
+        self._validate_custom_qcs(w_qcs, bitwidth_mode)
 
         node_attrs = self._collect_target_nodes_w_attrs(target_criterion, include_reused=False)
 
-        util_per_node: Dict[BaseNode, Utilization] = {}
+        util_per_node: Dict[NodeName, Utilization] = {}
         util_per_node_per_weight = {}
         for n in self._topo_sort(list(node_attrs.keys())):
-            w_qc = w_qcs.get(n) if w_qcs else None
+            w_qc = w_qcs.get(n.name) if w_qcs else None
             node_weights_util, per_weight_util = self.compute_node_weights_utilization(n, node_attrs[n],
                                                                                        bitwidth_mode, w_qc)
-            util_per_node[n] = node_weights_util
-            util_per_node_per_weight[n] = per_weight_util
+            util_per_node[n.name] = node_weights_util
+            util_per_node_per_weight[n.name] = per_weight_util
 
         total_util = sum(util_per_node.values()) if util_per_node else Utilization(0, 0)
         return total_util.bytes, util_per_node, util_per_node_per_weight
@@ -276,7 +306,7 @@ class ResourceUtilizationCalculator:
 
         attr_util = {}
         for attr in weight_attrs:
-            size = self._params_cnt[n][attr]
+            size = self._params_cnt[n.name][attr]
             nbits = self._get_weight_nbits(n, attr, bitwidth_mode, qc)
             bytes_ = size * nbits / 8
             attr_util[attr] = Utilization(size, bytes_)
@@ -287,7 +317,7 @@ class ResourceUtilizationCalculator:
     def compute_activations_utilization(self,
                                         target_criterion: TargetInclusionCriterion,
                                         bitwidth_mode: BitwidthMode,
-                                        act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None):
+                                        act_qcs: Optional[ActivationQCfgPerNode] = None):
         """
         Compute total activations utilization in the graph.
 
@@ -299,14 +329,16 @@ class ResourceUtilizationCalculator:
               activations, if not provided, the default configuration will be extracted from the node.
 
         Returns:
-            Total activation utilization of the network.
+            - Total activation utilization of the network.
+            - Total activation utilization per cut.
+            - Detailed activation utilization per cut per node.
         """
-        return self.compute_activation_utilization_by_cut(target_criterion, bitwidth_mode, act_qcs)[0]
+        return self.compute_activation_utilization_by_cut(target_criterion, bitwidth_mode, act_qcs)
 
     def compute_activation_utilization_by_cut(self,
                                               target_criterion: TargetInclusionCriterion,
                                               bitwidth_mode: BitwidthMode,
-                                              act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None) \
+                                              act_qcs: Optional[ActivationQCfgPerNode] = None) \
             -> Tuple[float, Dict[Cut, Utilization], Dict[Cut, Dict[BaseNode, Utilization]]]:
         """
         Compute graph activation cuts utilization.
@@ -323,8 +355,7 @@ class ResourceUtilizationCalculator:
             - Total activation utilization per cut.
             - Detailed activation utilization per cut per node.
         """
-        if act_qcs and not bitwidth_mode == BitwidthMode.QCustom:
-            raise ValueError(self.unexpected_qc_error)
+        self._validate_custom_qcs(act_qcs, bitwidth_mode)
 
         graph_target_nodes = self._get_target_activation_nodes(target_criterion, include_reused=True)
         # if there are no target activations in the graph, don't waste time looking for cuts
@@ -338,9 +369,9 @@ class ResourceUtilizationCalculator:
             if not cut_target_nodes:
                 continue
             for n in cut_target_nodes:
-                qc = act_qcs.get(n) if act_qcs else None
-                util_per_cut_per_node[cut][n] = self.compute_node_activation_tensor_utilization(n, target_criterion,
-                                                                                                bitwidth_mode, qc)
+                qc = act_qcs.get(n.name) if act_qcs else None
+                util_per_cut_per_node[cut][n.name] = self.compute_node_activation_tensor_utilization(n, target_criterion,
+                                                                                                     bitwidth_mode, qc)
             util_per_cut[cut] = sum(util_per_cut_per_node[cut].values())    # type: ignore
 
         total_util = max(util_per_cut.values())
@@ -349,9 +380,9 @@ class ResourceUtilizationCalculator:
     def compute_activation_tensors_utilization(self,
                                                target_criterion: TargetInclusionCriterion,
                                                bitwidth_mode: BitwidthMode,
-                                               act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None,
+                                               act_qcs: Optional[ActivationQCfgPerNode] = None,
                                                include_reused=False) \
-            -> Tuple[float, Dict[BaseNode, Utilization]]:
+            -> Tuple[float, Dict[NodeName, Utilization]]:
         """
         Compute resource utilization for graph's activations tensors.
 
@@ -362,21 +393,21 @@ class ResourceUtilizationCalculator:
               In custom mode, must provide configuration for all configurable activations. For non-configurable
               activations, if not provided, the default configuration will be extracted from the node.
             include_reused: whether to include reused nodes.
+
         Returns:
             - Total activation utilization of the network.
             - Detailed utilization per node. Dict keys are nodes in a topological order.
 
         """
-        if act_qcs and bitwidth_mode != BitwidthMode.QCustom:
-            raise ValueError(self.unexpected_qc_error)
+        self._validate_custom_qcs(act_qcs, bitwidth_mode)
 
         nodes = self._get_target_activation_nodes(target_criterion, include_reused=include_reused)
 
-        util_per_node: Dict[BaseNode, Utilization] = {}
+        util_per_node: Dict[NodeName, Utilization] = {}
         for n in self._topo_sort(nodes):
-            qc = act_qcs.get(n) if act_qcs else None
+            qc = act_qcs.get(n.name) if act_qcs else None
             util = self.compute_node_activation_tensor_utilization(n, None, bitwidth_mode, qc)
-            util_per_node[n] = util
+            util_per_node[n.name] = util
 
         total_util = max(util_per_node.values()).bytes if util_per_node else 0
         return total_util, util_per_node
@@ -396,6 +427,7 @@ class ResourceUtilizationCalculator:
             qc: activation quantization config for the node. Should be provided only in custom bit mode.
               In custom mode, must be provided if the activation is configurable. For non-configurable activation, if
               not passed, the default configuration will be extracted from the node.
+
         Returns:
             Node's activation utilization.
         """
@@ -408,7 +440,7 @@ class ResourceUtilizationCalculator:
             if not nodes:
                 return Utilization(0, 0)
 
-        size = self._act_tensors_size[n]
+        size = self._act_tensors_size[n.name]
         nbits = self._get_activation_nbits(n, bitwidth_mode, qc)
         bytes_ = size * nbits / 8
         return Utilization(size, bytes_)
@@ -416,9 +448,9 @@ class ResourceUtilizationCalculator:
     def compute_bops(self,
                      target_criterion: TargetInclusionCriterion,
                      bitwidth_mode: BitwidthMode,
-                     act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None,
-                     w_qcs: Optional[Dict[BaseNode, NodeWeightsQuantizationConfig]] = None) \
-            -> Tuple[int, Dict[BaseNode, int]]:
+                     act_qcs: Optional[ActivationQCfgPerNode] = None,
+                     w_qcs: Optional[WeightsQCfgPerNode] = None) \
+            -> Tuple[int, Dict[NodeName, int]]:
         """
         Compute bit operations based on nodes with kernel.
         Note that 'target_criterion' applies to weights, and BOPS are computed for the selected nodes regardless
@@ -438,30 +470,30 @@ class ResourceUtilizationCalculator:
             - Total BOPS count of the network.
             - Detailed BOPS count per node.
         """
-        if target_criterion != TargetInclusionCriterion.AnyQuantized:    # pragma: no cover
-            raise NotImplementedError('BOPS computation is currently only supported for quantized targets.')
-
-        nodes = self._collect_target_nodes_w_attrs(target_criterion, include_reused=True)
-        # filter out nodes with only positional weights # TODO add as arg to get target nodes
-        nodes = [n for n in nodes if n.has_kernel_weight_to_quantize(self.fw_info)]
+        self._validate_custom_qcs(act_qcs, bitwidth_mode)
+        self._validate_custom_qcs(w_qcs, bitwidth_mode)
 
         nodes_bops = {}
-        for n in nodes:
-            w_qc = w_qcs.get(n) if w_qcs else None
-            nodes_bops[n] = self.compute_node_bops(n, bitwidth_mode, act_qcs=act_qcs, w_qc=w_qc)
+        for n in self.graph.get_topo_sorted_nodes():
+            w_qc = w_qcs.get(n.name) if w_qcs else None
+            bops = self.compute_node_bops(n, target_criterion, bitwidth_mode, act_qcs=act_qcs, w_qc=w_qc)
+            if bops:
+                nodes_bops[n.name] = bops
 
         return sum(nodes_bops.values()), nodes_bops
 
     def compute_node_bops(self,
                           n: BaseNode,
+                          target_criterion: Optional[TargetInclusionCriterion],
                           bitwidth_mode: BitwidthMode,
-                          act_qcs: Optional[Dict[BaseNode, NodeActivationQuantizationConfig]] = None,
+                          act_qcs: Optional[ActivationQCfgPerNode] = None,
                           w_qc: Optional[NodeWeightsQuantizationConfig] = None) -> Union[float, int]:
         """
         Compute Bit Operations of a node.
 
         Args:
             n: node.
+            target_criterion: criterion to include nodes for computation.
             bitwidth_mode: bit-width mode for the computation.
             act_qcs: custom activations quantization configuration. Should be provided for custom bit mode only.
               In custom mode, must provide configuration for all configurable activations. For non-configurable
@@ -473,26 +505,58 @@ class ResourceUtilizationCalculator:
         Returns:
             Node's BOPS count.
         """
-        node_mac = self.fw_impl.get_node_mac_operations(n, self.fw_info)
-        if node_mac == 0:    # pragma: no cover
-            return node_mac
+        if target_criterion is None:
+            target_criterion = TargetInclusionCriterion.Any
+        if target_criterion not in [TargetInclusionCriterion.AnyQuantized, TargetInclusionCriterion.Any]:
+            raise ValueError('BOPS computation is supported only for Any and AnyQuantized targets.')
 
-        incoming_edges = self.graph.incoming_edges(n, sort_by_attr=EDGE_SINK_INDEX)
-        # TODO temporary adding this for const_representation test in torch which has Linear with const input
-        if not incoming_edges:    # pragma: no cover
+        self._validate_custom_qcs(act_qcs, bitwidth_mode)
+        self._validate_custom_qcs(w_qc, bitwidth_mode)
+
+        if isinstance(n, VirtualSplitWeightsNode):
+            # Virtual weights node can only be present if it couldn't be merged into VirtualActivationWeightsNode.
+            # This means that during MP search we cannot compute bops for all A/W nbits combinations. To prevent
+            # inconsistencies we ignore such nodes for bops computation.
             return 0
-        assert len(incoming_edges) == 1, \
-            f'Unexpected number of inputs {len(incoming_edges)} for BOPS calculation. Expected 1.'
-        input_act_node = incoming_edges[0].source_node
-        act_qc = act_qcs.get(input_act_node) if act_qcs else None
-        a_nbits = self._get_activation_nbits(input_act_node, bitwidth_mode, act_qc)
 
+        # Fetch the original weights node for mac computation (VirtualActivationWeightsNode input/output shapes are
+        # based on the activation original node, not weights original node)
+        orig_w_node = n
+        if isinstance(n, VirtualActivationWeightsNode):
+            orig_w_node = n.original_weights_node
+            if isinstance(orig_w_node, VirtualSplitWeightsNode):
+                orig_w_node = orig_w_node.origin_node
+
+        # check if the node has kernel
         kernel_attrs = self.fw_info.get_kernel_op_attributes(n.type)
-        if len(kernel_attrs) > 1:    # pragma: no cover
+        if len(kernel_attrs) > 1:  # pragma: no cover
             raise NotImplementedError('Multiple kernel attributes are not supported for BOPS computation.')
+        if not kernel_attrs or not kernel_attrs[0]:
+            return 0
+
         kernel_attr = kernel_attrs[0]
-        w_nbits = self._get_weight_nbits(n, kernel_attr, bitwidth_mode, w_qc)
+        node_mac = self.fw_impl.get_node_mac_operations(orig_w_node, self.fw_info)
+        if node_mac == 0:
+            return node_mac
+
+        # find the activation node from which to get quantization info and for which to look in custom configuration
+        if isinstance(n, VirtualActivationWeightsNode):
+            # we don't need the original node (and cannot use it for custom configuration anyway)
+            a_node = n
+        else:
+            # if we are running on the original (non-virtual) graph, we only compute bops if it would be computed in an
+            # equivalent virtual graph for consistency.
+            a_node = get_input_activation_if_composable(self.graph, n, warn=False)
+            if a_node is None:
+                return 0
+
+        if (target_criterion == TargetInclusionCriterion.AnyQuantized and
+                not (a_node.is_activation_quantization_enabled() or n.is_weights_quantization_enabled(kernel_attr))):
+            return 0
 
+        act_qc = act_qcs.get(a_node.name) if act_qcs else None
+        a_nbits = self._get_activation_nbits(a_node, bitwidth_mode, act_qc)
+        w_nbits = self._get_weight_nbits(n, kernel_attr, bitwidth_mode, w_qc)
         node_bops = a_nbits * w_nbits * node_mac
         return node_bops
 
@@ -531,10 +595,11 @@ class ResourceUtilizationCalculator:
         """
         nodes_attrs = {n: attrs for n in self.graph.nodes
                        if (attrs := self._get_target_weight_attrs(n, target_criterion))
-                           and (include_reused or not n.reuse)}
+                       and (include_reused or not n.reuse)}
         return nodes_attrs
 
-    def _get_target_weight_attrs(self, n: BaseNode, target_criterion: TargetInclusionCriterion) -> List[str]:
+    @staticmethod
+    def _get_target_weight_attrs(n: BaseNode, target_criterion: TargetInclusionCriterion) -> List[str]:
         """
         Collect weight attributes of a node per criterion.
 
@@ -692,3 +757,30 @@ class ResourceUtilizationCalculator:
             return w_qcs[0].weights_n_bits
 
         raise ValueError(f'Unknown mode {bitwidth_mode.name}')    # pragma: no cover
+
+    def _validate_custom_qcs(self,
+                             qcs: Union[BaseNodeQuantizationConfig, Dict[NodeName, BaseNodeQuantizationConfig]],
+                             bitwidth_mode: BitwidthMode):
+        """
+        Validate custom quantization configuration.
+
+        Args:
+            qcs: either a mapping from nodes names to quantization configuration, or just a quantization configuration.
+            bitwidth_mode: bit mode.
+
+        Raises:
+            ValueError: if validation fails.
+
+        """
+        if qcs is None:
+            return
+
+        if bitwidth_mode != BitwidthMode.QCustom:
+            raise ValueError(self.unexpected_qc_error)
+
+        if isinstance(qcs, (NodeActivationQuantizationConfig, NodeWeightsQuantizationConfig)):
+            return
+
+        unknown_nodes = set(qcs.keys()) - self._nodes_names
+        if unknown_nodes:
+            raise ValueError(self.unexpected_qc_nodes_error, unknown_nodes)

model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from typing import Optional
 
 from model_compression_toolkit.core.common import BaseNode, Graph, BaseSubstitution
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.common.graph.virtual_activation_weights_node import VirtualActivationWeightsNode
+from model_compression_toolkit.core.common.graph.virtual_activation_weights_node import VirtualActivationWeightsNode, \
+    VirtualSplitWeightsNode
 
 
 class BaseVirtualActivationWeightsComposition(BaseSubstitution):
@@ -39,26 +41,18 @@ class BaseVirtualActivationWeightsComposition(BaseSubstitution):
         Returns:
             Graph after applying the substitution.
         """
+        if not isinstance(weights_node, VirtualSplitWeightsNode):
+            raise TypeError(f'Matched node {weights_node} was expected to be of type VirtualSplitWeightsNode. '
+                            f'This substitution is expected to be called after activation-weights split.')
 
-        predecessors = graph.get_prev_nodes(weights_node)
-        if len(predecessors) != 1:
-            return graph
-
-        act_node = predecessors[0]
-
-        if len(graph.out_edges(act_node)) > 1:
-            Logger.warning(f"Node {act_node.name} has multiple outgoing edges, which is not supported with "
-                           f"mixed-precision bit-operations utilization, thus, edge {act_node.name} --> {weights_node.name} "
-                           f"would not be counted in the bit-operations calculations.")
+        act_node = get_input_activation_if_composable(graph, weights_node, warn=True)
+        if act_node is None:
             return graph
 
         # Virtual composed activation-weights node
-        # we pass a dummy initialization dict to initialize the super BaseNode class,
-        # the actual arguments values are irrelevant because they are being overridden or not used
         v_node = VirtualActivationWeightsNode(act_node,
                                               weights_node,
-                                              fw_info=graph.fw_info,
-                                              **weights_node.__dict__)
+                                              fw_info=graph.fw_info)
 
         # Update graph
         graph.add_node(v_node)
@@ -71,3 +65,29 @@ class BaseVirtualActivationWeightsComposition(BaseSubstitution):
         graph.remove_node(act_node)
 
         return graph
+
+
+def get_input_activation_if_composable(graph: Graph, weights_node: BaseNode, warn: bool) -> Optional[BaseNode]:
+    """
+    Get input activation node for composition, or None if not composable.
+
+    Args:
+        graph: graph.
+        weights_node: weights node for composition.
+        warn: whether to log a warning if not composable.
+
+    Returns:
+        Input activation node or None.
+    """
+    predecessors = graph.get_prev_nodes(weights_node)
+    assert len(predecessors) == 1, (f'Weights node is expected to have exactly one input, '
+                                    f'node {weights_node} has {len(predecessors)}')
+    act_node = predecessors[0]
+    if len(graph.out_edges(act_node)) > 1:
+        if warn:
+            Logger.warning(f"Node {act_node.name} has multiple outgoing edges, which is not supported with "
+                           f"mixed-precision search under bit-operations constraint. In such case, it might result in "
+                           f"incorrect resource utilization computation and suboptimal bits selection.")
+        return None
+
+    return act_node

model_compression_toolkit/core/common/substitutions/weights_activation_split.py

@@ -52,9 +52,9 @@ class BaseWeightsActivationSplit(BaseSubstitution):
         # The decomposition works on linear nodes, that is, nodes with kernel ops
         kernel_attr = graph.fw_info.get_kernel_op_attributes(node.type)[0]
         if kernel_attr is None:
-            Logger.error(f"Trying to split node weights and activation, but node "
-                         f"{node.name} doesn't have a kernel attribute.")
-        if not node.is_all_weights_candidates_equal(kernel_attr) and not node.is_all_activation_candidates_equal():
+            Logger.critical(f"Trying to split node weights and activation, but node "
+                            f"{node.name} doesn't have a kernel attribute.")
+        if node.is_configurable_weight(kernel_attr) and node.has_configurable_activation():
             # Node has both different weights and different activation configuration candidates
             weights_bits = [c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits
                             for c in node.get_unique_weights_candidates(kernel_attr)]

model_compression_toolkit/core/pytorch/constants.py

@@ -33,6 +33,7 @@ STRIDES = 'stride'
 DILATIONS = 'dilation'
 TENSOR_META = 'tensor_meta'
 FILTERS = 'out_channels'
+OUTPUT_PADDING = 'output_padding'
 TYPE = 'type'
 PAD = 'pad'
 VALUE = 'value'

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

@@ -0,0 +1,77 @@
+# Copyright 2025 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import Tuple
+import torch.nn as nn
+import torch
+from model_compression_toolkit.core.pytorch.constants import OUTPUT_PADDING
+from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
+from model_compression_toolkit.core import common
+from model_compression_toolkit.core.common import BaseNode, Graph
+from model_compression_toolkit.logger import Logger
+
+
+class ConvtransposeDynamicPadding(common.BaseSubstitution):
+    """
+    Replace output_padding of nn.ConvTranspose2d to align dynamic output_size input.
+    In case there is a dynamic output_size in ConvTranspose2d forward function, we recalculate the
+    output_padding here according to node.output_shape (which is equal to the dynamic output_size if existed).
+    """
+
+    def __init__(self):
+        """
+        Matches: nn.ConvTranspose2d
+        """
+        convtr_node = NodeOperationMatcher(nn.ConvTranspose2d)
+        super().__init__(matcher_instance=convtr_node)
+
+
+    def calc_dynamic_output_size(self, node: BaseNode) -> Tuple[int]:
+        """
+        Calc the output padding to support dunamic output_size of nn.ConvTranspose2d
+        Args:
+            node: node to calculate output padding
+
+        Returns:
+            corrected output padding
+        """
+        convtr = nn.ConvTranspose2d(**node.framework_attr)
+        num_spatial_dims = 2
+        output_padding = convtr._output_padding(torch.randn(size=node.input_shape[0]),
+                                                node.output_shape[0],
+                                                convtr.stride,
+                                                convtr.padding,
+                                                convtr.kernel_size,
+                                                num_spatial_dims,
+                                                convtr.dilation)
+        return tuple(output_padding)
+
+
+    def substitute(self,
+                   graph: Graph,
+                   node: BaseNode) -> Graph:
+        """
+        Substitute nn.ConvTranspose2d with corrected output_padding for cases of dynamic output_size
+        Args:
+            graph: Graph we apply the substitution on.
+            node: node that match the pattern in the substitution init.
+
+        Returns:
+            Graph after applying the substitution.
+        """
+
+        if not node.reuse:
+            output_padding = self.calc_dynamic_output_size(node)
+            node.framework_attr.update({OUTPUT_PADDING: output_padding})
+        return graph

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -62,6 +62,8 @@ from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.sc
     ScaledDotProductDecomposition
 from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.transform_function_call_method import \
     TransformFunctionCallMethod
+from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.convtranspose_dynamic_padding import \
+    ConvtransposeDynamicPadding
 from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.const_holder_conv import \
     FunctionalConvSubstitution
 from model_compression_toolkit.core.pytorch.graph_substitutions.substitutions.relu_bound_to_power_of_2 import \
@@ -286,7 +288,8 @@ class PytorchImplementation(FrameworkImplementation):
                 FunctionalBatchNorm(),
                 FunctionalLayerNorm(),
                 FunctionalLinear(),
-                RemoveIdentity()]
+                RemoveIdentity(),
+                ConvtransposeDynamicPadding()]
 
     def get_substitutions_pre_statistics_collection(self,
                                                     quant_config: QuantizationConfig

model_compression_toolkit/core/runner.py

@@ -229,8 +229,8 @@ def _set_final_resource_utilization(graph: Graph,
     final_ru = None
     if ru_targets:
         ru_calculator = ResourceUtilizationCalculator(graph, fw_impl, fw_info)
-        w_qcs = {n: n.final_weights_quantization_cfg for n in graph.nodes}
-        a_qcs = {n: n.final_activation_quantization_cfg for n in graph.nodes}
+        w_qcs = {n.name: n.final_weights_quantization_cfg for n in graph.nodes}
+        a_qcs = {n.name: n.final_activation_quantization_cfg for n in graph.nodes}
         final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized,
                                                               BitwidthMode.QCustom, act_qcs=a_qcs, w_qcs=w_qcs,
                                                               ru_targets=ru_targets, allow_unused_qcs=True)

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py

@@ -45,6 +45,10 @@ if FOUND_TORCH:
         """
         weight_quantizers, _ = fw_impl.get_inferable_quantizers(node)
         if len(weight_quantizers) > 0:
+            # Set reuse for weight quantizers if node is reused
+            for _, quantizer in weight_quantizers.items():
+                if node.reuse_group:
+                    quantizer.enable_reuse_quantizer()
             # for positional weights we need to extract the weight's value.
             weights_values = {attr: fw_impl.to_tensor(node.get_weights_by_keys(attr))
                               for attr in weight_quantizers if isinstance(attr, int)}

model_compression_toolkit/target_platform_capabilities/__init__.py

@@ -17,7 +17,8 @@ from model_compression_toolkit.target_platform_capabilities.targetplatform2frame
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import (
     FrameworkQuantizationCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater,
     LayerFilterParams, OperationsToLayers, get_current_tpc)
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, OperatorsSet, \
-    OperatorSetGroup, Signedness, AttributeQuantizationConfig, OpQuantizationConfig, QuantizationConfigOptions, Fusing
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import (
+    TargetPlatformCapabilities, OperatorsSet, OperatorSetGroup, Signedness, AttributeQuantizationConfig,
+    OpQuantizationConfig, QuantizationConfigOptions, Fusing, OperatorSetNames)
 
 from mct_quantizers import QuantizationMethod