Questions About Tutorial 5

[xiapxiaoyu1981]

Hello everyone, I am learning the CoDiPack software following the tutorial. While studying Tutorial 5, I encountered some confusion.

After executing runcodi::RealReverse();, in Step 1, the output is:

Update global:
f(4.0) = 1280
df/dx(4.0) = 1536

I can understand this result because f(x) = x^3 (x + x^2)，so when x = 4.0, f(4.0) = 1280
Further, df/dx = 4x^3 + 5x^4 , df/dx(4.0) = 1536. These make sense to me.

However, in Step 2, something changes. First, for y = func(x, false, global), the input parameter false means that the global variable is not updated. Additionally, between Step 1 and Step 2, there is no code resetting the global variable. In this case, the output is:
No update global:
f(4.0) = 1280
df/dx(4.0) = 756

For f(4.0) = 1280, I understand this because the global variable is not reset, so the global value from Step 1 is reused, where global = t * x. Thus, it is natural that f(4.0) = 1280. However, I don't understand how df/dx(4.0) = 756 is derived. I read the explanation in the tutorial, which states:
“Step 2 still uses, but does not update, the global variable and it should be treated as a constant in the CoDiPack taping process. However, since the variable has not been reset, it still holds the old identifier, and the result is wrong(4^3(4+4^2)≠756)."

I cannot figure out how this value of 756 is obtained. Even if it is incorrect, what might the process be to arrive at this result?

In Step 3, there is a further change compared to Step 2. Before registering x, the command tape.deactivateValue(global); is executed. This command sets the identifier of the global variable to zero. The result is:

No update global with reset:
f(4.0) = 1280
df/dx(4.0) = 576

Similarly, I don't understand why df/dx (4.0)=576. How is this 576 derived?

[MaxSagebaum]

Hi, thanks for looking at CoDiPack.

I will focus on step 3 first:
As you already said, global is deactivated beforhand and not updated. Therefore, global is a constant with respect to the differentiation. The value of global is x * t = x*x*x = 64 with x=4. It got this value during step one.

f is now f = global * t2 = global * (x + t) = global * (x + x^2). Since global has the same value we get the same result.
df/dx is now different since we no longer see the dependency of global with respect to x.
df/dx = global + 2 * global * x. This with x=4 and global=64 we get 576.

Step2:
It is very tricky do properly answer step 2. The whole tutorial is about sensibilizing the user for exactly this kind of problem. CoDiPack uses ids to track the dependencies of variables. It does not know if this dependency was created during this run or a previous run. If it is from a previous run, then a random link in the dependency graph is created and everything can happen. We do not know, what will happen.

In this special case:
For Step 1:

• x has id 1
• t has id 2
• global has id 3
• t2 has id 4
• y has id 5 and after the registerOutput id 6

For step 2:

• x has id 1
• t has id 2
• t2 has id 3
• y has id 4 and after the register Output id 5
• global has also id 3. That is, for updating the adjoint it is equivalent to t2. Value wise it is treated as having the value 64

So the return statement looks for CoDiPack for the reverse run something like return t2 * t2. But value wise it looks like return 64 * 20. The CoDiPack tape used is a Jacobian tape, so the reverse update is t2_bar += 64 * y_bar and global_bar += 20 * y_bar. Since t2 and global have the same id, it is actually: t2_bar += 64 * y_bar and t2_bar += 20 * y_bar. This is where the error comes from. The second part should not be active at all and therefore this update should not be done.

I hope this helps in understanding the problem.

[xiapxiaoyu1981]

Hi MaxSagebaum,

I’m very glad to receive your reply, and it greatly facilitated my understanding of this issue. First of all, please forgive me for the delayed response (yesterday, I got caught up with some things). Based on my debugging work, I think I’ve figured out what Steps 1, 2, and 3 in Tutorial 5 are doing:

