diff --git a/model_compression_toolkit/core/common/hessian/__init__.py b/model_compression_toolkit/core/common/hessian/__init__.py
index d1a43fe7a..94707b95e 100644
--- a/model_compression_toolkit/core/common/hessian/__init__.py
+++ b/model_compression_toolkit/core/common/hessian/__init__.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 from model_compression_toolkit.core.common.hessian.hessian_scores_request import (
-    HessianScoresRequest, HessianMode, HessianScoresGranularity, HessianEstimationDistribution
+    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
diff --git a/model_compression_toolkit/core/common/hessian/hessian_info_service.py b/model_compression_toolkit/core/common/hessian/hessian_info_service.py
index 3ab4344a3..41bd896df 100644
--- a/model_compression_toolkit/core/common/hessian/hessian_info_service.py
+++ b/model_compression_toolkit/core/common/hessian/hessian_info_service.py
@@ -47,6 +47,12 @@ def update(self, layers_hessians: Dict[str, np.ndarray], request: HessianScoresR
         """
         Updates the cache with new hessians estimations.
 
+        Note: we assume that the new hessians were computed on different samples than previously stored hessians.
+        If same samples were used more than once, duplicates will be stored. This can only be a problem if hessians
+        for the same query were computed via multiple requests and dataloader in each request yields same samples.
+        We cannot just filter out duplicates since in some cases we can get valid identical hessians on different
+        samples.
+
         Args:
             layers_hessians: a dictionary from layer names to their hessian score tensors.
             request: request per which hessians were computed.
@@ -60,7 +66,7 @@ def update(self, layers_hessians: Dict[str, np.ndarray], request: HessianScoresR
         for node_name, hess in layers_hessians.items():
             query = Query(request.mode, request.granularity, node_name)
             saved_hess = self._data.get(query)
-            new_hess = hess if saved_hess is None else np.unique(np.concatenate([saved_hess, hess], axis=0), axis=0)
+            new_hess = hess if saved_hess is None else np.concatenate([saved_hess, hess], axis=0)
             self._data[query] = new_hess
             n_nodes_samples.append(new_hess.shape[0])
 
diff --git a/model_compression_toolkit/core/common/hessian/hessian_scores_request.py b/model_compression_toolkit/core/common/hessian/hessian_scores_request.py
index cdef7387c..2943049ad 100644
--- a/model_compression_toolkit/core/common/hessian/hessian_scores_request.py
+++ b/model_compression_toolkit/core/common/hessian/hessian_scores_request.py
@@ -44,14 +44,6 @@ class HessianScoresGranularity(Enum):
     PER_TENSOR = 2
 
 
-class HessianEstimationDistribution(str, Enum):
-    """
-    Distribution for Hutchinson estimator random vector
-    """
-    GAUSSIAN = 'gaussian'
-    RADEMACHER = 'rademacher'
-
-
 @dataclasses.dataclass
 class HessianScoresRequest:
     """
@@ -68,15 +60,12 @@ class HessianScoresRequest:
             the computation. Can be None if all hessians for the request are expected to be pre-computed previously.
         n_samples: The number of samples to fetch hessian estimations for. If None, fetch hessians for a full pass
             of the data loader.
-        distribution: Distribution to use in Hutchinson estimation.
     """
     mode: HessianMode
     granularity: HessianScoresGranularity
     target_nodes: Sequence['BaseNode']
     data_loader: Optional[Iterable]
     n_samples: Optional[int]
-    # TODO remove
-    distribution: HessianEstimationDistribution = HessianEstimationDistribution.GAUSSIAN
 
     def __post_init__(self):
         if self.data_loader is None and self.n_samples is None:
@@ -85,4 +74,3 @@ def __post_init__(self):
     def clone(self, **kwargs):
         """ Create a clone with optional overrides """
         return dataclasses.replace(self, **kwargs)
-
diff --git a/model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py b/model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py
index 643623709..9151f21b7 100644
--- a/model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py
+++ b/model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py
@@ -15,20 +15,19 @@
 
 from typing import List
 
+import numpy as np
+import torch
 from torch import autograd
 from tqdm import tqdm
-import numpy as np
 
 from model_compression_toolkit.constants import MIN_HESSIAN_ITER, HESSIAN_COMP_TOLERANCE, HESSIAN_NUM_ITERATIONS
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.core.common.hessian import (HessianScoresRequest, HessianScoresGranularity,
-                                                           HessianEstimationDistribution)
+from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianScoresGranularity
 from model_compression_toolkit.core.pytorch.back2framework.float_model_builder import FloatPyTorchModelBuilder
 from model_compression_toolkit.core.pytorch.hessian.hessian_scores_calculator_pytorch import \
     HessianScoresCalculatorPytorch
 from model_compression_toolkit.core.pytorch.utils import torch_tensor_to_numpy
 from model_compression_toolkit.logger import Logger
-import torch
 
 
 class ActivationHessianScoresCalculatorPytorch(HessianScoresCalculatorPytorch):
@@ -92,29 +91,6 @@ def forward_pass(self):
         output = self.concat_tensors(output_tensors)
         return output, target_activation_tensors
 
-    def _generate_random_vectors_batch(self, shape: tuple, distribution: HessianEstimationDistribution,
-                                       device: torch.device) -> torch.Tensor:
-        """
-        Generate a batch of random vectors for Hutchinson estimation
-
-        Args:
-            shape: target shape
-            distribution: distribution to sample from
-            device: target device
-
-        Returns:
-            Random tensor
-        """
-        if distribution == HessianEstimationDistribution.GAUSSIAN:
-            return torch.randn(shape, device=device)
-
-        if distribution == HessianEstimationDistribution.RADEMACHER:
-            v = torch.randint(high=2, size=shape, device=device)
-            v[v == 0] = -1
-            return v
-
-        raise ValueError(f'Unknown distribution {distribution}')    # pragma: no cover
-
     def compute(self) -> List[np.ndarray]:
         """
         Compute the scores that are based on the approximation of the Hessian w.r.t the requested target nodes' activations.
@@ -141,8 +117,8 @@ def _compute_per_tensor(self, output, target_activation_tensors):
                                       for _ in range(len(target_activation_tensors))]
         prev_mean_results = None
         for j in tqdm(range(self.num_iterations_for_approximation), "Hessian random iterations"):  # Approximation iterations
-            # Getting a random vector with normal distribution
-            v = self._generate_random_vectors_batch(output.shape, self.hessian_request.distribution, output.device)
+            # Getting a random vector
+            v = self._generate_random_vectors_batch(output.shape, output.device)
             f_v = torch.sum(v * output)
             for i, ipt_tensor in enumerate(target_activation_tensors):  # Per Interest point activation tensor
                 # Computing the hessian-approximation scores by getting the gradient of (output * v)
@@ -183,7 +159,7 @@ def _compute_per_channel(self, output, target_activation_tensors):
                                       for _ in range(len(target_activation_tensors))]
 
         for j in tqdm(range(self.num_iterations_for_approximation), "Hessian random iterations"):  # Approximation iterations
