Format with YAPF

Google style, with 92-char line length
* 80 is arbitrarily small
* 130 is ridiculous
* 90-ish is recommended by Raymond Hettinger

Author: stephenjfox

demo.py

@@ -8,12 +8,13 @@
 
 from morph._models import EasyMnist
 
+
 def main():
     my_model = EasyMnist()
     # do one pass through the algorithm
     modified = morph.once(my_model)
 
-    print(modified) # proof that the thing wasn't tampered with
+    print(modified)  # proof that the thing wasn't tampered with
 
     my_dataloader = DataLoader(TensorDataset(torch.randn(2, 28, 28)))
 
@@ -23,4 +24,4 @@ def main():
 
 
 if __name__ == '__main__':
-    main() # TODO: add commandline arguments?
+    main()  # TODO: add commandline arguments?

morph/_models.py

@@ -2,7 +2,9 @@
 import torch.nn as nn
 import torch.nn.functional as F
 
+
 class EasyMnist(nn.Module):
+
     def __init__(self):
         super().__init__()
         self.linear1 = nn.Linear(784, 1000)
@@ -13,7 +15,7 @@ def forward(self, x_batch: torch.Tensor):
         """Simple ReLU-based activations through all layers of the DNN.
         Simple and effectively deep neural network. No frills.
         """
-        _input = x_batch.view(-1, 784) # shape for our linear1
+        _input = x_batch.view(-1, 784)  # shape for our linear1
         out1 = F.relu(self.linear1(x_batch))
         out2 = F.relu(self.linear2(out1))
         out3 = F.relu(self.linear3(out2))

morph/layers/sparse.py

@@ -3,6 +3,7 @@
 
 _ZERO_TENSOR = torch.tensor(0.)
 
+
 def sparsify(tensor: torch.Tensor, threshold: float = 0.0) -> torch.Tensor:
     """Sparsify a `tensor` with `0.0` for all values that do not meet the `threshold`.
     Defaults to rejecting negative numbers.
@@ -18,6 +19,7 @@ def sparsify(tensor: torch.Tensor, threshold: float = 0.0) -> torch.Tensor:
     """
     return tensor.where(tensor > threshold, _ZERO_TENSOR)
 
+
 def percent_waste(layer: nn.Module) -> float:
     """Computes the number of sparse neurons in a weight matrix,
     given the supplied layer.

morph/layers/widen.py

@@ -5,6 +5,7 @@
 
 from ..nn.utils import layer_has_bias
 
+
 # NOTE: should factor be {smaller, default at all}?
 # TODO: Research - is there a better type for layer than nn.Module?
 def widen(layer: nn.Module, factor=1.4, in_place=False) -> nn.Module:
@@ -29,24 +30,24 @@ def widen(layer: nn.Module, factor=1.4, in_place=False) -> nn.Module:
     # we know that layer.weight.size()[0] is the __output__ dimension in the linear case
     output_dim = 0
     if isinstance(layer, nn.Linear):
-        output_dim = layer.weight.size()[0] # FIXME: switch to layer.out_features?
-        input_dim = layer.weight.size()[1] # FIXME: switch to layer.in_features?
+        output_dim = layer.weight.size()[0]  # FIXME: switch to layer.out_features?
+        input_dim = layer.weight.size()[1]  # FIXME: switch to layer.in_features?
     # TODO: other classes, for robustness?
     # TODO: Use dictionary look-ups instead, because they're faster?
     else:
         raise ValueError('unsupported layer type:', type(layer))
-    
+
     logging.debug(f"current dimensions: {(output_dim, input_dim)}")
-    
-    new_size = round(factor * output_dim + .5) # round up, not down, if we can
-    
+
+    new_size = round(factor * output_dim + .5)  # round up, not down, if we can
+
     # We're increasing layer width from output_dim to new_size, so let's save that for later
     size_diff = new_size - output_dim
     # make the difference even, because it's easier to surrond the old weights
     if size_diff % 2 == 1: size_diff += 1
-    
-    with torch.no_grad():        
-        
+
+    with torch.no_grad():
+
         expanded_weights = _expand_bias_or_weight(layer.weight, size_diff)
         expanded_bias = _expand_bias_or_weight(layer.bias, size_diff)
 
@@ -58,7 +59,9 @@ def widen(layer: nn.Module, factor=1.4, in_place=False) -> nn.Module:
             layer.out_features = new_size
             layer.weight = p_weights
             layer.bias = p_bias
-            logging.warning('Using experimental "in-place" version. May have unexpected affects on activation.')
+            logging.warning(
+                'Using experimental "in-place" version. May have unexpected affects on activation.'
+            )
             return layer
         else:
             print(f"New shape = {expanded_weights.shape}")
@@ -67,6 +70,7 @@ def widen(layer: nn.Module, factor=1.4, in_place=False) -> nn.Module:
             l.bias = p_bias
             return l
 
+
 def _expand_bias_or_weight(t: nn.Parameter, increase: int) -> torch.Tensor:
     """Returns a tensor of shape `t`, with padding values drawn from a Guassian distribution
     with \mu = `torch.mean(layer.weight, dim=0)` and \sigma = `torch.std(layer.weight, dim=0)`.
