Fatal mul Dimension Size for Dimension Number 0 of Operands Does Not Match Can t Continue

Broadcasting refers to the ability of NumPy to handle arrays of different shapes during arithmetic operations. Actually, in arrays, Arithmetic operations can be done on corresponding elements of arrays.

• If 2 arrays are of the same shape, then arithmetic operation between 2 arrays can be done smoothly.
• If 2 arrays are of different shapes then element to element operation is not possible. But NumPy makes it possible using the concept of Broadcasting. The smaller array is broadcast to the size of the larger array to make it possible to perform arithmetic operations on them.

Example:

Here, a smaller array of size 1×1 is broadcasted to a larger array size as 2×1 where the 2^nd row also contains the same element of 1^st row i.e. 1. So 1st row=> 1+1=2 & 2nd row => 2+1=3.

If we try to perform an arithmetic operation between 2 arrays of different shapes or different dimensions sometimes NumPy Broadcasting fails. It throws an error like operands could not be broadcast together with shapes. There are some scenarios when broadcasting can occur and when it fails. So if it fails we need to convert the shape of array.

Example: To show where broadcasting fails

Python3

import numpy as np

Array1 = np.arange( 2 ).reshape( 1 , 2 )

Array2 = np.arange( 2 , 10 ).reshape( 3 , 3 )

print (Array1)

print (Array2)

print (Array1 + Array2)

Output:

Thrown Error

In order to perform broadcasting it internally follow some rules to convert a small-sized array into the shape of a large array. So whenever an error was thrown check the below-mentioned rules to modify the size of the array for successful broadcasting.

Rules for Broadcasting

Rule 1:

If both the arrays has same shape or dimensions then no error can be thrown by interpreter. Arithmetic operations can be performed on corresponding elements.

Example: To depict rule 1

Python3

import numpy as np

Array1 = np.arange( 4 ).reshape( 2 , 2 )

Array2 = np.arange( 4 , 8 ).reshape( 2 , 2 )

print (Array1)

print (Array2)

print ( '--Addition--' )

print (Array1 + Array2)

Output:

Explanation

Array1             Array2                                             Result

[[0   1]      +       [[4    5]    =      [[0+4      1+5]       =       [[4     6]

 [2   3 ]]              [6    7]]             [2+6      3+7]]                [8    10]]

Rule 2:

If one array has one dimension as 1 then the adjacent dimensions need to be compared with another array. If those are the same it broadcasts and performs arithmetic operations among them.

Example: To depict rule 2

Python3

import numpy as np

Array1 = np.arange( 2 ).reshape( 1 , 2 )

Array2 = np.arange( 2 , 8 ).reshape( 3 , 2 )

print (Array1)

print (Array2)

print ( '--Addition--' )

print (Array1 + Array2)

Output:

Here Array1 has one dimension as value 1 so we need to compare the second dimension, the value of 2 arrays are the same or not. If same, broadcast occurs else fails. We need to convert the size of the array as per the rule. In this example, the values are the same so the addition operation is performed smoothly.

Here Array1 is converted into a 3×2 shape array which is added to Array 2 to give the result.

[[0   1]

 [0   1]

 [0   1]]

Example: To depict rule 2

Python3

import numpy as np

Array1 = np.arange( 4 ).reshape( 2 , 2 )

Array2 = np.arange( 2 ).reshape( 2 , 1 )

print (Array1)

print (Array2)

print ( '--Subtraction--' )

print (Array1 - Array2)

Output:

Rule 3:

If the arrays are in the shape of m x n and n x m. In this case, the two arrays are broadcasted into m x m if m>n else n x n if n>m.

Example: To depict Rule 3

Python3

import numpy as np

Array1 = np.arange( 2 ).reshape( 2 , 1 )

Array2 = np.arange( 2 ).reshape( 1 , 2 )

print (Array1)

print (Array2)

print ( '--Addition--' )

print (Array1 + Array2)

Output:

Explanation

Array1 shape- 2×1

Array2 shape- 1×2    so 2 arrays are broadcasted into shape 2×2.

Arrays are broad casted as follows

Array1     +    Array2       Result

[[0   0]     +   [[0   1]       [[0+0   0+1]

 [1   1]]          [0   1]]       [1+0   1+1]]

Rule 4:

If any of array has its shape 1 x 1 then no matter about the other array shape it simply broadcast the array of shape 1 x 1 to shape of another array.

Example: To depict Rule 4

Python3

import numpy as np

Array1 = np.arange( 1 ).reshape( 1 , 1 )

Array2 = np.arange( 2 ).reshape( 1 , 2 )

print (Array1)

print (Array2)

print ( '--Addition--' )

print (Array1 + Array2)

Output

The Array1 shape is 1 x 1 so it is broadcasted to shape of Array2 which is 1x2 .

Array1    +     Array2   =    Result

[[0  0]]    +    [[0   1]]   =    [[0   1]]

The solution for the above example where broadcasting fails is to simply convert the shape of the Array1 to 1 x 3 or Array2 shape to 3 x 2 based on scenario-2.

verjuspith1948.blogspot.com

Source: https://www.geeksforgeeks.org/how-to-fix-valueerror-operands-could-not-be-broadcast-together-with-shapes/

Share this post