NumPy - np.exp() and np.log() | Application Architect

Key Insights

np.exp() and np.log() are vectorized operations that compute exponentials and natural logarithms element-wise, offering 10-100x performance improvements over Python loops for array operations
These functions form the mathematical foundation for machine learning algorithms including logistic regression, neural network activations, and probability distributions
NumPy handles edge cases automatically (infinity, NaN, zero) and provides numerical stability features critical for production systems dealing with very large or small numbers

Understanding Exponential and Logarithm Operations

The exponential function np.exp(x) computes e^x where e ≈ 2.71828, while np.log(x) computes the natural logarithm (base e). NumPy implements these as universal functions (ufuncs) that operate element-wise on arrays with C-level performance.

import numpy as np

# Basic operations
x = np.array([1, 2, 3, 4, 5])
exp_result = np.exp(x)
log_result = np.log(x)

print(f"exp(x): {exp_result}")
# exp(x): [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591 ]

print(f"log(x): {log_result}")
# log(x): [0.         0.69314718 1.09861229 1.38629436 1.60943791]

# Verify inverse relationship
print(f"log(exp(x)): {np.log(np.exp(x))}")
# log(exp(x)): [1. 2. 3. 4. 5.]

Performance Characteristics

The vectorized nature of NumPy operations provides substantial performance benefits over pure Python implementations.

import time

# Pure Python implementation
def python_exp(arr):
    import math
    return [math.exp(x) for x in arr]

# Generate test data
data = list(range(1000000))
np_data = np.array(data)

# Benchmark Python
start = time.time()
result_py = python_exp(data)
python_time = time.time() - start

# Benchmark NumPy
start = time.time()
result_np = np.exp(np_data)
numpy_time = time.time() - start

print(f"Python time: {python_time:.4f}s")
print(f"NumPy time: {numpy_time:.4f}s")
print(f"Speedup: {python_time/numpy_time:.1f}x")
# Typical output:
# Python time: 0.2847s
# NumPy time: 0.0031s
# Speedup: 91.8x

Handling Edge Cases and Special Values

NumPy handles mathematical edge cases according to IEEE 754 standards, returning appropriate special values.

# Edge cases for exp
edge_cases_exp = np.array([0, -np.inf, np.inf, np.nan])
print(f"exp edge cases: {np.exp(edge_cases_exp)}")
# exp edge cases: [ 1.  0. inf nan]

# Edge cases for log
edge_cases_log = np.array([0, -1, np.inf, np.nan])
print(f"log edge cases: {np.log(edge_cases_log)}")
# log edge cases: [      -inf        nan        inf        nan]
# Warning: divide by zero encountered in log
# Warning: invalid value encountered in log

# Practical handling
def safe_log(x, min_value=1e-10):
    """Compute log with numerical stability"""
    return np.log(np.maximum(x, min_value))

probabilities = np.array([0.9, 0.1, 0.0001, 0])
print(f"Safe log: {safe_log(probabilities)}")
# Safe log: [-0.10536052 -2.30258509 -9.21034037 -23.02585093]

Logarithm Variants

NumPy provides multiple logarithm functions for different bases and use cases.

x = np.array([1, 10, 100, 1000])

# Natural logarithm (base e)
ln = np.log(x)
print(f"ln(x): {ln}")
# ln(x): [0.         2.30258509 4.60517019 6.90775528]

# Base-10 logarithm
log10 = np.log10(x)
print(f"log10(x): {log10}")
# log10(x): [0. 1. 2. 3.]

# Base-2 logarithm
log2 = np.log2(x)
print(f"log2(x): {log2}")
# log2(x): [ 0.          3.32192809  6.64385619  9.96578428]

# Log of (1 + x) - more accurate for small x
small_x = np.array([0.001, 0.01, 0.1])
regular_log = np.log(1 + small_x)
log1p = np.log1p(small_x)
print(f"Difference: {np.abs(regular_log - log1p)}")
# Difference: [0.00000000e+00 0.00000000e+00 5.55111512e-17]

Logistic Regression Implementation

A practical example showing how np.exp() enables the sigmoid function in logistic regression.

class LogisticRegression:
    def __init__(self, learning_rate=0.01, iterations=1000):
        self.lr = learning_rate
        self.iterations = iterations
        self.weights = None
        self.bias = None
    
    def sigmoid(self, z):
        """Numerically stable sigmoid function"""
        # Prevent overflow by clipping
        z = np.clip(z, -500, 500)
        return 1 / (1 + np.exp(-z))
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        
        for _ in range(self.iterations):
            # Linear combination
            linear_pred = np.dot(X, self.weights) + self.bias
            # Apply sigmoid
            predictions = self.sigmoid(linear_pred)
            
            # Compute gradients
            dw = (1/n_samples) * np.dot(X.T, (predictions - y))
            db = (1/n_samples) * np.sum(predictions - y)
            
            # Update parameters
            self.weights -= self.lr * dw
            self.bias -= self.lr * db
    
    def predict_proba(self, X):
        linear_pred = np.dot(X, self.weights) + self.bias
        return self.sigmoid(linear_pred)
    
    def predict(self, X):
        return (self.predict_proba(X) >= 0.5).astype(int)

