Sigmoid Function

easyFREEClassificationMachine Learning 1

Implement the sigmoid (logistic) function that maps any real number to the range $(0, 1)$ .

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

Given a list of values, apply the sigmoid function to each and return the results.

To avoid overflow for large negative values, use the identity: for $z < 0$ , compute $\sigma(z) = \frac{e^z}{1 + e^z}$ .

Round each result to 4 decimal places.

Example

Input

z = [0, 2, -2]

Output

[0.5, 0.8808, 0.1192]

Reasoning

Input: z is a list of real numbers (logits): here [0, 2, -2]. Each value is squashed independently, so the output has the same length, 3.
$z = 0$ : $e^{0} = 1$ , so $\sigma(0) = \frac{1}{1 + 1} = 0.5$ , exactly halfway. A logit of zero means "no preference either way".
$z = 2$ : $e^{-2} \approx 0.13534$ , so $\sigma(2) = \frac{1}{1.13534} \approx 0.880797$ , which rounds to $0.8808$ at 4 decimal places.
$z = -2$ : using the overflow-safe form from the description, $\sigma(-2) = \frac{e^{-2}}{1 + e^{-2}} = \frac{0.13534}{1.13534} \approx 0.119203$ , giving $0.1192$ .
Output: [0.5, 0.8808, 0.1192], every value strictly between 0 and 1. Notice the symmetry $\sigma(-z) = 1 - \sigma(z)$ : $0.8808 + 0.1192 = 1$ .
For huge inputs like $\pm 100$ the true values sit within $10^{-43}$ of 0 or 1, so after rounding they appear as $0.0$ and $1.0$ .

Constraints

Input is a list of floats (can be negative, zero, or positive)
Return a list of sigmoid values, each rounded to 4 decimal places
Handle large positive/negative inputs without overflow

Learn this in

ClassificationML Study Plan Neural NetworksML Study Plan

More from Machine Learning 1

RBF Kernel Matrixhard Polynomial Kernelmedium Hinge Losseasy Linear Decision Boundaryeasy Gradient Boosting Residual Stephard

Concept primer

Background Knowledge

The sigmoid function, also known as the logistic function, is a mathematical function that maps any real number to a value between 0 and 1. It is often used in machine learning and classification problems, particularly in the context of binary classification, where the goal is to predict one of two classes or outcomes. The sigmoid function is defined as $\sigma(z) = \frac{1}{1 + e^{-z}}$ , where $e$ is the base of the natural logarithm.

In the context of neural networks, the sigmoid function is commonly used as an activation function for the output layer when the task is a binary classification problem. The sigmoid function is useful because it can take any real-valued input and produce an output that can be interpreted as a probability. However, one of the challenges with the sigmoid function is that it can suffer from overflow issues when dealing with large negative values. To mitigate this, an alternative formulation of the sigmoid function can be used for negative inputs: $\sigma(z) = \frac{e^z}{1 + e^z}$ .

The sigmoid function has several important properties, including being monotonic (always increasing) and differentiable. These properties make it a popular choice for many machine learning applications. Understanding the sigmoid function and its properties is essential for working with classification algorithms and neural networks.

Algorithm/Approach

The general approach to solving this problem involves applying the sigmoid function to each value in the input list. This requires implementing the sigmoid function using the given mathematical formula and handling the case where the input value is negative to avoid overflow.

Step-by-Step Strategy

To implement the solution:

Define the sigmoid function using the given formula: $\sigma(z) = \frac{1}{1 + e^{-z}}$ .
Create a loop to iterate over each value in the input list.
For each value, check if it is negative. If it is, use the alternative formulation: $\sigma(z) = \frac{e^z}{1 + e^z}$ .
Apply the sigmoid function to the current value and round the result to 4 decimal places.
Store the result in a new list.
Return the list of results.

Common Pitfalls

When implementing the solution, watch out for:

Not handling the case where the input value is negative, which can lead to overflow.
Not rounding the results to 4 decimal places as required.
Using the wrong formula for the sigmoid function.

Time & Space Complexity

The expected time complexity for this solution is O(n), where n is the number of values in the input list, since we need to iterate over each value once. The space complexity is also O(n), as we need to store the results in a new list.

solution.py

Python 3.13

Test results