Block chain account fine granularity detection method based on dynamic graph learning

Abstract

The invention relates to a block chain account fine granularity detection method based on dynamic graph learning, and belongs to the technical field of block chains. According to the method, a dynamic account association graph capable of accurately reflecting account states is constructed by analyzing a transaction mode of an account, a deep time evolution mode and neighborhood interaction characteristics between block chain accounts are captured from the angle of continuous time, a general encoder is pre-trained by using a graph neural network to convert account characteristics into high-dimensional embedding, and the block chain accounts are subjected to high-dimensional embedding. According to the method, an encoder capable of learning high-quality universal embedding is pre-trained, only a small number of marked samples are needed to perform fine adjustment on a model classifier, and fine-grained accurate detection of a block chain account and rapid updating of an increment category are realized.

Description

Technical Field

[0001] This invention relates to a fine-grained method for detecting blockchain accounts based on dynamic graph learning, belonging to the field of blockchain technology. Background Technology

[0002] Blockchain is a decentralized ledger technology with high security and immutability, which has garnered widespread attention and application in recent years. However, the decentralization and anonymity of blockchain have also led to a proliferation of malicious activities on blockchain platforms, seriously affecting the healthy development of the blockchain ecosystem.

[0003] Blockchain account detection technologies can be categorized into three types based on their technological approaches: heuristic decision-making methods, traditional machine learning methods, and graph learning methods. Heuristic decision-making methods typically focus on detecting specific types of malicious accounts, designing rule-based or heuristic algorithms for decision-making without relying on machine learning models or large datasets. Traditional machine learning methods refer to machine learning techniques that do not utilize graph structures, typically relying on predefined feature engineering and training specific models to detect malicious accounts. Graph learning methods usually convert transaction records into graph-structured data, using graph embedding or graph neural network techniques to extract graph features to detect malicious accounts.

[0004] The limitations of existing technologies in detecting blockchain accounts are mainly reflected in three aspects. First, heuristic decision-making and traditional machine learning methods mostly extract features from a relatively shallow perspective, and these features lack sufficient information to achieve high detection accuracy. Second, existing methods typically focus on binary classification of single-category malicious blockchain accounts, with specific feature extraction patterns and network structures, which prevents the models from achieving fine-grained detection of different malicious categories. Third, traditional machine learning and graph learning methods usually rely on large amounts of labeled data and lack the ability to quickly update incremental categories, thus failing to meet the growing demand for malicious blockchain account detection.

[0005] Therefore, there is a need to design a more efficient and more widely applicable blockchain account detection technology. Summary of the Invention

[0006] The purpose of this invention is to address the technical problems of existing blockchain account detection technologies, such as difficulty in distinguishing specific categories of malicious behavior and difficulty in quickly updating new categories to the model without affecting known categories. To effectively solve the problem of frequent malicious behavior in the blockchain ecosystem caused by malicious accounts, this invention creatively proposes a fine-grained blockchain account detection method based on dynamic graph learning. This method aims to capture the deep temporal evolution patterns and neighborhood interaction features between blockchain accounts from a continuous-time perspective by constructing a dynamic account association graph. Then, a general encoder pre-trained using a graph neural network is used to convert account features into high-dimensional embeddings, achieving fine-grained and accurate detection in small-sample scenarios and rapid updating of incremental categories.

[0007] The innovation of this invention lies in the following: by analyzing the transaction patterns of accounts, a dynamic account association graph that can accurately reflect the account status is constructed. This captures the deep temporal evolution patterns and neighborhood interaction features between blockchain accounts from a continuous time perspective. Then, the dynamic account association graph is mapped to the embedding space through a cascaded graph feature extractor and a graph-transformer. An encoder capable of learning high-quality general embeddings is pre-trained. Subsequently, only a small number of labeled samples are needed to fine-tune the model classifier, which can achieve fine-grained and accurate detection of blockchain accounts and rapid updating of incremental categories.

[0008] Beneficial effects

[0009] The method of the present invention has the following advantages compared with the prior art:

[0010] 1. This invention analyzes the transaction patterns of blockchain accounts and constructs a dynamic account association graph that can accurately reflect the account status, capturing the deep temporal evolution patterns and neighborhood interaction characteristics between blockchain accounts from a continuous time perspective.

[0011] 2. This invention uses a Graph-Transformer network to pre-train an encoder capable of learning high-quality general embeddings. During the fine-tuning stage, only a small number of labeled samples are needed to achieve accurate fine-grained detection and rapid transfer updates of incremental classes.