-            v = self._generate_random_vectors_batch(output.shape, self.hessian_request.distribution, output.device)
+            v = self._generate_random_vectors_batch(output.shape, output.device)
             f_v = torch.sum(v * output)
             for i, ipt_tensor in enumerate(target_activation_tensors):  # Per Interest point activation tensor
                 hess_v = autograd.grad(outputs=f_v,
diff --git a/model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py b/model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py
index eeebe4823..c25f3ce65 100644
--- a/model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py
+++ b/model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py
@@ -15,12 +15,10 @@
 
 from typing import Union, List
 
-from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
-from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.core.common.hessian import HessianScoresRequest
+import torch
+
 from model_compression_toolkit.core.common.hessian.hessian_scores_calculator import HessianScoresCalculator
 from model_compression_toolkit.logger import Logger
-import torch
 
 
 class HessianScoresCalculatorPytorch(HessianScoresCalculator):
@@ -28,28 +26,20 @@ class HessianScoresCalculatorPytorch(HessianScoresCalculator):
     Pytorch-specific implementation of the Hessian approximation scores Calculator.
     This class serves as a base for other Pytorch-specific Hessian approximation scores calculators.
     """
-    def __init__(self,
-                 graph: Graph,
-                 input_images: List[torch.Tensor],
-                 fw_impl,
-                 hessian_scores_request: HessianScoresRequest,
-                 num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
+    def _generate_random_vectors_batch(self, shape: tuple, device: torch.device) -> torch.Tensor:
         """
+        Generate a batch of random vectors for Hutchinson estimation using Rademacher distribution.
 
         Args:
-            graph: Computational graph for the float model.
-            input_images: List of input images for the computation.
-            fw_impl: Framework-specific implementation for Hessian scores computation.
-            hessian_scores_request: Configuration request for which to compute the Hessian approximation scores.
-            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian based scores.
+            shape: target shape.
+            device: target device.
 
+        Returns:
+            Random tensor.
         """
-        super(HessianScoresCalculatorPytorch, self).__init__(graph=graph,
-                                                             input_images=input_images,
-                                                             fw_impl=fw_impl,
-                                                             hessian_scores_request=hessian_scores_request,
-                                                             num_iterations_for_approximation=num_iterations_for_approximation)
-
+        v = torch.randint(high=2, size=shape, device=device)
+        v[v == 0] = -1
+        return v
 
     def concat_tensors(self, tensors_to_concate: Union[torch.Tensor, List[torch.Tensor]]) -> torch.Tensor:
         """
diff --git a/model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py b/model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py
index 3be1aaee5..d7d555b5f 100644
--- a/model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py
+++ b/model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py
@@ -12,19 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-from tqdm import tqdm
 from typing import List
+
+import numpy as np
 import torch
 from torch import autograd
-import numpy as np
+from tqdm import tqdm
+
+from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS, MIN_HESSIAN_ITER, HESSIAN_COMP_TOLERANCE
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianScoresGranularity
+from model_compression_toolkit.core.pytorch.back2framework.float_model_builder import FloatPyTorchModelBuilder
+from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
 from model_compression_toolkit.core.pytorch.hessian.hessian_scores_calculator_pytorch import \
     HessianScoresCalculatorPytorch
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.pytorch.back2framework.float_model_builder import FloatPyTorchModelBuilder
-from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
-from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS, MIN_HESSIAN_ITER, HESSIAN_COMP_TOLERANCE, HESSIAN_EPS
 
 
 class WeightsHessianScoresCalculatorPytorch(HessianScoresCalculatorPytorch):
@@ -84,8 +86,8 @@ def compute(self) -> List[np.ndarray]:
 
         prev_mean_results = None
         for j in tqdm(range(self.num_iterations_for_approximation)):
-            # Getting a random vector with normal distribution and the same shape as the model output
-            v = torch.randn_like(output_tensor, device=device)
+            # Getting a random vector with the same shape as the model output
+            v = self._generate_random_vectors_batch(output_tensor.shape, device=device)
             f_v = torch.mean(torch.sum(v * output_tensor, dim=-1))
             for i, ipt_node in enumerate(self.hessian_request.target_nodes):  # Per Interest point weights tensor
 
diff --git a/model_compression_toolkit/gptq/common/gptq_config.py b/model_compression_toolkit/gptq/common/gptq_config.py
index 972bd742e..3a96fd86b 100644
--- a/model_compression_toolkit/gptq/common/gptq_config.py
+++ b/model_compression_toolkit/gptq/common/gptq_config.py
@@ -17,7 +17,6 @@
 from typing import Callable, Any, Dict, Optional
 
 from model_compression_toolkit.constants import GPTQ_HESSIAN_NUM_SAMPLES, ACT_HESSIAN_DEFAULT_BATCH_SIZE
-from model_compression_toolkit.core.common.hessian import HessianScoresGranularity, HessianEstimationDistribution
 from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT
 
 
@@ -54,7 +53,6 @@ class GPTQHessianScoresConfig:
     scale_log_norm: bool = False
     hessian_batch_size: int = ACT_HESSIAN_DEFAULT_BATCH_SIZE
     per_sample: bool = False
-    estimator_distribution: HessianEstimationDistribution = HessianEstimationDistribution.GAUSSIAN
 
 
 @dataclass
diff --git a/model_compression_toolkit/gptq/common/gptq_training.py b/model_compression_toolkit/gptq/common/gptq_training.py
index 8ee533a3a..32fc85163 100644
--- a/model_compression_toolkit/gptq/common/gptq_training.py
+++ b/model_compression_toolkit/gptq/common/gptq_training.py
@@ -192,8 +192,7 @@ def _build_hessian_request(self, granularity: HessianScoresGranularity, data_loa
             granularity=granularity,
             target_nodes=self.compare_points,
             data_loader=data_loader,
-            n_samples=n_samples,
-            distribution=self.gptq_config.hessian_weights_config.estimator_distribution
+            n_samples=n_samples
         )
 
     @abstractmethod
diff --git a/model_compression_toolkit/gptq/pytorch/quantization_facade.py b/model_compression_toolkit/gptq/pytorch/quantization_facade.py
index 90ef9ba67..897f5121d 100644
--- a/model_compression_toolkit/gptq/pytorch/quantization_facade.py
+++ b/model_compression_toolkit/gptq/pytorch/quantization_facade.py
@@ -18,7 +18,6 @@
 from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE, PYTORCH
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.analyzer import analyzer_model_quantization
-from model_compression_toolkit.core.common.hessian import HessianScoresGranularity, HessianEstimationDistribution
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
@@ -119,7 +118,6 @@ def get_pytorch_gptq_config(n_epochs: int,
                 scale_log_norm=False,
                 hessian_batch_size=hessian_batch_size,
                 per_sample=True,
-                estimator_distribution=HessianEstimationDistribution.RADEMACHER
             )
             loss = loss or sample_layer_attention_loss
         else:
diff --git a/tests/pytorch_tests/function_tests/test_hessian_info_calculator.py b/tests/pytorch_tests/function_tests/test_hessian_info_calculator.py
index ce9eba242..9ec14e347 100644
--- a/tests/pytorch_tests/function_tests/test_hessian_info_calculator.py
+++ b/tests/pytorch_tests/function_tests/test_hessian_info_calculator.py
@@ -97,11 +97,19 @@ class multiple_inputs_model(torch.nn.Module):
     def __init__(self):
         super(multiple_inputs_model, self).__init__()
         self.conv1 = Conv2d(3, 3, kernel_size=3, stride=1, padding=1)
+        self.bn1 = BatchNorm2d(3)
+        self.relu1 = ReLU()
         self.conv2 = Conv2d(3, 3, kernel_size=3, stride=1, padding=1)
+        self.bn2 = BatchNorm2d(3)
+        self.relu2 = ReLU()
 
     def forward(self, inp1, inp2):
         x1 = self.conv1(inp1)
+        x1 = self.bn1(x1)
+        x1 = self.relu1(x1)
         x2 = self.conv2(inp2)
+        x2 = self.bn2(x2)
+        x2 = self.relu2(x2)
         return x1 + x2
 
 
diff --git a/tests/pytorch_tests/model_tests/feature_models/gptq_test.py b/tests/pytorch_tests/model_tests/feature_models/gptq_test.py
index b1ec5e2d0..602d7c839 100644
--- a/tests/pytorch_tests/model_tests/feature_models/gptq_test.py
+++ b/tests/pytorch_tests/model_tests/feature_models/gptq_test.py
@@ -12,26 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-import random
 
 import numpy as np
 import torch
 import torch.nn as nn
 
-import mct_quantizers
+import model_compression_toolkit as mct
 from model_compression_toolkit import DefaultDict
 from model_compression_toolkit.constants import GPTQ_HESSIAN_NUM_SAMPLES
-from model_compression_toolkit.core.common.hessian import HessianEstimationDistribution
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.gptq.common.gptq_constants import QUANT_PARAM_LEARNING_STR, MAX_LSB_STR
-from tests.pytorch_tests.model_tests.base_pytorch_feature_test import BasePytorchFeatureNetworkTest
-import model_compression_toolkit as mct
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, GradientPTQConfig, RoundingType, \
-    GPTQHessianScoresConfig, GradualActivationQuantizationConfig
 from model_compression_toolkit.core.pytorch.utils import to_torch_tensor, torch_tensor_to_numpy, set_model
+from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, RoundingType, \
+    GPTQHessianScoresConfig, GradualActivationQuantizationConfig
+from model_compression_toolkit.gptq.common.gptq_constants import QUANT_PARAM_LEARNING_STR, MAX_LSB_STR
 from model_compression_toolkit.gptq.pytorch.gptq_loss import multiple_tensors_mse_loss
+from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.latest import generate_pytorch_tpc
 from tests.common_tests.helpers.generate_test_tp_model import generate_test_tp_model
+from tests.pytorch_tests.model_tests.base_pytorch_feature_test import BasePytorchFeatureNetworkTest
 from tests.pytorch_tests.utils import extract_model_weights
 
 tp = mct.target_platform
@@ -60,7 +57,7 @@ def __init__(self, unit_test, weights_bits=8, weights_quant_method=QuantizationM
                  hessian_weights=True, norm_scores=True, log_norm_weights=True, scaled_log_norm=False, params_learning=True,
                  num_calibration_iter=GPTQ_HESSIAN_NUM_SAMPLES, gradual_activation_quantization=False,
                  hessian_num_samples=GPTQ_HESSIAN_NUM_SAMPLES, sample_layer_attention=False,
-                 loss=multiple_tensors_mse_loss, hessian_batch_size=1, estimator_distribution=HessianEstimationDistribution.GAUSSIAN):
+                 loss=multiple_tensors_mse_loss, hessian_batch_size=1):
         super().__init__(unit_test, input_shape=(3, 16, 16), num_calibration_iter=num_calibration_iter)
         self.seed = 0
         self.rounding_type = rounding_type
