Paper · 2021-06-18 · cs.LG
Anomaly Detection in Dynamic Graphs via Transformer
TADDY scores each edge of a dynamic graph for anomaly with one transformer. It samples the top-k diffusion neighbours of a target edge from the last tau snapshots, encodes each node by rank, distance and time lag, and trains on random negative edges. Author-reported: highest AUC in all 18 settings on six datasets.
Anomaly detectionGraph transformerDynamic graph embeddingPositional encodinganomaly-detectiondynamic-graphsgraph-learningtransformer
AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Some graphs change over time: messages, ratings or links keep appearing between the same kinds of nodes. An anomaly here is a new link that looks unlikely given what came before, such as a fake purchase in a shopping network.
TADDY scores each new link by looking at a small neighbourhood around it, taken from the last few time slices of the graph. Every node in that neighbourhood is described by a few numbers: how strongly it is tied to the link, how far it sits from the two ends of the link, and how long ago the slice was. One transformer reads all these descriptions together, so structure and timing are handled in the same step rather than by two separate networks.
The model is trained only on links that really appeared. It learns to tell them apart from randomly made-up pairs of nodes, so no labelled anomalies are needed. The authors report that it beats the baselines on six datasets.
TL;DR
TADDY is an unsupervised, end-to-end transformer for flagging anomalous edges in a dynamic graph given as a stream of snapshots. Each target edge gets a fixed-size substructure of nodes from the last tau snapshots, chosen by graph diffusion, and each node gets a learned encoding of its diffusion rank, distance to the edge and time lag §4.1–§4.2. The authors report the highest AUC in all 18 dataset and anomaly-proportion settings, with an average gain of 4.49% over the best baseline tab. 3 §5.2. There is no official code (see Paper vs code).
Problem
Anomalous edges in an evolving graph, for example fake orders in an e-commerce user-item network, should be detected §1. The authors name two difficulties §1:
- No node attributes. Many dynamic graphs have no raw features, because the attributes are missing, private or changing, so the encoder must build node features from the structure and the timing §1 §4.2.
- Coupled space and time. Whether an edge is normal depends on structure (shared neighbours) and on earlier interactions at the same time. Methods that run separate spatial and temporal modules can miss information that crosses both §1 §2.
The setting is unsupervised: training data is assumed to contain only normal edges, and labels are used only at test time §3. Test anomalies are injected synthetically, as described under Hyperparameters §5.1.1.
Method
Citations use the source's section, equation, table and algorithm numbers as they appear in the LaTeX counters. The journal typesetting may print them in a different style. TADDY has four components: edge-based substructure sampling, spatial-temporal node encoding, a dynamic graph transformer, and a discriminative anomaly detector §4. Notation follows tab. 1.
- Sampling §4.1. Each edge at time t is a target edge with two target nodes. For each snapshot in the window of length tau ending at t, compute a graph diffusion matrix S eq. 1 eq. 2 eq. 3. Add the rows of the two target nodes to get a connectivity score for every node eq. 4. Take the top k nodes by score, excluding the target nodes, as contextual nodes. Each snapshot contributes k + 2 nodes, so the substructure has tau(k + 2) nodes §4.1. The paper uses PPR diffusion in its experiments §5.1.4.
- Node encoding §4.2. Each row of the substructure gets three learned linear maps of a scalar, each into d_enc dimensions. The diffusion term maps the node's rank in its diffusion values §4.2.1 eq. 5. The distance term maps the smaller of the node's distances to the two target nodes; target nodes have distance 0 §4.2.2 eq. 6. The temporal term maps the time gap |t − i| between the target time t and the node's snapshot i §4.2.3 eq. 7. The three are summed, not concatenated §4.2.4 eq. 8. The authors use learned linear maps in place of the sinusoidal encodings of the original Transformer, because they judge learned maps more flexible for timestamps and positions §4.2. The encoding matrix X has shape tau(k + 2) × d_enc eq. 9.
- Transformer §4.3.1. The input is X. Each layer computes queries, keys and values as linear projections of its input eq. 11, then applies scaled dot-product attention with scale 1/sqrt(d_emb) eq. 10. The paper uses L layers and sets d = d_emb = d_enc §4.3.1 §5.1.4.
- Pooling §4.3.2. The edge embedding is the mean of the final node embeddings over all tau(k + 2) rows eq. 12.
- Scoring §4.4. The anomaly score is a sigmoid of a linear layer on the edge embedding eq. 13.
- Training §4.4 alg. 1. For each timestamp, sample pseudo-anomalous pairs, one per real edge, and reject any pair that is an edge in any training timestamp §4.4. Score every real and pseudo edge with steps 1 to 5. Apply binary cross-entropy with pseudo labels 0 for real edges and 1 for negatives §4.4 eq. 14, then take one gradient step per timestamp alg. 1. At test time, only steps 1 to 5 run §4.4.
Complexity: diffusion costs O(T n̄²) per the paper, and the whole method O(τ k m I + T n̄²) for I training iterations and m edges §4.5.
# Substructure of one target edge [§4.1] [eq. 1]-[eq. 4]
def sample_substructure(window, v1, v2, k):
# One block per snapshot in the window [§4.1]
rows = []
for snapshot in window:
# Diffusion matrix of this snapshot [§4.1] [eq. 2] [eq. 3]
diffusion = compute_diffusion(snapshot) # (n, n)
# Connectivity of the target edge: sum of its two node rows [eq. 4]
edge_scores = diffusion[v1] + diffusion[v2]
# Top-k nodes by score, target nodes excluded [§4.1]
contextual = top_k(edge_scores, k, exclude=[v1, v2])
# Target nodes plus contextual nodes for this snapshot [§4.1]
rows.append([v1, v2] + contextual)
return rows # tau blocks of k + 2 nodes# Node encoding, one row per sampled node [§4.2] [eq. 5]-[eq. 9]
def encode_substructure(rank, distance, lag):
# rank, distance, lag: one scalar per row (N,)
# Linear map of the diffusion rank [§4.2.1] [eq. 5]
x_diff = linear_diff(rank) # (N, d_enc)
# Linear map of the distance to the nearer target node [§4.2.2] [eq. 6]
x_dist = linear_dist(distance) # (N, d_enc)
# Linear map of the time gap |t - i| [§4.2.3] [eq. 7]
x_temp = linear_temp(lag) # (N, d_enc)
# Fuse by summation, not concatenation [§4.2.4] [eq. 8]
# Stacked over the N = tau(k + 2) rows [eq. 9]
return x_diff + x_dist + x_temp # (N, d_enc)# Dynamic graph transformer, then mean pooling [§4.3] [eq. 10]-[eq. 12]
def edge_embedding(X, num_layers, d_emb):
# Input is the encoding matrix of the target edge [§4.3.1] [eq. 9]
H = X # (N, d_emb), with d_emb = d_enc
for layer in range(num_layers):
# Queries, keys and values as projections of the layer input [eq. 11]
Q = H @ W_Q[layer] # (N, d_emb)
K = H @ W_K[layer] # (N, d_emb)
V = H @ W_V[layer] # (N, d_emb)
# Scaled dot-product attention over all N nodes [eq. 10]
scores = Q @ K.T / sqrt(d_emb) # (N, N)
H = softmax(scores, axis=1) @ V # (N, d_emb)
# Mean over all node embeddings gives the edge embedding [§4.3.2] [eq. 12]
return mean(H, axis=0) # (d_emb,)# Training with negative sampling [alg. 1] [§4.4] [eq. 13] [eq. 14]
def train(snapshots, epochs, tau, k, T):
# Random init of encoding maps, transformer and scorer [alg. 1]
params = init_parameters()
for epoch in range(epochs):
# Each timestamp from tau to T gives one gradient step [alg. 1]
for t in range(tau, T + 1):
# Pseudo-anomalous pairs, one per real edge [§4.4]
negatives = sample_negatives(snapshots, t)
# Window of tau snapshots ending at t [§4.1]
window = snapshots[t - tau + 1 : t + 1]
scores = []
labels = []
for edge, label in real_edges(snapshots, t, negatives):
# Features of the target edge [§4.1] [§4.2]
rank, distance, lag = build_features(window, edge, k)
# Encode, run the transformer, pool [§4.2] [§4.3]
X = encode_substructure(rank, distance, lag)
z = edge_embedding(X, num_layers=2, d_emb=32)
# Sigmoid score of the edge [eq. 13]
scores.append(anomaly_score(z, params))
# Pseudo label: 0 for real edges, 1 for negatives [§4.4]
labels.append(label)
# Binary cross-entropy over the timestamp [eq. 14]
loss = bce_loss(scores, labels)
# One update of all parameters [alg. 1]
params = update(params, gradient(loss))
return paramsKey equations, reproduced from the source. Equation numbers are those of the compiled paper.
\mathbf{S}=\sum_{k=0}^{\infty} \theta_{k} \mathbf{T}^{k} eq. 1
\mathbf{S}^{\mathrm{PPR}}=\alpha\left(\mathbf{I}_{n}-(1-\alpha) \mathbf{D}^{-1 / 2} \mathbf{A} \mathbf{D}^{-1 / 2}\right)^{-1} eq. 2
\mathbf{S}^{\text{heat}}=\exp \left(\beta \mathbf{A} \mathbf{D}^{-1}- \beta \right) eq. 3
\mathbf{s}_{e_{\rm tgt}}= \mathbf{s}_{v_1} + \mathbf{s}_{v_2} eq. 4
\mathbf{x}_{\rm diff}(v_j^i)= \mathrm{linear}\big(\mathrm{rank}(\mathbf{s}^i_{e_{\rm tgt}}[\mathrm{idx}(v_j^i)])\big) \in \mathbb{R}^{d_{enc}} eq. 5
\mathbf{x}_{\rm dist}(v_j^i)= \mathrm{linear}\big(\min(\mathrm{dist}(v_j^i,v_1^i),\mathrm{dist}(v_j^i,v_2^i))\big) \in \mathbb{R}^{d_{enc}} eq. 6
\mathbf{x}_{\rm temp}(v_j^i)= \mathrm{linear}(\lVert t-i \rVert) \in \mathbb{R}^{d_{enc}} eq. 7
\mathbf{x}(v_j^i)= \mathbf{x}_{\rm diff}(v_j^i) + \mathbf{x}_{\rm dist}(v_j^i) + \mathbf{x}_{\rm temp}(v_j^i) \in \mathbb{R}^{d_{enc}} eq. 8
\mathbf{X}(e^t_{\rm tgt}) = \bigoplus_{v_j^i \in \mathcal{S}(e_{\rm tgt}^t)} [\mathbf{x}(v_j^i)]^\mathsf{T} \in \mathbb{R}^{(\tau (k + 2)) \times d_{enc}} eq. 9
\mathbf{H}^{(l)} = \mathrm{softmax}\!\left(\frac{\mathbf{Q}^{(l)} \mathbf{K}^{(l)\top}}{\sqrt{d_{emb}}}\right) \mathbf{V}^{(l)} eq. 10
\mathbf{Q}^{(l)} =\mathbf{H}^{(l-1)} \mathbf{W}_{Q}^{(l)}, \quad \mathbf{K}^{(l)} =\mathbf{H}^{(l-1)} \mathbf{W}_{K}^{(l)}, \quad \mathbf{V}^{(l)} =\mathbf{H}^{(l-1)} \mathbf{W}_{V}^{(l)} eq. 11
\mathbf{z}(e_{\rm tgt}^t) = \mathrm{pooling}(\mathbf{Z}) = \sum_{k=1}^{n_s} \frac{(\mathbf{Z})_{k}}{n_s} eq. 12
f(e) = \mathrm{Sigmoid}\big(\mathbf{z}(e) \mathbf{w}_S + b_S\big) eq. 13
\mathcal{L} = -\sum_{i=1}^{m^t} \log \big( 1 - f(e_{\mathrm{pos},i})\big) + \log \big(f(e_{\mathrm{neg},i})\big) eq. 14
Eq. 14 is typeset ambiguously; see Pitfalls.
Hyperparameters
Values are as the paper states them. Where it does not, the cell says "not stated".
| Name | Value | Where | Notes |
|---|---|---|---|
| contextual nodes k | 5 | §5.1.4 fig. 3 | k is fixed at 5 for the trade-off between accuracy and speed §5.3.1 |
| time window tau | selected per dataset from {1, 2, 3, 4} | §5.1.4 §5.3.1 fig. 3 | the chosen value per dataset is not stated in the text; fig. 3 covers three datasets only |
| diffusion | PPR | §5.1.4 eq. 2 | teleport probability alpha: not stated; heat kernel not used |
| encoding dimension d_enc | 32 | §5.1.4 | equal to d_emb |
| attention layers L | 2 | §5.1.4 §5.3.2 fig. 4 | |
| attention heads | 2 | §5.1.4 | how heads are combined and the per-head width: not stated; eq. 10 is written for one head |
| optimizer | Adam | §5.1.4 | |
| learning rate | 0.001 | §5.1.4 | schedule, weight decay, batch size: not stated |
| epochs | 100 for UCI Messages, Bitcoin-Alpha, Bitcoin-OTC; 200 for Digg, Email-DNC, AS-Topology | §5.1.4 | |
| snapshot size | 1,000 (UCI Messages, Bitcoin-OTC); 2,000 (Email-DNC, Bitcoin-Alpha); 6,000 (Digg, AS-Topology) | §5.1.4 | the unit (edges per snapshot, or time span) is not stated |
| train/test split | first 50% of timestamps for training, last 50% for test | §5.1.3 | |
| injected anomaly proportion p_A | 1%, 5%, 10% of each test snapshot's edge count | §5.1.1 §5.1.3 | pairs of disconnected nodes; training data is clean |
| negative sampling | as many pseudo edges as real edges per timestamp | §4.4 | the sampling distribution is not stated beyond "random" |
| tuning | 5-fold cross-validation "on a rolling basis" | §5.1.4 | fold construction and whether test data was used: not stated |
| loss | binary cross-entropy with pseudo labels | §4.4 eq. 14 | sum or mean over edges: not stated |
| seeds, repeats | not stated | results are single numbers, with no variance reported | |
| hardware, framework | PyTorch 1.7.1; 4 × Quadro RTX 6000 (24 GB), Xeon Silver 4214R, 64 GB RAM | §5.1.5 |
Results
Author-reported. Metric: ROC-AUC, averaged over all test timestamps, with anomalous edges as the positive class §5.1.3 §5.2. Baselines are three graph embedding methods (node2vec, DeepWalk, spectral clustering, scored with the K-means detector of NetWalk §5.1.2) and three deep dynamic-graph methods (NetWalk, AddGraph, StrGNN) §5.1.2.
Datasets tab. 2:
| Dataset | Nodes | Edges | Avg. degree |
|---|---|---|---|
| UCI Messages | 1,899 | 13,838 | 14.57 |
| Digg | 30,360 | 85,155 | 5.61 |
| Email-DNC | 1,866 | 39,264 | 42.08 |
| Bitcoin-Alpha | 3,777 | 24,173 | 12.80 |
| Bitcoin-OTC | 5,881 | 35,588 | 12.10 |
| AS-Topology | 34,761 | 171,420 | 9.86 |
AUC, UCI Messages, Digg and Email-DNC, at 1%, 5% and 10% injected anomalies tab. 3:
| Method | UCI 1% | UCI 5% | UCI 10% | Digg 1% | Digg 5% | Digg 10% | Email 1% | Email 5% | Email 10% |
|---|---|---|---|---|---|---|---|---|---|
| node2vec | 0.7371 | 0.7433 | 0.6960 | 0.7364 | 0.7081 | 0.6508 | 0.7391 | 0.7284 | 0.7103 |
| Spectral Clustering | 0.6324 | 0.6104 | 0.5794 | 0.5949 | 0.5823 | 0.5591 | 0.8096 | 0.7857 | 0.7759 |
| DeepWalk | 0.7514 | 0.7391 | 0.6979 | 0.7080 | 0.6881 | 0.6396 | 0.7481 | 0.7303 | 0.7197 |
| NetWalk | 0.7758 | 0.7647 | 0.7226 | 0.7563 | 0.7176 | 0.6837 | 0.8105 | 0.8371 | 0.8305 |
| AddGraph | 0.8083 | 0.8090 | 0.7688 | 0.8341 | 0.8470 | 0.8369 | 0.8393 | 0.8627 | 0.8773 |
| StrGNN | 0.8179 | 0.8252 | 0.7959 | 0.8162 | 0.8254 | 0.8272 | 0.8775 | 0.9103 | 0.9080 |
| TADDY | 0.8912 | 0.8398 | 0.8370 | 0.8617 | 0.8545 | 0.8440 | 0.9348 | 0.9257 | 0.9210 |
AUC, Bitcoin-Alpha, Bitcoin-OTC and AS-Topology, at 1%, 5% and 10% tab. 3:
| Method | Alpha 1% | Alpha 5% | Alpha 10% | OTC 1% | OTC 5% | OTC 10% | AS 1% | AS 5% | AS 10% |
|---|---|---|---|---|---|---|---|---|---|
| node2vec | 0.6910 | 0.6802 | 0.6785 | 0.6951 | 0.6883 | 0.6745 | 0.6821 | 0.6752 | 0.6668 |
| Spectral Clustering | 0.7401 | 0.7275 | 0.7167 | 0.7624 | 0.7376 | 0.7047 | 0.6685 | 0.6563 | 0.6498 |
| DeepWalk | 0.6985 | 0.6874 | 0.6793 | 0.7423 | 0.7356 | 0.7287 | 0.6844 | 0.6793 | 0.6682 |
| NetWalk | 0.8385 | 0.8357 | 0.8350 | 0.7785 | 0.7694 | 0.7534 | 0.8018 | 0.8066 | 0.8058 |
| AddGraph | 0.8665 | 0.8403 | 0.8498 | 0.8352 | 0.8455 | 0.8592 | 0.8080 | 0.8004 | 0.7926 |
| StrGNN | 0.8574 | 0.8667 | 0.8627 | 0.9012 | 0.8775 | 0.8836 | 0.8553 | 0.8352 | 0.8271 |
| TADDY | 0.9451 | 0.9341 | 0.9423 | 0.9455 | 0.9340 | 0.9425 | 0.8953 | 0.8952 | 0.8934 |
Headline numbers, as the authors state them §5.2:
- TADDY has the highest AUC in all 18 dataset and proportion cells tab. 3.
- Average AUC gain over the best baseline in each cell: 4.49%. By proportion: 5.35% at 1%, 3.69% at 5%, 4.43% at 10%. On the two Bitcoin datasets the gain is 6.42%, against 3.53% on the other datasets §5.2.
- Ablation at 10% injected anomalies tab. 4 §5.4:
| Variant | UCI Messages | Bitcoin-Alpha | Bitcoin-OTC |
|---|---|---|---|
| TADDY | 0.8370 | 0.9423 | 0.9262 |
| w/o diffusion encoding | 0.8304 | 0.9329 | 0.9153 |
| w/o distance encoding | 0.5362 | 0.5043 | 0.5187 |
| w/o temporal encoding | 0.8399 | 0.9326 | 0.9021 |
- Sensitivity §5.3: AUC rises with k up to about 5 and then levels off §5.3.1 fig. 3. The text says d = 8 is best for UCI Messages and that AUC is flat from d = 32 on the Bitcoin datasets §5.3.2 fig. 4. AUC rises smoothly from 20% to 60% training data §5.3.3 fig. 5.
Paper vs code
No official code.
Searched, in the order the skill sets:
- Paper and arXiv metadata: the LaTeX source has no code link; its only URLs
are dataset pages in footnotes §5.1.1. The arXiv metadata in
raw/arxiv/2106.09876.jsonhas no code field. - Project page: none linked.
- GitHub repository search for
TADDYand foranomaly dynamic graph transformer. No repository owned by an author or the authors' lab appeared. The only TADDY implementation (yuetan031/TADDY_pytorch, MIT) is a third-party PyTorch port, so it was not used. Nothing was cloned.
There is no code to compare against. The inconsistencies below are internal to the paper.
Pitfalls
- PPR definition conflicts with its closed form. The text defines PPR with T = A D⁻¹ §4.1. The closed form in eq. 2 uses D^(−1/2) A D^(−1/2), which is the symmetric normalisation. Both cannot hold. Without code, the choice is not resolved. Use the series in eq. 1 with the T the text defines, or the closed form, and say which.
- Diffusion cost is understated. eq. 2 needs an inverse of an n × n matrix per snapshot. The complexity section gives O(T ñ²) for diffusion §4.5, which does not include the inverse. The paper does not say how the inverse is computed, or how the cost fits the stated O(τ k m I) total. Budget for dense n × n work per snapshot.
- Eq. 14 has a sign and scope problem. As typeset, the summation sign covers only the first term, and the negative term is +log f(e_neg). That sign pushes negative scores toward 0, which is the opposite of the stated pseudo label 1 for negatives §4.4. The standard binary cross-entropy has −log f for negatives. The intended form is probably the standard one, with the sum applying to both terms. This is an inference from the text, not from code. Whether the loss is summed or averaged over edges is not stated, and that changes the effective learning rate of 0.001.
- Set union versus fixed row count. §4.1 defines the substructure as a union over snapshots. eq. 9 stacks τ(k + 2) rows, one per (node, snapshot) pair. A node that is sampled in two snapshots is one entry in a union but two rows in the stack. The text does not say which to implement. The fixed size of τ(k + 2) suggests keeping duplicates.
- Rank encoding domain. §4.2.1 ranks diffusion values "in a single-timestamp substructure node set", but does not say whether ranks are taken over the whole snapshot or only over sampled nodes. Ties, and how many nodes are available when a snapshot has fewer than k non-target nodes with positive score, are not stated.
- Distance encoding is undefined and the most important term. "Relative distance" in §4.2.2 is not defined. The text does not say whether it is a hop count, in which snapshot it is measured, or what value unreachable nodes get. Removing this term drops AUC to 0.50 to 0.54 on the three ablation datasets tab. 4, so this detail matters most.
- Transformer block is under-specified. eq. 10 and eq. 11 describe only attention. The text names no residual connection, layer normalisation, feed-forward sublayer, or dropout. Attention uses 2 heads §5.1.4, but the equation is for one head, and it is not stated how heads are combined or what the per-head width is. Linear maps in the encoding are described without mentioning biases.
- Negative sampling distribution. §4.4 says "randomly sample" node pairs and reject any pair that is an edge in any training timestamp. The distribution is not stated (uniform over pairs is implied), nor whether self-pairs are excluded, nor what happens on dense graphs where rejection rarely succeeds.
- Test anomalies match the training negatives. Test anomalies are random pairs of disconnected nodes §5.1.1, and training negatives are random non-edges §4.4. Both use random pairs, so the benchmark measures how well injected random pairs are ranked. The paper does not evaluate on real labelled anomalies.
- Tuning and split. Hyperparameters are "tuned by 5-fold cross-validation on a rolling basis" §5.1.4, but the folds, and whether the test half was used for choosing τ, epochs or d, are not stated. Results are single averages. No seeds, repeats or spreads are reported §5.2.
- Unknown τ per dataset. The text selects τ per dataset from 1 to 4 §5.1.4, and fig. 3 shows sensitivity for three datasets only. The chosen values for Digg, Email-DNC and AS-Topology are not given anywhere in the text.
- Snapshot size is undefined. §5.1.4 gives snapshot sizes of 1,000 to 6,000 but not the unit. If the size counts edges, it sets how many edges fall into each timestamp, and so the number of training steps. The text does not say.
- Inconsistent numbers across tables and text.
- The Bitcoin-OTC TADDY score at 10% is 0.9425 in tab. 3, but the full-model row of tab. 4 reads 0.9262. Either the ablation used a different run or one of the tables has a typo.
- The text gives UCI Messages' average degree as 14.47 §4.1, and tab. 2 gives 14.57.
- The text names d = 8 as best for UCI §5.3.2, but every dataset uses d = 32 in the headline numbers §5.1.4.
- Ablation exception. Without the temporal encoding, UCI Messages scores 0.8399 against 0.8370 for the full model tab. 4. The authors note this exception §5.4.
- "Large margin". The abstract says "by a large margin". The per-cell gaps vary: on UCI Messages at 5%, TADDY leads StrGNN by 0.0146 AUC tab. 3. The 4.49% average §5.2 is the number to quote.
- Figure 2 example is not the experimental setting. The framework figure uses k = τ = 3 as a running example fig. 2. Experiments use k = 5 and τ in 1 to 4 §5.1.4.
Lineage
- Builds on: the Transformer for its attention and positional encoding idea, which the paper modifies by using learned linear maps §2 §4.2. Graph diffusion for contextual sampling, using PPR and the heat kernel §4.1; the paper cites these works by name without links.
- Compared against: node2vec, DeepWalk and spectral clustering with NetWalk's K-means detector; NetWalk, AddGraph and StrGNN §5.1.2. Each is named in the paper only; no cards for them exist in this repository.
- Related sampling: the paper says edge-centred local substructures are motivated by prior work, citing StrGNN for local structure §4.1.
- Superseded by: not known from this wiki.
Source and license
Adapted from “Anomaly Detection in Dynamic Graphs via Transformer” by Yixin Liu, Shirui Pan, Yu Guang Wang, Fei Xiong, Liang Wang, Qingfeng Chen, Vincent CS Lee (arXiv:2106.09876), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.