Cleaner .to()

src/transformers/models/bloom/modeling_bloom.py

@@ -1126,7 +1126,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/ctrl/modeling_ctrl.py

@@ -794,7 +794,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/diffllama/modeling_diffllama.py

@@ -1220,7 +1220,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/falcon/modeling_falcon.py

@@ -1363,7 +1363,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gemma/modeling_gemma.py

@@ -952,7 +952,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gemma2/modeling_gemma2.py

@@ -1042,7 +1042,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/glm/modeling_glm.py

@@ -962,7 +962,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gpt2/modeling_gpt2.py

@@ -1400,7 +1400,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gpt_bigcode/modeling_gpt_bigcode.py

@@ -1287,7 +1287,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gpt_neo/modeling_gpt_neo.py

@@ -1105,7 +1105,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gpt_neox/modeling_gpt_neox.py

@@ -1210,7 +1210,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/gptj/modeling_gptj.py

@@ -1247,7 +1247,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/helium/modeling_helium.py

@@ -949,7 +949,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/jamba/modeling_jamba.py

@@ -1683,7 +1683,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/jetmoe/modeling_jetmoe.py

@@ -1459,7 +1459,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/llama/modeling_llama.py

@@ -951,7 +951,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/mistral/modeling_mistral.py

@@ -1040,7 +1040,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/mixtral/modeling_mixtral.py

@@ -1193,7 +1193,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/mpt/modeling_mpt.py

@@ -685,7 +685,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/nemotron/modeling_nemotron.py

@@ -1198,7 +1198,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/openai/modeling_openai.py

@@ -810,7 +810,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/opt/modeling_opt.py

@@ -1302,7 +1302,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/persimmon/modeling_persimmon.py

@@ -1013,7 +1013,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/phi/modeling_phi.py

@@ -925,7 +925,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/phi3/modeling_phi3.py

@@ -1061,7 +1061,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/phimoe/modeling_phimoe.py

@@ -1601,7 +1601,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/qwen2/modeling_qwen2.py

@@ -936,7 +936,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/qwen2_moe/modeling_qwen2_moe.py

@@ -1442,7 +1442,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/stablelm/modeling_stablelm.py

@@ -1269,7 +1269,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/starcoder2/modeling_starcoder2.py

@@ -948,7 +948,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/zamba/modeling_zamba.py

@@ -1436,7 +1436,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else:

src/transformers/models/zamba2/modeling_zamba2.py

@@ -1862,7 +1862,7 @@ def forward(
         else:
             if input_ids is not None:
                 # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
-                non_pad_mask = torch.ne(input_ids, self.config.pad_token_id).int().to(logits.device)
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
                 token_indices = torch.arange(input_ids.shape[-1], device=logits.device)
                 last_non_pad_token = (token_indices * non_pad_mask).max(-1).values
             else: