update

correlation/foresight/pruners/measures/zen.py

@@ -0,0 +1,110 @@
+# Copyright 2021 Samsung Electronics Co., Ltd.
+#
+# 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.
+# =============================================================================
+
+import torch
+from torch import nn
+import numpy as np
+
+from . import measure
+
+
+def network_weight_gaussian_init(net: nn.Module):
+    with torch.no_grad():
+        for n, m in net.named_modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.normal_(m.weight)
+                if hasattr(m, 'bias') and m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.BatchNorm2d):
+                try:
+                    nn.init.ones_(m.weight)
+                    nn.init.zeros_(m.bias)
+                except:
+                    pass
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight)
+                if hasattr(m, 'bias') and m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            else:
+                continue
+
+    return net
+
+
+def get_zen(gpu, model, mixup_gamma=1e-2, resolution=32, batch_size=64, repeat=32,
+                      fp16=False):
+    info = {}
+    nas_score_list = []
+    if gpu is not None:
+        device = torch.device(gpu)
+    else:
+        device = torch.device('cpu')
+
+    if fp16:
+        dtype = torch.half
+    else:
+        dtype = torch.float32
+
+    with torch.no_grad():
+        for repeat_count in range(repeat):
+            network_weight_gaussian_init(model)
+            input = torch.randn(size=[batch_size, 3, resolution, resolution], device=device, dtype=dtype)
+            input2 = torch.randn(size=[batch_size, 3, resolution, resolution], device=device, dtype=dtype)
+            mixup_input = input + mixup_gamma * input2
+            output = model.forward_pre_GAP(input)
+            mixup_output = model.forward_pre_GAP(mixup_input)
+
+            nas_score = torch.sum(torch.abs(output - mixup_output), dim=[1, 2, 3])
+            nas_score = torch.mean(nas_score)
+
+            # compute BN scaling
+            log_bn_scaling_factor = 0.0
+            for m in model.modules():
+                if isinstance(m, nn.BatchNorm2d):
+                    try:
+                        bn_scaling_factor = torch.sqrt(torch.mean(m.running_var))
+                        log_bn_scaling_factor += torch.log(bn_scaling_factor)
+                    except:
+                        pass
+                pass
+            pass
+            nas_score = torch.log(nas_score) + log_bn_scaling_factor
+            nas_score_list.append(float(nas_score))
+
+    std_nas_score = np.std(nas_score_list)
+    avg_precision = 1.96 * std_nas_score / np.sqrt(len(nas_score_list))
+    avg_nas_score = np.mean(nas_score_list)
+
+    info = float(avg_nas_score)
+    return info
+
+
+
+
+
+@measure('zen', bn=True)
+def compute_zen(net, inputs, targets, split_data=1, loss_fn=None):
+    device = inputs.device
+    # Compute gradients (but don't apply them)
+    net.zero_grad()
+
+
+    try:
+        zen = get_zen(device,net)
+    except Exception as e:
+        print(e)
+        zen= np.nan
+
+    return zen