Numpy arrays are **a grid of values** of the same type. You can use these arrays to store a list of values that needs to be used for data analysis or machine learning activities.

When using the array of data in machine learning, you can only pass the normalized values to the algorithms to achieve better accuracy.

**You can normalize a NumPy array to a unit vector by using the sklearn.normalize() method.**

A unit vector is a vector that has a magnitude of `1`

.

In this tutorial, you’ll learn how to normalize a `NumPy`

array to a unit vector using the python libraries `sklearn.normalize()`

and `numpy.norm()`

method.

**If You’re in Hurry…**

You can use the below code snippet to normalize an array in `NumPy`

to a unit vector.

`np.linalg.norm()`

method will return one of eight different matrix norms or one of an infinite number of vector norms depending on the value of the `ord`

parameter. If you do not pass the `ord`

parameter, it’ll use the FrobeniusNorm.

When you divide the data using this Norm, you’ll get normalized data as shown below.

**Snippet**

```
import numpy as np
x = np.random.rand(10)*10
normalized_x=
````x/np.linalg.norm(x)`
print(normalized_x)

**Output**

```
[0.46925769 0.12092959 0.37642505 0.09316824 0.38277321 0.07894217
0.36265182 0.28934431 0.49484541 0.04406218]
```

This is how you can get a unit vector of a NumPy array.

**If You Want to Understand Details, Read on…**

In this tutorial, you’ll learn how to get the unit vector from a NumPy array using different methods.

Table of Contents

## Sample Numpy Array

First, let’s create a sample `NumPy`

array with `10`

random values. You can use this in the later steps to learn how to normalize the data.

**Snippet**

```
import numpy as np
from sklearn.preprocessing import normalize
x = np.random.rand(10)*10
x
```

**Output**

```
array([4.59743528, 2.49994446, 5.45313476, 2.22769086, 3.19143523,
8.56257209, 7.01471989, 6.23370745, 7.21487837, 8.86694182])
```

## Using SKlearn Normalize

In this section, you’ll learn how to normalize a `NumPy`

array using the sklearn `normalize()`

method.

Normalize() method scales the input vector to an individual unit norm.

It accepts one **mandatory** parameter.

`X`

– Array-like input. You can pass the data to be normalized in this parameter.

**Parameters**

It also accepts three other **optional **parameters.

`norm`

– *{‘l1’, ‘l2’, ‘max’}, default=’l2’* – The norm to be used for normalizing the data.

`axis`

– *{0, 1}, default=1* – axis used to normalize the data along. If `1`

, each sample will be normalized individually, If `0`

, each feature will be normalized.

`copy`

– *bool, default=True* – If `false`

, the normalization will take place in the same instance of the array. Otherwise, a new copy of the array will be created and normalized.

`return_norm`

– *bool, default=False* – Whether you need the computed norms to be returned or not.

**Snippet**

`normalize(x[:,np.newaxis], axis=0)`

is used to normalize the data in variable `X`

.

Where,

`np.newaxis`

increases the dimension of the NumPy array. Using it along the array X will make the array a one-dimensional array.

`x[:, np.newaxis]`

– To return all rows from the array for normalization.`axis=0`

– To normalize the each feature in the array

```
import numpy as np
from sklearn.preprocessing import normalize
x = np.random.rand(10)*10
normalized_x =
````normalize(x[:,np.newaxis], axis=0)`
print(normalized_x)

When you print the array, you’ll see the array is in a normalized form.

**Output**

```
[[0.05341832]
[0.42901918]
[0.34359858]
[0.00150131]
[0.48057246]
[0.3178608 ]
[0.27146542]
[0.27559803]
[0.37805814]
[0.26545377]]
```

## Using np.linalg.norm()

You can also use the `np.linalg.norm()`

method from the NumPy library to normalize the NumPy array into a unit vector.

`np.linalg.norm()`

method will return one of eight different matrix norms or one of an infinite number of vector norms depending on the value of the `ord`

parameter. If you do not pass the `ord`

parameter, it’ll use the FrobeniusNorm.

You can divide the data using the returned norm to get the unit vector of the NumPy array.

**Snippet**

```
import numpy as np
x = np.random.rand(10)*10
normalized_x=
````x/np.linalg.norm(x)`
print(normalized_x)

When you print the normalized vector, you’ll see the normalized value as shown below.

**Output**

```
[0.46925769 0.12092959 0.37642505 0.09316824 0.38277321 0.07894217
0.36265182 0.28934431 0.49484541 0.04406218]
```

This is how you can use the `np.linalg.norm()`

method to normalize the `NumPy`

array to a unit vector.

## Using Maths Formula

In this section, you’ll create a maths formula to normalize the `NumPy`

array to a unit vector.

You’ll create a vector norm by taking the square root of the sum of the values in the array. Then using this vector, you can create a normalized form of the data.

Use the below form to normalize the `NumPy`

array using the mathematical form.

**Snippet**

```
import numpy as np
x = np.random.rand(10)*10
normalized_x =
````x / np.sqrt(np.sum(x**2))`
print(normalized_x)

**Output**

```
[0.12280124 0.36840538 0.05669781 0.27392538 0.43742201 0.45143303
0.20542178 0.03980713 0.13138495 0.5610464 ]
```

This is how you can normalize a NumPy array into a unit vector by using the mathematical formula.

## Normalize Numpy Array Along Axis

In this section, you’ll learn how to normalize the NumPy array into a unit vector along the different axis. Namely, `row`

axis and `column`

axis.

### Normalize Numpy Array By Columns

You can use the `axis=0`

in the normalize function to normalize the NumPy array into a unit vector by columns. When you use this, **each feature of the dataset will be normalized.**

**Snippet**

```
import numpy as np
from sklearn.preprocessing import normalize
x = np.random.rand(10)*10
normalized_x =
````normalize(x[:,np.newaxis], axis=0)`
print(normalized_x)

This array has only one feature. Hence, when you print the normalized array, you’ll see the below values.

**Output**

```
[[0.23542553]
[0.38018535]
[0.05725614]
[0.01711471]
[0.59367405]
[0.58159005]
[0.04489816]
[0.09942305]
[0.1961091 ]
[0.23538758]]
```

### Normalize Numpy Array By Rows

You can use the `axis=1`

in the normalize function to normalize the NumPy array into a unit vector by rows. When you use this, **each sample of the dataset will be normalized individually.**

**Snippet**

```
import numpy as np
from sklearn.preprocessing import normalize
x = np.random.rand(10)*10
normalized_x =
````normalize(x[:,np.newaxis], axis=1)`
print(normalized_x)

The array has only one column. When you normalize based on the row, each sample will be normalized and you’ll see the output as below.

**Output**

```
[[1.]
[1.]
[1.]
[1.]
[1.]
[1.]
[1.]
[1.]
[1.]
[1.]]
```

This is how you can normalize the NumPy array by rows. Each sample will be sample individually.

## Conclusion

To summarize, you’ve learned how to normalize a `NumPy`

array into a unit vector for using it for various data analysis purposes.

You’ve also learned how to get the unit vector from a NumPy array using the maths formula, NumPy `norm()`

method, and the sklearn `normalize()`

method.

If you’ve any questions, comment below.