the output of the entries sum to $1$ , which means you can interpret them as probabilities.
the output of the Softmax function $y$ is sometimes referred to as the logit.

Application to neural network

When modelling with neural networks, we often run into the Softmax function. Suppose we wanted to build a neural network that aims to classify whether the image is a cat, a dog or a bird. In such a case, we often use the Softmax function as the activation function for the final layer. The output probabilities are saying that the model is:

70% sure the image is a cat
20% sure the image is a dog
10% sure the image is a bird

If you are performing predictions only without the need of probabilities, then the Softmax function is not necessary.

Comparison with Sigmoid function

Both the Softmax and sigmoid functions map inputs to a range of 0 to 1. However, the difference is that the inputs of the sigmoid do not sum to one as probabilities should.

Implementing Softmax function using Python's NumPy

Basic implementation

We can easily implement the Softmax function as described by equation $(1)$ using NumPy like so:



            filter_none
            Copy

        
        
        
            
                
                
                    import numpy as np

def softmax(x):
    """ x: 1D NumPy array of inputs """
    return np.exp(x) / np.sum(np.exp(x))

Let's use this function to compute the Softmax of vector $(2)$ :



            filter_none
            Copy

        
        
        
            
                
                
                    softmax([2, 1, 0.1])
                
            
            array([0.65900114, 0.24243297, 0.09856589])

Notice how the output is identical to what we calculated by hand.

Optimised implementation

Our basic implementation of the Softmax function is based directly on the definition of the Softmax function as described by $(1)$ :

y_{i} = \frac{e^{x_{i}}}{\sum_{j = 1}^{N} e^{x_{j}}}

The problem with this implementation is that exponential functions $e^{x}$ quickly become large as the value of $x$ increase. For instance, consider $\exp (100)$ :



            filter_none
            Copy

        
        
        
            
                
                
                    np.exp(100)
                
            
            2.6881171418161356e+43

Notice how even a small input of $x = 100$ would result in extremely large numbers. In fact, if we try $\exp (800)$ , the value is so large that it cannot be computed:



            filter_none
            Copy

        
        
        
            
                
                
                    np.exp(800)
                
            
            inf

This happens because computers represent numerical values using a fixed number of bytes (e.g. 8 bytes). The caveat is that extremely small or large numbers cannot be defined simply because there aren't enough bytes. If the number is so large that it cannot be represented using a fixed-number of bytes, then NumPy will return inf.

This limitation of our basic implementation means that large inputs will fail:



            filter_none
            Copy

        
        
        
            
                
                
                    softmax([800, 500, 600])
                
            
            array([1.00000000e+000, 5.14820022e-131, 1.38389653e-087])

Here, nan stands for not-a-number, that is, the number is too large that it cannot be computed. For this reason, the basic implementation is never used in practise.

The way to overcome this limitation is to reformulate the Softmax function like so:

\begin{matrix} (3) & \begin{aligned} y_{i} & = \frac{\exp (x_{i})}{\sum_{j = 1}^{N} \exp (x_{j})} \\ = \frac{C \cdot \exp (x_{i})}{C \cdot \sum_{j = 1}^{N} \exp (x_{j})} \\ = \frac{\exp (\ln (C)) \cdot \exp (x_{i})}{\exp (\ln (C)) \cdot \sum_{j = 1}^{N} \exp (x_{j})} \\ = \frac{\exp (\ln (C) + x_{i})}{\sum_{j = 1}^{N} \exp (\ln (C) + x_{j})} \\ = \frac{\exp (C^{'} + x_{i})}{\sum_{j = 1}^{N} \exp (C^{'} + x_{j})} \end{aligned} \end{matrix}

Note that all we have done is multiplied the numerator and denominator by some scalar constant $C$ , and hence $(3)$ is equivalent to the original equation of the Softmax function $(1)$ .

Let's now understand why $(3)$ is better for numerical computation. $C^{'}$ can be any constant value, so we can choose $C^{'}$ such that the exponent ( $C^{'} + x_{i}$ ) is small. This is how we can avoid large uncomputable numbers.

Now, what is a good value of $C^{'}$ ? If our goal is to minimize the exponent $C^{'} + x_{i}$ , we could set C' to be the negative maximum of our input vector x.

For instance, consider the following input vector:

x = (\begin{matrix} 800 \\ 500 \\ 600 \end{matrix})

The negative of the maximum of $x$ is:

\begin{aligned} C^{'} & = - max (x) \\ = - 800 \end{aligned}

From $(3)$ we know that:

\begin{array}{r} \frac{\exp (- 800 + 800)}{\exp (- 800 + 800) + \exp (- 800 + 500) + \exp (- 800 + 600)} = \frac{\exp (0)}{\exp (0) + \exp (- 300) + \exp (- 200)} \end{array}

Notice how we now avoid $\exp (800)$ , and our exponents are much smaller!

The implementation of $(3)$ in NumPy is as follows:



            filter_none
            Copy

        
        
        
            
                
                
                    def softmax(x):
    """ x: 1D NumPy array of inputs """
    c = -np.max(x)
    x += c
    return np.exp(x) / np.sum(np.exp(x))

Now, we can use the function like so:



            filter_none
            Copy

        
        
        
            
                
                
                    softmax([800, 500, 600])
                
            
            array([1.00000000e+000, 5.14820022e-131, 1.38389653e-087])

Notice how we do not have any nan this time.

Published by Isshin Inada

Edited by 0 others

Did you find this page useful?

thumb_up

thumb_down

Comment

Citation

Ask a question or leave a feedback...

thumb_up

thumb_down

chat_bubble_outline

settings

Enjoy our search

Hit / to insta-search docs and recipes!