[0012] 3. Extensive experimental data demonstrates that the effectiveness of this invention surpasses existing methods in various fine-grained detection scenarios. Particularly in incremental scenarios with small sample sizes, this invention improves the F1 score by approximately 25% compared to existing methods. Attached Figure Description

[0013] Figure 1 This is a flowchart of the dynamic account association graph construction process of the method of the present invention.

[0014] Figure 2This is a flowchart of a fine-grained blockchain account detection process based on dynamic graph learning. Detailed Implementation

[0015] The present invention will now be described in further detail with reference to the accompanying drawings and embodiments.

[0016] A fine-grained blockchain account detection method based on dynamic graph learning includes the following steps:

[0017] Step 1: Construct a blockchain transaction dataset .

[0018] Specifically, obtain different types of blockchain accounts and their first- and second-order transactions (which can be obtained through the API of a blockchain website) to construct a blockchain transaction dataset. .

[0019] Among them, set Including Transaction records: Each transaction record consists of a six-tuple. composition, , The hash value representing the transaction. Indicates the sender's address of the transaction. Indicates the address of the transaction recipient. This indicates the transaction fee. Indicates the transaction amount. Indicates the transaction timestamp.

[0020] Step 2: Construct a dynamic account association graph .

[0021] .in, It is a collection of account nodes. It is a set of associated edges. Indicates a continuous period of time. Indicates a specific moment in time. Represents a node exist The relationship between moments. Represents a node exist The relationship between moments. Represents the node feature matrix, Indicates the number of nodes. Represents the edge feature matrix, Indicates the number of edges. Dimensions representing node features The dimension representing the edge features. Represents the set of real numbers. For fine-grained detection tasks, the node's label is represented as... , , This indicates the number of account categories.

[0022] Specifically, step 2 includes the following steps:

[0023] Step 2.1: Integrate the attributes of the original transactions to construct the time-series transaction attributes. The original transactions can be in sequential format, with each transaction having 6 attributes.

[0024] Sort all transactions in ascending order by timestamp and integrate the initial attributes to construct time-series transaction attributes.

[0025] Specifically, time-series transaction attributes can include four components:<Sender,Receiver,Timestamp,RawMessage> Sender represents the account that sends the transaction, Receiver represents the account that receives the transaction, Timestamp represents the transaction timestamp, and RawMessage represents the raw information of the transaction. RawMessage includes the transaction amount, transaction fuel, and unit fuel price.

[0026] Step 2.2: Convert the original transaction sequence into a dynamic account association graph.

[0027] Specifically, blockchain transaction datasets All transactions are processed according to the procedure in step 2.1, generating a dynamic account association graph from a continuous time perspective. In the dynamic account association graph, each node represents a specific blockchain account, and each edge represents the relationship between two accounts (i.e., a transaction event). The dynamic account association graph serves as the input data for subsequent transactions.

[0028] Step 3: Construct a cascaded graph feature extractor.

[0029] Using a dynamic account association graph as input, a continuous event update mechanism is employed to extract the potential dynamic evolution features of the relationships between accounts. Simultaneously, a deep node feature representation is constructed by combining the global static features of the dynamic account association graph. The extracted features are then passed as input data to the encoder and classifier.

[0030] Specifically, step 3 may include the following steps:

[0031] Step 3.1: Dynamic Feature Extraction. Input the dynamic account association graph and initialize an empty dynamic feature matrix. The edge set in the dynamic account association graph Divide into multiple processing batches according to time sequence, for each node Create historical state memory It records the dynamic relationship evolution information.

[0032] Continuous event-driven historical state memory updates. For events involving the source node... and target node Each event Calculate the two messages to update their respective memory:

[0033] (1)

[0034] in, Represents a node In time The news, Represents a node In time Previous memories, The attributes that represent transaction events. This indicates a time encoder that captures the time dimension. It is a learnable message function.

[0035] Batch message aggregation processing. This involves messages from the same node within the same batch. Multiple events are aggregated using an average aggregation function to ensure computational efficiency in high-frequency trading scenarios and avoid event-by-event updates.

[0036] (2)

[0037] in, Represents a node In time Processed aggregated message, This represents the average aggregation function.

[0038] Memory state update. After a transaction event occurs, the current memory state is updated. and update the aggregated messages in the memory of the corresponding nodes. Memory updates are implemented using a GRU network:

[0039] (3)

[0040] in, Represents a node In time Memories It is a learnable memory update function.