@@ -79,7 +76,6 @@ def __init__(self, unit_test, weights_bits=8, weights_quant_method=QuantizationM
         self.sample_layer_attention = sample_layer_attention
         self.loss = loss
         self.hessian_batch_size = hessian_batch_size
-        self.estimator_distribution = estimator_distribution
 
     def get_quantization_config(self):
         return mct.core.QuantizationConfig(mct.core.QuantizationErrorMethod.NOCLIPPING,
@@ -156,10 +152,7 @@ def get_gptq_config(self):
                                                                                 norm_scores=self.norm_scores,
                                                                                 per_sample=self.sample_layer_attention,
                                                                                 hessians_num_samples=self.hessian_num_samples,
-                                                                                hessian_batch_size=self.hessian_batch_size,
-                                                                                estimator_distribution=self.estimator_distribution),
-
-
+                                                                                hessian_batch_size=self.hessian_batch_size),
                                  gptq_quantizer_params_override=self.override_params,
                                  gradual_activation_quantization_config=gradual_act_cfg)
 
diff --git a/tests/pytorch_tests/model_tests/test_feature_models_runner.py b/tests/pytorch_tests/model_tests/test_feature_models_runner.py
index 8eface3cd..44f8193bb 100644
--- a/tests/pytorch_tests/model_tests/test_feature_models_runner.py
+++ b/tests/pytorch_tests/model_tests/test_feature_models_runner.py
@@ -13,105 +13,105 @@
 # limitations under the License.
 # ==============================================================================
 import operator
