Introduction

The PyTorch equivalent of TensorFlow’s tf.cast is usually tensor.to(dtype=...), and in many cases the convenience methods such as .float(), .long(), or .bool() are even clearer. The operation is the same idea: create a tensor view or copy with a different dtype so later math uses the right numeric type.

The practical question is not just “how do I cast?” It is “which dtype does this operation expect?” because many PyTorch errors come from feeding tensors with the wrong type into a loss, embedding layer, or index operation.

Use to(dtype=...) as the Direct Equivalent

The closest translation of tf.cast(x, tf.float32) is:

1import torch
2
3x = torch.tensor([1, 2, 3], dtype=torch.int32)
4y = x.to(dtype=torch.float32)
5
6print(x.dtype)
7print(y.dtype)

This is the most general form because it also works well when you combine dtype conversion with device movement.

Convenience Methods Are Common Too

PyTorch provides shorthand methods for common dtypes.

1import torch
2
3x = torch.tensor([1, 0, 1])
4print(x.float())
5print(x.long())
6print(x.bool())

These are often easier to read in model code than a full to(dtype=...) call.

A common rule of thumb:

• use .float() for model inputs and activations when you want floating-point math
• use .long() for class indices, especially with embeddings or classification labels in some APIs
• use .bool() for masks

Device and Dtype Together

One advantage of to() is that you can cast and move in one step.

1import torch
2
3x = torch.tensor([1, 2, 3])
4if torch.cuda.is_available():
5    x = x.to(device="cuda", dtype=torch.float32)
6
7print(x.device)
8print(x.dtype)

That is one reason to() is usually the best mental match for tf.cast, even though the convenience methods are shorter.

Know the Common Training Cases

A few dtype expectations appear constantly in PyTorch:

• model weights are usually float32
• feature tensors for neural nets are usually float32
• class labels for CrossEntropyLoss should usually be integer class indices, typically long
• masks are often bool

For example:

1import torch
2import torch.nn as nn
3
4logits = torch.randn(4, 3)
5labels = torch.tensor([0, 2, 1, 1]).long()
6loss = nn.CrossEntropyLoss()(logits, labels)
7print(loss)

If labels were floating point here, the loss call would fail.

Casting Is Not the Same as Reshaping

Another frequent confusion is mixing dtype conversion with shape conversion. tf.cast and tensor.to() only change type. They do not change dimensions.

If you need a different shape, use operations like view, reshape, unsqueeze, or squeeze separately.

It is also worth remembering that casting may create a new tensor object rather than mutating the old one in place. In training code, make sure you keep using the returned tensor, especially when preparing inputs before they flow through autograd-enabled operations. That small detail explains a lot of “why is the dtype unchanged?” debugging sessions.

Common Pitfalls

• Using .type() with old string-based tensor class names when to(dtype=...) or .float() is clearer.
• Casting labels to float when the loss function expects integer class indices.
• Forgetting that casting changes dtype, not tensor shape.
• Moving tensors to the GPU but forgetting to cast related tensors to compatible dtypes.
• Applying repeated unnecessary casts inside the training loop instead of fixing the data pipeline earlier.

Summary

• The closest PyTorch equivalent of tf.cast is tensor.to(dtype=...).
• Convenience helpers like .float(), .long(), and .bool() are often the cleanest option.
• 'to() is especially useful when changing dtype and device together.'
• The correct dtype depends on the downstream operation, not just on stylistic preference.
• Most casting bugs are really “wrong dtype for this API” problems.