[0041] Dynamic embedding generation. Combining k-order neighborhood information. Generate dynamic node embeddings:

[0042] (4)

[0043] in, Represents a node In time Dynamic embedding. This represents the attributes of a transaction event.

[0044] For each time Dynamic characteristics of graph nodes = It not only reflects the local structure between nodes and their neighbors, but also captures evolutionary information with time dependence and contextual relevance.

[0045] Step 3.2: Static feature extraction.

[0046] To achieve more comprehensive deep feature extraction, this invention additionally extracts the global state of the graph nodes throughout the entire time span as static features. These static features include statistical features (such as transaction frequency and node type) and topological features (such as in-degree and out-degree), which are categorized into three aspects: transaction count, timestamp, and transaction amount.

[0047] For example, 26-dimensional static features can be extracted for each graph node.

[0048] Step 3.3: Feature Fusion and Standardization. After obtaining the static features, they are combined with the dynamic features to form a deep node feature representation. Then, the data is scaled to a given range (which can be achieved by applying normalization techniques) to ensure the comparability between data points while maintaining the original feature vector distribution.

[0049] Specifically, the z-score method can be used to perform normalization tasks:

[0050] (5)

[0051] in, The original data representing each dimension of the feature. The mean of the dimensional features. The standard deviation of a dimensional feature Represents the standard score.

[0052] Step 4: Construct a pre-trained general encoder.

[0053] The encoder is pre-trained using classes with abundant labeled samples and a triple loss function, transforming the feature representations into high-dimensional embeddings. Encoders trained in this way have the ability to distinguish between different categories, significantly enhancing the model's generalization ability.

[0054] Specifically, step 4 may include the following steps:

[0055] Step 4.1: Pre-train the backbone network.

[0056] Specifically, the pre-trained backbone network can use Graph-Transformer, which combines the advantages of graph convolution and Transformer to capture the relationships between nodes in graph structure data.

[0057] First, calculate multi-head attention. To measure nodes For nodes The contribution of each node in layer L. Features can be converted into query vectors using their respective linear transformation matrices. Key vectors Sum value vector :

[0058] (6)

[0059] (7)

[0060] (8)

[0061] in, This represents the linear transformation matrix of layer L over the query vector. This represents the linear transformation matrix of layer L with respect to the key vector. This represents the linear transformation matrix of layer L over the value vector; Represents a node Features of layer L Represents a node Features in layer L.

[0062] Pass the result through a factor The scaling factor is the dimension of the key vector. The scaled result is then used... Normalize the function:

[0063] (9)

[0064] in, This represents the linear transformation matrix applied to the edge relation. Represents a node and The edge relationships between them.

[0065] After multi-head attention in the computation graph, node features are updated by aggregating neighborhood information, and then a non-linear function is executed. This is used to activate vectors and further optimize node embedding. Specifically, first, neighboring nodes... and edge The feature vectors are linearly transformed and summed, and then the information of all neighboring nodes is aggregated using attention coefficients:

[0066] (10)

[0067] (11)

[0068] in, Represents a node Features in layer L+1 Indicates the first Aggregated information from individual attention heads; Indicates the first in layer L Multiple heads of attention; , , , , Represents different linear transformation weight matrices.

[0069] The network architecture combines graph structure and self-attention mechanism, enabling the model to effectively learn hidden patterns in account relationships, thereby generating more informative node embeddings.

[0070] Step 4.2: Introduce the ternary loss function.

[0071] To help the pre-trained encoder distinguish between different categories of accounts, this method introduces a ternary loss function, which optimizes the encoder parameters by calculating the distance between the anchor point, positive samples, and negative samples, ensuring that the distance between similar samples is small and the distance between dissimilar samples is large.

[0072] In the ternary loss function, the triples consist of an anchor sample, a positive sample, and a negative sample. Anchor samples and positive samples belong to the same class, while negative samples come from different classes. After selecting the triples, the loss function is calculated. :

[0073] (12)

[0074] in, It is a sample and The square of the distance between them; It is a hyperparameter that represents the distance in the loss function. Indicates anchor sample, Indicates a positive sample. This indicates a negative sample.

[0075] To avoid overfitting or training difficulties, this invention employs a Semi-Hard triplet loss strategy, ensuring that negative samples are neither too close nor too far from anchor samples. The Semi-Hard triplet loss is defined as follows:

[0076] (13)

[0077] By minimizing the Semi-Hard triplet loss, the pre-trained encoder can effectively distinguish between different categories of accounts and has stronger generalization ability when faced with new data.

