Shapes & Dimensions in Python

A tensor's rank and shape are the two properties that describe its structure. Rank is simply the number of dimensions (axes) a tensor has: a scalar like tf.constant(5) has rank 0, a list of numbers like tf.constant([1, 2, 3]) has rank 1 (a vector), and a nested list like tf.constant([[1,2],[3,4]]) has rank 2 (a matrix). Higher-rank tensors — rank 3, 4, and beyond — represent things like batches of images (batch, height, width, channels) or sequences of word embeddings.

Shape complements rank by telling you exactly how many elements exist along each axis. Where rank answers 'how many dimensions', shape answers 'how big is each dimension' — a shape of (3, 3) is a rank-2 tensor with 3 rows and 3 columns, while a shape of (32, 128, 128, 3) is a rank-4 tensor representing a batch of 32 RGB images sized 128x128.

Getting rank and shape right early matters because nearly every TensorFlow error a beginner hits — from ValueError: Dimensions must be equal to layers that silently produce garbage predictions — traces back to a mismatch between the shape a layer expects and the shape it actually receives. Building an intuition for rank and shape now pays off throughout the rest of this course.

Every TensorFlow tensor exposes a .shape attribute that returns a TensorShape object describing its dimensions, and it prints like a Python tuple for convenience. For matrix = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), calling matrix.shape returns (3, 3) — three rows, three columns — matching the rank-2 structure introduced in the previous section.

Checking .shape is one of the most common debugging habits in TensorFlow, because it costs nothing and immediately confirms whether data flowing through your pipeline looks the way you expect. It's especially useful right after loading a dataset, right before feeding a batch into a model, and right after any operation (like tf.reshape, tf.expand_dims, or a Keras layer) that might change dimensionality.

You'll also see .get_shape() used interchangeably with .shape in older TensorFlow code and documentation — they return equivalent information, but .shape is the idiomatic property to reach for in TensorFlow 2.x.

When you print a tensor's .shape and see a single-element tuple like (4,), that trailing comma is doing real work — it's Python's way of marking a one-element tuple, not just a number in parentheses. (4,) means the tensor has exactly one axis containing 4 elements: a rank-1 vector, not a scalar and not a 4x4 matrix.

This distinction trips up beginners constantly because (4,), (4, 1), and (1, 4) all 'contain' four numbers but describe three different structures: a flat vector, a column matrix, and a row matrix respectively. TensorFlow treats them as incompatible shapes for many operations, so an operation expecting (4, 1) will raise a ValueError if you feed it a (4,) vector instead.

The fix is to read shape tuples literally, one comma-separated position at a time, rather than just counting the numbers inside them. When in doubt, print .shape (or .ndim for the rank alone) before and after any transformation to confirm the tensor has the structure your next layer or operation actually expects.

Neural network layers are picky about the shape of the data they receive — a convolutional layer wants (batch, height, width, channels), a dense layer wants (batch, features). tf.reshape() lets you rearrange a tensor's elements into a new shape without changing any of the underlying values, which is exactly how you bridge the gap between the shape your data comes in and the shape a layer expects.

In matrix = tf.reshape(vector, shape=(2, 3)), the six values in the original 1D vector [1, 2, 3, 4, 5, 6] are simply relabeled into two rows of three columns — reading left to right, top to bottom, the values keep their original order. No data is duplicated, dropped, or recomputed; reshape is purely a metadata operation describing how the same underlying buffer should be indexed.

Because it's just a reinterpretation of the same values, reshape only works when the total element count of the input matches the total element count of the target shape. That constraint — rows times columns must equal the original length — is the rule the next section explores when it's violated.

Calling tf.reshape(tensor, shape=(3, 3)) on a tensor that only contains 8 elements will raise an InvalidArgumentError (a ValueError when caught in eager mode), because 3x3 demands exactly 9 elements and TensorFlow refuses to invent or discard data to make the shapes fit. Reshape is a strict, lossless operation — it re-labels existing values, it never pads with zeros or truncates the tensor to make an incompatible shape 'work'.

This is a deliberate safety rail: silently zero-padding a mismatched reshape would corrupt your data in ways that are almost impossible to notice until a model trains on garbage. Instead, TensorFlow fails loudly and immediately at the point of the mistake, which is far easier to debug than a model that trains to a suspiciously bad accuracy three epochs later.

When you hit this error in practice, the fix is almost always to double check the element count with tf.size(tensor) or tensor.shape before reshaping, and confirm the target shape's dimensions actually multiply out to that same total.

Passing -1 as one of the dimensions in tf.reshape() tells TensorFlow 'figure this dimension out for me' — it computes the missing size from the tensor's total element count and the dimensions you did specify. tf.reshape(vector, shape=(-1, 2)) says 'I want exactly 2 columns, calculate however many rows are needed.'

This is more than a convenience — it's a defensive coding habit. Hardcoding both dimensions of a reshape means the code silently breaks the moment the input size changes (a different batch size, a different dataset). Using -1 for the dimension that should track the input size keeps the reshape correct automatically.

Only one -1 is allowed per tf.reshape() call, since TensorFlow needs the rest of the dimensions to be concrete numbers in order to solve for the unknown one. If none of the given dimensions divide evenly into the total element count, you get the same InvalidArgumentError covered in the previous section.

Working through the arithmetic makes the -1 behavior concrete: a tensor with 12 elements reshaped with shape=(-1, 3) fixes the second dimension at 3, so TensorFlow solves 12 / 3 = 4 for the missing dimension and produces a (4, 3) tensor — 4 rows of 3 columns each, in the original element order.

