fixed some warning with pytorch 1.9

mirco · mirco · commit 794a9424f193 · 2021-06-16T17:44:52.000-04:00
diff --git a/speechbrain/decoders/seq2seq.py b/speechbrain/decoders/seq2seq.py
@@ -486,7 +486,9 @@ def _update_hyp_and_scores(
             for index in eos_indices:
                 # convert to int
                 index = index.item()
-                batch_id = index // self.beam_size
+                batch_id = torch.div(
+                    index, self.beam_size, rounding_mode="floor"
+                )
                 if len(hyps_and_scores[batch_id]) == self.beam_size:
                     continue
                 hyp = alived_seq[index, :]
@@ -704,7 +706,7 @@ def forward(self, enc_states, wav_len):  # noqa: C901
 
             # The index of which beam the current top-K output came from in (t-1) timesteps.
             predecessors = (
-                candidates // vocab_size
+                torch.div(candidates, vocab_size, rounding_mode="floor")
                 + self.beam_offset.unsqueeze(1).expand_as(candidates)
             ).view(batch_size * self.beam_size)
 
diff --git a/speechbrain/nnet/CNN.py b/speechbrain/nnet/CNN.py
@@ -1047,14 +1047,14 @@ def get_padding_elem(L_in: int, stride: int, kernel_size: int, dilation: int):
     dilation : int
     """
     if stride > 1:
-        n_steps = math.ceil(((L_in - kernel_size * dilation) / stride) + 1)
-        L_out = stride * (n_steps - 1) + kernel_size * dilation
-        padding = [kernel_size // 2, kernel_size // 2]
+        half_kernel = torch.div(kernel_size, 2, rounding_mode="floor")
+        padding = [half_kernel, half_kernel]
 
     else:
-        L_out = (L_in - dilation * (kernel_size - 1) - 1) // stride + 1
+        tot_padding = dilation * (kernel_size - 1)
+        half_padding = torch.div(tot_padding, 2, rounding_mode="floor")
 
-        padding = [(L_in - L_out) // 2, (L_in - L_out) // 2]
+        padding = [half_padding, half_padding]
     return padding
 
 
diff --git a/speechbrain/processing/decomposition.py b/speechbrain/processing/decomposition.py
@@ -86,15 +86,15 @@ def gevd(a, b=None):
     bsh = f(b)
 
     # Performing the Cholesky decomposition
-    lsh = torch.cholesky(bsh)
+    lsh = torch.linalg.cholesky(bsh)
     lsh_inv = torch.inverse(lsh)
     lsh_inv_T = torch.transpose(lsh_inv, D - 2, D - 1)
 
     # Computing the matrix C
     csh = torch.matmul(lsh_inv, torch.matmul(ash, lsh_inv_T))
 
     # Performing the eigenvalue decomposition
-    es, ysh = torch.symeig(csh, eigenvectors=True)
+    es, ysh = torch.linalg.eigh(csh, UPLO="U")
 
     # Collecting the eigenvalues
     dsh = torch.zeros(
@@ -166,7 +166,7 @@ def svdl(a):
     ash_mm_ash_T = torch.matmul(ash, ash_T)
 
     # Finding the eigenvectors and eigenvalues
-    es, ush = torch.symeig(ash_mm_ash_T, eigenvectors=True)
+    es, ush = torch.linalg.eigh(ash_mm_ash_T, UPLO="U")
 
     # Collecting the eigenvalues
     dsh = torch.zeros(ush.shape, dtype=es.dtype, device=es.device)
diff --git a/speechbrain/processing/diarization.py b/speechbrain/processing/diarization.py
@@ -357,8 +357,8 @@ def _graph_connected_component(graph, node_id):
     if sparse.issparse(graph):
         # speed up row-wise access to boolean connection mask
         graph = graph.tocsr()
-    connected_nodes = np.zeros(n_node, dtype=np.bool)
-    nodes_to_explore = np.zeros(n_node, dtype=np.bool)
+    connected_nodes = np.zeros(n_node, dtype=bool)
+    nodes_to_explore = np.zeros(n_node, dtype=bool)
     nodes_to_explore[node_id] = True
     for _ in range(n_node):
         last_num_component = connected_nodes.sum()
diff --git a/speechbrain/processing/multi_mic.py b/speechbrain/processing/multi_mic.py
@@ -768,7 +768,7 @@ def _extract_delays(xxs, tdoa_max=None):
 
         # If no tdoa specified, cover the whole frame
         if tdoa_max is None:
-            tdoa_max = n_fft // 2
+            tdoa_max = torch.div(n_fft, 2, rounding_mode="floor")
 
         # Splitting the GCC-PHAT values to search in the range
         slice_1 = xxs[..., 0:tdoa_max, :]
@@ -1496,7 +1496,9 @@ def sphere(levels_count=4):
             (unique_scalar.shape[0], 2), dtype=unique_scalar.dtype
         )
 
-        unique_values[:, 0] = torch.floor_divide(unique_scalar, index_max + 1)
+        unique_values[:, 0] = torch.div(
+            unique_scalar, index_max + 1, rounding_mode="floor"
+        )
         unique_values[:, 1] = unique_scalar - unique_values[:, 0] * (
             index_max + 1
         )