[0078] Step 5: Build a fine-grained account classifier.

[0079] Based on the pre-trained encoder, the classifier is fine-tuned using partially labeled samples from the new categories, enabling rapid incremental updates to the model.

[0080] Specifically, focus loss is used as the loss function for the fine-grained account classifier. An adjustment factor is introduced based on the standard cross-entropy loss. and scaling factor This reduces the impact of easily classified samples on the overall loss and encourages the model to focus on learning samples that are difficult to classify.

[0081] For multi-class classification problems, the predicted probability distribution is as follows: The formula is defined as:

[0082] (14)

[0083] in, Represents the focus loss function. Indicates sample label, Represents the predicted probability distribution; Represents the predicted probability distribution of a specified sample; Used to measure the weight between different categories; Penalize easily classifiable samples. This represents the standard cross-entropy loss.

[0084] Step 6: Perform fine-grained detection of blockchain accounts using a blockchain account fine-grained detection model based on dynamic graph learning.

[0085] Example

[0086] This embodiment establishes a fine-grained blockchain account detection model based on dynamic graph learning, and compares the actual performance of this model with existing methods to verify the advantages and effectiveness of the present invention. The specific implementation steps are as follows:

[0087] Step 1: Collect and build a blockchain transaction dataset.

[0088] A total of 6,217 tagged malicious blockchain accounts were obtained from the APIs of CryptoScamDB (https: / / cryptoscamdb.org / scams) and Etherscan (https: / / etherscan.io). These tagged accounts were used as central nodes to capture their first-order and second-order transactions via the API provided by Etherscan. All unsuccessful transactions were removed as they were meaningless to the task. After cleanup, a total of 769,050 first-order transactions and 58,791,559 second-order transactions were obtained.

[0089] Step 2: Convert the cleaned blockchain transaction dataset into a dynamic account association graph.

[0090] like Figure 1 As shown, blockchain accounts and their first-order neighbors are considered as graph nodes, and first-order transactions are considered as edges. Ultimately, the constructed dynamic account association graph contains multiple types of accounts, involving 195,628 nodes and 683,368 edges.

[0091] Step 3: Construct a cascaded graph feature extractor.

[0092] In the dynamic graph feature extraction stage, the memory state dimension of the dynamic graph network is set to 128, the number of attention heads is set to 2, and the output embedding dimension is set to 64 to obtain dynamic node embeddings. In the static graph feature extraction stage, features are extracted from 26 dimensions. The two sets of features are fused and the resulting features are normalized. Each node and edge is assigned a 90-dimensional and a 4-dimensional feature vector, respectively, representing their structural and attribute information.

[0093] Step 4: Build a pre-trained general encoder and train it.

[0094] like Figure 2 As shown, in real-world blockchain networks, the labeled samples of different classes are extremely imbalanced. Following this real-world data distribution, classes with abundant labels are considered known classes, and classes with limited labeled samples are considered incremental classes. A general encoder is pre-trained using 70% of the known data. The encoder parameters are selected as follows: a 2-layer Graph-Transformer network is used, with 100 triples selected based on a Semi-Hard strategy, a batch size of 64, an output node embedding dimension of 128, and learning rate and number of training epochs set to 0.01 and 50, respectively.

[0095] Step 4.1: Calculate the key vector for each node, then compute multi-head attention to measure the node's contribution. Next, aggregate neighborhood information to update node features, and then execute a non-linear function. To activate vectors, thereby optimizing node embedding.

[0096] Step 4.2: Use the Semi-Hard triplet loss strategy to help the pre-trained encoder distinguish between different categories of accounts.

[0097] Step 5: Build a fine-grained account classifier and fine-tune the model.

[0098] Randomly select from each class A support set is formed from a set of samples, and the model is fine-tuned. The focus loss function is used to calculate the difference between the predicted values ​​and the true values ​​output by the classifier.

[0099] Step 6: Use a fine-grained blockchain account detection model based on dynamic graph learning to perform fine-grained detection of blockchain accounts.

[0100] The method of this invention is compared with nine existing methods (Logistic Regression, DeepWalk, Node2Vec, Trans2Vec, GCN, GAT, GraphSAGE, TTAGN, BERT4ETH) in two scenarios: incremental fine-grained detection and full data fine-grained detection, in order to verify the effectiveness of this invention.

