Merge pull request #38 from Tensor46/develop

Develop

Author: Tensor46

core/NeuralLayers/convolution.py

@@ -163,6 +163,9 @@ def __init__(self,
             if maintain_out_size:
                 out_pad = (tensor_size[2]*strides[0] - self.tensor_size[2],
                            tensor_size[3]*strides[1] - self.tensor_size[3])
+                self.tensor_size = (tensor_size[0], out_channels,
+                                    math.floor(h)+out_pad[0],
+                                    math.floor(w)+out_pad[1])
             self.Convolution = \
                 nn.ConvTranspose2d(tensor_size[1]//pre_expansion,
                                    out_channels*pst_expansion, filter_size,

core/NeuralLayers/linear.py

@@ -22,6 +22,7 @@ class Linear(nn.Module):
             default = None
         dropout (float): 0. - 1., default = 0.
         bias (bool): to enable bias, default = True
+        out_shape (tuple): a desired output shape in tuple with out batches
 
     Return:
         torch.Tensor of shape (B, out_features)
@@ -33,30 +34,45 @@ def __init__(self,
                  activation: str = None,
                  dropout: float = 0.,
                  bias: bool = True,
+                 out_shape: tuple = None,
                  **kwargs):
         super(Linear, self).__init__()
+        self.t_size = tuple(tensor_size)
         # Checks
-        assert type(tensor_size) in [int, list, tuple], \
-            "Linear: tensor_size must tuple/list"
+        if not type(tensor_size) in [int, list, tuple]:
+            raise TypeError("Linear: tensor_size must tuple/list")
 
         if isinstance(tensor_size, int):
             in_features = tensor_size
         else:
             assert len(tensor_size) >= 2, \
                 "Linear: when tuple/list, tensor_size must of length 2 or more"
             in_features = np.prod(tensor_size[1:])
-        assert isinstance(out_features, int), "Linear:out_features must be int"
-        assert isinstance(dropout, float), "Linear: dropout must be float"
-        if dropout > 0.:
+
+        if not isinstance(out_features, int):
+            raise TypeError("Linear:out_features must be int")
+
+        if not isinstance(dropout, float):
+            raise TypeError("Linear: dropout must be float")
+        if 1. > dropout > 0.:
             self.dropout = nn.Dropout2d(dropout)
+
         if isinstance(activation, str):
             activation = activation.lower()
         assert activation in [None, "", ] + Activations.available(),\
             "Linear: activation must be None/''/" + \
             "/".join(Activations.available())
-        assert isinstance(bias, bool), "Linear: bias must be bool"
-        multiplier = 2 if activation in ("maxo", "rmxo") else 1
+        self.act = activation
+
+        if not isinstance(bias, bool):
+            raise TypeError("Linear: bias must be bool")
 
+        if out_shape is not None:
+            assert np.prod(out_shape) == out_features, \
+                "Linear: np.prod(out_shape) != out_features"
+            self.out_shape = out_shape
+
+        multiplier = 2 if activation in ("maxo", "rmxo") else 1
         # get weight and bias
         self.weight = nn.Parameter(torch.rand(out_features*multiplier,
                                               in_features))
@@ -66,9 +82,12 @@ def __init__(self,
             self.bias = nn.Parameter(torch.zeros(out_features*multiplier))
         # get activation function
         if activation is not None:
-            self.activation = Activations(activation)
+            if activation in Activations.available():
+                self.activation = Activations(activation)
         # out tensor size
         self.tensor_size = (1, out_features)
+        if hasattr(self, "out_shape"):
+            self.tensor_size = tuple([1, ] + list(out_shape))
 
     def forward(self, tensor):
         if tensor.dim() > 2:
@@ -80,13 +99,25 @@ def forward(self, tensor):
             tensor = tensor + self.bias.view(1, -1)
         if hasattr(self, "activation"):
             tensor = self.activation(tensor)
+        if hasattr(self, "out_shape"):
+            tensor = tensor.view(-1, *self.out_shape)
         return tensor
 
+    def __repr__(self):
+        msg = "x".join(["_"]+[str(x)for x in self.t_size[1:]]) + " -> "
+        if hasattr(self, "dropout"):
+            msg += "dropout -> "
+        msg += "{}({})".format("linear", "x".join([str(x) for x in
+                                                   self.weight.shape]))+" -> "
+        if hasattr(self, "activation"):
+            msg += self.act + " -> "
+        msg += "x".join(["_"]+[str(x)for x in self.tensor_size[1:]])
+        return msg
 
 # from core.NeuralLayers import Activations
 # tensor_size = (2, 3, 10, 10)
 # x = torch.rand(*tensor_size)
-# test = Linear(tensor_size, 16, "maxo", 0., bias=True)
+# test = Linear(tensor_size, 16, "", 0., True, (1, 4, 4))
 # test(x).size()
 # test.weight.shape
 # test.bias.shape

core/NeuralLayers/obfuscatedecolor.py

@@ -75,9 +75,9 @@ def forward(self, tensor):
                     tensor[i, ] = tmp.expand(-1, 3, -1, -1)
                 self.n_decolor += 1
 
-        random_shit = torch.rand(1, *tensor.size()[1:])
+        random_shift = torch.rand(1, *tensor.size()[1:])
         if tensor.is_cuda:
-            random_shit = random_shit.cuda()
+            random_shift = random_shift.cuda()
 
         for i in range(tensor.size(0)):
             if self.n_obfuscate == self.p_obfuscate.size(0):
@@ -91,7 +91,7 @@ def forward(self, tensor):
 
                 sh, eh = self.sample_height[self.n_sample_height]
                 sw, ew = self.sample_width[self.n_sample_width]
-                tensor[i, :, sh:eh, sw:ew] = random_shit[0, :, sh:eh, sw:ew]
+                tensor[i, :, sh:eh, sw:ew] = random_shift[0, :, sh:eh, sw:ew]
 
                 self.n_sample_height += 1
                 self.n_sample_width += 1

core/NeuralLayers/sae.py

@@ -14,17 +14,17 @@ class ConvolutionalSAE(nn.Module):
     def __init__(self, tensor_size, filter_size, out_channels, strides=(1, 1),
                  pad=True, activation="relu", dropout=0., normalization=None,
                  pre_nm=False, groups=1, weight_norm=False, equalized=False,
-                 shit=False, learningRate=0.1, *args, **kwargs):
+                 shift=False, learningRate=0.1, *args, **kwargs):
 
         super(ConvolutionalSAE, self).__init__()
         self.encoder = Convolution(tensor_size, filter_size, out_channels,
                                    strides, pad, activation, dropout,
                                    normalization, pre_nm, groups, weight_norm,
-                                   equalized, shit, **kwargs)
+                                   equalized, shift, **kwargs)
         self.decoder = Convolution(self.encoder.tensor_size, filter_size,
                                    out_channels, strides, pad, activation,
                                    dropout, normalization, pre_nm, groups,
-                                   weight_norm, equalized, shit,
+                                   weight_norm, equalized, shift,
                                    transpose=True, **kwargs)
         self.decoder.tensor_size = tensor_size