-
 import unittest
-from functools import partial
 
 import numpy as np
 import torch
 from torch import nn
+
 import model_compression_toolkit as mct
-from model_compression_toolkit.core.common.hessian import HessianEstimationDistribution
 from model_compression_toolkit.core.common.mixed_precision.distance_weighting import MpDistanceWeighting
 from model_compression_toolkit.core.common.network_editors import NodeTypeFilter, NodeNameFilter
+from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
 from model_compression_toolkit.gptq.common.gptq_config import RoundingType
 from model_compression_toolkit.gptq.pytorch.gptq_loss import sample_layer_attention_loss
 from model_compression_toolkit.target_platform_capabilities import constants as C
+from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.trainable_infrastructure import TrainingMethod
+from tests.pytorch_tests.model_tests.feature_models.activation_16bit_test import Activation16BitTest, \
+    Activation16BitMixedPrecisionTest
 from tests.pytorch_tests.model_tests.feature_models.add_net_test import AddNetTest
+from tests.pytorch_tests.model_tests.feature_models.add_same_test import AddSameNetTest
 from tests.pytorch_tests.model_tests.feature_models.bn_attributes_quantization_test import BNAttributesQuantization
+from tests.pytorch_tests.model_tests.feature_models.bn_folding_test import BNFoldingNetTest, BNForwardFoldingNetTest
+from tests.pytorch_tests.model_tests.feature_models.bn_function_test import BNFNetTest
 from tests.pytorch_tests.model_tests.feature_models.compute_max_cut_test import ComputeMaxCutTest
