# How to Fix: ValueError: Operands could not be broadcast together with shapes?

**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 ofThe smaller array is broadcast to the size of the larger array to make it possible to perform arithmetic operations on them.**Broadcasting.**

**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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `2` `).reshape(` `1` `, ` `2` `)` `Array2 ` `=` `np.arange(` `2` `, ` `10` `).reshape(` `3` `, ` `3` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `print` `(Array1` `+` `Array2)` |

**Output:**

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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `4` `).reshape(` `2` `, ` `2` `)` `Array2 ` `=` `np.arange(` `4` `, ` `8` `).reshape(` `2` `, ` `2` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `# addition between 2 arrays` `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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `2` `).reshape(` `1` `, ` `2` `)` `Array2 ` `=` `np.arange(` `2` `, ` `8` `).reshape(` `3` `, ` `2` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `# addition between 2 arrays` `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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `4` `).reshape(` `2` `, ` `2` `)` `Array2 ` `=` `np.arange(` `2` `).reshape(` `2` `, ` `1` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `# subtraction between 2 arrays` `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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `2` `).reshape(` `2` `, ` `1` `)` `Array2 ` `=` `np.arange(` `2` `).reshape(` `1` `, ` `2` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `# addition between 2 arrays` `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 necessary packages` `import` `numpy as np` ` ` `# create 2 arrays` `Array1 ` `=` `np.arange(` `1` `).reshape(` `1` `, ` `1` `)` `Array2 ` `=` `np.arange(` `2` `).reshape(` `1` `, ` `2` `)` ` ` `# print 2 arrays` `print` `(Array1)` `print` `(Array2)` ` ` `# addition between 2 arrays` `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**.**