Introduction

This PyTorch error means .view() is being applied to a tensor whose memory layout is not contiguous in the way .view() requires. The tensor may have the shape you expect, but operations such as transpose, permute, or strided slicing can change how the data is laid out in memory without changing the visible values.

Why .view() Fails on Non-Contiguous Tensors

.view() does not rearrange data. It only creates a new tensor shape over the same memory block. For that to work, the underlying storage must already be compatible with the requested shape.

1import torch
2
3x = torch.arange(12).reshape(3, 4)
4y = x.t()
5
6print(y.shape)
7print(y.is_contiguous())
8
9z = y.view(12)

y is a transposed view of x, so it shares storage but uses a different stride pattern. That is why y.is_contiguous() is False, and the final .view(12) raises the runtime error.

Inspect Shape, Stride, and Contiguity

When this error appears, the fastest diagnostic step is to inspect the tensor right before the failing .view() call.

1import torch
2
3x = torch.arange(12).reshape(3, 4)
4y = x.t()
5
6print("shape:", y.shape)
7print("stride:", y.stride())
8print("contiguous:", y.is_contiguous())

Shape alone is not enough. The stride tells you how PyTorch walks through memory, and that is what determines whether .view() can reinterpret the tensor safely.

Fix 1: Use .contiguous() Before .view()

If you specifically want .view() semantics after a layout-changing operation, make the tensor contiguous first.

1import torch
2
3x = torch.arange(12).reshape(3, 4)
4y = x.t()
5z = y.contiguous().view(12)
6
7print(z)

.contiguous() creates a new tensor with a compatible memory layout. After that, .view() works as expected.

Fix 2: Use .reshape() Instead

In many cases, .reshape() is the more convenient solution.

1import torch
2
3x = torch.arange(12).reshape(3, 4)
4y = x.t()
5z = y.reshape(12)
6
7print(z)

.reshape() returns a view when possible and makes a copy when necessary. If you do not specifically need zero-copy behavior, it is usually the safer API.

Where This Happens in Real Models

This error appears often after dimension reordering in neural networks. Attention blocks, sequence models, and convolution pipelines frequently permute tensor dimensions and then flatten the result.

1import torch
2
3batch = torch.randn(2, 3, 4)
4permuted = batch.permute(0, 2, 1)
5
6print(permuted.is_contiguous())
7flattened = permuted.contiguous().view(2, -1)
8print(flattened.shape)

It also happens with slices that use steps larger than one.

1import torch
2
3x = torch.arange(24).reshape(2, 3, 4)
4y = x[:, :, ::2]
5
6print(y.shape)
7print(y.is_contiguous())
8print(y.reshape(2, -1))

The point is that many perfectly normal tensor operations produce non-contiguous results.

Choose the Fix Deliberately

If you are debugging quickly, switching from .view() to .reshape() is often the simplest fix. If you are optimizing a hot path, you should understand whether that introduces a copy and whether the copy is acceptable.

Likewise, adding .contiguous() everywhere will make the error disappear, but it can also hide unnecessary data copies. Use it at points where layout changes actually occurred.

A Small Debug Helper

In larger models, a tiny helper can save time.

1import torch
2
3
4def describe(name, tensor):
5    print(name)
6    print("  shape:", tuple(tensor.shape))
7    print("  stride:", tensor.stride())
8    print("  contiguous:", tensor.is_contiguous())
9
10x = torch.randn(2, 3, 4)
11y = x.permute(0, 2, 1)
12describe("y", y)

Once you confirm that the tensor is non-contiguous, the next step is mechanical: either make it contiguous or use an API that can allocate a compatible copy.

Common Pitfalls

A common mistake is assuming that matching shapes are enough for .view() to succeed. They are not. Memory layout matters too.

Another is adding .contiguous() everywhere without thinking about performance. That fixes correctness, but it may introduce extra copies in a tight training loop.

Developers also often expect permute or transpose to physically reorder data immediately. In reality, they usually create a view with different strides.

Summary

• '.view() requires a compatible contiguous memory layout, not just the right shape.'
• Operations such as transpose, permute, and stepped slicing often produce non-contiguous tensors.
• Use .contiguous().view(...) when you need .view() after a layout-changing operation.
• Use .reshape(...) when you want the safer API that can copy if necessary.
• Check shape, stride, and is_contiguous() when debugging tensor reshape errors.