20250722 meeting

1
2
3
4

train_ts_mean = np.mean(stacked_train, axis=1)  # (24, 5000)
train_ts_std = np.std(stacked_train, axis=1, ddof=0)  # (24, 5000)
for i in range(24):  # Time series standardization for each location
    stacked_train[i] = (stacked_train[i] - train_ts_mean[i]) / train_ts_std[i]

1
2
3

train_sp_mean = np.mean(stacked_train, axis=2)  # (24, 250)
for i in range(24):  # Centralization of each spatial point at time t
    stacked_train[i] = stacked_train[i] - np.mean(train_sp_mean[i][:, None])

1

   stacked_train[i] = stacked_train[i] - train_sp_mean[i][:, None]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

## mrts
mrts = MRTS(locs = torch.tensor(locations_choose), k = locations_choose.shape[0]).forward()
mrts = np.asarray(mrts)

## linear model
betas_all = []
residuals_all = []

X = mrts                     # shape: (5000, 5000)
X_pinv = np.linalg.pinv(X)   # shape: (5000, 5000)

for i in range(24):
    y = stacked_train[i].T   # shape: (5000, 250)
    beta = X_pinv @ y        # shape: (5000, 250)
    y_hat = X @ beta         # shape: (5000, 250)
    residuals = y - y_hat    # shape: (5000, 250)

    betas_all.append(beta.T)
    residuals_all.append(residuals.T)

## beta and residual
betas_all = np.stack(betas_all)         # (24, 250, 5000) 5000 is not location, it is beta
residuals_all = np.stack(residuals_all) # (24, 250, 5000)

 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

wavenet:
  # WaveNet model parameters
  input_channels: 24  # Number of input channels
  output_channels: 24  # Number of output channels
  residual_layers: 26  # Number of residual layers
  residual_channels: 64  # Number of channels in residual blocks
  skip_channels: 64  # Number of channels in skip connections

  # Diffusion step embedding dimensions
  diffusion_step_embed_dim_input: 128  # Input dimension
  diffusion_step_embed_dim_hidden: 512  # Middle dimension
  diffusion_step_embed_dim_output: 512  # Output dimension

  # Structured State Spaces sequence model (S4) configurations
  s4_max_sequence_length: 250  # Maximum sequence length
  s4_state_dim: 64  # State dimension
  s4_dropout: 0.0  # Dropout rate
  s4_bidirectional: true  # Whether to use bidirectional layers
  s4_use_layer_norm: true  # Whether to use layer normalization

diffusion:
  # Diffusion model parameters
  T: 200  # Number of diffusion steps
  beta_0: 0.0001  # Initial beta value
  beta_T: 0.02  # Final beta value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Training configuration
batch_size: 500  # Batch size
output_directory: "./results/surface air temperature/beta"  # Output directory for checkpoints and logs
ckpt_iter: "max"  # Checkpoint mode (max or min)
iters_per_ckpt: 100  # Checkpoint frequency (number of epochs)
iters_per_logging: 100  # Log frequency (number of iterations)
n_iters: 60000  # Maximum number of iterations
learning_rate: 0.0005  # Learning rate

# Additional training settings
only_generate_missing: true  # Generate missing values only
use_model: 2  # Model to use for training
masking: "forecast"  # Masking strategy for missing values
missing_k: 10  # Number of missing values

# Data paths
data:
  train_path: "./datasets/surface air temperature/beta/train_betas.npy"  # Path to training data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Inference configuration
batch_size: 500  # Batch size for inference
output_directory: "./results/surface air temperature/inference/beta"  # Output directory for inference results
ckpt_path: "./results/surface air temperature/beta"  # Path to checkpoint for inference
trials: 1 # Replications

# Additional training settings
only_generate_missing: true  # Generate missing values only
use_model: 2  # Model to use for training
masking: "forecast"  # Masking strategy for missing values
missing_k: 10  # Number of missing values

# Data paths
data:
  test_path: "./datasets/surface air temperature/beta/test_betas.npy"  # Path to test data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

## inference
beta_inference_data = inference_data_concatenate(beta_inference_path).transpose(1, 2, 0)  # (24, 260, 5000)
residual_inference_data = inference_data_concatenate(residual_inference_path).transpose(1, 2, 0)  # (24, 260, 5000)

X = mrts                                     # shape: (5000, 5000)
y_inference = []
for i in tqdm(range(24)):
    beta = beta_inference_data[i].T          # shape: (5000, 260)
    residual = residual_inference_data[i].T  # shape: (5000, 260)
    y_hat = X @ beta + residual              # shape: (5000, 260)

    y_inference.append(y_hat)                # (24, 5000, 260)

y_inference = np.array(y_inference)
y_inference = y_inference.transpose(0, 2, 1)  # (24, 260, 5000)

for i in range(24):
    y_inference[i] = y_inference[i] + np.mean(train_sp_mean[i][:, None])

for i in range(24):
    y_inference[i] = y_inference[i] * train_ts_std[i] + train_ts_mean[i]