Auction mechanism design method based on graph neural network
By using an improved graph neural network model, the problems of strategy coupling and multidimensional private information in social network auctions are solved, improving the accuracy and efficiency of auction prediction and achieving a near-optimal auction mechanism design.
Patent Information
- Application Number
- CN202511285248.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-10
- Publication Date
- 2025-12-30
AI Technical Summary
In existing social network auction frameworks, the policy coupling between agents and the complexity of multidimensional private information make it difficult to design the optimal auction mechanism, and traditional methods cannot effectively solve this problem.
We adopt an auction mechanism design method based on graph neural networks. By combining an improved GNN model with graph attention network (GAT), tree-like long short-term memory network (Tree-LSTM) and path attention module, we construct a multi-task loss function to optimize the social network auction model.
It significantly improves the ability to parse social network topology, enhances the robustness of modeling policy coupling behavior, improves the relevance and interpretability of auction prediction, and optimizes computational efficiency and generalization ability.
Smart Images
Figure CN121235801A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the fields of game theory and the auction industry, specifically to a method for designing auction mechanisms based on graph neural networks. Background Technology
[0002] In recent years, the number of auction companies in China has continued to grow, and the market size has expanded significantly. Industry development trends are influenced by multiple factors, including the market environment and technological advancements. Among these, online auctions, relying on internet technology and serving as a crucial component of e-commerce, have developed particularly rapidly. At the theoretical research level, scholars both domestically and internationally have continuously explored optimization paths for auction mechanisms, with research directions including identifying value interdependencies in sequential auctions and introducing deep learning technology into the auction field. However, traditional auction models often face performance bottlenecks due to insufficient numbers of bidders. To overcome this limitation, scholars first proposed a social network-based auction framework in 2017, which expands the potential participant group by utilizing the social relationship networks among bidders, thereby improving auction efficiency.
[0003] Since the introduction of the social network auction framework, scholars both domestically and internationally have conducted extensive research on it from multiple perspectives, including model extension, scenario adaptation, and property analysis. Nevertheless, the core issue of how to design the optimal auction mechanism within this framework remains unresolved. Designing the optimal auction mechanism for social networks faces two major challenges: ① Agents (bidders) in social networks form close connections through information dissemination, and their strategic behaviors influence each other, resulting in a strategy coupling problem that makes it difficult to accurately model and solve using traditional mechanism design methods; ② Agents possess not only private valuations of the auctioned items (traditional information dimension) but also multi-dimensional atypical private information, such as the ability to disseminate information about their social neighbors. This complexity and atypicality of information presents a multi-dimensional private information challenge, rendering the classic Myerson optimal auction theory, which relies on the assumption of single-dimensional private information, ineffective in this scenario.
[0004] Therefore, there is an urgent need for a near-optimal social network auction mechanism and design method to effectively solve the modeling and optimization challenges brought about by strategy coupling and multi-dimensional private information. Summary of the Invention
[0005] To overcome the aforementioned shortcomings of existing social network-based auction frameworks, this invention provides a method for designing auction mechanisms based on graph neural networks.
[0006] The first technical solution adopted in this invention is an auction mechanism design method based on graph neural networks, the steps of which are as follows: Step 1. Perform algorithmic analysis and Python programming on the VCG (Vickery Clarke Groves, i.e., social welfare maximization mechanism) and IDM (Information Diffusion Mechanism, i.e., information dissemination mechanism) mechanisms in the propagation auction design, and reproduce these two mechanisms; Step 2. Generate a large amount of data according to the mechanism implemented in Step 1, preprocess and simplify the data, and divide it into training set and validation set for fitting model according to proportion; Step 3. Improve the general GNN model by continuously optimizing it in three stages based on the Graph Attention Network (GAT) to gradually enhance the model and build an improved GNN model to fit the auction information data. Step 4. Train the improved GNN network model in three stages, analyze the overall fitting data, and obtain the optimal parameters; Step 5. Randomly generate auction information data, input it into the improved GNN model, compare the results with the mechanism implemented in Step 1, and draw conclusions.
[0007] Preferably, in step 1: We conducted algorithmic analysis and Python programming on the VCG and IDM mechanisms in the propagation auction design to reproduce these two mechanisms.
[0008] To understand the core of the VCG and IDM mechanisms, we need to look at the core features of the VCG mechanism: a classic mechanism design aimed at maximizing social welfare; and the core features of the IDM mechanism: an auction mechanism based on the diffusion of information in a social network, which determines the winner and the price through a key propagation sequence.
[0009] Algorithm analysis reveals the following: The VCG mechanism's algorithm proceeds as follows: Traverse the entire tree, find the node with the highest bid (the winner), and pay the highest bid remaining after removal. Non-winners pay the highest bid remaining after removing themselves and their propagated subtrees minus the original highest bid. The auctioneer's profit is the algebraic sum of all bids. The IDM mechanism's algorithm proceeds as follows: The winner is the first node on the key propagation sequence to become the highest bidder after removing its child node. The winner pays the highest bid remaining after removing itself and its propagated subtrees. Non-winners pay the highest bid remaining after removing their child node and its propagated subtrees minus the highest bid remaining after removing themselves and their propagated subtrees. The auctioneer's profit is the algebraic sum of all bids.
[0010] Preferably, in step 2: Based on the mechanism implemented in step 1, a large amount of data is generated. The data is preprocessed and simplified, and then divided proportionally into training and validation sets for the fitted model. The specific method is as follows: Randomly generate tens of thousands of tree-shaped propagation structures containing 3-5 nodes (small scale), 15-20 nodes (medium scale), or 50-100 nodes (large scale). The root node represents the auctioneer, and the remaining nodes are bidders. The value of the node is the bid price, and the edge between nodes indicates that the auction information can be propagated between the two nodes. Input the randomly generated tree into the algorithm implemented in step 1 to obtain the allocation and payment results of each propagation auction tree, generating a large dataset; The dataset is simplified by deleting invalid data that does not reflect the core of the propagation auction mechanism. Specifically, if the winner's payout label and the auctioneer's profit label of a data point have the same value, meaning that no profit is generated at other nodes in the propagation path, then the data is invalid and should be deleted. Construct a tree graph and generate data labels to convert the tree-shaped auction data into a format that can be processed by graph neural networks.
[0011] Preferably, in step 3: An improvement was made to the general GNN model. Based on the Graph Attention Network (GAT), the model was continuously optimized in three stages to achieve gradual enhancement. The improved GNN model was then used to fit auction information data.
[0012] Phase ① GATBaseline: The GNN model structure in this stage includes two GAT layers as feature extractors, followed by three task-specific prediction heads. The first GAT layer (conv1) has an input dimension of 1 (single feature per node), uses two attention heads, each outputting 64-dimensional features, resulting in a total output dimension of 128 after concatenation, and uses the ELU activation function. The second GAT layer (conv2) has an input dimension of 128 (i.e., the output of conv1), uses one attention head, outputting 64-dimensional features, and also uses the ELU activation function. The task prediction heads (the task prediction heads in subsequent stages ② and ③ are the same) include an allocation prediction head (alloc_head), which receives the graph-level features (64-dimensional) output from conv2, maps them to 1-dimensionality through a linear layer, and uses the Sigmoid activation function to output the probability (between 0 and 1) of a node obtaining an auction item. The payment prediction head receives the graph-level features (64-dimensional) output from conv2. First, it uses a sigmoid function to constrain the values between 0 and 1. Then, it uses a scaling and translation method, i.e., modified_sigmoid = 30 * (sigmoid(x) - 0.5), to constrain the predicted payment amount to the range of -15 to 15. The revenue prediction head receives the graph-level embedding vector (64-dimensional) obtained by performing global mean pooling on all node features output from conv2. It directly outputs a one-dimensional prediction of the total auction revenue (without an activation function) through a linear layer.
[0013] Phase ② TreeEnhancedGAT: This stage improves upon GAT by incorporating a bidirectional Tree-LSTM (a tree-structured long short-term memory network with the training and validation sets divided in an 8:2 ratio). Tree-LSTM, an RNN with more complex computational units, is introduced in this improvement. Through bidirectional propagation (top-down and bottom-up) of the tree structure, it forms more comprehensive node embeddings, capturing hierarchical relationships and global contextual information between nodes. The parent-child relationships of the tree structure are used to enhance node representations, enabling more refined encoding of node features. GAT excels at capturing local neighborhood relationships, while Tree-LSTM supplements global hierarchical information. Theoretically, the fusion of the two complements each other and can significantly improve the model's multi-task learning ability. Stage ②'s GATConv is the same as Stage ①, except that it introduces a Tree-LSTM module. The key component of this module is the bidirectional LSTM unit. Top-down LSTM: Input current node features + parent node hidden state, output the current node's downward propagation hidden state hidden_dim. The formula is expressed as follows:
[0014] Bottom-up LSTM: The opposite of the former, it takes the current node's features and the hidden states of its child nodes as input, and outputs the current node's uppropagation hidden state `hidden_dim`. The formula is expressed as follows:
[0015] Each node is ultimately represented as a concatenation of top-down and bottom-up hidden states, with an output dimension of 64x2=128. This module does not use an activation function. Stage ② also has a feature fusion layer, which concatenates and fuses the 64-dimensional output features of GAT with the 128-dimensional output of Tree-LSTM, processes the fusion input through the ELU activation function, and finally outputs 128-dimensional features.
[0016] Stage ③ HierarchicalAttentionGNN: Building upon the GATConv and Tree-LSTM phases of the previous two phases, this stage introduces a new PathAttention module. This module extracts features along the path from nodes to the root, calculates attention weights, and dynamically evaluates the importance of each node's path to the root node in task prediction through a path attention mechanism. The introduction of this module combines the local neighborhood attention of GAT with the hierarchical structure information of Tree-LSTM, further enhancing the model's ability to model complex tree structures. By adjusting node features through attention weights, the model focuses more on paths crucial to task prediction, i.e., key propagation paths, avoiding excessive interference from other paths. The input to this module is the 128-dimensional feature vector concatenated from the feature fusion layer of phase ②, and the output is a 1-dimensional attention score tensor. The attention score is normalized using the Sigmoid function and ranges from 0 to 1; a larger value indicates that the path containing that node is more important for task prediction. Similarly, the GNN structure in stage ③ also includes a feature fusion layer. Its input dimensions are 64 dimensions from the output of GATConv, 128 dimensions from the output of the Tree-LSTM module, and a 193-dimensional feature vector formed by concatenating a 1-dimensional attention score. After processing by the ELU activation function, the output dimension is 128.
[0017] Preferably, in step 4: The improved GNN network model is trained in three stages, and the overall fitting data is analyzed to obtain the optimal parameters. The specific method is as follows: Training was performed using the AdamW optimizer (initial learning rate 0.01, weight decay). The model employs ReduceLROnPlateau learning rate scheduling (patience value 10) and gradient pruning (threshold 1.0). A multi-task loss function is used (allocation 0.6 / payout 0.3 / profit 0.1 weights). The allocation task uses weighted cross-entropy (winner 5x weight), the payout task uses Huber loss (non-zero samples 8x weight), and profit prediction is based on MSE. Each model stage is trained independently for 100 epochs, for a total of 300 epochs. During training iterations, non-root nodes are probabilistically removed and the computational subgraph is reconstructed to reduce the complexity of message passing and tree traversal, achieving computational acceleration and implicit regularization while maintaining the ability to capture global structural semantics. Evaluation metrics include winner allocation accuracy, payout MAE (winner only), and auctioneer profit. Furthermore, visualization analysis is achieved through confusion matrix, payment error distribution, and revenue regression plot, comprehensively optimizing the auction tree prediction performance.
[0018] The multi-task loss function comprehensively measures the losses of the three prediction tasks: allocation, payment, and revenue. The overall loss function is:
[0019] The allocation loss function is
[0020] The payment loss function is
[0021] The profit and loss function is
[0022] in, To assign task weights, For payment tasks, As for the weight of the revenue task, For the sample size, These are the weighting coefficients. For real labels, To predict probabilities, For non-zero payment samples, Non-zero sample weights; This is the actual payment value. To predict payment value, For the number of auction instances, For the true total revenue, To predict total revenue.
[0023] Preferably, in step 5: Randomly generate auction information data, input it into the improved GNN model, compare the results with the mechanism implemented in step 1, and draw conclusions. Specifically, load the optimal weights into the trained model, predict the auction scenario, and do not perform loss calculation or backpropagation during the inference process. The network structure is the same as during training, the input is the propagated auction tree, and the return is the auction allocation and payment prediction results.
[0024] The second technical solution adopted in this invention is an auction mechanism design system based on graph neural networks, which is used to implement the auction mechanism design method based on graph neural networks to complete an approximately optimal auction mechanism design based on graph neural networks.
[0025] The third technical solution adopted in this invention is a computer device, including a memory, a processor, and a computer program stored in the memory. When the processor executes the computer program, it implements the auction mechanism design method based on graph neural networks to complete an approximate optimal auction mechanism design based on graph neural networks.
[0026] The fourth technical solution adopted in this invention is a computer-readable storage medium storing a computer program. When the computer program is executed by a processor, it implements the auction mechanism design method based on graph neural networks to complete an approximate optimal auction mechanism design based on graph neural networks.
[0027] The present invention has the following beneficial effects: 1. Deep Hierarchical Perception: Introducing a bidirectional Tree-LSTM module, it accurately models the tree-like hierarchical relationship of auction data by aggregating subtree information from bottom to top (hidden state of child node → parent node) and passing global dependencies from top to bottom (hidden state of parent node → child node), solving the deficiency of traditional GAT that only focuses on local neighbors, and significantly improving the ability to parse social network topology; 2. Dynamic Focusing on Critical Paths: The newly added PathAttention module calculates attention weights along the path from nodes to the root, dynamically identifies propagation paths that are crucial to payment / revenue prediction, suppresses interference from irrelevant paths, enhances the model's robustness in modeling policy coupling behavior, and improves prediction specificity and interpretability. 3. Multi-task collaborative optimization: Design a multi-task loss function, optimize the allocation accuracy through weighted cross-entropy, control the outlier error of payment prediction through Huber loss, and fit the total revenue of the auctioneer through MSE loss, flexibly balance the auction objective, and approach the maximization of social welfare. 4. Progressive training strategy: A three-stage progressive enhancement architecture (GAT→+Tree-LSTM→+PathAttention) is adopted, which inherits the weights of the previous modules step by step to avoid the convergence instability problem of complex models being trained all at once, and achieves a steady performance improvement. 5. Improved computational efficiency and generalization: The model introduces a subgraph training strategy based on random node sampling. By probabilistically removing non-root nodes and reconstructing the computational subgraph during training iterations, the complexity of message passing and tree traversal is reduced, achieving computational acceleration and implicit regularization, while maintaining the ability to capture global structural semantics. Attached Figure Description
[0028] Figure 1 This is a flowchart illustrating the steps of the auction mechanism design method based on graph neural networks in an embodiment of the present invention.
[0029] Figure 2 This is a graph neural network structure diagram of the auction mechanism design method based on graph neural networks in an embodiment of the present invention. Detailed Implementation
[0030] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.
[0031] This embodiment provides a method for designing an auction mechanism based on a graph neural network, including the following steps: reproducing the benchmark auction mechanism, generating and preprocessing data, constructing a progressively enhanced GNN model, training the model in stages, and performing prediction verification. The design and implementation of each step are described below.
[0032] (a) Reproduce the benchmark auction mechanism.
[0033] We conducted algorithmic analysis and Python programming on the VCG and IDM mechanisms in the propagation auction design to reproduce these two mechanisms.
[0034] VCG mechanism allocation rules:
[0035] In this rule, This indicates the agent who obtains the item (i.e., the winner in the VCG mechanism), if ,but Otherwise, it is 0.
[0036] VCG mechanism payment rules:
[0037] In this rule, for the winner , Payment is For other related agents Payment is For those not present Other agents in the group paid out 0.
[0038] IDM mechanism allocation rules:
[0039] In this rule, This indicates the agent who receives the item (i.e., the winner in the IDM mechanism). If... ,but ;if Middle but not And the report valuation equal Then they will also receive allocation. Otherwise, it is 0.
[0040] Payment rules for the IDM mechanism:
[0041] In this rule, for the winner , Payment is ;if exist Middle but not the winner Then its payment is Otherwise, the payment is 0.
[0042] (ii) Creating a dataset.
[0043] Tens of thousands of tree-shaped propagation structures with 3-5 nodes (small scale), 15-20 nodes (medium scale), or 50-100 nodes (large scale) are randomly generated and input into the algorithm implemented by the above mechanism to obtain the allocation and payment results for each propagation auction tree, generating a large dataset. Finally, the dataset is simplified and divided into training and validation sets in an 8:2 ratio.
[0044] (III) Constructing an improved model.
[0045] An improvement to the general GNN model is achieved by continuously optimizing the Graph Attention Network (GAT) in three stages, thus progressively enhancing the model. The improved GNN model is then used to fit auction information data. The specific method is as follows.
[0046] Phase ① GATBaseline: The GNN model structure in this stage includes two layers of Graph Attention Network (GAT) as feature extractors, followed by three task-specific prediction heads (the prediction heads for subsequent stages ② and ③ are the same).
[0047] The first layer GAT(conv1): The input dimension is 1 (single feature per node), using 2 attention heads, each head outputs 64-dimensional features, and the total output dimension after concatenation is 128. The activation function is ELU.
[0048] The second layer, GAT(conv2), has an input dimension of 128 (i.e., the output of conv1), uses one attention head, and outputs 64-dimensional features. The activation function is also ELU.
[0049] Allocate prediction head (alloc_head): Receives the graph-level features (64-dimensional) output from conv2, maps them to 1-dimensionality through a linear layer, and uses the Sigmoid activation function to output the probability (between 0 and 1) of the node obtaining the auction item.
[0050] Payment prediction head: Receives graph-level features (64-dimensional) output from conv2. First, the values are restricted to between 0 and 1 by the Sigmoid function. Then, the predicted payment amount is restricted to the range of -15 to 15 by the scaling and translation method, i.e., modified_sigmoid=30*(sigmoid(x)-0.5).
[0051] Revenue prediction head: Receives a graph-level embedding vector (64-dimensional) obtained by global mean pooling of all node features output from conv2, and directly outputs a one-dimensional prediction of the total revenue of the entire auction through a linear layer (without activation function).
[0052] Phase ② TreeEnhancedGAT: This stage improves upon GAT by incorporating a bidirectional Tree-LSTM (Tree-based Long Short-Term Memory) network. Tree-LSTM, an RNN with more complex computational units, is introduced in this improvement. Through bidirectional propagation (top-down and bottom-up) of the tree structure, it forms more comprehensive node embeddings, capturing hierarchical relationships and global contextual information between nodes. It utilizes the parent-child relationships of the tree structure to enhance node representations and encode node features more finely. GAT excels at capturing local neighborhood relationships, while Tree-LSTM supplements global hierarchical information. Theoretically, the fusion of the two can significantly enhance the model's multi-task learning capabilities. Stage ②'s GATConv is the same as Stage ①, except that it introduces a Tree-LSTM module, which contains the key component, the bidirectional LSTM unit.
[0053] Top-down LSTM: Input the current node's features + the parent node's hidden state, output the current node's downward propagation hidden state `hidden_dim`. The formula expression flow is as follows:
[0054] Bottom-up LSTM: The opposite of the former, it takes the current node's features and the hidden states of its child nodes as input, and outputs the current node's uppropagation hidden state `hidden_dim`. The formula is expressed as follows:
[0055] Each node is ultimately represented as a concatenation of top-down and bottom-up hidden states, with an output dimension of 64x2=128. This module does not use an activation function. Stage ② also has a feature fusion layer, which concatenates and fuses the 64-dimensional output features of GAT with the 128-dimensional output of Tree-LSTM, processes the fusion input through the ELU activation function, and finally outputs 128-dimensional features.
[0056] Stage ③ HierarchicalAttentionGNN: Building upon the GATConv and Tree-LSTM phases of the previous two phases, this stage introduces a new PathAttention module. This module extracts features along the path from nodes to the root, calculates attention weights, and dynamically evaluates the importance of each node's path to the root node in task prediction through a path attention mechanism. The introduction of this module combines the local neighborhood attention of GAT with the hierarchical structure information of Tree-LSTM, further enhancing the model's ability to model complex tree structures. By adjusting node features through attention weights, the model focuses more on paths crucial to task prediction, i.e., key propagation paths, avoiding excessive interference from other paths. The input to this module is the 128-dimensional feature vector concatenated from the feature fusion layer of phase ②, and the output is a 1-dimensional attention score tensor. The attention score is normalized using the Sigmoid function and ranges from 0 to 1; a larger value indicates that the path containing that node is more important for task prediction. Similarly, the GNN structure in stage ③ also includes a feature fusion layer. Its input dimensions are 64 dimensions from the output of GATConv, 128 dimensions from the output of the Tree-LSTM module, and a 193-dimensional feature vector formed by concatenating a 1-dimensional attention score. After processing by the ELU activation function, the output dimension is 128.
[0057] (iv) Training the model.
[0058] Training employs the AdamW optimizer (initial learning rate 0.01, weight decay 1e-4), coupled with ReduceLROnPlateau learning rate scheduling (patience value 10) and gradient pruning (threshold 1.0); a multi-task loss function (allocation 0.6 / payout 0.3 / profit 0.1 weights); where allocation tasks use weighted cross-entropy (winner 5x weight), payment tasks use Huber loss (non-zero samples 8x weight), and profit prediction uses MSE; each model stage is trained independently for 100 epochs, for a total of 300 epochs; simultaneously, during training iterations, non-root nodes are probabilistically removed and computational subgraphs are reconstructed to reduce the complexity of message passing and tree traversal, achieving computational acceleration and implicit regularization while maintaining the ability to capture global structural semantics; evaluation metrics include winner allocation accuracy, payout MAE (winner only), and auctioneer profit R², and visualization analysis is achieved through confusion matrix, payout error distribution, and profit regression graph, comprehensively optimizing auction tree prediction performance.
[0059] The multi-task loss function comprehensively measures the losses from the three prediction tasks: allocation, payment, and revenue. That is, the overall loss function is:
[0060] The allocation loss function is:
[0061] The payment loss function is:
[0062] The profit / loss function is:
[0063] in, To assign task weights, For payment tasks, As for the weight of the revenue task, For the sample size, These are the weighting coefficients. For real labels, To predict probabilities, For non-zero payment samples, Non-zero sample weights; This is the actual payment value. To predict payment value, For the number of auction instances, For the true total revenue, To predict total revenue.
[0064] (v) Predict auction scenarios and output prediction results.
[0065] The trained model is loaded with optimal weights to predict auction scenarios. The inference process does not involve loss calculation or backpropagation. The network structure is the same as during training. The input is the propagated auction tree, and the output is the auction allocation and payment prediction results.
[0066] We trained on datasets with (small-scale, medium-scale, and large-scale node counts) based on the VCG and IDM mechanisms, respectively, and then visualized and compared the confusion matrix, payment error distribution, and revenue regression graph obtained from the training. The results are shown in Table 1.
[0067] Table 1 Comparison of training results with different numbers of nodes under different mechanisms
[0068] As shown in Table 1, the success rates for allocation and payment predictions are high for both the VCG and IDM mechanisms. Furthermore, smaller nodes demonstrate higher accuracy in predicting node allocations, while larger nodes show higher accuracy in predicting node payments and seller profits. This indicates that the improved GNN model of this invention can effectively fit and reproduce the VCG and IDM mechanisms, providing significant guidance for the design of auction mechanisms based on graph neural networks.
[0069] Obviously, the above embodiments of the present invention are merely illustrative examples to illustrate the invention and are not intended to limit the implementation of the invention. Other obvious variations or modifications derived from the essential spirit of the invention still fall within the protection scope of the invention.
Claims
1. A method for auction mechanism design based on graph neural networks, characterized in that, The steps are as follows: Step 1. Reproduce the benchmark auction mechanism: algorithmically analyze and program the VCG mechanism and IDM mechanism in the propagation auction design, reproduce the two mechanisms; Step 2. Generate and preprocess data: randomly generate tree-shaped propagation auction structures of different sizes, input the mechanism in step 1 to generate allocation and payment result data sets, preprocess and simplify the data to delete invalid data, and divide it into training set and validation set in proportion to fit the model; Step 3. Build a GNN model with progressive enhancement: Phase 1: Use a two-layer graph attention network as a feature extractor, followed by an allocation prediction head, a payment prediction head, and a revenue prediction head; Phase 2: Integrate a bidirectional Tree-LSTM module based on phase 1 to enhance hierarchical feature representation through top-down and bottom-up propagation; Phase 3: Add a PathAttention module based on phase 2 to calculate attention weights along the path from the node to the root to focus on key propagation paths; Step 4. Train the model in stages: use the AdamW optimizer for training; Use the ReduceLROnPlateau learning rate scheduler, use gradient clipping technology, use a multi-task weighted loss function, and probabilistically remove non-root nodes to reconstruct the subgraph during the training iteration process to analyze the overall fitting data and obtain the optimal parameters; Step 5. Prediction verification: input the randomly generated auction data into the trained GNN model to output the allocation and payment prediction results, and compare them with the benchmark mechanism results to evaluate the performance.
2. The graph neural network-based auction mechanism design method of claim 1, wherein, In step 1: The core feature of the VCG mechanism is the classic mechanism design that aims to maximize social welfare; The core feature of the IDM mechanism is an auction mechanism based on social network information diffusion, which determines the winner and price through a key propagation sequence; The algorithmic process of the VCG mechanism: traverse the entire tree, find the node with the highest bid, which is the winner, the winner's payment is the highest bid of the remaining tree after removing the winner, the non-winner's payment is the highest bid after removing itself and its propagation subtree minus the original highest bid, and the auctioneer's revenue is the sum of all bidders' payments; The algorithmic process of the IDM mechanism: the winner is the first node removed in the key propagation sequence that becomes the highest bid, the winner's payment is the highest bid after removing the winner and its propagation subtree, the non-winner's payment is the highest bid after removing the child node and its propagation subtree minus the highest bid after removing itself and its propagation subtree, and the auctioneer's revenue is the sum of all bidders' payments.
3. The graph neural network-based auction mechanism design method according to claim 2, wherein, In step 1: use python to program the IDM mechanism and VCG mechanism.
4. The graph neural network-based auction mechanism design method of claim 1, wherein, Step 2 is as follows: Randomly generate tens of thousands of tree-shaped propagation structures with 3-5 nodes (small scale), 15-20 nodes (medium scale), or 50-100 nodes (large scale), the root node represents the auctioneer, the rest of the nodes are bidders, and the value of the node is the bid. The edge between the nodes indicates that the auction information can be propagated between the two nodes; Input the randomly generated tree into the algorithm implemented in step 1 to obtain the allocation and payment results of each propagation auction tree, generating a large number of data sets; The data set is simplified, and invalid data that cannot reflect the core of the propagation auction mechanism is deleted. Specifically, if the winner payment label of the data is the same as the value of the auctioneer revenue label, that is, no other node on the propagation path generates revenue, the data is invalid, and is deleted; A tree graph is constructed, and data labels are generated to convert the tree-shaped auction data into a format that can be processed by a graph neural network.
5. The graph neural network-based auction mechanism design method according to claim 1, wherein, In step 3: The stage ① model includes two GAT layers as feature extractors, followed by three task-specific prediction heads. Specifically, the first GAT layer has an input dimension of 1, two attention heads, an output concatenation dimension of 128, and an activation function of ELU; the second GAT layer has an input dimension of 128, one attention head, an output dimension of 64, and an activation function of ELU; the allocation prediction head outputs the winning probability of a node using a Sigmoid function; the payment prediction head limits the output to [-15, 15] using a scaling and translation method (modified_sigmoid=30×(sigmoid(x)-0.5)); and the revenue prediction head outputs the total auction revenue using a linear layer after global average pooling. The bidirectional Tree-LSTM module in stage ② includes: a top-down LSTM that updates the current node features based on the parent node hidden state; and a bottom-up LSTM that updates the current node features based on the mean of the child node hidden states; the final representation of a node is the concatenation of the bidirectional hidden states. The PathAttention module in stage ③ includes: the input is the fused features from stage ②; and the output is a 1-dimensional attention score normalized by Sigmoid, with higher scores indicating stronger path importance.
6. The graph neural network-based auction mechanism design method according to claim 1, characterized in that, In step 4, the multi-task loss function integrates the loss of the allocation, payment, and revenue prediction tasks; The overall loss function is The allocation loss function is The payment loss function is The revenue loss function is in, To assign task weights, For payment tasks, As for the weight of the revenue task, For the sample size, These are the weighting coefficients. For real labels, To predict probabilities, For non-zero payment samples, Non-zero sample weights; This is the actual payment value. To predict payment value, For the number of auction instances, For the true total revenue, To predict total revenue.
7. The graph neural network-based auction mechanism design method according to claim 6, characterized in that, Step 4 in particular is: training using an AdamW optimizer with an initial learning rate of 0.01 and a weight decay of ; The patience value of the ReduceLROnPlateau learning rate scheduler is set to 10; the gradient clipping technology is adopted, and the gradient clipping threshold is 1.0; the multi-task weighted loss function is used, wherein the allocation task weight is 0.6, the payment task weight is 0.3, and the income task weight is 0.1; in the training iteration process, the non-root node reconstruction calculation subgraph is removed probabilistically to reduce the complexity of message passing and tree traversal, realize calculation acceleration and implicit regularization, and meanwhile maintain the ability to capture the global structure semantics; the evaluation indexes include winner allocation accuracy, payment MAE of only winners and auctioneer income , and the visual analysis is realized through a confusion matrix, payment error distribution and income regression diagram, so that the prediction performance of the auction tree is comprehensively optimized.
8. The graph neural network-based auction mechanism design method according to claim 1, wherein, In step 5, the trained model is loaded with the optimal weights, and the auction scenario is predicted. The inference process does not perform loss calculation and backpropagation, the network structure is the same as during training, the input is the propagation auction tree, and the output is the allocation and payment prediction results of the auction.
9. A graph neural network-based auction mechanism design system, characterized in that, The processor executes the computer program to implement the graph neural network-based auction mechanism design method of any one of claims 1-8 to complete a graph neural network-based approximately optimal auction mechanism design.
10. A computer device comprising a memory, a processor, and a computer program stored on the memory, wherein the computer program comprises instructions that, when executed by the processor, cause the processor to perform the method of any one of claims 1-9. The processor executes the computer program to implement the graph neural network-based auction mechanism design method of any one of claims 1-8 to complete a graph neural network-based approximately optimal auction mechanism design.