diff --git a/src/backends/tosaCommon/operatorMappings/ActivationOperator.cpp b/src/backends/tosaCommon/operatorMappings/ActivationOperator.cpp
index c17c4c7..480cdf5 100644
--- a/src/backends/tosaCommon/operatorMappings/ActivationOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/ActivationOperator.cpp
@@ -126,49 +126,43 @@
         std::string outputNameRescaleIdentity   = std::string("intermediate4_") + GetUniqueTosaMappingID();
         std::string outputNameRescaleMaxMin     = std::string("intermediate5_") + GetUniqueTosaMappingID();
 
-        DType rescale_type      = DType::DType_INT32;
-        float alpha             = activationDescriptor->m_A;
-        double scale_alpha      = inputs[0]->GetQuantizationScale() * alpha / outputs[0]->GetQuantizationScale();
-        double scale_identity   = inputs[0]->GetQuantizationScale() / outputs[0]->GetQuantizationScale();
-        int32_t input_zp        = inputs[0]->GetQuantizationOffset();
-        int32_t output_zp       = outputs[0]->GetQuantizationOffset();
+        DType rescale_type    = DType::DType_INT32;
+        float alpha           = activationDescriptor->m_A;
+        double scale_alpha    = inputs[0]->GetQuantizationScale() * alpha / outputs[0]->GetQuantizationScale();
+        double scale_identity = inputs[0]->GetQuantizationScale() / outputs[0]->GetQuantizationScale();
+        int32_t input_zp      = inputs[0]->GetQuantizationOffset();
+        int32_t output_zp     = outputs[0]->GetQuantizationOffset();
 
         // Value op_rescale_alpha_in =
         //        buildRescale(rewriter, op, rescale_type, input, scale_alpha,
         //                     input_qtype.getZeroPoint(), 0, true, true);
         TosaSerializationOperator* rescaleAlphaOp = nullptr;
-        TosaSerializationTensor* rescaleAlphaTensor = nullptr;
         CreateRescaleTosaOperator(inputName,
                                   outputNameRescaleAlpha,
-                                  rescale_type,
-                                  inputShape0,
                                   scale_alpha,
                                   input_zp,
                                   0,
                                   true,
                                   true,
-                                  &rescaleAlphaOp,
-                                  &rescaleAlphaTensor);
-        tensors.push_back(rescaleAlphaTensor);
-
+                                  &rescaleAlphaOp);
+        tensors.push_back(new TosaSerializationTensor(outputNameRescaleAlpha,
+                                                      GetTosaTensorShape(inputs[0]->GetShape()),
+                                                      rescale_type, {}));
         // Value op_rescale_identity_in =
         //       buildRescale(rewriter, op, rescale_type, input, scale_identity,
         //                    input_qtype.getZeroPoint(), 0, true, true);
         TosaSerializationOperator* rescaleIdentityOp = nullptr;
-        TosaSerializationTensor* rescaleIdentityTensor = nullptr;
         CreateRescaleTosaOperator(inputName,
                                   outputNameRescaleIdentity,
-                                  rescale_type,
-                                  inputShape0,
                                   scale_identity,
                                   input_zp,
                                   0,
                                   true,
                                   true,
-                                  &rescaleIdentityOp,
-                                  &rescaleIdentityTensor);
-        tensors.push_back(rescaleIdentityTensor);
-
+                                  &rescaleIdentityOp);
+        tensors.push_back(new TosaSerializationTensor(outputNameRescaleIdentity,
+                                                      GetTosaTensorShape(inputs[0]->GetShape()),
+                                                      rescale_type, {}));
         // Value result_int32;
         // if (alpha <= 1.0) {
         //    auto max_op = CreateOpAndInfer<tosa::MaximumOp>(
@@ -199,19 +193,18 @@
                                                {outputNameRescaleMaxMin});
 
         }
-        tensors.push_back(new TosaSerializationTensor(outputNameRescaleMaxMin, inputShape0, rescale_type, {}));
+        tensors.push_back(new TosaSerializationTensor(outputNameRescaleMaxMin,
+                                                      GetTosaTensorShape(inputs[0]->GetShape()),
+                                                      rescale_type, {}));
 
         // Value output = buildRescaleFromInt32(rewriter, op, output_type, result_int32,
         //                                      1.0, output_qtype.getZeroPoint());
         TosaSerializationOperator* rescaleOutputOp = nullptr;
         CreateFromInt32RescaleTosaOperator(outputNameRescaleMaxMin,
                                            outputName,
-                                           outputDType0,
-                                           outputShape0,
                                            1.0,
                                            output_zp,
-                                           &rescaleOutputOp,
-                                           nullptr);
+                                           &rescaleOutputOp);
 
         // operatorInputNames/operatorOutputNames ends up being the same as
         // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
