fix pylint (#2321)

Author: lvyufeng

src/mindnlp/diffusers.py

@@ -8,5 +8,6 @@
 )
 
 # Setup backward compatibility: apply patches
+# pylint: disable=wrong-import-position
 from .patch.diffusers import setup_diffusers_module
 setup_diffusers_module()

src/mindnlp/inference/__init__.py

@@ -1,2 +1,2 @@
 from .llm import LLM
-from .sampling_params import SamplingParams
+from .sampling_params import SamplingParams

src/mindnlp/inference/config.py

@@ -23,4 +23,4 @@ def __post_init__(self):
         assert 1 <= self.tensor_parallel_size <= 8
         self.hf_config = AutoConfig.from_pretrained(self.model)
         self.max_model_len = min(self.max_model_len, self.hf_config.max_position_embeddings)
-        assert self.max_num_batched_tokens >= self.max_model_len
+        assert self.max_num_batched_tokens >= self.max_model_len

src/mindnlp/inference/engine/block_manager.py

@@ -109,4 +109,4 @@ def may_append(self, seq: Sequence):
             last_block.update(h, token_ids)
             self.hash_to_block_id[h] = last_block.block_id
         else:
-            assert last_block.hash == -1
+            assert last_block.hash == -1

src/mindnlp/inference/engine/llm_engine.py

@@ -94,4 +94,4 @@ def generate(
         outputs = [{"text": self.tokenizer.decode(token_ids), "token_ids": token_ids} for token_ids in outputs]
         if use_tqdm:
             pbar.close()
-        return outputs
+        return outputs

src/mindnlp/inference/engine/model_runner.py

@@ -1,9 +1,9 @@
 import os
 import pickle
-import mindtorch
-import mindtorch.distributed as dist
 from multiprocessing.synchronize import Event
 from multiprocessing.shared_memory import SharedMemory
+import mindtorch
+import mindtorch.distributed as dist
 
 from ..config import Config
 from ..engine.sequence import Sequence
@@ -156,7 +156,7 @@ def prepare_prefill(self, seqs: list[Sequence]):
                 if i != seq.num_blocks - 1:
                     end = start + self.block_size
                 else:
-                    end = start + seq.last_block_num_tokens 
+                    end = start + seq.last_block_num_tokens
                 slot_mapping.extend(list(range(start, end)))
         if cu_seqlens_k[-1] > cu_seqlens_q[-1]:    # prefix cache
             block_tables = self.prepare_block_tables(seqs)
@@ -255,4 +255,4 @@ def capture_cudagraph(self):
             context_lens=context_lens,
             block_tables=block_tables,
             outputs=outputs,
-        )
+        )

src/mindnlp/inference/engine/scheduler.py

@@ -68,4 +68,5 @@ def postprocess(self, seqs: list[Sequence], token_ids: list[int]) -> list[bool]:
             if (not seq.ignore_eos and token_id == self.eos) or seq.num_completion_tokens == seq.max_tokens:
                 seq.status = SequenceStatus.FINISHED
                 self.block_manager.deallocate(seq)
-                self.running.remove(seq)
+
+                self.running.remove(seq)

src/mindnlp/inference/engine/sequence.py

@@ -80,4 +80,4 @@ def __setstate__(self, state):
         if self.num_completion_tokens == 0:
             self.token_ids = state[-1]
         else:
-            self.last_token = state[-1]
+            self.last_token = state[-1]

src/mindnlp/inference/layers/activation.py

@@ -6,9 +6,9 @@
 class SiluAndMul(nn.Module):
 
     def __init__(self):
-        super().__init__()
+        super().__init__()  # pylint: disable=useless-parent-delegation
 
     @mindtorch.compile
     def forward(self, x: mindtorch.Tensor) -> mindtorch.Tensor:
         x, y = x.chunk(2, -1)
-        return F.silu(x) * y
+        return F.silu(x) * y

src/mindnlp/inference/layers/attention.py

@@ -1,12 +1,12 @@
 import mindtorch
 from mindtorch import nn
-import triton
-import triton.language as tl
 
 from ..utils.context import get_context
 
 
 def store_kvcache(key: mindtorch.Tensor, value: mindtorch.Tensor, k_cache: mindtorch.Tensor, v_cache: mindtorch.Tensor, slot_mapping: mindtorch.Tensor):
+    # pylint: disable=undefined-variable
+    # These are conditionally imported from flash_attn or other backends
     N, num_heads, head_dim = key.shape
     D = num_heads * head_dim
     assert key.stride(-1) == 1 and value.stride(-1) == 1
@@ -40,12 +40,15 @@ def forward(self, q: mindtorch.Tensor, k: mindtorch.Tensor, v: mindtorch.Tensor)
         if context.is_prefill:
             if context.block_tables is not None:    # prefix cache
                 k, v = k_cache, v_cache
+            # pylint: disable=undefined-variable
             o = flash_attn_varlen_func(q, k, v,
                                        max_seqlen_q=context.max_seqlen_q, cu_seqlens_q=context.cu_seqlens_q,
                                        max_seqlen_k=context.max_seqlen_k, cu_seqlens_k=context.cu_seqlens_k,
                                        softmax_scale=self.scale, causal=True, block_table=context.block_tables)
         else:    # decode
-            o = flash_attn_with_kvcache(q.unsqueeze(1), k_cache, v_cache,
-                                        cache_seqlens=context.context_lens, block_table=context.block_tables, 
+            # flash_attn_with_kvcache is conditionally imported from flash_attn
+            # pylint: disable=undefined-variable
+            o = flash_attn_with_kvcache(q.unsqueeze(1), k_cache, v_cache,  # noqa: F821
+                                        cache_seqlens=context.context_lens, block_table=context.block_tables,
                                         softmax_scale=self.scale, causal=True)
-        return o
+        return o