*47*

**What is the Activation Function in AI?**

The **activation function** in AI is a mathematical formula that determines how much a neuron in an artificial neural network (ANN) should fire. It takes the input from the previous layer of neurons, applies some transformation, and produces the output for the next layer of neurons.

The activation function is one of the most important components of an **ANN**, as it affects the learning ability, accuracy, and speed of the network. Different activation functions have different properties and advantages, and choosing the right one can make a big difference in the performance of your AI model.

**Types of Activation Functions in AI**

There are many types of activation functions in AI, but they can be broadly classified into three categories:

**linear****non-linear****hybrid**

### 1. **Linear Activation Functions**

Linear activation functions are the simplest ones, as they do not apply any transformation to the input. They just multiply the input by a constant factor, usually 1. The most common linear activation function is the **identity function**, which returns the input as it is.

Identity Function: Theidentity functionis useful for regression problems, where the output is a continuous value, such as predicting the price of a house or the temperature of a city.

However, it is not suitable for classification problems, where the output is a discrete value, such as identifying the type of an animal or the sentiment of a text.

This is because the identity function cannot capture the non-linear relationships between the input and the output, and it cannot handle multiple classes.

Another drawback of linear activation functions is that they make the network prone to the **vanishing gradient problem**. This is a situation where the gradient of the error function becomes very small or zero, and the network stops learning.

This happens because the derivative of a linear function is constant, and it does not change with the input. Therefore, the error does not propagate well through the network, and the weights do not update effectively.

### 2. **Non-linear Activation Functions**

Non-linear activation functions are more complex and powerful than linear ones, as they apply some non-linear transformation to the input. They can capture the non-linear relationships between the input and the output, and they can handle multiple classes.

They also **avoid the vanishing gradient problem**, as their derivatives vary with the input.

Some of the most popular non-linear activation functions are:

### A. **Sigmoid Function**

The

sigmoid functionis a smooth and curved function that maps any input to a value between 0 and 1. It is often used for binary classification problems, where the output is either 0 or 1, such as detecting spam emails or diagnosing diseases. The sigmoid function is also useful for modeling probabilities, as it can represent the likelihood of an event.

### Disadvantages: Sigmoid Function

However, the sigmoid function has some disadvantages, such as:

#### i. **Saturation problem**

It is prone to the **saturation problem**. This is a situation where the output of the function becomes very close to 0 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This happens because the sigmoid function has a steep slope near 0 and 1, and a flat slope near the middle.

#### ii. **Zero-centered**

It is not **zero-centered**. This means that the output of the function is always positive, and it does not have a mean of zero. This can cause the gradient to oscillate or change signs during the backpropagation, and make the learning process unstable.

#### iii. **Computationally expensive**

It is **computationally expensive**. This means that it takes more time and resources to calculate the output and the derivative of the function, compared to other functions.

The sigmoid function is defined as:

\sigma(x) = \frac{1}{1 + e^{-x}}

The derivative of the sigmoid function is:

\sigma'(x) = \sigma(x) (1 - \sigma(x))

Here is a plot of the sigmoid function and its derivative:

#### PYTHON