index 1c8682b..96701d4 100644
--- a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
@@ -140,7 +140,6 @@
                                                     {convOutStr});
     operators.push_back(conv2d_op);
 
-
     if (isInputInt8)
     {
         int32_t output_zp = outputs[0]->GetQuantizationOffset();
@@ -149,11 +148,8 @@
         const std::vector<float>& weight_scales = inputs[1]->GetQuantizationScales();
 
         TosaSerializationOperator* rescaleOp = nullptr;
-        TosaSerializationTensor* rescaleTensor = nullptr;
         CreateRescaleTosaOperatorPerChannel(outputConv2dName,
                                             outputName,
-                                            DType_INT8,
-                                            outputShape0,
                                             0,
                                             output_zp,
                                             true,
@@ -161,11 +157,13 @@
                                             input_scale,
                                             output_scale,
                                             weight_scales,
-                                            &rescaleOp,
-                                            &rescaleTensor);
+                                            &rescaleOp);
         operators.push_back(rescaleOp);
-        tensors.push_back(rescaleTensor);
+        tensors.push_back(new TosaSerializationTensor(outputName,
+                                                      outputShape0,
+                                                      DType_INT8, {}));
     }
+
     // operatorInputNames/operatorOutputNames ends up being the same as
     // blockInputNames/blockOutputNames for one-to-one ArmNN to TOSA mappings
     return new TosaSerializationBasicBlock(blockName,     // name
diff --git a/src/backends/tosaCommon/operatorMappings/QuantizeOperator.cpp b/src/backends/tosaCommon/operatorMappings/QuantizeOperator.cpp
index 1a104d8..1242d3b 100644
--- a/src/backends/tosaCommon/operatorMappings/QuantizeOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/QuantizeOperator.cpp
@@ -55,7 +55,7 @@
 
     std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputInfo.GetShape());
     DType inputDType0 = ArmNNToDType(inputInfo.GetDataType());
-    float isFloatInput = inputDType0 == DType::DType_FP16 || inputDType0 == DType::DType_FP32;
+    bool isFloatInput = inputDType0 == DType::DType_FP16 || inputDType0 == DType::DType_FP32;
 
     // Only add input tensors if connected layer is an input layer.
     // As intermediate or constant tensors will be created separately.
@@ -147,19 +147,17 @@
         int32_t output_zp       = outputs[0]->GetQuantizationOffset();
 
         TosaSerializationOperator* rescaleOp = nullptr;
-        TosaSerializationTensor* rescaleTensor = nullptr;
         CreateRescaleTosaOperator(inputName,
                                   outputName,
-                                  outputDType0,
-                                  inputShape0,
                                   scale_alpha,
                                   input_zp,
                                   output_zp,
                                   true,
                                   true,
-                                  &rescaleOp,
-                                  &rescaleTensor);
-        tensors.push_back(rescaleTensor);
+                                  &rescaleOp);
+        tensors.push_back(new TosaSerializationTensor(outputName,
+                                                      inputShape0,
+                                                      outputDType0, {}));
 
         // operatorInputNames/operatorOutputNames ends up being the same as
         // blockInputNames/blockOutputNames for one-to-one ArmNN to TOSA mappings
