NumPy is a powerful Python library used for numerical computing and working with multidimensional array data, including functions for repeating and tilling arrays. These tilling and repeating array functions play an important role in data manipulation, machine learning, image processing, and scientific computing. In this article, we will look at how to repeat and tile array using NumPy in Python. We will provide examples and explain the key differences.
Table of Contents
What are Repeat and Tile Array Using NumPy in Python?
Tiling means dividing an array into smaller parts called sub-arrays or tiles. For example, you can break a 2D array into quadrants. You can also split a 1D array into chunks of a certain size. Tiling allows you to work with blocks of an array separately, enhancing performance for large arrays that exceed memory capacity.
Repeating an array means creating copies of array elements, either by duplicating the entire array or repeating each element of the array. This is useful for expanding datasets, creating patterned data, or reformatting array shapes.
NumPy provides two primary functions to tile and repeat NumPy arrays including numpy.tile(), numpy.repeat(), and using advanced indexing with NumPy arrays.
numpy.repeat()– Repeats each element of an array along a specified axis.numpy.tile()– Repeats the entire array in a tiles pattern to create a larger array.
These functions are widely used in tasks like feature engineering, data augmentation, and image processing.
Below are some common use cases for repeat and tile arrays with NumPy:
- Making small sets of data bigger by copying data points.
- Creating smooth tiled images or textures by repeating blocks of pixels.
- Making test data with patterns like waves or jagged lines.
- Changing arrays by repeating elements to fit new sizes.
- Building arrays for machine learning with copied data examples.
- Doing tasks on chunks of arrays instead of the whole array.
Tiling Arrays with Numpy in Python
Tiling splits an array into smaller equal-sized blocks or tiles. The split is done along an axis, dividing the dimensions of the specified axis into tiles of a given size.
Numpy provided several approaches to tile arrays:
Using numpy.split
The numpy.split function breaks an array into multiple sub-arrays along a specified axis.
import numpy as np
array = np.arange(9).reshape(3,3)
print(array)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]
rows = np.split(array, 3, axis=0)
print(rows[0])
# [[0 1 2]]
cols = np.split(array, 3, axis=1)
print(cols[0])
# [[0]
# [3]
# [6]]numpy.split function takes the array, the number of splits, and the axis to split. It returns a list of sub-arrays. The simplest way to tile an array into blocks.
Using numpy.array_split
This numpy.array_split is the same as numpy.split but it allows splitting into a specific number of tiles.
numpy.array_split evenly divides the axis into the number of tiles. This provides precise control over the tiling.
import numpy as np
array = np.arange(9).reshape(3, 3)
tiles = np.array_split(array, 4)
print(tiles[0])
# [[0 1 2]]
tiles = np.array_split(array, 4, axis=1)
print(tiles[0])
# [[0]
# [3]
# [6]]Using numpy.reshape
The numpy.reshape function can be used to tile arrays by reshaping them into higher dimensional versions: See the example:
By dividing the flattened array’s elements into pieces along the new dimensions, reshaping produces tiles. For 1D and 2D arrays, this offers a straightforward tiling approach.
import numpy as np
array = np.arange(9)
tiled = np.reshape(array, (3, 3))
# [[0 1 2]
# [3 4 5]
# [6 7 8]]Using numpy.vsplit and numpy.hsplit
NumPy provides convenience methods like numpy.vsplit and numpy. hsplit will split along the vertical (0th) and horizontal (1st) axes, respectively:
import numpy as np
array = np.arange(16).reshape(4, 4)
rows = np.vsplit(array, 2)
cols = np.hsplit(array, 2)
# This will spilits the array into 2 rows and 2 columns.Using Advanced Indexing
By choosing slices along an axis, Numpy Advanced Indexing offers an additional method for tiling arrays.
import numpy as np
arr = np.arange(9).reshape(3, 3)
# Tile into 4 quadrants
quad1 = arr[0:1, 0:1]
quad2 = arr[0:1, 1:2]
quad3 = arr[1:2, 0:1]
quad4 = arr[1:2, 1:2]
# Tile into 4 columns
col1 = arr[:, 0:1]
col2 = arr[:, 1:2]
col3 = arr[:, 2:3]
col4 = arr[:, 3:4]The above example will split the array explicitly into sections by selecting slices. This gives more control over the tile size.
Tiling Multidimensional Arrays
Higher dimensional arrays tile similarly, but with indexing or splitting along several axes:
import numpy as np
array_3d = np.arange(8).reshape(2, 2, 2)
# Split along first axis into 2 tiles
tiles = np.array_split(array_3d, 2)
# Split along second axis into 2 tiles
tiles = np.array_split(array_3d, 2, axis=1)
# Using advanced indexing
quad1 = array_3d[:, :1, :1]
quad2 = array_3d[:, 1:, :1]
quad3 = array_3d[:, :1, 1:]
quad4 = array_3d[:, 1:, 1:]Multidimensional tiling is made possible by the extension of fundamental tiling techniques to higher dimensions, such as numpy.split, numpy.reshape, and indexing/slicing.
Repeating Arrays with NumPy in Python
Numpy provides many approaches to repeat and tile array using Numpy in Python. Some of them are listed below:
Using numpy.tile
The numpy.tile function creates copies of the complete array. We just have to specify a single repetition factor and it will duplicate the whole array:
import numpy as np
array = np.arange(3)
tiled = np.tile(array, 2)
# [0 1 2 0 1 2]For 2D arrays, you can provide a repetition factor for each axis:
array_2d = np.array([[1, 2], [3, 4]])
tiled = np.tile(array_2d, (2, 3))
# This will repeat the outer axis 2 times and inner axis 3 times.
"""
[[1 2 1 2 1 2]
[3 4 3 4 3 4]
[1 2 1 2 1 2]
[3 4 3 4 3 4]]
"""Using numpy.repeat
This function duplicates each element in an array. You just have to specify the number of repetitions for each element:
import numpy as np
array = np.arange(3)
repeated = np.repeat(array, 3)
# [0 0 0 1 1 1 2 2 2]This repeats each element in the 1D array 3 times and this repeat function of numpy also works on higher-dimensional arrays:
array_2d = np.array([[1, 2], [3, 4]])
repeated = np.repeat(array_2d, 2, axis=1)
# [[1 1 2 2]
# [3 3 4 4]]Using numpy.resize
The numpy.resize function repeats elements to fill a new array with the given shape:
import numpy as np
array = np.arange(6)
arr_resized = np.resize(array, (3, 3))
"""
[[0 1 2]
[3 4 5]
[0 1 2]]
"""To convert the original flattened array into the new multidimensional structure, elements are repeated.
Repeating Array Elements with Indexing
NumPy indexing can also be used to duplicate elements by creating index arrays that duplicate indices:
import numpy as np
arr = np.arange(3)
indices = np.array([0, 0, 1, 2, 2, 2])
repeated = arr[indices]
# [0 0 1 2 2 2]This produces repeated elements by choosing elements from arr based on the duplicated index values in indices.
Examples and Applications
Above parts, we learn above numpy functions repeat and tile array using numpy in Python. Now we will look at some examples of applying these techniques for tiling and repeating arrays with Numpy in Python.
Tiling Images
Images can be segmented and portions of an image processed separately by tiling them into blocks:
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
img = np.array(Image.open('image_for_tiling_using_numpy.jpg'))
# Tile into 9 blocks
tiles = np.array_split(img, 3, axis=0)
tiles = [np.array_split(x, 3, axis=1) for x in tiles]
# Display first tile
plt.imshow(tiles[0][0])
plt.title("Top Left Quadrant")
plt.show()Tiling via splitting allows you to operate on different portions of the image, such as applying filters or detections to each tile.
Repeating Array Elements
Data augmentation is a crucial technique in machine learning and deep learning to increase the size and diversity of a dataset without collecting new data. One simple augmentation method is element repetition, where existing elements in an array are duplicated to introduce variations. This example duplicates elements in a 1D array:
import numpy as np
# Original array
arr = np.array([1, 2, 3, 4, 5])
# Repeat each element 3 times
repeated_arr = np.repeat(arr, 3)
print("Original Array:", arr)
print("Repeated Array:", repeated_arr)
#Output:
#Original Array: [1 2 3 4 5]
#Repeated Array: [1 1 1 2 2 2 3 3 3 4 4 4 5 5 5]Tiling Multidimensional Arrays
Tiling multidimensional arrays is a useful technique for processing large datasets, such as time-series data, images, or spectral data cubes. This method allows breaking down large arrays into smaller, manageable chunks for efficient computation.
let’s assume we’re working with a video dataset where each frame is a 2D image, and we want to split the frames into smaller chunks for batch processing.
import numpy as np
# Simulate a video dataset (20 frames of 128x128 images with 3 color channels)
video_data = np.random.rand(20, 128, 128, 3) # Shape: (Time, Height, Width, Channels)
# Split the time axis into 4 chunks
video_chunks = np.array_split(video_data, 4)
print(video_chunks[0].shape) # Expected output: (5, 128, 128, 3)Repeating Array as Column Vector
We can use np.repeat() to transform a 1D array into a column vector by introducing a new axis and repeating along it.
import numpy as np
# Original 1D array
arr = np.array([1, 2, 3])
# Reshape into a column vector by repeating along axis 1
arr_col = np.repeat(arr[:, np.newaxis], 1, axis=1)
print(arr_col)
# Output:
"""
[[1]
[2]
[3]]
"""Related Blogs:
>> Histogramming and Binning Data with NumPy in Python
>> A Comprehensive Guide to Filter Function in Python
>> What is Threading Mutex in Python – Simple Way
>> Encoding and Decoding Using Base64 Strings in Python
Conclusion: Repeat and Tile Array using Numpy in Python
In this guide, we explored various techniques to repeat and tile array using NumPy in Python, covering essential operations for data manipulation and augmentation. These methods help in efficiently handling multidimensional data, making them highly useful in machine learning, image processing, and numerical computing.
Key Takeaways:
Tiling and Splitting: Use numpy.tile() to duplicate entire arrays and numpy.array_split() to divide arrays into smaller chunks for batch processing.
Repeating Elements: numpy.repeat() allows you to duplicate individual elements along a specific axis, useful for data augmentation.
Multidimensional Operations: Learn to repeat and tile along multiple axes for handling complex datasets.
Practical Use Cases: These techniques are widely applied in image processing, time-series analysis, and scientific computing.
By mastering how to repeat and tile array using NumPy in Python, you can efficiently preprocess and structure data for various analytical and modeling tasks.
For more in-depth details, refer to the NumPy documentation.
Happy Coding!