# Example usage
np.random.seed(42)
X = np.random.randn(100, 2)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

model = LogisticRegression()
model.fit(X, y)
predictions = model.predict(X)
accuracy = np.mean(predictions == y)
print(f"Accuracy: {accuracy:.2%}")
# Accuracy: 95.00%

Log-Sum-Exp Trick for Numerical Stability

Computing logarithms of sums of exponentials is common in machine learning but numerically unstable. The log-sum-exp trick prevents overflow.

def naive_log_sum_exp(x):
    """Naive implementation - prone to overflow"""
    return np.log(np.sum(np.exp(x)))

def stable_log_sum_exp(x):
    """Numerically stable implementation"""
    max_x = np.max(x)
    return max_x + np.log(np.sum(np.exp(x - max_x)))

# Test with large values
large_values = np.array([1000, 1001, 1002])

try:
    naive_result = naive_log_sum_exp(large_values)
    print(f"Naive result: {naive_result}")
except:
    print("Naive implementation: overflow!")
    # Naive implementation: overflow!

stable_result = stable_log_sum_exp(large_values)
print(f"Stable result: {stable_result}")
# Stable result: 1002.4076059644443

# Application in softmax
def stable_softmax(x):
    """Numerically stable softmax"""
    exp_x = np.exp(x - np.max(x))
    return exp_x / np.sum(exp_x)

logits = np.array([1000, 1001, 1002])
probabilities = stable_softmax(logits)
print(f"Softmax probabilities: {probabilities}")
# Softmax probabilities: [0.09003057 0.24472847 0.66524096]
print(f"Sum: {np.sum(probabilities)}")
# Sum: 1.0

Cross-Entropy Loss Calculation

Cross-entropy loss uses both logarithms and exponentials, requiring careful numerical handling.

def binary_cross_entropy(y_true, y_pred, epsilon=1e-15):
    """Binary cross-entropy with numerical stability"""
    # Clip predictions to prevent log(0)
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    return -np.mean(y_true * np.log(y_pred) + 
                    (1 - y_true) * np.log(1 - y_pred))

def categorical_cross_entropy(y_true, y_pred, epsilon=1e-15):
    """Categorical cross-entropy"""
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    return -np.sum(y_true * np.log(y_pred)) / y_true.shape[0]

# Binary classification example
y_true = np.array([1, 0, 1, 1, 0])
y_pred = np.array([0.9, 0.1, 0.8, 0.7, 0.2])
bce_loss = binary_cross_entropy(y_true, y_pred)
print(f"Binary CE Loss: {bce_loss:.4f}")
# Binary CE Loss: 0.1985

# Multi-class classification example
y_true_cat = np.array([[1, 0, 0],
                       [0, 1, 0],
                       [0, 0, 1]])
y_pred_cat = np.array([[0.8, 0.1, 0.1],
                       [0.1, 0.7, 0.2],
                       [0.2, 0.2, 0.6]])
cce_loss = categorical_cross_entropy(y_true_cat, y_pred_cat)
print(f"Categorical CE Loss: {cce_loss:.4f}")
# Categorical CE Loss: 0.3567

Broadcasting and Memory Efficiency

NumPy’s broadcasting rules allow efficient operations on arrays of different shapes without creating intermediate copies.

# Broadcasting example
x = np.array([[1, 2, 3],
              [4, 5, 6]])  # Shape: (2, 3)
y = np.array([1, 2, 3])     # Shape: (3,)

# Element-wise operations with broadcasting
result = np.exp(x - y)  # y is broadcast to (2, 3)
print(f"Result shape: {result.shape}")
print(result)
# Result shape: (2, 3)
# [[1.         1.         1.        ]
#  [7.3890561  7.3890561  7.3890561 ]]

# Memory efficiency check
large_array = np.random.randn(1000, 1000)
offset = np.random.randn(1000)

# No copy created - operates in-place on views
result = np.exp(large_array - offset)
print(f"Result memory: {result.nbytes / 1024**2:.2f} MB")
# Result memory: 7.63 MB

These functions are foundational for scientific computing and machine learning applications. Understanding their numerical properties and performance characteristics enables building robust, efficient systems that handle edge cases gracefully while maintaining computational speed.