Fix the warning related to Multi-directional Broadcasting

Author: Neel-Shah-29

tmva/sofie/inc/TMVA/SOFIE_common.hxx

@@ -105,8 +105,8 @@ ETensorType GetTemplatedType(T /*obj*/ ){
 namespace UTILITY{
 template<typename T>
 T* Unidirectional_broadcast(const T* original_data, const std::vector<size_t> original_shape, const std::vector<size_t> target_shape);
-template <typename T>
-std::vector<size_t> Multidirectional_broadcast(const T* original_data,  std::vector<size_t> input1_shape, std::vector<size_t> input2_shape);
+
+std::vector<size_t> Multidirectional_broadcast(std::vector<size_t> input1_shape, std::vector<size_t> input2_shape);
 std::string Clean_name(std::string input_tensor_name);
 
 

tmva/sofie/src/SOFIE_common.cxx

@@ -135,41 +135,21 @@ T* UTILITY::Unidirectional_broadcast(const T* original_data, const std::vector<s
       return new_datavector;
 }
 
-template <typename T>
-std::vector<size_t>  UTILITY::Multidirectional_broadcast(const T* original_data, std::vector<size_t> input1_shape,  std::vector<size_t> input2_shape)
+
+
+std::vector<size_t>  UTILITY::Multidirectional_broadcast(std::vector<size_t> input1_shape,  std::vector<size_t> input2_shape)
 {
    std::vector<size_t> input_shape = (input1_shape > input2_shape)?input1_shape:input2_shape;
    std::vector<size_t> output_shape(input_shape);
 
-   //check if both the input have same shape, nothing to do directly return the output_shape as the same shape.
-   if(input1_shape.size() == input2_shape.size()){
-      if(input1_shape == input2_shape){
-         return output_shape;
-      }
-      else{
-   //Check the shape values, if input1[i] not equal to input2[i] we have the result shape equal to input1[i] if input2[i] = 1 or viceversa
-         for(size_t j = 0; j < input1_shape.size() ; j++){
-            if(input1_shape[j] == input2_shape[j]){
-               output_shape[j] = input1_shape[j];
-            }
-            else if(input1_shape[j] > input2_shape[j] && input2_shape[j] == 1){
-               output_shape[j] = input1_shape[j];
-            }
-            else if(input2_shape[j] > input1_shape[j] && input1_shape[j] == 1){
-               output_shape[j] = input2_shape[j];
-            }
-         }
-         return output_shape;
-      }
-   }
-   else if(input1_shape.size() < input2_shape.size()){
+   if(input1_shape.size() < input2_shape.size()){
    // Check if input1_shape.size() < input2_shape.size() we insert in the shape vector values of 1 at the beginning of the tensor until input1_shape.size() == input2_shape.size()
       auto it = input1_shape.begin();
       while (input1_shape.size() < input2_shape.size()) {
          it = input1_shape.insert(it, 1);
       }
       if(input1_shape.size()==input1_shape.size()){
-         UTILITY::Multidirectional_broadcast(original_data,input1_shape,input2_shape);
+         UTILITY::Multidirectional_broadcast(input1_shape,input2_shape);
       }
    }
    else if(input2_shape.size() < input1_shape.size()){
@@ -179,9 +159,28 @@ std::vector<size_t>  UTILITY::Multidirectional_broadcast(const T* original_data,
          it = input2_shape.insert(it, 1);
       }
       if(input1_shape.size()==input1_shape.size()){
-         UTILITY::Multidirectional_broadcast(original_data,input1_shape,input2_shape);
+         UTILITY::Multidirectional_broadcast(input1_shape,input2_shape);
       }
    }
+      //check if both the input have same shape, nothing to do directly return the output_shape as the same shape.
+   else if(input1_shape.size() == input2_shape.size()){
+      if(input1_shape != input2_shape){
+         //Check the shape values, if input1[i] not equal to input2[i] we have the result shape equal to input1[i] if input2[i] = 1 or viceversa
+         for(size_t j = 0; j < input1_shape.size() ; j++){
+            if(input1_shape[j] == input2_shape[j]){
+               output_shape[j] = input1_shape[j];
+            }
+            else if(input1_shape[j] > input2_shape[j] && input2_shape[j] == 1){
+               output_shape[j] = input1_shape[j];
+            }
+            else if(input2_shape[j] > input1_shape[j] && input1_shape[j] == 1){
+               output_shape[j] = input2_shape[j];
+            }
+         }
+      }
+
+   }
+   return output_shape;
 
 }
 
@@ -192,7 +191,6 @@ std::string UTILITY::Clean_name(std::string input_tensor_name){
 }
 
 template float* UTILITY::Unidirectional_broadcast(const float* original_data, const std::vector<size_t> original_shape, const std::vector<size_t> target_shape);
-template std::vector<size_t>  UTILITY::Multidirectional_broadcast(const float* original_data, std::vector<size_t> input1_shape, std::vector<size_t> input2_shape);
 
 }//SOFIE
 }//Experimental

tmva/sofie_parsers/src/RModelParser_ONNX.cxx

@@ -40,8 +40,8 @@ std::unique_ptr<ROperator> make_ROperator_BasicBinary(const onnx::NodeProto& nod
       } else {
          // check if input tensor is an initialized tensor
          bool isInitializer = false;
-         for (int i=0; i < graphproto.initializer_size(); i++){
-            if (input_name == graphproto.initializer(i).name()) {
+         for (int j=0; j < graphproto.initializer_size(); j++){
+            if (input_name == graphproto.initializer(j).name()) {
                isInitializer = true;
                break;
             }