```
import numpy as np
import matplotlib.pyplot as plt
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return sigmoid(x) * (1 - sigmoid(x))
x = np.linspace(-10, 10, 100)
y = sigmoid(x)
y_prime = sigmoid_derivative(x)
plt.plot(x, y, label="sigmoid")
plt.plot(x, y_prime, label="sigmoid derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

### B. **Tanh Function**

The

tanh functionis a scaled and shifted version of the sigmoid function, that maps any input to a value between -1 and 1. It is often used for classification and regression problems, where the output can be positive or negative, such as predicting the sentiment of a text or the direction of a stock price.

The tanh function is also useful for modeling bipolar signals, as it can represent the polarity of an event.

### Advantages: Tang Function

The tanh function has some advantages over the sigmoid function, such as:

#### i. **Zero-centered**

It is **zero-centered**. This means that the output of the function has a mean of zero, and it can have both positive and negative values. This can make the gradient more balanced and consistent during the backpropagation, and make the learning process faster and more stable.

#### ii. **Steeper slope**

It has a **steeper slope**. This means that the output of the function changes more rapidly with the input, and the gradient is larger. This can make the network more sensitive and responsive to the input, and improve the accuracy and speed of the network.

### Disadvantages: Tanh Function

However, the tanh function also has some disadvantages, such as:

#### i. **Saturation problem**

It is still prone to the **saturation problem**. This is a situation where the output of the function becomes very close to -1 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This happens because the tanh function has a steep slope near -1 and 1, and a flat slope near the middle.

#### ii. **Computationally expensive**

It is still **computationally expensive**. This means that it takes more time and resources to calculate the output and the derivative of the function, compared to other functions.

The tanh function is defined as:

\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}

The derivative of the tanh function is:

\tanh'(x) = 1 - \tanh^2(x)

Here is a plot of the tanh function and its derivative:

#### PYTHON

```
import numpy as np
import matplotlib.pyplot as plt
def tanh(x):
return np.tanh(x)
def tanh_derivative(x):
return 1 - tanh(x) ** 2
x = np.linspace(-10, 10, 100)
y = tanh(x)
y_prime = tanh_derivative(x)
plt.plot(x, y, label="tanh")
plt.plot(x, y_prime, label="tanh derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

### C. **ReLU Function**

The

ReLU functionis a piecewise linear function that returns the input if it is positive, and zero if it is negative. It is one of the most widely used activation functions in AI, especially for deep neural networks, where the number of layers and neurons is large.The ReLU function is useful for many problems, such as

image recognition,natural language processing, andcomputer vision.

### Advantages: ReLU Function

The ReLU function has many advantages, such as:

#### i. **Simple and fast**

It is **simple and fast**. This means that it takes less time and resources to calculate the output and the derivative of the function, compared to other functions.

#### ii. **Sparse and efficient**

It is **sparse and efficient**. This means that it activates only a subset of neurons at a time, and reduces the computational load and memory usage of the network. This also helps to prevent overfitting, as it introduces some randomness and variability in the network.

#### iii. **Saturation problem**

It avoids the **saturation problem**. This is a situation where the output of the function becomes very close to 0 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This does not happen with the ReLU function, as it has a constant gradient of 1 for positive inputs, and it does not saturate.

### Disadvantages: ReLU Function

However, the ReLU function also has some disadvantages, such as:

#### i. **Dying ReLU problem**

It suffers from the **dying ReLU problem**. This is a situation where the output of the function becomes zero for all inputs, and the gradient becomes zero. This makes the network stop learning.

#### ii. Not **differentiable**

It is not **differentiable**. This means that it does not have a well-defined derivative at zero, and it is not smooth. This can cause some problems for the optimization algorithms, such as gradient descent, that rely on the derivative of the function.

The ReLU function is defined as:

\text{ReLU}(x) = \max(0, x)

The derivative of the ReLU function is:

\text{ReLU}'(x) = \begin{cases} 1, & \text{if } x > 0 \\ 0, & \text{if } x < 0 \\ \text{undefined}, & \text{if } x = 0 \end{cases}

Here is a plot of the ReLU function and its derivative:

#### PYTHON

```
import numpy as np
import matplotlib.pyplot as plt
def relu(x):
return np.maximum(0, x)
def relu_derivative(x):
return np.where(x > 0, 1, 0)
x = np.linspace(-10, 10, 100)
y = relu(x)
y_prime = relu_derivative(x)
plt.plot(x, y, label="ReLU")
plt.plot(x, y_prime, label="ReLU derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

### D. **Leaky ReLU Function**

The

leaky ReLU functionis a modified version of the ReLU function, that returns a small positive value instead of zero for negative inputs. It is designed to overcome the dying ReLU problem, by allowing some gradient to flow through the network even for negative inputs.The

leaky ReLU functionis useful for problems where the input can have both positive and negative values, such as audio processing, speech recognition, and natural language understanding.

### Advantages: leaky ReLU function

The leaky ReLU function has some advantages over the ReLU function, such as:

#### I. **Dying ReLU problem**

It avoids the **dying ReLU problem**. This is a situation where the output of the function becomes zero for all inputs, and the gradient becomes zero. This makes the network stop learning. This does not happen with the leaky ReLU function, as it has a small positive gradient for negative inputs, and it does not die.

### Disadvantages: leaky ReLU Function

However, the leaky ReLU function also has some disadvantages, such as:

### i. Not** differentiable**

It is still not **differentiable**. This means that it does not have a well-defined derivative at zero, and it is not smooth. This can cause some problems for the optimization algorithms, such as gradient descent, that rely on the derivative of the function.

#### II. Not **zero-centered**

It is still not **zero-centered**. This means that the output of the function is always positive, and it does not have a mean of zero. This can cause the gradient to oscillate or change signs during the backpropagation, and make the learning process unstable.

The leaky ReLU function is defined as:

\text{Leaky ReLU}(x) = \max(\alpha x, x)where \alpha is a small positive constant, usually 0.01.

The derivative of the leaky ReLU function is:

\text{Leaky ReLU}'(x) = \begin{cases} \alpha, & \text{if } x < 0 \\ 1, & \text{if } x > 0 \\ \text{undefined}, & \text{if } x = 0 \end{cases}

Here is a plot of the leaky ReLU function and its derivative:

```
import numpy as np
import matplotlib.pyplot as plt
def leaky_relu(x, alpha=0.01):
return np.maximum(alpha * x, x)
def leaky_relu_derivative(x, alpha=0.01):
return np.where(x > 0, 1, alpha)
x = np.linspace(-10, 10, 100)
y = leaky_relu(x)
y_prime = leaky_relu_derivative(x)
plt.plot(x, y, label="leaky ReLU")
plt.plot(x, y_prime, label="leaky ReLU derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

## 3. **Hybrid Activation Functions**

**Hybrid activation functions** are combinations of linear and non-linear functions, that aim to combine the best of both worlds. They can have different behaviors for different ranges of inputs, and they can adapt to the needs of the network.

Some of the most popular hybrid activation functions are:

### A. **ELU Function**

The

ELU functionis a non-linear function that returns the input if it is positive, and a negative exponential function if it is negative. It is similar to the leaky ReLU function, but it has a smoother transition from negative to positive values.The

ELU functionis useful for problems where the input can have both positive and negative values, such as image processing, computer vision, and natural language generation.

### Advantages: ELU Function

The ELU function has some advantages over the leaky ReLU function, such as:

#### i. **Differentiable**

It is **differentiable**. This means that it has a well-defined derivative at zero, and it is smooth. This can make the optimization algorithms, such as gradient descent, work better and faster.

#### ii. **Zero-centered**

It is **zero-centered**. This means that the output of the function has a mean of zero, and it can have both positive and negative values. This can make the gradient more balanced and consistent during the backpropagation, and make the learning process faster and more stable.

### Disadvantages: ELU Function

However, the ELU function also has some disadvantages, such as:

#### i. **Saturation problem**

It is still prone to the **saturation problem**. This is a situation where the output of the function becomes very close to -1 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This happens because the ELU function has a steep slope near -1 and 1, and a flat slope near the middle.

#### ii. **Computationally expensive**

It is still **computationally expensive**. This means that it takes more time and resources to calculate the output and the derivative of the function, compared to other functions.

The ELU function is defined as:

\text{ELU}(x) = \begin{cases} x, & \text{if } x > 0 \\ \alpha (e^x - 1), & \text{if } x \leq 0 \end{cases}where \alpha is a positive constant, usually 1.

The derivative of the ELU function is:

\text{ELU}'(x) = \begin{cases} 1, & \text{if } x > 0 \\ \alpha e^x, & \text{if } x \leq 0 \end{cases}

Here is a plot of the ELU function and its derivative:

```
import numpy as np
import matplotlib.pyplot as plt
def elu(x, alpha=1):
return np.where(x > 0, x, alpha * (np.exp(x) - 1))
def elu_derivative(x, alpha=1):
return np.where(x > 0, 1, alpha * np.exp(x))
x = np.linspace(-10, 10, 100)
y = elu(x)
y_prime = elu_derivative(x)
plt.plot(x, y, label="ELU")
plt.plot(x, y_prime, label="ELU derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

### B. **Softmax Function**

The

softmax functionis a non-linear function that converts a vector of inputs into a vector of probabilities, such that the sum of the probabilities is 1. It is often used for multi-class classification problems, where the output is one of several possible classes, such as identifying the type of an animal or the genre of a movie.The

softmax functionis also useful for modeling multinomial distributions, as it can represent the probability of each outcome.

### Advantages: Softmax Function

It is **normalized**. This means that the output of the function is always between 0 and 1, and the sum of the output is 1. This can make the interpretation and comparison of the output easier and more meaningful.

It is **differentiable**. This means that it has a well-defined derivative, and it is smooth. This can make the optimization algorithms, such as gradient descent, work better and faster.

### Disadvantages: Softmax Function

It is prone to the **overflow problem**. This is a situation where the input of the function becomes very large or very small, and the output becomes very close to 0 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This happens because the softmax function involves exponentiation, which can cause numerical instability and overflow.

It is **computationally expensive**. This means that it takes more time and resources to calculate the output and the derivative of the function, compared to other functions.

The softmax function is defined as:

\text{Softmax}(x_i) = \frac{e^{x_i}}{\sum_{j=1}^n e^{x_j}}where x_i is the input for the i-th neuron, and n is the number of neurons in the layer.

The derivative of the softmax function is:

\text{Softmax}'(x_i) = \text{Softmax}(x_i) (1 - \text{Softmax}(x_i))

Here is a plot of the softmax function and its derivative for a vector of three inputs:

#### PYTHON

```
import numpy as np
import matplotlib.pyplot as plt
def softmax(x):
return np.exp(x) / np.sum(np.exp(x))
def softmax_derivative(x):
return softmax(x) * (1 - softmax(x))
x = np.array([1, 2, 3])
y = softmax(x)
y_prime = softmax_derivative(x)
plt.bar(x, y, label="softmax")
plt.bar(x, y_prime, label="softmax derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

### C. **Swish Function**

The

swish functionis a non-linear function that returns the input multiplied by the sigmoid of the input. It is a self-gated function, meaning that it can adaptively adjust its output based on the input.The

swish functionis useful for problems where the input can have both positive and negative values, such as image processing, computer vision, and natural language processing.

### Advantages: Swish Function

The swish function has some advantages, such as:

It is **smooth and differentiable**. This means that it has a well-defined derivative, and it is continuous. This can make the optimization algorithms, such as gradient descent, work better and faster.

It is **unbounded and zero-centered**. This means that the output of the function can have any value, and it has a mean of zero. This can make the gradient more balanced and consistent during the backpropagation, and make the learning process faster and more stable.

It avoids the **saturation problem**. This is a situation where the output of the function becomes very close to 0 or 1, and the gradient becomes very small or zero. This makes the network slow to learn or stop learning. This does not happen with the swish function, as it has a moderate slope for all inputs, and it does not saturate.

### Disadvantages: Swish Function

However, the swish function also has some disadvantages, such as:

It is **computationally expensive**. This means that it takes more time and resources to calculate the output and the derivative of the function, compared to other functions.

The swish function is defined as:

\text{Swish}(x) = x \sigma(x)

The derivative of the swish function is:

\text{Swish}'(x) = \sigma(x) + x \sigma'(x)

Here is a plot of the swish function and its derivative:

```
import numpy as np
import matplotlib.pyplot as plt
def swish(x):
return x * sigmoid(x)
def swish_derivative(x):
return sigmoid(x) + x * sigmoid_derivative(x)
x = np.linspace(-10, 10, 100)
y = swish(x)
y_prime = swish_derivative(x)
plt.plot(x, y, label="swish")
plt.plot(x, y_prime, label="swish derivative")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()
```

## How to Choose the Right Activation Function in AI

Now that you have learned about the types, characteristics, and applications of some of the most common activation functions in AI, you might be wondering how to choose the right one for your specific problem.

There is no definitive answer to this question, as different activation functions may work better or worse depending on the data, the network architecture, the optimization algorithm, and the task.

However, here are some general guidelines and tips that can help you make an informed decision:

### 1. **Experiment with different activation functions**

The best way to find out which activation function works best for your problem is to try different ones and compare their results. You can use metrics such as **accuracy**, **loss**, **speed**, and **stability **to evaluate the **performance** of each activation function.

You can also use tools such as **TensorBoard **or **Matplotlib** to visualize the output and the gradient of each activation function, and see how they affect the network.

### 2. **Consider the characteristics of your data and your task**

Some activation functions may be more suitable for certain types of data and tasks than others. For example, if your data is **binary **or **probabilistic**, you may want to use the **sigmoid function**. If your data is **bipolar** or **continuous**, you may want to use the **tanh** **function**.

If your data is **sparse **or **high-dimensional**, you may want to use the **ReLU** **function**. If your task is **multi-class classification**, you may want to use the **softmax function**.

### 3. **Consider the characteristics of your network and your optimization algorithm**

Some activation functions may be more compatible with certain network architectures and optimization algorithms than others. For example, if your network is **deep **or **complex**, you may want to use the **ReLU function **or its variants, as they are simple, fast, and efficient.

If your network is **shallow **or **simple**, you may want to use the **sigmoid function **or the **tanh function**, as they are smooth and differentiable. If your optimization algorithm is **gradient**–**based**, you may want to **avoid activation functions **that have **zero** or **constant gradients**, such as the **linear **function or the **ReLU **function, as they can cause the vanishing or exploding gradient problem.

#### 4. **Consider the trade-offs and the limitations of each activation function**

No activation function is perfect, and each one has its own advantages and disadvantages. You should be aware of the trade-offs and the limitations of each activation function, and weigh them against your goals and constraints.

For example, if you want to achieve **high accuracy** and **speed**, you may want to use the **ReLU function**, but you should also be careful of the **dying ReLU problem**. If you want to achieve smooth and **consistent **learning, you may want to use the **tanh** **function**, but you should also be careful of the **saturation** **problem**.

If you want to achieve **normalized** and **interpretable** **output**, you may want to use the **softmax** **function**, but you should also be careful of the **overflow problem**.

**Summary**

To summarize, the **activation function in AI** is a mathematical formula that determines how much a neuron in an artificial neural network should fire. It is one of the most important components of an ANN, as it affects the learning ability, accuracy, and speed of the network. Different activation functions have different properties and advantages, and choosing the right one can make a big difference in the performance of your AI model.

Some of the most common activation functions in AI are:

i. **Linear function**: A simple function that returns the input as it is. It is useful for regression problems, but not for classification problems. It also suffers from the vanishing gradient problem.

ii. **Sigmoid function**: A smooth and curved function that returns a value between 0 and 1. It is useful for binary classification problems and modeling probabilities, but it suffers from the saturation problem, the zero-centered problem, and the computational expense problem.

iii. **Tanh function**: A scaled and shifted version of the sigmoid function that returns a value between -1 and 1. It is useful for classification and regression problems and modeling bipolar signals, but it also suffers from the saturation problem and the computational expense problem.

iv. **ReLU function**: A piecewise linear function that returns the input if it is positive, and zero if it is negative. It is one of the most widely used activation functions in AI, especially for deep neural networks. It is simple, fast, sparse, and efficient, but it suffers from the dying ReLU problem and the differentiability problem.

v. **Leaky ReLU function**: A modified version of the ReLU function that returns a small positive value instead of zero for negative inputs. It is designed to overcome the dying ReLU problem, but it still suffers from the differentiability problem and the zero-centered problem.

vi. **ELU function**: A non-linear function that returns the input if it is positive, and a negative exponential function if it is negative. It is similar to the leaky ReLU function, but it has a smoother transition from negative to positive values. It is differentiable and zero-centered, but it still suffers from the saturation problem and the computational expense problem.

vii. **Softmax function**: A non-linear function that converts a vector of inputs into a vector of probabilities, such that the sum of the probabilities is 1. It is often used for multi-class classification problems and modeling multinomial distributions, but it suffers from the overflow problem and the computational expense problem.

viii. **Swish function**: A non-linear function that returns the input multiplied by the sigmoid of the input. It is a self-gated function, meaning that it can adaptively adjust its output based on the input. It is smooth, differentiable, unbounded, and zero-centered, but it is computationally expensive.

The best way to choose the right activation function for your specific problem is to experiment with different ones and compare their results. You should also consider the characteristics of your data, your task, your network, and your optimization algorithm, and weigh the trade-offs and the limitations of each activation function.