[0101] For the Logistic Regression method, the maximum number of iterations for convergence was set to 10,000. For the DeepWalk, Node2Vec, and Trans2Vec methods, the walk length was set to 20, the number of walks to 10, and the context size to 10. The return parameter p and input / output parameters q for Node2Vec were set to 0.25 and 0.4, respectively. GCN, GAT, GraphSAGE, and TTAGN were all set to 2-layer graph neural networks. BERT4ETH was set to an 8-layer network with 2 attention heads per layer. All methods were run 5 times, and the average Macro-F1 score from the 5 tests was used as the final model performance. Macro-F1 measures the average F1 score across all classes in a fine-grained classification task, giving equal weight to the performance of each class and preventing the overall model performance evaluation from being dominated by the majority of classes. The formula for calculating Macro-F1 is as follows:

[0102] (15)

[0103] To evaluate the fine-grained classification performance of different methods in incremental classification scenarios, this invention adjusts the number of fine-tuned samples for each class in step 5. Set to 5, 10, and 20.

[0104] The method of this invention significantly improves the Macro-F1 score compared to existing methods in incremental fine-grained detection scenarios. The efficiency improvement is 25.59% to 64.78% compared to existing methods. Furthermore, the performance of this invention is even better with a larger sample size.

[0105] To comprehensively evaluate the fine-grained detection capabilities of different methods, this invention continued to test under full-data conditions. For all types of account data, 70% of the data for each class was selected as training data, and the remaining 30% was used to test the performance of different models.

[0106] This invention still demonstrates the best detection capability in fine-grained detection tasks under full-data scenarios, with Macro-F1 scores improving by 11.8% to 36.08% compared to other methods. This indicates that the dynamic account association graph of this invention can effectively extract potential interaction features between blockchain accounts and reduce the dependence on large amounts of labeled data.

[0107] The embodiments of the present invention have been described above in conjunction with the accompanying drawings and examples. However, those skilled in the art can make several improvements without departing from the principles of this patent, and these improvements also fall within the scope of protection of this patent.

Claims

1. A method for blockchain account fine-grained detection based on dynamic graph learning, characterized in that, The method comprises the following steps: Step 1 : Constructing a Blockchain Transaction Dataset ; Step 2: Constructing a dynamic account association graph , ; wherein, is a set of account nodes, is a set of association edges, denotes a continuous time period, denotes a specific time instant; denotes a node at the association relationship at time instant, denotes a node at the association relationship at time instant ; denotes a node feature matrix, denotes the number of nodes, denotes an edge feature matrix, denotes the number of edges, denotes the dimension of node features, denotes the dimension of edge features, denotes a set of real numbers; for a fine-grained detection task, the label of a node is represented as , , denotes the number of account categories; Step 3: Constructing a cascading graph feature extractor; With dynamic account association graph For input, the potential dynamic evolution characteristics of the association between accounts are extracted using a continuous event update mechanism; at the same time, combined with the global static characteristics of the dynamic account association graph , a deep node feature representation is constructed; the extracted features are transmitted to the encoder and classifier as input data; Step 4: Constructing a pre-trained general encoder; Step 5: Constructing a fine-grained account classifier; On the basis of the pre-trained encoder, the classifier is fine-tuned using part of the labeled samples from the new category to realize the incremental update of the model; Step 6: Using the blockchain account fine-grained detection model based on dynamic graph learning to detect the blockchain account in a fine-grained manner.

2. The blockchain account fine-grained detection method based on dynamic graph learning of claim 1, wherein, In step 1, different categories of blockchain accounts and their first and second order transactions are obtained to build a blockchain transaction dataset ; set comprising transaction records: Each transaction record consists of a six-tuple , , a hash value representing the transaction, a sender address representing the transaction, a receiver address representing the transaction, a transaction fee representing the transaction, a transaction amount representing the transaction, a transaction timestamp.

3. The blockchain account fine-grained detection method based on dynamic graph learning of claim 1, wherein, Step 2 comprises the following steps: Step 2.1: Integrating the attributes of the original transaction to construct the time series transaction attribute; all transactions are sorted in ascending order of timestamp, and the initial attributes are integrated to construct the time series transaction attribute; Step 2.2: Convert the original transaction sequence into a dynamic account association graph; in the dynamic account association graph, each node represents a specific blockchain account, and each edge represents the relationship between two accounts; the dynamic account association graph serves as the input data for the subsequent process.

4. The blockchain account fine-grained detection method based on dynamic graph learning of claim 3, wherein, The time series transaction attribute includes four components: <Sender, Receiver, Timestamp, RawMessage>; Sender represents the transaction sending account, Receiver represents the transaction receiving account, Timestamp represents the transaction timestamp, and RawMessage represents the transaction raw information.