@@ -88,19 +92,19 @@ def _expand_bias_or_weight(t: nn.Parameter, increase: int) -> torch.Tensor:
         # take the std and mean so we can sample from that normal distribution
         std = torch.std(t, dim=0)
         mean = torch.mean(t, dim=0)
-    
+
         # We sandwich the existing tensor between new tensors with tensor.cat(t_0, t_1, ... t_n)
         # the data takes the following shape (all at the same dimension)
         # [samples * (increase // 2), t.data, more_samples * (increase // 2)],
 
         new_values = torch.normal(mean, std).unsqueeze(0)
-        
+
         for _ in range(increase // 2 - 1):
             new_values = torch.cat((torch.normal(mean, std).unsqueeze(0), new_values))
-        
+
         new_values = torch.cat((new_values, t.data))
-        
+
         for _ in range(increase // 2):
             new_values = torch.cat((new_values, torch.normal(mean, std).unsqueeze(0)))
-        
+
         return new_values

morph/nn/_morph_net.py

@@ -2,23 +2,22 @@
 import torch.nn as nn
 from torch.utils.data import DataLoader
 
+
 class Morph(nn.Module):
     """An encapsulation of the benefits of MorphNet, namely:
     1. automatically shrinking and widening, to produce a new architecture w.r.t. layer widths
     2. Training of the network, to match (or beat) model performance
     3. 
     """
-    
+
     @classmethod
     def shrink_out(cls, child_layer):
         new_out = int(child_layer.out_features * percent_waste(child_layer))
         return nn.Linear(child_layer.in_features, new_out)
-    
+
     def __init__(self, net: nn.Module, epochs: int, dataloader: DataLoader):
         super().__init__()
-        self.layers = nn.ModuleList([
-            Morph.shrink_out(c) for c in net.children()
-        ])
+        self.layers = nn.ModuleList([Morph.shrink_out(c) for c in net.children()])
 
     def run_training(self):
         """Performs the managed training for this instance"""

morph/nn/morph.py

@@ -1,5 +1,6 @@
 import torch.nn as nn
 
+
 def once(net: nn.Module, experimental_support=False) -> nn.Module:
     """Runs an experimental implementation of the MorphNet algorithm on `net`
       producing a new network:

morph/nn/shrink.py

@@ -1,29 +1,27 @@
 import torch
 import torch.nn as nn
 
-
-
 #################### HELPERS ####################
 
+
 def _group_layers_by_algo(children_list):
     """Group the layers into how they will be acted upon by my implementation of the algorithm:
     1. First child in the list
     2. Slice of all the child, those that are not first nor last
     3. Last child in the list
     """
-    
+
     list_len = len(children_list)
-    
+
     # validate input in case I slip up
     if list_len < 1:
         raise ValueError('Invalid argument:', children_list)
-    
+
     if list_len <= 2:
-        return children_list # interface?
+        return children_list  # interface?
 
-    
     first = children_list[0]
     middle = children_list[1:-1]
     last = children_list[-1]
-    
+
     return first, middle, last

morph/nn/utils.py

@@ -1,82 +1,109 @@
 import torch.nn as nn
 
+
 def layer_has_bias(layer: nn.Module) -> bool:
     return not layer.bias is None
 
+
 def make_children_list(children_or_named_children):
     """Receives `nn.Module.children()` or `nn.Module.named_children()`.
     Returns: that generator collected as a list
     """
     return [c for c in children_or_named_children]
 
+
 #################### NEW LAYERS ####################
 
-def new_layer(base_layer: nn.Module, type_name: str, in_dim: int, out_dim: int) -> nn.Module:
+
+def new_layer(base_layer: nn.Module, type_name: str, in_dim: int,
+              out_dim: int) -> nn.Module:
 
     has_bias = layer_has_bias(base_layer)
 
     if layer_is_linear(type_name):
         return nn.Linear(in_dim, out_dim, bias=has_bias)
-    
+
     if layer_is_conv2d(type_name):
-        return nn.Conv2d(in_dim, out_dim, kernel_size=base_layer.kernel_size,
-            stride=base_layer.stride, bias=has_bias)
+        return nn.Conv2d(
+            in_dim,
+            out_dim,
+            kernel_size=base_layer.kernel_size,
+            stride=base_layer.stride,
+            bias=has_bias)
 
     raise ValueError('User got around type check ;)')
 
+
 def new_input_layer(base_layer: nn.Module, type_name: str, out_dim: int) -> nn.Module:
     has_bias = layer_has_bias(base_layer)
-    
+
     if layer_is_linear(type_name):
         return nn.Linear(base_layer.in_features, out_features=out_dim, bias=has_bias)
-        
+
     if layer_is_conv2d(type_name):
-        return nn.Conv2d(base_layer.in_channels, out_channels=out_dim,
-            kernel_size=base_layer.kernel_size, stride=base_layer.stride, bias=has_bias)
+        return nn.Conv2d(
+            base_layer.in_channels,
+            out_channels=out_dim,
+            kernel_size=base_layer.kernel_size,
+            stride=base_layer.stride,
+            bias=has_bias)
+
 
 def new_output_layer(base_layer: nn.Module, type_name: str, in_dim: int) -> nn.Module:
     has_bias = layer_has_bias(base_layer)
-    
+
     if layer_is_linear(type_name):
         return nn.Linear(in_dim, base_layer.out_features, bias=has_bias)
-        
+
     if layer_is_conv2d(type_name):
-        return nn.Conv2d(in_dim, base_layer.out_channels,
-            kernel_size=base_layer.kernel_size, stride=base_layer.stride, bias=has_bias)
+        return nn.Conv2d(
+            in_dim,
+            base_layer.out_channels,
+            kernel_size=base_layer.kernel_size,
+            stride=base_layer.stride,
+            bias=has_bias)
 
 
 def redo_layer(layer: nn.Module, new_in=None, new_out=None) -> nn.Module:
     if new_in is None and new_out is None:
-        return layer
-    
+        return layehr
+
     _type = type_name(layer)
     if not type_supported(_type):
         raise ValueError('Unsupported layer type:', _type)
-    
-    if new_in is not None and new_out is not None:
+
+    received_new_input = new_in is not None
+    received_new_output = new_out is not None
+
+    if received_new_input and received_new_output:
         return new_layer(layer, _type, new_in, new_out)
-    
-    if new_in is not None:
+
+    if received_new_input:
         # we need a new input dim, but retain the same output dim
         return new_output_layer(layer, _type, new_in)
-    
-    if new_out is not None:
+
+    if received_new_output:
         # we need a new output dim, but retain the same input dim
         return new_input_layer(layer, _type, new_out)
 
+
 #################### TYPE HELPERS ####################
 
+
 def layer_is_conv2d(name: str):
     return name == 'Conv2d'
 
+
 def layer_is_linear(name: str):
     return name == 'Linear'
 
+
 def type_name(o):
     '''Returns the simplified type name of the given object.
     Eases type checking, rather than any(isinstance(some_obj, _type) for _type in [my, types, to, check])
     '''
     return type(o).__name__
 
+
 def type_supported(type_name: str) -> bool:
-    return type_name in ['Conv2d', 'Linear']
+    return type_name in ['Conv2d', 'Linear']

morph/nn/utils_test.py

@@ -1,9 +1,11 @@
-import torch.nn as nn
 import unittest
+import torch.nn as nn
 
 from .utils import new_input_layer, new_output_layer
 
+
 class TestLayer(unittest.TestCase):
+
     def test_new_input_layer_only_touches_output_Linear(self):
         test = new_input_layer(nn.Linear(5, 4), 'Linear', 7)
         expected = nn.Linear(5, 7)
@@ -25,8 +27,7 @@ def test_new_output_layer_only_touches_output_Linear(self):
                          "The output dimensions should be unchanged")
 
     def test_new_output_layer_only_changes_input_Conv2d(self):
-        test = new_output_layer(
-            nn.Conv2d(3, 12, kernel_size=3, stride=1), 'Conv2d', 6)
+        test = new_output_layer(nn.Conv2d(3, 12, kernel_size=3, stride=1), 'Conv2d', 6)
         expected = nn.Conv2d(6, 12, 3, 1)
 
         self.assertEqual(expected.in_channels, test.in_channels,
@@ -39,8 +40,7 @@ def test_new_output_layer_only_changes_input_Conv2d(self):
                          "The padding aspect shoud be the same")
 
     def test_new_input_layer_only_changes_output_Conv2d(self):
-        test = new_input_layer(
-            nn.Conv2d(3, 12, kernel_size=3, stride=1), 'Conv2d', 16)
+        test = new_input_layer(nn.Conv2d(3, 12, kernel_size=3, stride=1), 'Conv2d', 16)
         expected = nn.Conv2d(3, 16, 3, 1)
 
         self.assertEqual(expected.in_channels, test.in_channels,

setup.cfg

@@ -1,2 +1,6 @@
 [metadata]
-description-file = README.md
+description-file = README.md
+
+[yapf]
+based_on_style = google
+column_limit = 92