The same 12 elements could just as easily become (3, 4), (2, 6), (6, 2), (12, 1), or (1, 12) — reshape doesn't know or care about any 'natural' layout, it only cares that rows times columns equals 12. Whichever dimension you fix determines what -1 solves for.

This is why it pays to reason about reshape target shapes explicitly rather than guessing: write out what the fixed dimension represents (batch size, feature count, sequence length) and let -1 absorb whichever dimension you don't want to compute by hand.

Reshaping changes a tensor's overall structure, but just as often you need the opposite operation: pulling a smaller piece out of a larger tensor without touching the rest. That's slicing — extracting a specific row, a range of columns, or an arbitrary rectangular sub-region from a multi-dimensional tensor.

Slicing is a core skill for real workloads: cropping a region out of an image tensor, pulling a single time step out of a sequence, or splitting a batch into training and validation chunks all come down to indexing tensors precisely along one or more axes.

The next two sections walk through TensorFlow's slicing syntax and then apply it to a concrete example, so you leave with both the mental model and the muscle memory for reading and writing slice expressions correctly.

TensorFlow deliberately reuses the same slicing syntax you already know from Python lists and NumPy arrays, so there's no separate slicing API to learn. Square brackets [] index into a tensor, and a colon start:stop inside those brackets selects a range along that axis, with either side left blank to mean 'from the beginning' or 'to the end'.

For a multi-dimensional tensor, each axis gets its own slice expression separated by commas: tensor[a:b, c:d] slices rows a through b-1 and, within those rows, columns c through d-1. A bare colon : on its own means 'take everything along this axis', which is how you keep one dimension untouched while slicing another.

Because this mirrors NumPy exactly, any slicing intuition you've built with numpy.ndarray transfers directly to tf.Tensor — the only real difference is that tensors are immutable, so a slice returns a new tensor rather than a mutable view you could assign into.

Applying the slicing rules from the previous section to a concrete case: for a 2D image tensor of shape (100, 100), extracting every row but only the first 50 columns is image[:, :50]. The bare colon : in the first (row) position means 'take all rows', and :50 in the second (column) position means 'take columns 0 through 49'.

A common mistake is reaching for image[50:, :] instead, which does the opposite of what's intended here — it keeps rows 50 onward (the bottom half of the image) rather than restricting columns, because the two axes aren't interchangeable. The position of a slice expression inside the brackets always corresponds to a specific axis, so mixing up row-slicing and column-slicing silently returns the wrong data with no error at all.

The safest way to avoid this class of bug is to name your axes explicitly in a comment (# [rows, cols]) while you're learning, and to print .shape on the result to confirm it matches what you expected — image[:, :50] on a (100, 100) tensor should produce a (100, 50) result.

At this point you have the full toolkit for reasoning about a tensor's structure: rank tells you how many axes it has, shape tells you how big each axis is, tf.reshape() (with or without the -1 shortcut) lets you rearrange those axes without touching the underlying values, and slicing lets you extract a specific sub-region along any combination of axes.

These four ideas — rank, shape, reshape, and slicing — aren't just NumPy trivia carried over into TensorFlow; they're the vocabulary every layer, loss function, and data pipeline in this course will assume you're fluent in. Debugging a shape mismatch error is, in practice, the single most common day-to-day task when building models.

With tf.constant tensors and their shapes under control, the next lesson moves to tf.Variable — the mutable counterpart to a constant tensor that TensorFlow uses to store and update the trainable weights of a model — along with the core mathematical operations you'll perform on tensors during training.

A "Tensor" is just a mathematical container. Its power comes from its "Shape" (Dimensions) and its "Rank".

You can check the shape of any tensor using the .shape attribute. A shape of (3, 3) means a 3-by-3 matrix.

If x.shape returns (4,), what kind of mathematical structure is the tensor?

• →A 4x4 Matrix.
• →A 1-dimensional Vector containing 4 elements.
• →A scalar value of 4.

Often, Neural Networks require data to be in a very specific shape. You can morph the data without changing the values using tf.reshape().

What happens if you try to execute tf.reshape(tensor, shape=(3, 3)) on a tensor that only contains 8 elements?

• →TensorFlow fills the missing spot with a zero.
• →TensorFlow throws an error because the new shape (3x3=9 elements) does not match the original number of elements (8). Data cannot be created or destroyed.
• →It works perfectly.

You can use the magic -1 inside tf.reshape(). TensorFlow will calculate that dimension automatically for you based on the other dimensions.

If you have a tensor with 12 elements and run tf.reshape(tensor, shape=(-1, 3)), what will the final shape be?

• →(12, 3)
• →(4, 3) because TensorFlow calculates 12 / 3 = 4 for the unknown dimension.
• →It will crash.

Now, prepare yourself. We are about to enter the ADA Defense Protocol. Ensure you understand tensor slicing.

TensorFlow uses standard Python/NumPy slicing rules. You use brackets [] and colons : to extract sections of the tensor.

ADA DEFENSE: You have a 2D matrix named image of shape (100, 100). How do you extract ALL rows, but only the first 50 columns?

• →image[50:, :]
• →image[:, :50]
• →image[all, 50]

Threat neutralized. Dimensional awareness achieved. Proceeding to Variables and Mathematics.

Reshape a Real Tensor. Finish reshape_vector(): reshape morphs the shape without changing the data or element count.