diff --git a/src/backends/tosaCommon/operatorMappings/TosaRescaleOperatorUtils.hpp b/src/backends/tosaCommon/operatorMappings/TosaRescaleOperatorUtils.hpp
index 56337cf..c37d651 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaRescaleOperatorUtils.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaRescaleOperatorUtils.hpp
@@ -9,8 +9,6 @@
 
 inline void CreateRescaleTosaOperator(const std::string& inputName,
                                       const std::string& outputName,
-                                      DType output_type,
-                                      const std::vector<int32_t>& shape,
                                       const std::vector<int32_t>& multipliers,
                                       const std::vector<int32_t>& shifts,
                                       int32_t input_zp,
@@ -18,8 +16,7 @@
                                       bool double_round,
                                       bool scale32,
                                       bool per_channel,
-                                      TosaSerializationOperator** op,
-                                      TosaSerializationTensor** tensor)
+                                      TosaSerializationOperator** op)
 {
     if (!op)
     {
@@ -42,21 +39,10 @@
     {
         throw armnn::Exception("CreateRescaleTosaOperator: failed to created operator");
     }
-    if (tensor != nullptr)
-    {
-        // tensor
-        *tensor = new TosaSerializationTensor(outputName, shape, output_type, {});
-        if (! (*tensor))
-        {
-            throw armnn::Exception("CreateRescaleTosaOperator: failed to created tensor");
-        }
-    }
 }
 
 inline void CreateRescaleTosaOperator(const std::string& inputName,
                                       const std::string& outputName,
-                                      DType output_type,
-                                      const std::vector<int32_t>& shape,
                                       int32_t scale_multiplier,
                                       int32_t scale_shift,
                                       int32_t input_zp,
@@ -64,13 +50,12 @@
                                       bool double_round,
                                       bool scale32,
                                       bool per_channel,
-                                      TosaSerializationOperator** op,
-                                      TosaSerializationTensor** tensor)
+                                      TosaSerializationOperator** op)
 {
     const std::vector<int32_t> multipliers{scale_multiplier};
     const std::vector<int32_t> shifts{scale_shift};
-    CreateRescaleTosaOperator(inputName, outputName, output_type, shape, multipliers, shifts,
-                              input_zp, output_zp, double_round, scale32, per_channel, op, tensor);
+    CreateRescaleTosaOperator(inputName, outputName, multipliers, shifts,
+                              input_zp, output_zp, double_round, scale32, per_channel, op);
 }
 
 /// The following is taken from mlir/lib/Dialect/Tosa/Utils/QuantUtils.cpp in the LLVM project
@@ -165,15 +150,12 @@
 
 inline void CreateRescaleTosaOperator(const std::string& inputName,
                                       const std::string& outputName,
-                                      DType output_type,
-                                      const std::vector<int32_t>& shape,
                                       double scale,
                                       int32_t input_zp,
                                       int32_t output_zp,
                                       bool double_round,
                                       bool scale32,
-                                      TosaSerializationOperator** op,
-                                      TosaSerializationTensor** tensor)
+                                      TosaSerializationOperator** op)
 {
     int32_t multiplier;
     int32_t shift;
@@ -187,14 +169,12 @@
         ComputeMultiplierAndShiftTosaScale16(scale, multiplier, shift);
     }
 
-    CreateRescaleTosaOperator(inputName, outputName, output_type, shape, multiplier, shift,
-                              input_zp, output_zp, double_round, scale32, false, op, tensor);
+    CreateRescaleTosaOperator(inputName, outputName, multiplier, shift,
+                              input_zp, output_zp, double_round, scale32, false, op);
 }
 
 inline void CreateRescaleTosaOperatorPerChannel(const std::string& inputName,
                                                 const std::string& outputName,
-                                                DType output_type,
-                                                const std::vector<int32_t>& shape,
                                                 int32_t input_zp,
                                                 int32_t output_zp,
                                                 bool double_round,
@@ -202,8 +182,7 @@
                                                 double input_scale,
                                                 double output_scale,
                                                 const std::vector<float>& weight_scales,
-                                                TosaSerializationOperator** op,
-                                                TosaSerializationTensor** tensor)
+                                                TosaSerializationOperator** op)
 {
     std::vector<int32_t> op_tensor_multipliers;
     std::vector<int32_t> op_tensor_shifts;
@@ -229,19 +208,16 @@
         op_tensor_shifts.push_back(shift);
     }
 
-    CreateRescaleTosaOperator(inputName, outputName, output_type, shape, op_tensor_multipliers, op_tensor_shifts,
-                              input_zp, output_zp, double_round, scale32, true, op, tensor);
+    CreateRescaleTosaOperator(inputName, outputName, op_tensor_multipliers, op_tensor_shifts,
+                              input_zp, output_zp, double_round, scale32, true, op);
 }
 
 inline void CreateFromInt32RescaleTosaOperator(const std::string& inputName,
                                                const std::string& outputName,
-                                               DType output_type,
-                                               const std::vector<int32_t>& shape,
                                                double output_scale,
                                                int32_t output_zp,
-                                               TosaSerializationOperator** op,
-                                               TosaSerializationTensor** tensor)
+                                               TosaSerializationOperator** op)
 {
-    CreateRescaleTosaOperator(inputName, outputName, output_type, shape, output_scale,
-                              0, output_zp, true, true, op, tensor);
+    CreateRescaleTosaOperator(inputName, outputName, output_scale,
+                              0, output_zp, true, true, op);
 }