Update

Author: hirofumi0810

.coveragerc

@@ -5,6 +5,7 @@ source = neural_sp
 [report]
 exclude_lines =
     raise ValueError
+    raise TypeError
     raise NotImplementedError
     if __name__ == .__main__.:
 

neural_sp/models/modules/mocha.py

@@ -72,7 +72,8 @@ def __init__(self, kdim, qdim, adim, atype, n_heads, init_r,
         if conv1d:
             self.conv1d = CausalConv1d(in_channels=kdim,
                                        out_channels=kdim,
-                                       kernel_size=conv_kernel_size)
+                                       kernel_size=conv_kernel_size,
+                                       param_init=param_init)
             # padding=(conv_kernel_size - 1) // 2
 
         if atype == 'add':
@@ -92,10 +93,6 @@ def reset_parameters(self, bias):
         if bias:
             nn.init.constant_(self.w_key.bias, 0.)
             nn.init.constant_(self.w_query.bias, 0.)
-        if self.conv1d is not None:
-            logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.conv1d.__class__.__name__)
-            for n, p in self.conv1d.named_parameters():
-                init_with_xavier_uniform(n, p)
 
     def reset(self):
         self.key = None
@@ -591,7 +588,7 @@ def forward(self, key, value, query, mask=None, aw_prev=None,
 
 
 def add_gaussian_noise(xs, std):
-    """Additive gaussian nosie to encourage discreteness."""
+    """Add Gaussian nosie to encourage discreteness."""
     noise = xs.new_zeros(xs.size()).normal_(std=std)
     return xs + noise
 

neural_sp/models/modules/positional_embedding.py

@@ -89,7 +89,9 @@ def forward(self, xs, scale=True):
             xs = xs + self.pe[:, :xs.size(1)]
             xs = self.dropout(xs)
         elif self.pe_type == 'concat':
-            xs = torch.cat([xs, self.pe[:, :xs.size(1)]], dim=-1)
+            raise NotImplementedError
+            xs = torch.cat([xs, self.pe[:, :xs.size(1)].repeat([xs.size(0), 1, 1])], dim=-1)
+            # TODO(hirofumi0810): need dimension reduction
             xs = self.dropout(xs)
         elif '1dconv' in self.pe_type:
             xs = self.pe(xs)

test/modules/test_zoneout.py

@@ -47,12 +47,18 @@ def test_forward(rnn_type, args):
     module = importlib.import_module('neural_sp.models.modules.zoneout')
     zoneout_cell = module.ZoneoutCell(**args)
 
-    if rnn_type == 'lstm':
-        h, c = zoneout_cell(xs, (hxs, cxs))
-        assert h.size() == (batch_size, cell_size)
-        assert c.size() == (batch_size, cell_size)
-    elif rnn_type == 'gru':
-        h = zoneout_cell(xs, hxs)
-        assert h.size() == (batch_size, cell_size)
-    else:
-        raise ValueError(rnn_type)
+    for mode in ['train', 'eval']:
+        if mode == 'train':
+            zoneout_cell.train()
+        elif mode == 'eval':
+            zoneout_cell.eval()
+
+        if rnn_type == 'lstm':
+            h, c = zoneout_cell(xs, (hxs, cxs))
+            assert h.size() == (batch_size, cell_size)
+            assert c.size() == (batch_size, cell_size)
+        elif rnn_type == 'gru':
+            h = zoneout_cell(xs, hxs)
+            assert h.size() == (batch_size, cell_size)
+        else:
+            raise ValueError(rnn_type)