Activation functions in ML Python - Model Metrics & Evaluation

Metrics & Evaluation - Activation functions

Which metric matters for Activation Functions and WHY

Activation functions affect how well a model learns and predicts. The key metrics to watch are loss and accuracy. Loss shows how far off predictions are during training. Accuracy shows how often the model predicts correctly. Good activation functions help lower loss and raise accuracy by allowing the model to learn complex patterns.

Confusion Matrix Example

For a classification model using activation functions like ReLU or Sigmoid, the confusion matrix helps us see prediction results:

      Actual \ Predicted | Positive | Negative
      -------------------|----------|---------
      Positive           |    85    |   15
      Negative           |    10    |   90
    

Here, TP=85, FP=10, FN=15, TN=90. Activation functions influence these numbers by shaping model outputs.

Precision vs Recall Tradeoff

Activation functions impact model sensitivity. For example, Sigmoid outputs probabilities, helping balance precision and recall. ReLU can speed up learning but may cause some neurons to "die" (stop learning), affecting recall.

In a spam filter, high precision means fewer good emails marked as spam. Using activation functions that help the model focus on clear signals improves precision.

In medical diagnosis, high recall means catching most sick patients. Activation functions that allow subtle signals to pass help improve recall.

Good vs Bad Metric Values for Activation Functions

Good: Low loss (e.g., below 0.2), high accuracy (above 85%), balanced precision and recall (both above 80%). This means the activation function helps the model learn well.

Bad: High loss (above 1.0), low accuracy (below 60%), very low recall or precision (below 50%). This suggests the activation function may cause learning problems like vanishing gradients or dead neurons.

Common Pitfalls with Activation Functions

• Vanishing gradients: Functions like Sigmoid can squash values, making learning slow or stuck.
• Dead neurons: ReLU can output zero for many inputs, causing some neurons to stop updating.
• Choosing wrong function: Using linear activation in hidden layers limits model power.
• Ignoring data scale: Activation functions may behave poorly if input data is not normalized.

Self Check

Your model uses ReLU activation and shows 98% accuracy but training loss stays high and validation accuracy is low. Is this good?

Answer: No. High accuracy with high loss and low validation accuracy suggests overfitting or dead neurons. The activation function might cause some neurons to stop learning. Try Leaky ReLU or check data preprocessing.

Key Result

Activation functions influence loss and accuracy by enabling models to learn complex patterns effectively.

Practice

1. What is the main purpose of an activation function in a neural network?

easy

A. To split data into training and testing sets

B. To initialize the weights of the network

C. To reduce the size of the dataset

D. To add non-linearity so the network can learn complex patterns

Solution

1. Step 1: Understand the role of activation functions

   Activation functions introduce non-linearity to the network, allowing it to learn complex patterns beyond simple straight lines.

2. Step 2: Compare with other options

   Weight initialization, data splitting, and dataset size reduction are unrelated to activation functions.

3. Final Answer:

   To add non-linearity so the network can learn complex patterns -> Option D

4. Quick Check:

   Activation function purpose = Add non-linearity [OK]

Hint: Activation functions make models learn complex patterns [OK]

Common Mistakes:

• Confusing activation functions with weight initialization
• Thinking activation functions reduce dataset size
• Believing activation functions split data

2. Which of the following is the correct Python syntax to apply the ReLU activation function on a variable x using NumPy?

easy

A. relu_x = np.maximum(0, x)

B. relu_x = np.min(0, x)

C. relu_x = np.exp(x)

D. relu_x = np.log(x)

Solution

1. Step 1: Recall ReLU function definition

   ReLU returns the maximum between 0 and the input value, so np.maximum(0, x) is correct.

2. Step 2: Check other options

   np.min(0, x) returns the minimum, which is incorrect. np.exp(x) and np.log(x) are exponential and logarithm functions, not ReLU.

3. Final Answer:

   relu_x = np.maximum(0, x) -> Option A

4. Quick Check:

   ReLU = max(0, x) [OK]

Hint: ReLU = max between zero and input [OK]

Common Mistakes:

• Using np.min instead of np.maximum
• Confusing ReLU with exponential or log functions
• Forgetting to import numpy as np

3. Given the following Python code using NumPy, what is the output of print(output)?

import numpy as np
x = np.array([-2, 0, 3])
output = 1 / (1 + np.exp(-x))
print(output)

medium

A. [0 0 3]

B. [0.11920292 0.5 0.95257413]

C. [-2 0 3]

D. [1 1 1]

Solution

1. Step 1: Identify the activation function used

   The code applies the sigmoid function: 1 / (1 + exp(-x)) on each element of x.

2. Step 2: Calculate sigmoid values for each element

   For x = -2: sigmoid ≈ 0.1192; for 0: sigmoid = 0.5; for 3: sigmoid ≈ 0.9526.

3. Final Answer:

   [0.11920292 0.5 0.95257413] -> Option B

4. Quick Check:

   Sigmoid([-2,0,3]) = [0.119,0.5,0.953] [OK]

Hint: Sigmoid outputs values between 0 and 1 [OK]

Common Mistakes:

• Confusing sigmoid with identity function
• Expecting original input as output
• Miscomputing exponential values

4. The following code attempts to implement the Tanh activation function but has an error. What is the error?

import numpy as np
def tanh(x):
    return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(x))

print(tanh(1))

medium

A. The denominator should be (np.exp(x) + np.exp(-x)) instead of (np.exp(x) + np.exp(x))

B. The numerator should be (np.exp(x) + np.exp(-x))

C. The function should use np.tanh(x) directly

D. The function is missing a return statement

Solution

1. Step 1: Review the Tanh formula

   Tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x)). The denominator in the code is incorrect.

2. Step 2: Identify the error in denominator

   The code uses (np.exp(x) + np.exp(x)) which doubles exp(x) instead of adding exp(-x).

3. Final Answer:

   The denominator should be (np.exp(x) + np.exp(-x)) instead of (np.exp(x) + np.exp(x)) -> Option A

4. Quick Check:

   Tanh denominator = exp(x)+exp(-x) [OK]

Hint: Check denominator carefully for plus and minus signs [OK]

Common Mistakes:

• Copying exp(x) twice in denominator
• Swapping numerator and denominator terms
• Forgetting to return the value

5. You want to design a neural network for a binary classification task. Which activation function should you use in the output layer to get a probability between 0 and 1, and why?

hard

A. Tanh, because it outputs values between -1 and 1

B. ReLU, because it outputs only positive values

C. Sigmoid, because it outputs values between 0 and 1 suitable for probabilities

D. Linear, because it outputs raw scores

Solution

1. Step 1: Understand output layer needs for binary classification

   The output should represent a probability, so it must be between 0 and 1.

2. Step 2: Match activation functions to output range

   Sigmoid outputs between 0 and 1, perfect for probabilities. ReLU outputs 0 or more but unbounded. Tanh outputs between -1 and 1, not suitable for probabilities. Linear outputs any real number.

3. Final Answer:

   Sigmoid, because it outputs values between 0 and 1 suitable for probabilities -> Option C

4. Quick Check:

   Binary output needs sigmoid for probability [OK]

Hint: Use sigmoid for binary output probabilities [OK]

Common Mistakes:

• Using ReLU or Tanh in output layer for probabilities
• Choosing linear activation for classification output
• Not considering output range needed