CoDiPack should be using an operator overloading strategy to compute derivatives, so naturally, I started by drawing the computational graph, as shown in Figure 1.

The forward process is quite simple, and can be solved sequentially from left to right. However, in order to achieve the backward solve, it is necessary to record certain information during the forward computation. (I’m not entirely sure how CoDiPack implements this, but it should be similar to my understanding.) The program likely saves something like this for each operator: Tape = [inputs = [self.name], outputs = [x.name], propagate = propagate], where self.name and x.name should correspond to the variable IDs in CoDiPack, and propagate records the overloaded method for the operator.

Now, let's take a look at what Step 1 is doing:

According to the chain rule:
df/dv5 = 1
df/dv4 = df/dv5 * dv5/dv4 = 1 * v3 = 64
df/dv3 = df/dv5 * dv5/dv3 = 1 * v4 = 20
df/dv2 = df/dv3 * dv3/dv2 + df/dv4 * dv4/dv2 = 204+641 = 144
df/dv1 = df/dv4dv4/dv1 + df/dv3dv3/dv1 + df/dv2dv2/dv1 = 64 * 1 + 20 * 16 + 144 * 8 = 1536
df/dx = df/dv1dv1/dx = 1536 * 1= 1536
At this point, we have obtained the derivative of f with respect to x, which matches the program's result.

Let's skip Step 2 for now and take a look at Step 3:

For Step 3, due to the statement tape.deactivateValue(global);, the variable Global's IDs are set to zero in CoDiPack. From your previous reply, I understand that if a variable's IDs are zero, it is treated as a constant in derivative calculations. I’m not entirely sure what this means in the computational graph, but I assume it looks like Figure 2.

Since the forward process is still 1280, the forward computation should be unaffected. However, in the backward propagation, since Global (represented as v3 in the figure) is no longer involved, we assume that all the dashed lines passing through v3 are cut off.

Let's proceed with the calculation using the chain rule:
df/dv5 = 1
df/dv4 = df/dv5 * dv5/dv4 = 1 * v3 = 64
df/dv2 = df/dv4 * dv4/dv2 = 641 = 64
df/dv1 = df/dv4dv4/dv1 + df/dv2dv2/dv1 = 64 * 1 + 64 * 8 = 576
df/dx = df/dv1dv1/dx = 576 * 1= 576
This is consistent with the program's result.

Now let's look at Step 2. Since the variable global (v3) and the variable t2 (v4) have the same identifier, during the backward propagation of v3 and v4, the overloaded operator could be either addition or multiplication. Let's assume that at this point, global no longer overloads the multiplication operator, but instead overloads the addition operator.

Let’s see what happens:
df/dv5 = 1
df/dv4 = df/dv5 * dv5/dv4 = 1 * v3 = 64
df/dv3 = df/dv5 * dv5/dv3 = 1 * v4 = 20
df/dv2 = df/dv3 * dv3/dv2 + df/dv4 * dv4/dv2 = 201+641 =84
df/dv1 = df/dv4dv4/dv1 + df/dv3dv3/dv1 + df/dv2*dv2/dv1 = 64 * 1 + 20 * 1 + 84 * 8 = 64 + 20 + 672 = 756
This is consistent with the program's result.

Since I’m not very familiar with CoDiPack, I can’t be sure my thoughts are entirely correct. I can only say that they happen to align with the inputs (by the way, I feel like I’m probably right ;) ).

[MaxSagebaum]

Yes, this is correct.

Tape = [inputs = [self.name], outputs = [x.name], propagate = propagate], where self.name and x.name should correspond to the variable IDs in CoDiPack, and propagate records the overloaded method for the operator.

The types codi::RealReverse and codi::RealReverseIndexare Jacobian tapes. They compute the Jaocbian of each operator and store these together with the indices. What you describe is a primal value taping approach. This is implemented incodi::RealReversePrimalandcodi::RealReversePrimalIndex`. The last two will probably provide a different result in step 2. ;)