-from tests.pytorch_tests.model_tests.feature_models.layer_norm_net_test import LayerNormNetTest
+from tests.pytorch_tests.model_tests.feature_models.concat_threshold_test import ConcatUpdateTest
+from tests.pytorch_tests.model_tests.feature_models.const_quantization_test import ConstQuantizationTest, \
+    AdvancedConstQuantizationTest, ConstQuantizationMultiInputTest, ConstQuantizationExpandTest
+from tests.pytorch_tests.model_tests.feature_models.const_representation_test import ConstRepresentationTest, \
+    ConstRepresentationMultiInputTest, ConstRepresentationLinearLayerTest, ConstRepresentationGetIndexTest, \
+    ConstRepresentationCodeTest
+from tests.pytorch_tests.model_tests.feature_models.constant_conv_substitution_test import ConstantConvSubstitutionTest, \
+    ConstantConvReuseSubstitutionTest, ConstantConvTransposeSubstitutionTest
 from tests.pytorch_tests.model_tests.feature_models.conv2d_replacement_test import DwConv2dReplacementTest
+from tests.pytorch_tests.model_tests.feature_models.dynamic_size_inputs_test import ReshapeNetTest
+from tests.pytorch_tests.model_tests.feature_models.gptq_test import GPTQAccuracyTest, GPTQWeightsUpdateTest, \
+    GPTQLearnRateZeroTest
+from tests.pytorch_tests.model_tests.feature_models.layer_name_test import ReuseNameNetTest
+from tests.pytorch_tests.model_tests.feature_models.layer_norm_net_test import LayerNormNetTest
+from tests.pytorch_tests.model_tests.feature_models.linear_collapsing_test import TwoConv2DCollapsingTest, \
+    ThreeConv2DCollapsingTest, FourConv2DCollapsingTest, SixConv2DCollapsingTest
+from tests.pytorch_tests.model_tests.feature_models.lut_quantizer_test import LUTWeightsQuantizerTest, \
+    LUTActivationQuantizerTest
 from tests.pytorch_tests.model_tests.feature_models.manual_bit_selection import ManualBitWidthByLayerTypeTest, \
     ManualBitWidthByLayerNameTest, Manual16BitTest, Manual16BitTestMixedPrecisionTest