5. The blockchain account fine-grained detection method based on dynamic graph learning of claim 1, wherein, Step 3 comprises the following steps: Step 3.1: Dynamic feature extraction; input dynamic account association graph , initialize empty dynamic feature matrix , divide the edge set in the dynamic account association graph into multiple processing batches in chronological order, create a historical state memory for each node , record its dynamic relationship evolution information ​​ Continuous event-driven history state memory updates; for each event involving a source node and a target node , two messages are computed to update their respective memories: wherein, represents a node at time a message, represents a node at time a memory, represents an attribute of a transaction event, represents a time encoder capturing the time dimension, is a learnable message function; Batch message aggregation processing; multiple events involving the same node in the same batch are integrated using an average aggregation function ​ wherein, representing a node at a time processed aggregated messages, representing an average aggregation function; Memory state update; after the transaction event occurs, according to the current memory And update the aggregated message in the memory of the corresponding node The memory update is realized by using a GRU network: wherein, representing nodes at time of memory, is a learnable memory update function; Dynamic embedding generation; incorporating k-order neighborhood information Generating dynamic node embeddings: wherein, representing a node at a time of dynamic embedding; representing attributes of a transaction event; Step 3.2: Static feature extraction; Extract the global state of the graph nodes within the entire time span as static features; the static features include statistical features and topological features; Step 3.3: Feature fusion and standardization; after obtaining the static features, combine them with the dynamic features to form a deep node feature representation; then, scale the data to a given range to ensure the comparability between data points while maintaining the original feature vector distribution.

6. The blockchain account fine-grained detection method based on dynamic graph learning of claim 5, wherein, In step 3.3, the z-score method is used to perform the normalization task: wherein, represents raw data for each dimension feature, represents a mean value of the dimension feature, represents a standard deviation of the dimension feature, represents a standard score.

7. The blockchain account fine-grained detection method based on dynamic graph learning of claim 1, wherein, Step 4 comprises the following steps: Step 4.1: Pre-training the backbone network; First, multi-head attention is computed to measure the contribution of nodes ; for each node of L layers, a respective linear transformation matrix is used to transform the features into a query vector , a key vector , and a value vector : ​ wherein, represents a linear transformation matrix of the Lth layer for a query vector, represents a linear transformation matrix of the Lth layer for a key vector, represents a linear transformation matrix of the Lth layer for a value vector; represents a node a feature at the Lth layer, represents a node a feature at the Lth layer; The results are normalized by a factor The scaling is the dimension size of the key vector; the scaled results are normalized using the function: ) wherein, represents a linear transformation matrix for the edge relationship, represents a node and between the nodes; After multi-head attention in the computation graph, node features are updated by aggregating neighborhood information, and then a non-linear function is executed. To activate vectors and further optimize node embedding; first, for adjacent nodes... and edge The feature vectors are linearly transformed and summed, and then the information of all neighboring nodes is aggregated using attention coefficients: wherein, representing a node at L+1 layer, representing the aggregated information of the th multi-head attention at L layer; , , , , representing different linear transformation weight matrices;​ Step 4.2: Introducing a ternary loss function to optimize the encoder parameters by calculating the distance between anchor points, positive samples, and negative samples; The triplet in the triplet loss function includes an anchor sample, a positive sample and a negative sample; the anchor sample and the positive sample belong to the same class, and the negative sample comes from different classes; after selecting the triplet, the loss function is calculated : wherein, is the distance squared between the sample and ; is a hyperparameter representing the distance in the loss function; represents an anchor sample, represents a positive sample, represents a negative sample; Semi-Hard triplet loss strategy is adopted to ensure that the negative sample is neither too close nor too far from the anchor sample; the Semi-Hard triplet loss is defined as: .

8. The blockchain account fine-grained detection method based on dynamic graph learning of claim 1, wherein, Step 4 comprises the following steps: Focal loss is used as the loss function of the fine-grained account classifier; a regulation factor is introduced on the basis of standard cross-entropy loss and a scaling factor ; for multi-classification problems, the predicted probability distribution is , which is defined as: wherein, denotes a focal loss function, denotes a sample label, denotes a predicted probability distribution; denotes a predicted probability distribution for a specified sample; for measuring the weight between different classes; controls the penalty of easy-to-classify samples, denotes a standard cross-entropy loss.

Images