Implement resize_layers, proving utilities useful

But showing that some things are too granual right now and may
  be less flexible than I want them to be.
* API usage shouldn't be so dependent on passing around strings
  - That's kind of pathetic
  + Make an informed decision about what's best for the API, then
    do it.
* Since redo_layer() is so effective, use it to lower the import
  entity count.
* NIT: make_children_list should be something like 'children_as_list'

Author: stephenjfox

morph/nn/_types.py

@@ -6,4 +6,5 @@ def type_name(o):
 
 
 def type_supported(type_name: str) -> bool:
+    # NOTE: already considerd a constants file. I don't like that precident
     return type_name in ['Conv2d', 'Linear']

morph/nn/widen.py

@@ -1,50 +1,46 @@
 import torch.nn as nn
 
-from morph.nn.utils import make_children_list, group_layers_by_algo
+# TODO: nope. This is really long
+from morph.nn.utils import group_layers_by_algo, layer_is_conv2d, make_children_list, new_input_layer, new_output_layer, redo_layer, type_name, type_supported
+
 
 # TODO: refactor out width_factor
-def new_resize_layers(net: nn.Module):
-    
+def resize_layers(net: nn.Module):
+
     old_layers = make_children_list(net.named_children())
     (first_name, first_layer), middle, last = group_layers_by_algo(old_layers)
-    
-    last_out = first_layer.out_channels # count of the last layer's out features
-    
-    new_out_next_in = int(last_out * 1.4)
-    
-    # NOTE: is there a better way to do this part?
-    network = nn.Module() # new network
-    
-    network.add_module(first_name, nn.Conv2d(
-        first_layer.in_channels, new_out_next_in, kernel_size=first_layer.kernel_size,
-        stride=first_layer.stride
-    ))
-    
+
+    first_layer_output_size = first_layer.out_channels  # count of the last layer's out features
+
+    new_out_next_in = int(first_layer_output_size * 1.4)
+
+    # NOTE: is there a better way to do this part? Maybe nn.Sequential?
+    network = nn.Module()  # new network
+
+    network.add_module(
+        first_name,
+        new_input_layer(first_layer, type_name(first_layer), out_dim=new_out_next_in))
+
     # TODO: format and utilize the functions in utils for making layers
-    for name, child in middle:        
-        # otherwise, we want to 
-        type_name = type(child).__name__
-        if type_name in ['Conv2d', 'Linear']:
-
-            temp = 0
-            if type_name == 'Conv2d':
-                temp = int(child.out_channels * 1.4)
-                network.add_module(name, nn.Conv2d(
-                    new_out_next_in, out_channels=temp,
-                    kernel_size=child.kernel_size, stride=child.stride
-                ))
-            else: # type_name == 'Linear'
-                temp = int(child.out_features * 1.4)
-                network.add_module(name, nn.Linear(
-                    in_features=new_out_next_in, out_features=temp
-                ))
-                
-            new_out_next_in = temp
-    
+    for name, child in middle:
+        # otherwise, we want to
+        _t = type_name(child)
+        if type_supported(_t):
+
+            new_out = 0
+            # TODO: look up performance on type name access. Maybe this could just be layer_is_conv2d(child)
+            if layer_is_conv2d(_t):
+                new_out = int(child.out_channels * 1.4)
+            else:  # type_name == 'Linear'
+                new_out = int(child.out_features * 1.4)
+
+            new_layer = redo_layer(child, new_in=new_out_next_in, new_out=new_out)
+            new_out_next_in = new_out
+            network.add_module(name, new_layer)
+
     last_name, last_layer = last
-    network.add_module(last_name, nn.Conv2d(
-        new_out_next_in, last_layer.out_channels,
-        kernel_size=last_layer.kernel_size, stride=last_layer.stride
-    ))
-    
+    network.add_module(
+        last_name,
+        new_output_layer(last_layer, type_name(last_layer), in_dim=new_out_next_in))
+
     return network