+from tests.pytorch_tests.model_tests.feature_models.metadata_test import MetadataTest
+from tests.pytorch_tests.model_tests.feature_models.mixed_precision_activation_test import \
+    MixedPrecisionActivationSearch8Bit, MixedPrecisionActivationSearch2Bit, MixedPrecisionActivationSearch4Bit, \
+    MixedPrecisionActivationSearch4BitFunctional, MixedPrecisionActivationMultipleInputs, \
+    MixedPrecisionDistanceFunctions, MixedPrecisionActivationConfigurableWeights
 from tests.pytorch_tests.model_tests.feature_models.mixed_precision_bops_test import MixedPrecisionBopsBasicTest, \
     MixedPrecisionBopsAllWeightsLayersTest, MixedPrecisionWeightsOnlyBopsTest, MixedPrecisionActivationOnlyBopsTest, \
-    MixedPrecisionBopsAndWeightsMemoryUtilizationTest, MixedPrecisionBopsAndActivationMemoryUtilizationTest, MixedPrecisionBopsAndTotalMemoryUtilizationTest, \
+    MixedPrecisionBopsAndWeightsMemoryUtilizationTest, MixedPrecisionBopsAndActivationMemoryUtilizationTest, \
+    MixedPrecisionBopsAndTotalMemoryUtilizationTest, \
     MixedPrecisionBopsWeightsActivationUtilizationTest, MixedPrecisionBopsMultipleOutEdgesTest
+from tests.pytorch_tests.model_tests.feature_models.mixed_precision_weights_test import MixedPrecisionSearch4Bit, \
+    MixedPrecisionActivationDisabledTest, MixedPrecisionSearchLastLayerDistance, MixedPrecisionWithHessianScores, \
+    MixedPrecisionSearch8Bit, MixedPrecisionSearchPartWeightsLayers, MixedPrecisionSearch2Bit, \
+    MixedPrecisionWeightsConfigurableActivations
+from tests.pytorch_tests.model_tests.feature_models.multi_head_attention_test import MHALayerNetTest, \
+    MHALayerNetFeatureTest
+from tests.pytorch_tests.model_tests.feature_models.multiple_output_nodes_multiple_tensors_test import \
+    MultipleOutputsMultipleTensorsNetTest
+from tests.pytorch_tests.model_tests.feature_models.multiple_outputs_node_test import MultipleOutputsNetTest
+from tests.pytorch_tests.model_tests.feature_models.output_in_the_middle_test import OutputInTheMiddleNetTest
+from tests.pytorch_tests.model_tests.feature_models.parameter_net_test import ParameterNetTest
+from tests.pytorch_tests.model_tests.feature_models.permute_substitution_test import PermuteSubstitutionTest
 from tests.pytorch_tests.model_tests.feature_models.qat_test import QuantizationAwareTrainingTest, \
     QuantizationAwareTrainingMixedPrecisionCfgTest, QuantizationAwareTrainingMixedPrecisionRUCfgTest, \
     QuantizationAwareTrainingQuantizerHolderTest
