Apply ToTensor Transform

easyFREETransformsPyTorch TransformsPytorch

Problem Statement

Apply the ToTensor transform to convert a NumPy array (simulating an image) into a PyTorch tensor.

Background

ToTensor from torchvision.transforms converts image data (PIL Image or NumPy array) into a normalized FloatTensor. It handles both the type conversion and value scaling automatically.

Your Task

Write a function apply_to_tensor(numpy_array) that applies the ToTensor transform and returns a dictionary describing the resulting tensor's shape, dtype, and value range.

Output Format

Return a dictionary with keys: "shape" (list), "dtype" (string), "min_val" (float, 2 decimals), "max_val" (float, 2 decimals).

Example

Input

numpy array of shape (2, 2, 3) with values 0-255

Output

{"shape": [3, 2, 2], "dtype": "torch.float32", "min_val": 0.0, "max_val": 1.0}

Reasoning

Input: a tiny $2 \times 2$ image with 3 colour channels, laid out height × width × channels, $(H, W, C) = (2, 2, 3)$ , as unsigned 8-bit integers in $[0, 255]$ . The top-left pixel is the colour triple $(0, 128, 255)$ .
Layout: the tensor is channels-first, $(C, H, W)$ , so the shape becomes [3, 2, 2]. Channel 0 is a $2 \times 2$ grid holding the first value of every pixel: $0, 64, 255, 100$ .
Scaling: every value is divided by $255$ and stored as 32-bit floating-point numbers: $64/255 \approx 0.251$ , $128/255 \approx 0.502$ , $255/255 = 1$ .
Range: the smallest raw value is $0 \to 0/255 = 0$ , the largest is $255 \to 1$ . Rounded to 2 decimal places, min_val is 0.0 and max_val is 1.0.
Output: a dictionary whose "shape" is a plain list of the three dimension sizes and whose "dtype" names the 32-bit float type as text.
Notice: values are only rearranged and rescaled. A uniform image of $127$ s gives $127/255 \approx 0.498$ , so both min_val and max_val round to 0.5.

Constraints

Use torchvision.transforms.ToTensor
Input will be a NumPy array with shape (H, W, C) and dtype uint8
Values are in range [0, 255]
Round min_val and max_val to 2 decimal places

Learn this in

PyTorch FundamentalsFoundations

More from Pytorch

Apply Softmax for Predictionseasy Count Model Parametersmedium Build with nn.Sequentialeasy Use nn.Flatten Layereasy Create a Simple Neural Network Classeasy

Concept primer

1. Background Knowledge

PyTorch Tensors are multi-dimensional arrays central to deep learning, supporting GPU acceleration and automatic differentiation. Images are typically represented as NumPy arrays with shape (H, W, C) (height × width × channels) and uint8 dtype [0, 255] range.

ToTensor() from torchvision.transforms performs two critical operations:

Type conversion: uint8 → torch.float32
Normalization: Pixel values ∈ [0, 255] → [0.0, 1.0] via division by 255
Dimension permutation: (H, W, C) → (C, H, W) (PyTorch convention)

Mathematical transformation:

tensor = numpy_array.astype(float) / 255.0
tensor = tensor.permute(2, 0, 1) # CHW format

This normalization is essential because neural networks converge faster with inputs in [0, 1] or standardized ranges.

Prerequisites:

import torch
import torchvision.transforms as transforms
import numpy as np

2. Algorithm Approach

The solution uses a single transform pipeline:

ToTensor() handles conversion + normalization + permutation automatically
Tensor properties extraction using PyTorch tensor methods:

tensor.shape → list conversion
tensor.dtype → string representation
tensor.min().item(), tensor.max().item() → scalar extraction

Dictionary construction with rounded min/max values

Core insight: ToTensor() is a composable transform designed specifically for this exact use case—no manual math required.

3. Step-by-Step Strategy

def apply_to_tensor(numpy_array):
 # Step 1: Apply ToTensor transform
 transform = transforms.ToTensor()
 tensor = transform(numpy_array)

 # Step 2: Extract required properties
 shape = list(tensor.shape) # Convert tuple to list
 dtype = str(tensor.dtype) # "torch.float32"
 min_val = round(float(tensor.min()), 2) # Round to 2 decimals
 max_val = round(float(tensor.max()), 2) # Round to 2 decimals

 # Step 3: Return dictionary
 return {
 "shape": shape,
 "dtype": dtype,
 "min_val": min_val,
 "max_val": max_val
 }

Verification with sample:

Input: (2, 2, 3) uint8 array [0-255]
Output: (3, 2, 2) float32 tensor [0.0-1.0]
✅ Matches expected {"shape": [3, 2, 2], "dtype": "torch.float32", "min_val": 0.0, "max_val": 1.0}

4. Common Pitfalls

Mistake	Why It Fails	Fix
Manual division by 255	Forgets channel permutation (HWC→CHW)	Use ToTensor()
tensor.shape as tuple	Output expects list	list(tensor.shape)
tensor.dtype as object	Output expects string	str(tensor.dtype)
tensor.min() without .item()	Returns tensor, not float	tensor.min().item()
No rounding	min_val may be 0.00392157	round(..., 2)
Wrong import	torch.ToTensor doesn't exist	torchvision.transforms.ToTensor

Shape transformation visualization:

Input: np.array(shape=(H=2, W=2, C=3)) # HWC
 [[[...], [...]], # H
 [[...], [...]]] # H

Output: tensor(shape=(C=3, H=2, W=2)) # CHW
 [ # C
 [[..,..], # H
 [..,..]], # H
...
 ]

5. Time & Space Complexity

Time Complexity: $O(H \times W \times C)$

Single pass through all pixels for conversion + normalization
Min/max computation: $O(HWC)$ linear scan
Shape/dtype extraction: $O(1)$

Space Complexity: $O(H \times W \times C)$

Input NumPy: $O(HWC)$ bytes (uint8)
Output tensor: $O(4HWC)$ bytes (float32 = 4× larger)
Net increase: $O(3HWC)$ due to type promotion
Temporary transform objects: $O(1)$

For typical images (e.g., 224×224×3):

Time: ~150K operations (negligible)
Space: ~0.6MB (float32 tensor dominates)

This transform is memory-bound for large images/batches, but PyTorch optimizes memory layout for GPU transfer.

solution.py

Python 3.13

Test results