[fix] address linting errors reported by quick-checks

Author: khanld

examples/librispeech/s0/README.md

@@ -365,7 +365,7 @@ test other
     * dynamic batch size 120.000, 2 gpu, acc_grad 4, 200 epochs, dither 1.0
     * adamw, lr 1e-3, warmuplr, warmup_steps: 25000
     * specaug and speed perturb
-* Decoding info: 
+* Decoding info:
     * ctc_weight 0.3, reverse weight 0.5, average_num 100, beam size 10
     * Chunk size, left context size, and right context size are represented as (c, l, r)
     * Results on test-clean / test other

wenet/chunkformer/attention.py

@@ -28,7 +28,7 @@ def __init__(self, n_head, n_feat, dropout_rate):
         torch.nn.init.xavier_uniform_(self.pos_bias_v)
 
     def rel_shift(self, x, left_context_size: int = 0, right_context_size: int = 0):
-        """Compute relative positional encoding. The position should capture both 
+        """Compute relative positional encoding. The position should capture both
         left and right context.
 
         Args:
@@ -88,8 +88,8 @@ def forward(self, query: torch.Tensor,
         q, k, v = self.forward_qkv(query, key, value)
         q = q.transpose(1, 2)  # (batch, time1, head, d_k)
 
-        limited_context_attn = (chunk_size > 0 
-                                and left_context_size > 0 
+        limited_context_attn = (chunk_size > 0
+                                and left_context_size > 0
                                 and right_context_size > 0)
 
         # NOTE(xcsong):
@@ -121,7 +121,7 @@ def forward(self, query: torch.Tensor,
             # chunking query
             # [B, time1, head, d_k]
             q_size = q.size(1)
-            n_frames_pad = (chunk_size - ((q_size - chunk_size) % chunk_size)) 
+            n_frames_pad = (chunk_size - ((q_size - chunk_size) % chunk_size))
             n_frames_pad = n_frames_pad % chunk_size
             q = torch.nn.functional.pad(q, (0, 0, 0, 0, 0, n_frames_pad))
             # [B, n_chunks, head, d_k, q_size]
@@ -135,12 +135,12 @@ def forward(self, query: torch.Tensor,
             # (batch, head, time1, d_k * 2)
             kv = torch.cat([k, v], dim=-1)
             kv = torch.nn.functional.pad(
-                kv, 
+                kv,
                 (0, 0, left_context_size, n_frames_pad + right_context_size))
             # [B, head, n_chunks, d_k * 2, l + c + r]
             kv = kv.unfold(
-                2, 
-                size=left_context_size + chunk_size + right_context_size, 
+                2,
+                size=left_context_size + chunk_size + right_context_size,
                 step=chunk_size)
             # [B, n_chunks, head, l + c + r, d_k * 2]
             kv = kv.permute(0, 2, 1, 4, 3)
@@ -158,12 +158,12 @@ def forward(self, query: torch.Tensor,
 
             # Chunking mask for key and value
             mask_kv = torch.nn.functional.pad(
-                mask, 
+                mask,
                 (left_context_size, n_frames_pad + right_context_size))
             # [B, 1, n_chunks, chunk_size]
             mask_kv = mask_kv.unfold(
-                -1, 
-                size=left_context_size + chunk_size + right_context_size, 
+                -1,
+                size=left_context_size + chunk_size + right_context_size,
                 step=chunk_size)
             # [B, * n_chunks, chunk_size]
             mask_kv = mask_kv.reshape(-1, mask_kv.size(3))

wenet/chunkformer/embedding.py

@@ -109,7 +109,7 @@ def forward(
         pos_emb = self.position_encoding(
             chunk_size=chunk_size,
             left_context_size=left_context_size,
-            right_context_size=right_context_size, 
+            right_context_size=right_context_size,
             apply_dropout=False
         ).to(device=x.device, dtype=x.dtype)
         return self.dropout(x), self.dropout(pos_emb)

wenet/chunkformer/encoder.py

@@ -183,8 +183,8 @@ def __init__(
 
     def limited_context_selection(self):
         full_context_training = True
-        if (self.dynamic_chunk_sizes is not None 
-            and self.dynamic_left_context_sizes is not None 
+        if (self.dynamic_chunk_sizes is not None
+            and self.dynamic_left_context_sizes is not None
                 and self.dynamic_right_context_sizes is not None):
             chunk_size = random.choice(self.dynamic_chunk_sizes)
             left_context_size = random.choice(self.dynamic_left_context_sizes)
@@ -274,12 +274,12 @@ def forward(self,
         Main forward function that dispatches to either the standard
         forward pass or the parallel chunk version based on the
         model's training mode.
-        """     
+        """
         # for masked batch chunk context inference
         # should add a better flag to trigger
         if decoding_chunk_size > 0 and num_decoding_left_chunks > 0:
             # If both decoding_chunk_size and num_decoding_left_chunks
-            # are set, use the parallel chunk decoding. 
+            # are set, use the parallel chunk decoding.
             return self.forward_parallel_chunk(
                 xs=xs,
                 xs_origin_lens=xs_lens,
@@ -290,8 +290,8 @@ def forward(self,
                 **kwargs
             )
         else:
-            (chunk_size, 
-                left_context_size, 
+            (chunk_size,
+                left_context_size,
                 right_context_size) = self.limited_context_selection()
             return self.forward_encoder(
                 xs=xs,

wenet/chunkformer/subsampling.py

@@ -169,8 +169,8 @@ def forward(self,
         else:
             x = x.transpose(1, 2)
         x, pos_emb = self.pos_enc(
-            x, 
-            chunk_size=chunk_size, 
+            x,
+            chunk_size=chunk_size,
             left_context_size=left_context_size,
             right_context_size=right_context_size)
         mask = ~make_pad_mask(lengths, x.size(1)).unsqueeze(1)