+from tests.pytorch_tests.model_tests.feature_models.relu_bound_test import ReLUBoundToPOTNetTest, \
+    HardtanhBoundToPOTNetTest
 from tests.pytorch_tests.model_tests.feature_models.relu_replacement_test import SingleLayerReplacementTest, \
     ReluReplacementTest, ReluReplacementWithAddBiasTest
 from tests.pytorch_tests.model_tests.feature_models.remove_assert_test import AssertNetTest
 from tests.pytorch_tests.model_tests.feature_models.remove_broken_node_test import BrokenNetTest
-from tests.pytorch_tests.model_tests.feature_models.concat_threshold_test import ConcatUpdateTest
-from tests.pytorch_tests.model_tests.feature_models.add_same_test import AddSameNetTest
-from tests.pytorch_tests.model_tests.feature_models.bn_folding_test import BNFoldingNetTest, BNForwardFoldingNetTest
-from tests.pytorch_tests.model_tests.feature_models.linear_collapsing_test import TwoConv2DCollapsingTest, \
-    ThreeConv2DCollapsingTest, FourConv2DCollapsingTest, SixConv2DCollapsingTest
+from tests.pytorch_tests.model_tests.feature_models.remove_identity_test import RemoveIdentityTest
+from tests.pytorch_tests.model_tests.feature_models.reshape_substitution_test import ReshapeSubstitutionTest
 from tests.pytorch_tests.model_tests.feature_models.residual_collapsing_test import ResidualCollapsingTest1, \
     ResidualCollapsingTest2
-from tests.pytorch_tests.model_tests.feature_models.dynamic_size_inputs_test import ReshapeNetTest
-from tests.pytorch_tests.model_tests.feature_models.mixed_precision_activation_test import \
-    MixedPrecisionActivationSearch8Bit, MixedPrecisionActivationSearch2Bit, MixedPrecisionActivationSearch4Bit, \
-    MixedPrecisionActivationSearch4BitFunctional, MixedPrecisionActivationMultipleInputs, \
-    MixedPrecisionDistanceFunctions, MixedPrecisionActivationConfigurableWeights
-from tests.pytorch_tests.model_tests.feature_models.relu_bound_test import ReLUBoundToPOTNetTest, \
-    HardtanhBoundToPOTNetTest
+from tests.pytorch_tests.model_tests.feature_models.reuse_layer_net_test import ReuseLayerNetTest, \
+    ReuseFunctionalLayerNetTest, ReuseModuleAndFunctionalLayersTest
 from tests.pytorch_tests.model_tests.feature_models.scalar_tensor_test import ScalarTensorTest
-from tests.pytorch_tests.model_tests.feature_models.second_moment_correction_test import ConvSecondMomentNetTest, \
-    ConvTSecondMomentNetTest, MultipleInputsConvSecondMomentNetTest, ValueSecondMomentTest
-from tests.pytorch_tests.model_tests.feature_models.symmetric_activation_test import SymmetricActivationTest
-from tests.pytorch_tests.model_tests.feature_models.test_softmax_shift import SoftmaxLayerNetTest, \
-    SoftmaxFunctionNetTest
-from tests.pytorch_tests.model_tests.feature_models.permute_substitution_test import PermuteSubstitutionTest
-from tests.pytorch_tests.model_tests.feature_models.reshape_substitution_test import ReshapeSubstitutionTest
-from tests.pytorch_tests.model_tests.feature_models.constant_conv_substitution_test import ConstantConvSubstitutionTest, \
-    ConstantConvReuseSubstitutionTest, ConstantConvTransposeSubstitutionTest
-from tests.pytorch_tests.model_tests.feature_models.multi_head_attention_test import MHALayerNetTest, \
-    MHALayerNetFeatureTest
-from tests.pytorch_tests.model_tests.feature_models.scaled_dot_product_attention_test import ScaledDotProductAttentionTest
 from tests.pytorch_tests.model_tests.feature_models.scale_equalization_test import \
     ScaleEqualizationWithZeroPadNetTest, ScaleEqualizationNetTest, \
     ScaleEqualizationReluFuncNetTest, ScaleEqualizationReluFuncWithZeroPadNetTest, \
     ScaleEqualizationConvTransposeWithZeroPadNetTest, ScaleEqualizationReluFuncConvTransposeWithZeroPadNetTest, \
     ScaleEqualizationConvTransposeReluFuncNetTest
