Python `for` loop doesn't update `numpy` array values

I'm trying to make a simple numerical gradient function and part of it is a for loop updating parameter values that would later be evaluated. The code is as follows:

import numpy as np


def target_gradient(theta):
    e = 10

    for i in range(theta.shape[0]):
        theta_upper = theta
        theta_lower = theta
        theta_upper[i] = theta[i] + e
        theta_lower[i] = theta[i] - e
        print(f"theta_upper {theta_upper}")
        print(f"theta_lower {theta_lower}")


    return theta_upper, theta_lower

u, l = target_gradient(np.array([1, 1, 1, 1, 1]))

However, instead of the anticipated output, I get [1 1 1 1 1] for both arrays. Print statements are there for monitoring and they show that throughout the loop the arrays didn't change (i.e. were [1 1 1 1 1]).e=10 is so that the effect is more pronounced. I also tried the enumerate() approach, but get the same result.

The full gradient funtion would look something like this

def target_gradient(theta, x, y):
    e = 0.01
    gradient = np.zeros(theta.shape[0])

    for i in range(theta.shape[0]):
        theta_upper = theta
        theta_lower = theta
        theta_upper[i] = theta[i] + e
        theta_lower[i] = theta[i] - e

        gradient[i] = (
            foo(theta=theta_upper, x=x, y=y) - foo(theta=theta_lower, x=x, y=y)
        ) / (2 * e)

    return gradient

Therefore, I am intentionally declaring theta_upper = theta inside the loop because I want to calculate the gradient for which I need partial (numerical) derivatives.

The best approach depends on what foo is:

If foo can take vector arguments and return vector values, e.g.

def foo(theta, x, y):
    return x * y * np.sin(theta)

Then you can simply do:

def target_gradient(theta, x, y, e=0.01):
    foo_upper = foo(theta + e, x, y) # Add e to the entire theta vector, and call foo
    foo_lower = foo(theta - e, x, y) # Subtract e from the entire theta vector, and call foo
    return (foo_upper - foo_lower) / (2 * e)

Based on your code, where you pass a vector theta_upper to foo, I suspect this is the case.

If foo can't take vector arguments and return vector values, e.g.

def foo(theta, x, y):
    return x * y * math.sin(theta)

then you need to iterate over theta, and call foo for each value.

def target_gradient(theta, x, y, e=0.01):
    gradient = np.zeros(theta.shape[0])

    for i in range(theta.shape[0]):
        foo_upper = foo(theta[i] + e, x[i], y[i]) # Take a single value of theta, and add e
        foo_lower = foo(theta[i] - e, x[i], y[i]) # Take a single value of theta, and subtract e
        gradient[i] = (foo_upper - foo_lower) / (2 * e)

    return gradient

The reason why theta_upper and theta_lower are not changing inside the loop is because you are creating copies of theta and assigning them to theta_upper and theta_lower. Therefore, when you modify theta_upper[i] or theta_lower[i], you are not modifying the original theta array.

To fix this, you can use the copy() method to create a copy of theta that you can modify inside the loop, like this:

def target_gradient(theta):
    e = 10

    for i in range(theta.shape[0]):
        theta_upper = theta.copy()
        theta_lower = theta.copy()
        theta_upper[i] = theta[i] + e
        theta_lower[i] = theta[i] - e
        print(f"theta_upper {theta_upper}")
        print(f"theta_lower {theta_lower}")

    return theta_upper, theta_lower