( self, n_steps: int, n_features: int, n_layers: int, d_model: int,

( self, data: Union[dict, str], return_X_ori: bool, return_y: bool, fi

( self, n_steps: int, n_features: int, n_layers: int, d_model: int,

(self, n_steps, n_features, rnn_hidden_size)

( self, data: Union[dict, str], return_X_ori: bool, return_y: bool, fi

( self, n_steps: int, n_features: int, rnn_hidden_size: int, batch_siz

( self, n_layers: int, n_steps: int, n_features: int, d_model: int,

( self, data: Union[dict, str], return_X_ori: bool, return_y: bool, fi

( self, n_steps: int, n_features: int, n_layers: int, d_model: int,

( self, input_dim, time_length, latent_dim, encoder_sizes=(64, 64),

( self, data: Union[dict, str], return_X_ori: bool, return_y: bool, fi

( self, n_steps: int, n_features: int, latent_size: int, encoder_sizes

( self, n_steps: int, n_features: int, n_layers: int, d_model: int,

( self, data: Union[dict, str], return_X_ori: bool, return_y: bool, fi

( self, n_steps: int, n_features: int, n_layers: int, d_model: int,

( self, lr: float = 0.01, rho: float = 0.9, eps: float = 1e-08, weight

( self, lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: flo

(self, lr, lr_scheduler: Optional[LRScheduler] = None)

( self, lr: float = 0.001, momentum: float = 0, weight_decay: float = 0,

( self, lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: flo

( self, lr: float = 0.01, lr_decay: float = 0, weight_decay: float = 0.01,

( self, lr: float = 0.001, momentum: float = 0, alpha: float = 0.99, e

( self, lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: flo

(self, factor=1.0 / 3, total_iters=5, last_epoch=-1, verbose=False)

( self, lr_lambda: Union[Callable, list], last_epoch: int = -1, verbose: bool

(self, last_epoch=-1, verbose=False)

(self, o)

(self, lr_lambda, last_epoch=-1, verbose=False)

( self, start_factor=1.0 / 3, end_factor=1.0, total_iters=5, last_epoc

(self, gamma, last_epoch=-1, verbose=False)

(self, step_size, gamma=0.1, last_epoch=-1, verbose=False)

(self, milestones, gamma=0.1, last_epoch=-1, verbose=False)

( self, data: Union[dict, str], return_X_ori: bool, return_X_pred: bool,

(self, c_in)

( self, mask_flag=True, factor=5, attention_dropout=0.1, scale=None,

(self, attention, d_model, d_ff=None, dropout=0.1, activation="relu")

( self, self_attention, cross_attention, d_model, d_ff=None, d

(self, layers, norm_layer=None, projection=None)

(self, k, alpha, c=1, nl=1, initializer=None, **kwargs)

( self, ich=1, k=8, alpha=16, c=128, nCZ=1, L=0,

( self, in_channels, out_channels, seq_len_q, seq_len_kv, mode

( self, in_channels, out_channels, seq_len_q, seq_len_kv, mode

( self, in_channels, out_channels, seq_len, modes=0, mode_select_method="random" )

( self, in_channels, out_channels, seq_len_q, seq_len_kv, mode

( self, n_steps, n_pred_steps, n_layers, n_heads, d_model,

(self, input_size: int)

( self, n_steps: int, n_features: int, rnn_hidden_size: int, loss_calc

(self, d_input: int)

(self, input_size: int, hidden_size: int, bias: bool = True)

( self, n_steps: int, d_input: int, n_clusters: int, d_rnn_hidden: int

(self, input_size: int, output_size: int, diag: bool = False)

( self, n_steps: int, n_features: int, rnn_hidden_size: int, )

(self, dim, nhead, dropout=0.1, aux=False)

(self, d_model, dim_feedforward, dropout=0.1, activation="sigmoid")

(self, d_model, nhead, d_head=None, dropout=0.1)

(self, d_model, pred_len, k=None, low_freq=1)

(self, d_model, c_out, dropout=0.1)

( self, d_model, n_heads, c_out, seq_len, pred_len, k,

(self, pred_len, nhead, dropout=0.1)

(self, d_model, nhead, c_out, pred_len, dropout=0.1)

(self, layers)

( self, cell_type: str, n_layer: int, d_input: int, d_hidden: int,

( self, n_layers: int, n_features: int, d_hidden: int, cell_type: str,

( self, cell_type: str, d_input: int, )

( self, n_steps: int, n_features: int, n_generator_layers: int, rnn_hi

(self, n_diffusion_steps, d_embedding=128, d_projection=None)

( self, n_diffusion_steps, d_diffusion_embedding, d_input, d_side,

( self, n_layers, n_heads, n_channels, d_target, d_time_embedd

( self, in_channels: Union[int, Tuple[int, int]], out_channels: int, n_nodes:

( self, n_features, n_layers, d_model, d_ffn, n_heads,

( self, seq_len, dim_proj, d_model, n_heads, d_ff=None,

(self, model_dim, node_embedding_dim)

( self, model_dim, node_embedding_dim, feed_forward_dim=2048, dropout=

(self, input_size, output_size, dropout=0.0, bias=True)

( self, factor=1, attention_dropout=0.1, )

(self, correlation, d_model, n_heads, d_keys=None, d_values=None)

(self, n_channels)

(self, kernel_size)

( self, attention, d_model, d_ff=None, moving_avg=25, dropout=

( self, self_attention, cross_attention, d_model, c_out, d_ff=

( self, n_layers, n_heads, d_model, d_ffn, factor, mov

( self, seg_num, factor, d_model, n_heads, d_k, d_v,

( self, win_size, d_model, n_heads, d_ff, depth, dropo

( self, self_attention, cross_attention, seg_len, d_model, d_ff=None, dropout=0.1 )

(self, layers)

( self, n_steps: int, n_features: int, individual: bool = False, d_mod

(self, d_model, patch_len, stride, padding, dropout)

(self, n_features, d_model, d_output, head_dropout, y_range=None)

(self, n_features, d_model, n_classes, head_dropout)

( self, d_model, n_patches, n_steps_forecast, head_dropout=0,

( self, n_layers: int, n_heads: int, d_model: int, d_ffn: int,

( self, n_features: int, rnn_hidden_size: int, hint_rate: float = 0.7,

( self, n_steps: int, n_features: int, rnn_hidden_size: int, lambda_ms

(self, in_channels, out_channels, num_kernels=6, init_weight=True)

( self, n_layers, n_steps, n_pred_steps, top_k, d_model,

( self, d_model: int, d_ffn: int, n_heads: int, d_k: int, d_v:

( self, d_model: int, d_ffn: int, n_heads: int, d_k: int, d_v:

( self, n_layers: int, n_steps: int, n_features: int, d_model: int,

(self, temperature: float, attn_dropout: float = 0.1)

( self, n_heads: int, d_model: int, d_k: int, d_v: int, attent