-from tests.pytorch_tests.model_tests.feature_models.layer_name_test import ReuseNameNetTest
-from tests.pytorch_tests.model_tests.feature_models.lut_quantizer_test import LUTWeightsQuantizerTest, \
-    LUTActivationQuantizerTest
-from tests.pytorch_tests.model_tests.feature_models.mixed_precision_weights_test import MixedPrecisionSearch4Bit, \
-    MixedPrecisionActivationDisabledTest, MixedPrecisionSearchLastLayerDistance, MixedPrecisionWithHessianScores, \
-    MixedPrecisionSearch8Bit, MixedPrecisionSearchPartWeightsLayers, MixedPrecisionSearch2Bit, \
-    MixedPrecisionWeightsConfigurableActivations
-from tests.pytorch_tests.model_tests.feature_models.multiple_output_nodes_multiple_tensors_test import \
-    MultipleOutputsMultipleTensorsNetTest
-from tests.pytorch_tests.model_tests.feature_models.multiple_outputs_node_test import MultipleOutputsNetTest
-from tests.pytorch_tests.model_tests.feature_models.output_in_the_middle_test import OutputInTheMiddleNetTest
-from tests.pytorch_tests.model_tests.feature_models.parameter_net_test import ParameterNetTest
-from tests.pytorch_tests.model_tests.feature_models.reuse_layer_net_test import ReuseLayerNetTest, \
-    ReuseFunctionalLayerNetTest, ReuseModuleAndFunctionalLayersTest
+from tests.pytorch_tests.model_tests.feature_models.scaled_dot_product_attention_test import \
+    ScaledDotProductAttentionTest
+from tests.pytorch_tests.model_tests.feature_models.second_moment_correction_test import ConvSecondMomentNetTest, \
+    ConvTSecondMomentNetTest, MultipleInputsConvSecondMomentNetTest, ValueSecondMomentTest
 from tests.pytorch_tests.model_tests.feature_models.shift_negative_activation_test import ShiftNegaviteActivationNetTest
 from tests.pytorch_tests.model_tests.feature_models.split_concat_net_test import SplitConcatNetTest
+from tests.pytorch_tests.model_tests.feature_models.symmetric_activation_test import SymmetricActivationTest
+from tests.pytorch_tests.model_tests.feature_models.test_softmax_shift import SoftmaxLayerNetTest, \
+    SoftmaxFunctionNetTest
 from tests.pytorch_tests.model_tests.feature_models.torch_tensor_attr_net_test import TorchTensorAttrNetTest
-from tests.pytorch_tests.model_tests.feature_models.bn_function_test import BNFNetTest
-from tests.pytorch_tests.model_tests.feature_models.gptq_test import GPTQAccuracyTest, GPTQWeightsUpdateTest, \
-    GPTQLearnRateZeroTest
+from tests.pytorch_tests.model_tests.feature_models.tpc_test import TpcTest
 from tests.pytorch_tests.model_tests.feature_models.uniform_activation_test import \
     UniformActivationTest
-from tests.pytorch_tests.model_tests.feature_models.metadata_test import MetadataTest
-from tests.pytorch_tests.model_tests.feature_models.tpc_test import TpcTest
-from tests.pytorch_tests.model_tests.feature_models.const_representation_test import ConstRepresentationTest, \
-    ConstRepresentationMultiInputTest, ConstRepresentationLinearLayerTest, ConstRepresentationGetIndexTest, \
-    ConstRepresentationCodeTest
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from tests.pytorch_tests.model_tests.feature_models.const_quantization_test import ConstQuantizationTest, \
-    AdvancedConstQuantizationTest, ConstQuantizationMultiInputTest, ConstQuantizationExpandTest
-from tests.pytorch_tests.model_tests.feature_models.remove_identity_test import RemoveIdentityTest
-from tests.pytorch_tests.model_tests.feature_models.activation_16bit_test import Activation16BitTest, \
-    Activation16BitMixedPrecisionTest
-from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
 
 
 class FeatureModelsTestRunner(unittest.TestCase):
@@ -659,7 +659,6 @@ def test_gptq_with_gradual_activation(self):
     def test_gptq_with_sample_layer_attention(self):
         kwargs = dict(sample_layer_attention=True, loss=sample_layer_attention_loss,
                       hessian_weights=True, hessian_num_samples=None,
-                      estimator_distribution=HessianEstimationDistribution.RADEMACHER,
                       norm_scores=False, log_norm_weights=False, scaled_log_norm=False)
         GPTQAccuracyTest(self, **kwargs).run_test()
         GPTQAccuracyTest(self, hessian_batch_size=16, rounding_type=RoundingType.SoftQuantizer, **kwargs).run_test()