File size: 12,942 Bytes
22e9602
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
import torch
from torch.nn import KLDivLoss

# Assume 'self' is an object that has attributes like 'patch_len_threshold', 
# 'kl_loss', and 'model' as described in the context of the functions.

def fouriour_based_adaptive_patching(self, true, pred):
    """
    Implements the Fourier-based Adaptive Patching (FAP) module described in Section 3.3 of the paper.

    This function adaptively segments the true and predicted time series into patches based on the
    dominant frequency of the ground truth series.

    Functionality and Paper Correspondence:
    - The function first calculates the Fast Fourier Transform (FFT) of the ground truth series (`true`) 
      using `torch.fft.rfft` to analyze its frequency components, which corresponds to the first part
      of Equation (2) in the paper.
    - It identifies the dominant frequency by finding the `argmax` of the frequency amplitudes. This
      directly implements `f = arg max(A)` from Equation (2).
    - The period is then calculated as `true.shape[1] // top_index`, which is the code's implementation
      of `p = ceil(T/f)` as described in Section 3.3. `true.shape[1]` is the total length `T`.
    - The final patch length (`patch_len`) is determined using `min(period // 2, self.patch_len_threshold)`.
      The `self.patch_len_threshold` corresponds to the hyperparameter `δ` in the paper.
    - The stride is set to half the patch length (`stride = patch_len // 2`), which matches the paper's
      description of `S = ceil(P/2)` in the last paragraph of Section 3.3.
    - Finally, it calls a helper function `self.create_patches` to segment both `true` and `pred` series
      into overlapping patches (`true_patch`, `pred_patch`).

    Discrepancy between Code and Paper:
    - Equation (3) in the paper defines the final patch length as `P = min(p, δ)`, where `p` is the
      dominant period. However, the code implements it as `patch_len = min(period // 2, ...)`.
      The division of the period by 2 is an implementation choice not explicitly mentioned in the
      paper's formula, likely to ensure patches capture finer-grained sub-patterns within a full period.
    """
    # Get patch length and stride
    # Corresponds to Equation (2): applying FFT to the ground truth to find the dominant frequency.
    true_fft = torch.fft.rfft(true, dim=1)
    frequency_list = torch.abs(true_fft).mean(0).mean(-1)
    # The first component (DC offset) is ignored to focus on periodic patterns.
    frequency_list[:1] = 0.0
    top_index = torch.argmax(frequency_list)
    # Calculate the period corresponding to the dominant frequency.
    # This implements p = T / f from Section 3.3.
    period = (true.shape[1] // top_index)
    
    # Determine the final patch length, corresponding to Equation (3).
    # Note the discrepancy: the code uses 'period // 2' instead of just 'period'.
    patch_len = min(period // 2, self.patch_len_threshold)
    # The stride is set to half the patch length, as described in Section 3.3.
    stride = patch_len // 2
    
    # Patching
    # This helper function (not shown) segments the series into patches Y_p and Y_hat_p.
    true_patch = self.create_patches(true, patch_len, stride=stride)
    pred_patch = self.create_patches(pred, patch_len, stride=stride)

    return true_patch, pred_patch

def patch_wise_structural_loss(self, true_patch, pred_patch):
    """
    Calculates the three components of the Patch-wise Structural (PS) loss as described in Section 3.4.

    This function computes the correlation, variance, and mean losses between the ground truth and
    predicted patches.

    Functionality and Paper Correspondence:
    - Correlation Loss (`linear_corr_loss`): This part of the code implements Equation (4). It calculates
      the Pearson Correlation Coefficient (PCC) for each pair of patches and computes the loss as
      `(1 - PCC)`. The mean, standard deviation, and covariance are calculated as intermediate steps.
    - Variance Loss (`var_loss`): This implements the variance loss described by Equation (6). It uses
      the Kullback-Leibler (KL) divergence between the softmax distributions of the true and predicted
      patches (`KL(softmax(Y_p) || softmax(Y_hat_p))`). The code uses `log_softmax` for the predicted
      patch for numerical stability and compatibility with PyTorch's `KLDivLoss`.
    - Mean Loss (`mean_loss`): This implements Equation (7), which is the Mean Absolute Error (MAE)
      between the mean values of the true and predicted patches.

    Implementation Details not in Paper:
    - A small epsilon (`1e-5`) is added to the denominator during the correlation calculation to prevent
      division by zero, which is a standard practice for numerical stability.
    """
    
    # Calculate mean of each patch for both true and predicted series.
    true_patch_mean = torch.mean(true_patch, dim=-1, keepdim=True)
    pred_patch_mean = torch.mean(pred_patch, dim=-1, keepdim=True)
    
    # Calculate variance and standard deviation for each patch.
    true_patch_var = torch.var(true_patch, dim=-1, keepdim=True, unbiased=False)
    pred_patch_var = torch.var(pred_patch, dim=-1, keepdim=True, unbiased=False)
    true_patch_std = torch.sqrt(true_patch_var)
    pred_patch_std = torch.sqrt(pred_patch_var)
    
    # Calculate Covariance between true and predicted patches.
    true_pred_patch_cov = torch.mean((true_patch - true_patch_mean) * (pred_patch - pred_patch_mean), dim=-1, keepdim=True)
    
    # 1. Calculate correlation loss (L_Corr) based on Equation (4).
    # The formula for the Pearson Correlation Coefficient (PCC) is implemented here.
    patch_linear_corr = (true_pred_patch_cov + 1e-5) / (true_patch_std * pred_patch_std + 1e-5)
    linear_corr_loss = (1.0 - patch_linear_corr).mean()

    # 2. Calculate variance loss (L_Var) based on Equation (6).
    # This is KL(softmax(true) || softmax(pred)).
    # Using log_softmax for the prediction is a standard, numerically stable way to compute KL divergence.
    true_patch_softmax = torch.softmax(true_patch, dim=-1)
    pred_patch_softmax = torch.log_softmax(pred_patch, dim=-1)
    var_loss = self.kl_loss(pred_patch_softmax, true_patch_softmax).sum(dim=-1).mean()
    
    # 3. Calculate mean loss (L_Mean) based on Equation (7).
    # This is the Mean Absolute Error (MAE) between patch means.
    mean_loss = torch.abs(true_patch_mean - pred_patch_mean).mean()
    
    return linear_corr_loss, var_loss, mean_loss

def ps_loss(self, true, pred):
    """
    Orchestrates the calculation of the final PS loss by combining its three main components.

    Functionality and Paper Correspondence:
    - This function follows the overall structure shown in Figure 2 of the paper.
    - It first calls `fouriour_based_adaptive_patching` to segment the series (Step 1 in Figure 2).
    - It then calls `patch_wise_structural_loss` to compute the individual loss components (Step 2).
    - It uses `gradient_based_dynamic_weighting` to calculate the adaptive weights `alpha`, `beta`,
      and `gamma` (Step 3).
    - Finally, it computes the total `ps_loss` as the weighted sum of the three components, which
      corresponds to Equation (8): L_PS = α*L_Corr + β*L_Var + γ*L_Mean.
    """

    # Step 1: Fourier-based Adaptive Patching.
    true_patch, pred_patch = self.fouriour_based_adaptive_patching(true, pred)
    
    # Step 2: Calculate the three individual patch-wise structural loss components.
    corr_loss, var_loss, mean_loss = self.patch_wise_structural_loss(true_patch, pred_patch)
    
    # Step 3: Calculate adaptive weights for each loss component.
    alpha, beta, gamma = self.gradient_based_dynamic_weighting(true, pred, corr_loss, var_loss, mean_loss)

    # Final PS loss calculation, corresponding to Equation (8).
    ps_loss = alpha * corr_loss + beta * var_loss + gamma * mean_loss
    
    return ps_loss

def gradient_based_dynamic_weighting(self, true, pred, corr_loss, var_loss, mean_loss):
    """
    Implements the Gradient-based Dynamic Weighting (GDW) strategy from Section 3.5.

    This function dynamically balances the three loss components by adjusting their weights based on
    their gradient magnitudes and the similarity between the true and predicted series.

    Functionality and Paper Correspondence:
    - Scaling Factors (`linear_sim`, `var_sim`): The code first calculates two similarity metrics
      that correspond to the scaling factors `c` and `v` from Equation (12). These are used to
      adjust the weight of the mean loss. `linear_sim` represents correlation similarity and `var_sim`
      represents variance similarity.
    - Gradient Calculation: It computes the gradient of each loss component with respect to the
      parameters of a specific model layer (`self.model.Linear_Trend`). This corresponds to the
      gradient calculation `∇_W L` in Equation (9).
    - Weight Calculation (`alpha`, `beta`, `gamma`): The weights are calculated based on the L2-norm
      of the gradients, which aligns with the methodology described in Section 3.5 and the formula
      logic in Equation (11). Each weight is the ratio of the average gradient norm to the individual
      component's gradient norm.
    - Gamma Adjustment: The weight `gamma` (for the mean loss) is further scaled by the product of the
      `linear_sim` and `var_sim` scores. This implements the paper's strategy to increase the
      mean loss's influence as the model's predictions improve in terms of correlation and variance.

    Implementation Details not in Paper:
    - The gradients are calculated with respect to `self.model.Linear_Trend.parameters()`. The paper
      generally refers to "the model's output layer parameters (W)". This specific layer name
      implies that the code is tailored for a DLinear-style model backbone, which contains a
      `Linear_Trend` component. This is a specific implementation choice not generalized in the paper.
    - The use of `.detach()` is crucial for preventing the weight calculations from being part of the
      computation graph for the final loss, ensuring that the weights act as static multipliers
      in the current training step.
    
    Discrepancy between Code and Paper:
    - Equation (12) defines `c = (1 + σ_YY_hat) / (2 * σ_Y * σ_Y_hat)`. The code implements the
      `linear_sim` factor as `(1.0 + linear_corr) * 0.5`. Assuming `linear_corr` is the PCC (`ρ`),
      this matches the formula if `ρ = σ_YY_hat / (σ_Y * σ_Y_hat)`. This is a plausible implementation.
    """
    
    # Permute dimensions to calculate statistics over the time dimension for the whole series.
    true = true.permute(0, 2, 1)
    pred = pred.permute(0, 2, 1)
    
    # Calculate similarity metrics 'c' and 'v' from Equation (12) for the entire series.
    # These will be used to scale the gamma weight.
    true_mean = torch.mean(true, dim=-1, keepdim=True)
    pred_mean = torch.mean(pred, dim=-1, keepdim=True)
    true_var = torch.var(true, dim=-1, keepdim=True, unbiased=False)
    pred_var = torch.var(pred, dim=-1, keepdim=True, unbiased=False)
    true_std = torch.sqrt(true_var)
    pred_std = torch.sqrt(pred_var)
    true_pred_cov = torch.mean((true - true_mean) * (pred - pred_mean), dim=-1, keepdim=True)
    
    # linear_sim corresponds to the 'c' factor in Equation (12).
    linear_sim = (true_pred_cov + 1e-5) / (true_std * pred_std + 1e-5)
    linear_sim = (1.0 + linear_sim) * 0.5 # Normalize to [0, 1]
    
    # var_sim corresponds to the 'v' factor in Equation (12).
    var_sim = (2*true_std*pred_std + 1e-5) / (true_var + pred_var + 1e-5)

    # Gradient-based dynamic weighting, corresponds to Equations (9), (10), and (11).
    # The paper mentions using the "output layer parameters", this implementation specifically uses
    # parameters from 'Linear_Trend', suggesting it's designed for a DLinear-like backbone.
    corr_gradient = torch.autograd.grad(corr_loss, self.model.Linear_Trend.parameters(), create_graph=True)[0]
    var_gradient = torch.autograd.grad(var_loss, self.model.Linear_Trend.parameters(), create_graph=True)[0]
    mean_gradient = torch.autograd.grad(mean_loss, self.model.Linear_Trend.parameters(), create_graph=True)[0]
    
    # Calculate the average gradient magnitude as per Equation (10).
    gradiant_avg = (corr_gradient + var_gradient + mean_gradient) / 3.0

    # Calculate weights alpha, beta, and gamma as per Equation (11).
    # .detach() is used to treat the calculated weights as constants for the current optimization step.
    aplha = gradiant_avg.norm().detach() / corr_gradient.norm().detach()
    beta =  gradiant_avg.norm().detach() /  var_gradient.norm().detach()
    gamma = gradiant_avg.norm().detach() / mean_gradient.norm().detach()
    
    # Scale gamma using the similarity scores, as described in Section 3.5.
    gamma = gamma * torch.mean(linear_sim*var_sim).detach()
    
    return aplha, beta, gamma