fix len(modules)=0 case

calc_util.py

@@ -65,10 +65,11 @@ def word_embedding_operation(model_config, inference_config):
     #\end{equation}
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'embed' in x and 'pos' not in x, model_config['module_classes'])
-        A = [inference_config['batchsize'], inference_config['input_seq_length'], modules[0][0]]
-        B = modules[0]
-        op_count = matrix_operation(A, B)
-        return op_count
+        if len(modules) > 0:
+            A = [inference_config['batchsize'], inference_config['input_seq_length'], modules[0][0]]
+            B = modules[0]
+            op_count = matrix_operation(A, B)
+            return op_count
 
     A = [inference_config['batchsize'], inference_config['input_seq_length'], model_config['vocab_size']]
     B = [model_config['vocab_size'], model_config['hidden_size']]
@@ -79,7 +80,8 @@ def word_embedding_operation(model_config, inference_config):
 def positional_embedding_operation(model_config, inference_config):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'embed' in x and 'pos' in x, model_config['module_classes'])
-        return multiplication_in_int64([inference_config['batchsize'], inference_config['input_seq_length'], modules[0][-1]])
+        if len(modules) > 0:
+            return multiplication_in_int64([inference_config['batchsize'], inference_config['input_seq_length'], modules[0][-1]])
 
     return multiplication_in_int64([inference_config['batchsize'], inference_config['input_seq_length'], model_config['hidden_size']])
 
@@ -87,15 +89,16 @@ def positional_embedding_operation(model_config, inference_config):
 def attention_K_operation(model_config, inference_config, seq_length):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'att' in x and 'k' in x , model_config['module_classes'])
-        total = 0
-        for module in modules:
-            if len(module) > 1:
-                A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
-                B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
-                total += model_config['num_attention_heads']*matrix_operation(A, B)
-            else:
-                total += model_config['hidden_size']
-        return total
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                if len(module) > 1:
+                    A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
+                    B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
+                    total += model_config['num_attention_heads']*matrix_operation(A, B)
+                else:
+                    total += model_config['hidden_size']
+            return total
 
     A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
     B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
@@ -104,15 +107,16 @@ def attention_K_operation(model_config, inference_config, seq_length):
 def attention_Q_operation(model_config, inference_config, seq_length):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'att' in x and 'q' in x , model_config['module_classes'])
-        total = 0
-        for module in modules:
-            if len(module) > 1:
-                A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
-                B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
-                total += model_config['num_attention_heads']*matrix_operation(A, B)
-            else:
-                total += model_config['hidden_size']
-        return total
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                if len(module) > 1:
+                    A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
+                    B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
+                    total += model_config['num_attention_heads']*matrix_operation(A, B)
+                else:
+                    total += model_config['hidden_size']
+            return total
      
     A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
     B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
@@ -121,15 +125,16 @@ def attention_Q_operation(model_config, inference_config, seq_length):
 def attention_V_operation(model_config, inference_config, seq_length):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'att' in x and 'v' in x , model_config['module_classes'])
-        total = 0
-        for module in modules:
-            if len(module) > 1:
-                A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
-                B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
-                total += model_config['num_attention_heads']*matrix_operation(A, B)
-            else:
-                total += model_config['hidden_size']
-        return total
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                if len(module) > 1:
+                    A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
+                    B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
+                    total += model_config['num_attention_heads']*matrix_operation(A, B)
+                else:
+                    total += model_config['hidden_size']
+            return total
      
     A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
     B = [model_config['hidden_size'], model_config['hidden_size_per_head']]
@@ -155,15 +160,16 @@ def attention_multV_operation(model_config, inference_config, seq_length_Q, seq_
 def attention_out_operation(model_config, inference_config, seq_length):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'att' in x and 'k' in x , model_config['module_classes'])
-        total = 0
-        for module in modules:
-            if len(module) > 1:
-                A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
-                B = [model_config['hidden_size'], model_config['hidden_size']]
-                total += matrix_operation(A, B)
-            else:
-                total += model_config['hidden_size']
-        return total
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                if len(module) > 1:
+                    A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
+                    B = [model_config['hidden_size'], model_config['hidden_size']]
+                    total += matrix_operation(A, B)
+                else:
+                    total += model_config['hidden_size']
+            return total
     
     A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
     B = [model_config['hidden_size'], model_config['hidden_size']]
@@ -174,11 +180,12 @@ def layernorm_operation(model_config, inference_config, seq_length):
     # 5 is a modeled value
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'norm' in x, model_config['module_classes'])
-        total = 0
-        for module in modules:
-            total += model_config['hidden_size']
-        return 5*total
-    
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                total += model_config['hidden_size']
+            return 5*total
+        
     layernorm_operation = (5*inference_config['batchsize']*seq_length*model_config['hidden_size'])
     return model_config['num_hidden_layers'] * model_config['layernorm_operation'] * layernorm_operation
 
@@ -186,15 +193,16 @@ def layernorm_operation(model_config, inference_config, seq_length):
 def mlp_operation(model_config, inference_config, seq_length):
     if model_config['module_classes']:
         modules = get_module_tensors_matched(lambda x: 'fc' in x or 'mlp' in x, model_config['module_classes'])
-        total = 0
-        for module in modules:
-            if len(module) > 1:
-                A = [inference_config['batchsize'], seq_length, module[1]]
-                B = [module[1], module[0]]
-                total += matrix_operation(A, B)
-            else:
-                total += modules[-1][0]
-        return total
+        if len(modules) > 0:
+            total = 0
+            for module in modules:
+                if len(module) > 1:
+                    A = [inference_config['batchsize'], seq_length, module[1]]
+                    B = [module[1], module[0]]
+                    total += matrix_operation(A, B)
+                else:
+                    total += modules[-1][0]
+            return total
     
     A = [inference_config['batchsize'], seq_length, model_config['hidden_size']]
     B = [model_config['hidden_size'], model_config['intermediate_size']]