An advertisement effect evaluation method and system based on artificial intelligence

Abstract

The application discloses an advertisement effect evaluation method and system based on artificial intelligence, and the method comprises the following steps: acquiring multi-source data containing user behavior data flow and advertisement delivery index flow synchronously through a distributed collection engine, generating a time-space synchronous multi-dimensional data cube; decoupling the multi-dimensional data cube to output a dynamic feature topology network with weights; inputting the dynamic feature topology network into an adversarial training framework to finally output an advertisement conversion probability space-time distribution graph; deploying a real-time feedback attribution calculation unit based on the advertisement conversion probability space-time distribution graph to generate an incremental attribution graph with a confidence interval; inputting the incremental attribution graph into a strategy generation adversarial network to output a set of adversarial optimization advertisement delivery strategies meeting the Pareto optimality. The application can improve the accuracy and real-time performance of advertisement effect evaluation.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of artificial intelligence, in particular to an advertisement effect evaluation method and system based on artificial intelligence. BACKGROUND

[0002] With the rapid development of digital advertising, traditional advertisement effect evaluation methods mainly rely on manual statistics or simple data analysis models, which are difficult to cope with massive, multi-source and high-dimensional advertising data. Existing technologies usually cannot effectively handle the temporal and spatial differences between data, resulting in inaccurate attribution results, and the optimization of advertising placement strategies often lacks dynamic adjustment capability, making it difficult to adapt to real-time changes in user behavior and market environment. SUMMARY

[0003] The purpose of the present application is to provide an advertisement effect evaluation method and system based on artificial intelligence to solve the problems in the prior art and improve the accuracy and real-time performance of advertisement effect evaluation.

[0004] One embodiment of the present application provides an advertisement effect evaluation method based on artificial intelligence, which comprises:

[0005] Synchronously acquiring multi-source data containing user behavior data stream and advertising placement index stream through a distributed collection engine, eliminating the time offset of multi-source data by using a timestamp-driven event window alignment algorithm, and generating a spatio-temporally synchronized multi-dimensional data cube;

[0006] Decoupling the multi-dimensional data cube, separating a stable feature set and a transient feature set through a cross-attention mechanism, and modeling the nonlinear interaction between features using a graph neural network to output a dynamic feature topology network with weights;

[0007] Inputting the dynamic feature topology network into an adversarial training framework, wherein the generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, and the discriminator of the adversarial training framework compares the hidden space difference between the real conversion path and the virtual conversion path to iteratively optimize the model parameters, and finally outputs an advertisement conversion probability spatio-temporal distribution map;

[0008] Based on the advertisement conversion probability spatio-temporal distribution map, deploying a real-time feedback attribution calculation unit, simulating the evolution process of user decision-making paths through Monte Carlo tree search, dynamically updating the contribution weights of each touch point, and generating an incremental attribution map with confidence intervals;

[0009] The incremental attribution graph is input into a strategy generation adversarial network, a generator of the strategy generation adversarial network is used to synthesize a multi-dimensional advertising delivery strategy vector under a constraint condition, a discriminator of the strategy generation adversarial network verifies the strategy effectiveness in combination with historical ROI data, and an optimal advertising delivery strategy set that satisfies Pareto is output.

[0010] Optionally, the multi-source data containing user behavior data streams and advertising delivery index streams are synchronously acquired through a distributed collection engine, time offset of the multi-source data is eliminated by using a timestamp-driven event window alignment algorithm, and a spatiotemporal synchronous multi-dimensional data cube is generated, including:

[0011] According to user terminal burying point logs and advertising server interface streams, a clock drift compensation algorithm is used to align original timestamps, and multi-source data streams with unified time bases are generated;

[0012] Based on the multi-source data streams with unified time bases, user complete session tracks are intercepted through event-triggered sliding windows, and spatiotemporal correlation sequences of behavior events and advertising exposure events are extracted;

[0013] The spatiotemporal correlation sequences are input into an adaptive grid division engine, event density is aggregated according to a dynamic resolution, and an initial spatiotemporal event tensor is generated;

[0014] A low-rank tensor completion model is applied to the initial spatiotemporal event tensor, missing data blocks are repaired, and a complete multi-dimensional data cube is output.

[0015] Optionally, the multi-dimensional data cube is decoupled in features, stable feature sets and transient feature sets are separated through a cross-attention mechanism, and a dynamic feature topology network with weights is output by modeling nonlinear interaction relationships between features by using a graph neural network, including:

[0016] The multi-dimensional data cube is sliced into a feature vector set, mutual information entropy between features is calculated through a multi-head cross-attention mechanism, and a high-entropy interaction feature pair set is generated;

[0017] Based on the high-entropy interaction feature pair set, a spectral clustering algorithm is used to divide stable feature subsets and transient feature subsets;

[0018] A dynamic interaction graph structure is constructed according to the stable feature subsets and the transient feature subsets, wherein a node of the dynamic interaction graph structure represents a feature unit, and an edge weight of the dynamic interaction graph structure represents a feature transition probability;

[0019] The dynamic interaction graph is input into a time series graph neural network, a feature evolution path is modeled through a gated temporal convolution module, and a time series enhanced feature topology is output;

[0020] Gradient importance distillation is performed on the time-enhanced feature topology, a node influence factor is calculated, and a dynamic feature topology network with semantic weights is generated.

[0021] Optionally, the dynamic feature topology network is input into an adversarial training framework, wherein a generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, and a discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the hidden space difference between the real conversion path and the virtual conversion path, and finally outputs an advertisement conversion probability spatiotemporal distribution map, including:

[0022] Based on the dynamic feature topology network, a graph attention encoder is used to extract topology structure features, and a long short-term memory network is used to generate a virtual conversion path sequence;

[0023] A dual-channel discriminator module is constructed, wherein a first channel calculates the Mahalanobis distance between the real conversion path and the virtual conversion path in the hidden space, and a second channel verifies the compliance degree of the path logical constraint, and outputs a dual-channel difference matrix;

[0024] Generator parameters are iteratively optimized using the dual-channel difference matrix, and when the misjudgment rate of the discriminator for real / virtual conversion paths continuously decreases by less than a threshold value for a preset number of rounds, it is determined that the generator has reached a convergence state;

[0025] The converged generator is executed in the feature embedding space to perform Monte Carlo sampling, and an advertisement conversion probability spatiotemporal distribution heat map is output.

[0026] Optionally, based on the advertisement conversion probability spatiotemporal distribution map, a real-time feedback attribution calculation unit is deployed, the evolution process of the user decision path is simulated through a Monte Carlo tree search algorithm, the contribution weight of each touch point is dynamically updated, and an incremental attribution map with a confidence interval is generated, including:

[0027] The advertisement conversion probability spatiotemporal distribution map is mapped into a decision state tree, wherein the tree nodes of the decision state tree represent the advertisement touch points, and the edge weights of the decision state tree represent the conversion transition probability;

[0028] The evolution of the user decision path is simulated through an incremental Monte Carlo tree search algorithm, and the path access frequency distribution is recorded;

[0029] Based on the path access frequency distribution, a Shapley value is calculated, and the touch point contribution weight is dynamically updated using an exponential decay function;

[0030] The stability of the touch point contribution weight is evaluated using a bootstrap sampling method, and an attribution weight vector with a confidence interval is generated;

[0031] The attribution weight vector is converted into a dynamic force-directed graph structure, wherein the node size of the dynamic force-directed graph structure represents the attribution weight, and the edge transparency represents the transition probability strength, and finally an incremental attribution map is output.

[0032] Optionally, the incremental attribution graph input strategy is generated using a strategy generation adversarial network, a generator of the strategy generation adversarial network synthesizes a multi-dimensional advertising delivery strategy vector under a constraint condition, a discriminator of the strategy generation adversarial network verifies the strategy effectiveness in combination with historical ROI data, and outputs a set of adversarial optimization advertising delivery strategies satisfying the Pareto optimality, including:

[0033] The node weight and edge transition probability of the incremental attribution graph are encoded into a graph constraint matrix, which is input into the graph convolution coding layer of the strategy generator;

[0034] The strategy generator fuses the graph constraint matrix and the historical ROI data, and synthesizes a multi-dimensional advertising delivery strategy vector through a conditional adversarial generation mechanism;

[0035] The strategy discriminator receives the strategy vector, performs three-order verification in combination with the historical ROI database, and outputs a three-dimensional effectiveness score matrix, wherein the three-order verification includes: budget constraint verification: strategy total cost and historical cost distribution comparison; conversion gain verification: strategy expected conversion rate and historical benchmark difference; risk entropy verification: Sharpe ratio calculation of strategy combination;

[0036] According to the effectiveness score matrix, the strategy generator is iteratively optimized, and when the distribution density of the multi-dimensional advertising delivery strategy vector on the Pareto frontier reaches saturation, a non-dominated solution set is extracted as a set of adversarial optimization advertising delivery strategies satisfying the Pareto optimality.

[0037] Another embodiment of the present application provides an artificial intelligence-based advertising effect evaluation system, which comprises:

[0038] An acquisition module is configured to synchronously acquire multi-source data containing user behavior data streams and advertising delivery index streams through a distributed acquisition engine, eliminate time offset of the multi-source data by using a timestamp-driven event window alignment algorithm, and generate a spatiotemporally synchronized multi-dimensional data cube;

[0039] A separation module is configured to decouple features of the multi-dimensional data cube, separate a stable feature set and a transient feature set through a cross-attention mechanism, and output a dynamic feature topology network with weights by modeling nonlinear interaction relationships between the features using a graph neural network;

[0040] A generation module is configured to input the dynamic feature topology network into an adversarial training framework, wherein a generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, a discriminator of the adversarial training framework compares hidden space differences between a real conversion path and the virtual conversion path to iteratively optimize model parameters, and finally outputs a spatiotemporal distribution map of advertising conversion probability;

[0041] The simulation module is used to deploy a real-time feedback attribution calculation unit based on the spatiotemporal distribution map of the advertising conversion probability, simulate the evolution of the user decision path through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution map with confidence intervals.

[0042] The output module is used to input the incremental attribution graph into the strategy generative adversarial network, use the generator of the strategy generative adversarial network to synthesize a multi-dimensional advertising strategy vector under constraints, and use the discriminator of the strategy generative adversarial network to verify the effectiveness of the strategy in combination with historical ROI data, and output a set of adversarial optimized advertising strategies that satisfy Pareto optimality.

[0043] Another embodiment of this application provides a storage medium storing a computer program, wherein the computer program is configured to execute the method described in any of the preceding claims when running.

[0044] Another embodiment of this application provides an electronic device including a memory and a processor, wherein the memory stores a computer program and the processor is configured to run the computer program to perform the method described in any of the preceding claims.

[0045] Compared with existing technologies, this invention provides an AI-based advertising effectiveness evaluation method. It synchronously acquires multi-source data, including user behavior data streams and advertising performance metrics streams, through a distributed acquisition engine, generating a spatiotemporally synchronized multidimensional data cube. The multidimensional data cube is then decoupled to output a weighted dynamic feature topology network. This dynamic feature topology network is input into an adversarial training framework, ultimately outputting a spatiotemporal distribution map of advertising conversion probabilities. Based on this spatiotemporal distribution map, a real-time feedback attribution calculation unit is deployed to generate an incremental attribution graph with confidence intervals. This incremental attribution graph is then input into a strategy generation adversarial network, outputting a Pareto-optimal set of adversarial optimized advertising strategies, thereby improving the accuracy and real-time performance of advertising effectiveness evaluation. Attached Figure Description

[0046] Figure 1 A hardware structure block diagram of a computer terminal for an artificial intelligence-based advertising effectiveness evaluation method provided in an embodiment of the present invention;

[0047] Figure 2 A flowchart illustrating an artificial intelligence-based advertising effectiveness evaluation method provided in an embodiment of the present invention;

[0048] Figure 3 This is a schematic diagram of the structure of an artificial intelligence-based advertising effectiveness evaluation system provided in an embodiment of the present invention. Detailed Implementation

[0049] The embodiments described below with reference to the drawings are exemplary and are used only to explain the present application, and cannot be explained as a limitation of the present application.

[0050] The embodiment of the present application first provides an advertisement effect evaluation method based on artificial intelligence, which can be applied to an electronic device such as a computer terminal, specifically, a general computer and the like. The following will be described in detail taking the computer terminal as an example. Figure 1 The hardware structure block diagram of the computer terminal of the advertisement effect evaluation method based on artificial intelligence provided by the embodiment of the present application is shown in FIG. 1. Figure 1 As shown in the figure, the computer device includes a processor, a memory and a network interface connected through a system bus, wherein the memory can include a non-volatile storage medium and an internal memory.

[0051] The non-volatile storage medium can store an operating system and a computer program. The computer program includes program instructions, which, when executed, can cause the processor to execute any kind of advertisement effect evaluation method based on artificial intelligence. The processor is used to provide computing and control capability to support the operation of the entire computer device. The internal memory provides an environment for the running of the computer program in the non-volatile storage medium, which, when executed by the processor, can cause the processor to execute any kind of advertisement effect evaluation method based on artificial intelligence. The network interface is used for network communication, such as sending assigned tasks and the like. Those skilled in the art can understand that Figure 1 The structure shown in the figure is only a block diagram of part of the structure related to the scheme of the present application, and does not constitute a limitation on the computer device to which the scheme of the present application is applied. The specific computer device can include more or less components than those shown in the figure, or combine certain components, or have a different component arrangement.

[0052] It should be understood that the processor can be a central processing unit (CPU), and the processor can also be other general-purpose processors, digital signal processors (DSP), application specific integrated circuits (ASIC), field programmable gate arrays (FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components, etc. Among them, the general-purpose processor can be a microprocessor or the processor can also be any conventional processor, etc.

[0053] Referring to Figure 2 , the embodiment of the present application provides an advertisement effect evaluation method based on artificial intelligence, which can include the following steps:

[0054] S201 synchronously acquires multi-source data, including user behavior data streams and advertising delivery metric streams, through a distributed acquisition engine. It uses a timestamp-driven event window alignment algorithm to eliminate time offsets in the multi-source data and generate a spatiotemporally synchronized multi-dimensional data cube. Specifically, it can align the original timestamps with the user terminal tracking logs and advertising server interface streams using a clock drift compensation algorithm to generate a multi-source data stream with a unified time base.

[0055] During system initialization, tracking loggers deployed on user terminals (such as mobile apps and web pages) continuously record user behavior events (such as clicks, browsing duration, and page jumps), while the advertising platform's ad server interface stream outputs real-time advertising metrics (such as CPM, CTR, and CPC). These two data sources have inherent time discrepancies: user terminal clocks may drift due to device sleep mode, and there are millisecond-level time differences between server clusters. To address this issue, the system implements a clock drift compensation algorithm. This algorithm first deploys a high-precision Network Time Protocol (NTP) server in the data center, with a time error not exceeding 1 millisecond. All user tracking logs are appended with a local timestamp (LT) upon transmission, while the ad server records a server timestamp (ST) when the data packet is generated. The compensation algorithm uses the NTP server time as the reference time (RT) to calculate the clock offset (CO) for each data source. For example, the time deviation (LT) from the time base time (RT) of a mobile terminal is +350 milliseconds, while the time deviation (ST) from the time base time (RT) of an advertising server is -120 milliseconds. The system maintains a dynamic offset matrix for each data source, and performs real-time compensation and correction on the original timestamp (adding or subtracting the corresponding offset from the original timestamp), ultimately outputting a corrected timestamp (CT) that is strictly synchronized with the reference time. This process is executed thousands of times per second, ensuring that the time deviation of massive data streams is compressed to the millisecond level.

[0056] The key of clock drift compensation is the continuous update of dynamic offset. The system deploys a Heartbeat Calibration Agent at each data collection node (user device or server). The agent sends a Synchronization Request Packet to the NTP server every fixed period (e.g. 30 seconds), records the request sending local time (T1), NTP server receiving time (T2), NTP server response time (T3), and agent receiving response time (T4). By calculating the Round-Trip Delay (RTD = (T4 - T1) - (T3 - T2)) and the clock offset (CO = [(T2 - T1) + (T3 - T4)] / 2), the offset matrix is dynamically updated. To cope with network jitter, the system uses the Exponential Weighted Moving Average (EWMA) algorithm to smooth the historical offset data. For example, the newly calculated offset CO_new is fused with the historical value CO_old by a weight coefficient a = 0.2: CO_updated = a x CO_new + (1 - a) x CO_old. At the same time, a maximum allowed time difference threshold (MAX_DeltaT = 500 milliseconds) is set, and if the calculated offset exceeds the threshold, an abnormal alarm is triggered and the system switches to a backup NTP server cluster. All corrected time stamps (CT) are attached with a unique Session ID (SID) to form a Time-Aligned Multisource Data Stream, laying the foundation for subsequent event correlation.

[0057] In practical applications, extreme scenarios need to be handled, for example, a user device generates a large range of time jumps in the flight mode. The system adds an event sequence number (ESN) in the buried point log. When detecting the time stamp interval anomaly (such as more than 1 hour) between adjacent events and the sequence number is not continuous, the time backtracking verification module is started. The module combines the last valid network time reported by the device, the local event density (such as the number of triggered events per second), and the time sequence received by the server side, matches multi-dimensional time characteristics through the dynamic time warping algorithm (DTW), and reconstructs a reasonable time axis. For example, a user browses an advertisement and disconnects the network for 10 minutes, during which 3 local click events are generated. According to the event operation interval (such as a click interval of 2 seconds) and the last recorded network time on the server side, the system automatically interpolates to generate a compensation time stamp. Finally, the time synchronization error rate (TimeSync Error Rate) of all data streams is controlled below 0.01%, ensuring the accurate alignment of cross-platform behavior and advertisement exposure events.

[0058] Based on the time reference uniformity of multi-source data streams, the user complete session trajectory is intercepted through the event triggered sliding window, and the spatio-temporal correlation sequence of behavior events and advertisement exposure events is extracted.

[0059] The time-synchronized data stream enters the Session Trajectory Builder. This engine defines the Session Start Event, including: the user opens the APP, jumps to the ad landing page from an external link, or more than 30 minutes from the last event (i.e. session timeout time TS = 1800 seconds). When the start event is detected, a dynamic sliding window (DSW) is immediately created. The window length (WL) is initialized to the default value of 300 seconds, but will be extended in real time according to user behavior: for example, when the user triggers the "add to cart" event, the window is automatically extended to 600 seconds to accommodate possible decision delays. Within the window period, the engine continuously captures two types of key data: 1) User Behavior Sequence, including page scroll depth, button click coordinates, dwell time; 2) Ad Exposure Sequence, including ad slot ID, creative hash, exposure duration. Each event carries a corrected timestamp CT and a geohash (GH).

[0060] The core of spatio-temporal association is the Event Chain Fusion Algorithm. This algorithm first arranges all events in the sliding window in ascending order of time, and then performs three levels of association:

[0061] Temporal proximity association: if the interval between the end time of ad exposure and the start time of behavior event is less than the threshold AT1 = 200 milliseconds, it is determined to be a direct trigger (such as closing the ad immediately after clicking the purchase button);

[0062] Spatial overlap association: when the ad overlay covers the page button, calculate the intersection over union (IoU) of the two in the screen coordinate system, if IoU > 0.6 and the interval between events < AT2 = 1 second, establish a strong spatial association; Behavior pattern association: identify behavior patterns (such as "ad exposure -> page scrolling -> multiple price comparisons -> click to purchase") through a pre-trained Hidden Markov Model (HMM), output the state transition probability matrix.

[0063] Spatio-Temporal Association Sequence (STAS) is finally generated, whose data structure is: [timestamp CT, event type, ad ID, behavior type, geohash GH, association strength value AS (0~1)].

[0064] To handle high concurrency scenarios, the system uses a Distributed Session State Machine. Each user session is assigned an independent partition key (Partition Key = User ID + Session ID), and the event stream is stored in Kafka message queues by partition. The trigger and closing of the sliding window are dynamically managed by the Event Stream Processor: when there are no new events for 5 seconds continuously (i.e., the silence timeout threshold QT = 5 seconds) or the window length reaches the maximum value MAX WL = 1200 seconds, the current window is automatically closed and the trajectory compression is triggered. The compression process uses the Critical Path Extraction algorithm, which retains event nodes related to conversion targets (such as orders, registrations) with a correlation coefficient greater than 0.3 and removes irrelevant noise events (such as accidental clicks). Finally, each session outputs a weighted spatio-temporal association sequence as an atomic unit for subsequent analysis.

[0065] The spatio-temporal association sequence is input into the adaptive grid partitioning engine, which aggregates event density according to dynamic resolution to generate an initial spatio-temporal event tensor.

[0066] The core task of the Adaptive Grid Partitioning Engine is to solve the problem of data sparsity. After receiving the spatio-temporal association sequence (STAS), the engine first establishes a three-dimensional coordinate system: the X-axis is the time dimension (unit: minute), the Y-axis is the geospatial dimension (Geohash precision: 7 bits, approximately 150 meters grid), and the Z-axis is the event type dimension (encoded as a 32-dimensional one-hot vector). The initial grid resolution is set to a fixed value (e.g., time bucket 1 minute, geographic grid 1 square kilometer), but will be dynamically adjusted according to the event density:

[0067] Temporal dimension: In peak hours (e.g., 20:00-22:00), when the number of events in a 1-minute bucket exceeds a threshold (e.g., 1000), automatically split into 30-second sub-buckets; Spatial dimension: For urban commercial district areas (e.g., Geohash prefix wx4g), when the grid event density > 50 times / square kilometer, increase the Geohash precision to 8 bits (about 38-meter grid); Event dimension: Use Principal Component Analysis (PCA) for dimension reduction, retaining 16 principal components with cumulative variance contribution rate > 85%.

[0068] Dynamic resolution adjustment relies on the Density Peak Detection algorithm. This algorithm calculates the local density (Local Density, LD = number of events in the cell / cell volume) and relative distance (Delta Distance, DD = distance to the nearest high-density cell) of each grid cell. A density peak point is defined as meeting the following conditions simultaneously: LD > 2 times the average density (LD_threshold = 2 × LD_mean) and DD > system set distance threshold (e.g., DD_min = 5 kilometers). When a peak point is detected, the engine performs Quadtree Splitting with the point as the center: divide the current grid into 4 sub-grids (time or space dimension), and recalculate the density of the sub-grids. For example, a certain commercial district grid has LD = 120 times / cubic kilometer in the 19:30 bucket (far exceeding the average of 40 times), so it is divided into 4 sub-grids of 500 × 500 meters. The reverse process also exists: if the sub-grid has LD < LD_mean × 0.5 for 3 consecutive periods, it is merged into the parent grid.

[0069] After grid aggregation, an initial spatio-temporal event tensor (Initial Spatio-Temporal Event Tensor, ISET) is generated. The tensor is a four-dimensional structure: [time bucket index × geographic grid index × event type principal component × statistical indicator]. The statistical indicators include:

[0070] Event Count (EC); Conversion Rate (CR = number of conversion events / total number of events); Mean Association Strength (MAS).

[0071] Tensor filling employs Nearest Neighbor Interpolation: for new cells generated by grid splitting, 80% of the data from the parent cell is inherited, and 20% of the neighborhood mean is superimposed. The final output tensor size is dynamically variable, with a typical size of [number of time buckets T=1440] × [number of geographic grids G=5000] × [event dimension E=16] × [number of indicators M=3], achieving efficient storage through tensor slicing technology.

[0072] A low-rank tensor completion model is applied to the initial spatiotemporal event tensor to repair missing data blocks and output a complete multidimensional data cube.

[0073] The initial spatiotemporal event tensor (ISET) suffers from missing data (e.g., undocumented data in remote grid areas). The system employs a Low-Rank Tensor Completion Model (LRTCM) to address this issue. The model assumes the complete tensor can be decomposed into a Tucker decomposition of three low-rank matrices: the product of the core tensor and factor matrices. The model sets the rank parameters to [R_time=10, R_geo=8, R_event=5] and solves iteratively using Alternating Least Squares (ALS).

[0074] The completion process includes three stages of optimization:

[0075] Missing data labeling: A binary mask tensor is created, and grid events below a confidence threshold (e.g., EC < 5) are marked as missing; Weighted regularization optimization: A spatio-temporal smoothness constraint is added to the objective function to penalize drastic changes in adjacent grids; Incremental update: When a new real-time data stream is added, local completion is performed only on the affected grids (within a 5km radius of the new event coverage) to reduce computational cost. The completion effect is evaluated using a dual verification mechanism.

[0076] Internal validation: Randomly hide 10% of the known data and calculate the root mean square error (RMSE) between the completed value and the original value. The requirement is that RMSE < 0.15. External validation: Compare the advertising conversion rate of the completed area with the results of manual sampling survey. The error threshold is set to ±5%.

[0077] The final output is a complete multidimensional data cube, whose data structure includes: time layer: 5-minute bucket aggregation; spatial layer: unified Geohash precision level 7; event layer: 16-dimensional principal component vector; and index layer: completed EC / CR / MAS values. This cube serves as the input for subsequent feature decoupling, ensuring that all analysis unit data is complete and spatially continuous.

[0078] In S202, the multidimensional data cube is decoupled into features, and a stable feature set and a transient feature set are separated by a cross-attention mechanism. A graph neural network is used to model the nonlinear interaction between features, and a dynamic feature topology network with weights is output. Specifically, the method can include:

[0079] In S2021, the multidimensional data cube is sliced into a feature vector set, and the mutual information entropy between features is calculated by a multi-head cross-attention mechanism to generate a high-entropy interaction feature pair set.

[0080] The three-dimensional structure of the multidimensional data cube corresponds to the time dimension (user behavior sequence), the spatial dimension (ad touch position), and the feature dimension (behavior index and ad index). The system first uses a sliding window slicing technique to extract data segments at a fixed step (e.g., every 5 minutes) along the time axis. Each segment is flattened into a feature vector (Feature Vector) containing hundreds of feature values such as user click rate, exposure duration, and conversion signals at all spatial positions in that period. These feature vectors form a feature vector set (Feature Vector Set, FVS). Then, the system starts a multi-head cross-attention mechanism (Multi-head Cross Attention Mechanism, MCAM). This mechanism includes multiple parallel computing heads (usually 8-16), each of which independently calculates the correlation of different feature subspaces. For example, one attention head focuses on user behavior features (such as page dwell time and scroll depth), and another head focuses on ad features (such as creative type and bidding strategy). Within each head, a similarity matrix (Similarity Matrix, SM) is calculated by querying (Query, Q), key (Key, K), and value (Value, V) triplets. Specifically, two feature vectors (such as "ad click rate" and "page bounce rate") are mapped to Q and K vectors, respectively. The dot product of the two vectors is normalized by Softmax to generate an attention weight (Attention Weight, AW), which reflects the association strength of the two features in the current context.

[0081] Based on the attention weights, the system further calculates the mutual information entropy (MIE) between the features. Mutual information entropy measures the statistical dependence of two feature variables. For example, if the MIE value of "advertising exposure frequency" and "add-to-cart behavior" is higher than a threshold (such as 0.35), it indicates that there is a strong association between the two. The calculation process uses a non-parametric estimation method: first, a joint probability distribution table (JPDT) is constructed based on the attention weights to record the co-occurrence frequency of feature pairs; then, the entropy value (EV) is calculated based on the JPDT. Each attention head outputs a high-entropy candidate set (HECS) containing the top 10% of feature combinations in terms of MIE value (such as the "search keyword matching degree-CTR" pair). Finally, the multi-head results are fused through weighted voting fusion (WVF) to generate a global high-entropy interaction feature pair set (HEIFPS). Each entry in this set contains a pair of feature identifiers and their normalized MIE value (range 0 to 1), such as the entry "Feature A-ID: CTR, Feature B-ID: CPA, MIE: 0.78".

[0082] To improve computational efficiency, the system uses a dynamic pruning strategy (DPS). During the attention weight calculation phase, if the Euclidean distance (ED) between two feature vectors exceeds a pre-set radius (such as 3.5 standard deviations), the subsequent MIE calculation is skipped. At the same time, a feature importance cache (FIC) is introduced, which directly reuses the cache results for high-frequency and high-entropy feature pairs (such as "ad position-user device type") in history, reducing real-time calculation. The final generated HEIFPS set is used as the core input for subsequent feature decoupling, with a sparse matrix (SMX) data format, where the row / column indices correspond to feature IDs, and the matrix element values are MIE scores.

[0083] S2022, based on the high-entropy interaction feature pair set, a spectral clustering algorithm is used to divide stable feature subsets and transient feature subsets;

[0084] High-entropy interaction feature pairs set (HEIFPS) essentially describes the nonlinear correlation network between features. The system models this network as a weighted undirected graph (WUG): nodes (ND) represent individual features (e.g., "user region"), edges (ED) connect feature pairs with high MIE values, and edge weights (EW) are MIE values (e.g., 0.68). The core of the spectral clustering algorithm (SCA) is to divide the graph into two subgraphs (stable feature subset (SFS) and transient feature subset (TFS)). First, construct the Laplacian matrix (LM) of the graph: the diagonal elements are node degrees (DG, the sum of connected edge weights), and the non-diagonal elements are negative edge weights. For example, the DG value of the node "ad creative ID" is the sum of its MIE with all other features.

[0085] Eigen decomposition (ED) is performed on the Laplacian matrix, and the eigenvectors (EV) corresponding to the first k smallest eigenvalues (SEV) are extracted. Here, k is fixed at 2, corresponding to two clusters. The second smallest eigenvector (SSEV) is used as the basis for division: after sorting the nodes by SSEV component values, perform a binary cut (BC). For example, nodes with component values greater than 0 are classified as SFS, and nodes with component values less than 0 are classified as TFS. Stable features (SFS) usually have time invariance (e.g., user portrait attributes), and their correlation network is dense and balanced in weight; transient features (TFS) fluctuate dramatically over time (e.g., real-time bidding price), and their correlation network is sparse and concentrated in weight. When performing actual segmentation, modularity optimization (MO) is added: calculate the modularity score (MS, range -1 to 1) for different cutting points, and select the cutting scheme that maximizes MS (target MS > 0.4).

[0086] To enhance robustness, the system performs Multi-scale Validation (MSV). The HEIFPS set is reconstructed with different similarity thresholds (e.g. MIE > 0.3, > 0.5, > 0.7) and the spectral clustering process is repeated. If the Consistency Rate (CR) of feature subset division at each scale is more than 85% (e.g. "user age" always belongs to SFS, "current session" always belongs to TFS), the result is reliable. Finally, two feature subsets are output: SFS contains node list (e.g. feature ID list [101, 205, 307]) and its type label "stable", TFS contains node list (e.g. [402, 518]) and label "transient".

[0087] S2023, constructing a dynamic interaction graph structure according to the stable feature subset and the transient feature subset, wherein a node of the dynamic interaction graph structure represents a feature unit, and an edge weight of the dynamic interaction graph structure represents a feature transition probability;

[0088] Based on the divided SFS and TFS, the system constructs a dynamic interaction graph (DIG). The node set (Node Set, NS) contains all feature units (Unit Feature, UF), and each node stores feature metadata (Metadata, MD): feature ID, name (e.g. "impression_count"), type (stable / transient), and statistics (mean, variance). The generation of the edge set (Edge Set, ES) follows the Causal Inference Principle (CIP): the transfer entropy (Transfer Entropy, TE) algorithm is used to calculate the influence direction and strength between features. For example, the transfer entropy value (e.g. 0.42) from "ad impression count" (node A) to "page dwell time" (node B) is used as the edge weight, representing the causal influence of A on B.

[0089] Dynamicity is reflected in the time-varying property (Time-varying Property, TVP) of the edge weight. The system calculates the transfer entropy in a time window (e.g. 1 hour) as the granularity:

[0090] Data alignment: extract the feature value sequence (e.g. [1.2, 0.8, 1.5]) of SFS and TFS within the window; probability estimation: calculate the joint probability distribution by kernel density estimation (Kernel Density Estimation, KDE). Entropy calculation:

[0091] TE_{A→B}=Σp(b_{t+1},b_t,a_t) log2[p(b_{t+1}|b_t,a_t) / p(b_{t+1}|b_t)]Output Entropy. The result updates the edge weight matrix (EWM) in real time, for example, the edge weight of A→B is updated to 0.39 at time t. At the same time, a weight decay mechanism (WDM) is established: the historical weights are exponentially decayed (decay factor 0.95), ensuring that the graph structure reflects the latest dynamics.

[0092] The graph structure is optimized by small-world network restructuring (SWNR). First, remove weakly connected edges with weights below a threshold (e.g., 0.1) to reduce noise; second, add hub edges (HE) across subsets: select the nodes with the highest degree centrality (DC) in SFS and TFS (e.g., "user interest tags" in SFS and "real-time bid ranking" in TFS), and forcibly add bidirectional connections with an initial weight of 0.5. The final DIG is stored as an adjacency list (AL), with an example format: Node ID: 102 [Type: stable]; Neighbor List: → Node ID: 305 [Weight: 0.76]; → Node ID: 411 [Weight: 0.58].

[0093] S2024, input the dynamic interaction graph into the temporal graph neural network, model the feature evolution path through the gated temporal convolution module, and output the temporal enhanced feature topology;

[0094] The dynamic interaction graph (DIG) is input, and its temporal graph neural network (TGNN) contains three layers of processing:

[0095] 1. Graph Convolutional Layer (GCL):

[0096] GATv2 is used. When aggregating neighbor information for each node, weighted summation is performed through attention mechanism (AM). For example, node "click rate" aggregates the feature vectors of its neighbors "exposure" (weight 0.7) and "ad position" (weight 0.3). The output is a node embedding vector (NEV) with a dimension of 256.

[0097] 2. Gated Temporal Convolution Module (GTCM):

[0098] Process the evolution of node features along the time axis. The module contains two parallel branches:

[0099] Causal Convolution Branch (CCB): uses a one-dimensional convolution kernel (width 3) to slide along time and extract local patterns (e.g., "the upward trend of conversion rate within 5 minutes after exposure"); Gating Mechanism Branch (GMB): generates gating values (range 0-1) through a Sigmoid function to control information transmission (e.g., a gating value of 0.8 means retaining 80% of the historical state); the outputs of the two branches are multiplied element-wise (Element-wise Multiplication, EM) to form temporal enhanced features (Temporal Enhanced Feature, TEF). For example, for the "add-to-cart rate" node, output its 24-time-step evolution vector sequence.

[0100] 3. Topology Fusion Layer (TFL):

[0101] Fuse the spatial topology relationship output by GCL with the temporal evolution features output by GTCM. Use Gated Recurrent Unit (GRU) as the fusioner: use NEV as the initial state and TEF as the input sequence to iteratively update the node state. Finally, output the Temporal Enhanced Feature Topology (TEFT), which has a three-dimensional tensor structure: dimension 1: node ID (total 150 features); dimension 2: time step (length 24); dimension 3: feature embedding (dimension 256).

[0102] This topology fully captures the nonlinear interaction of features in the space-time dimension (e.g., "after the ad creative is replaced, how does the user's click behavior affect the conversion decision over time").

[0103] S2025, perform gradient importance distillation on the Temporal Enhanced Feature Topology to calculate the node influence factor and generate a dynamic feature topology network with semantic weights.

[0104] The goal of Gradient Importance Distillation (GID) is to quantify the contribution of each feature node to the final prediction target (ad conversion). The system uses the Integrated Gradient (IG) method:

[0105] Baseline Input (BI): All features take the mean value (e.g., click rate = 1.2%); define the Prediction Function (PF): convert the TEFT input into a fully connected layer (128 neurons) output into a probability; Path Integral (PI): along the straight path from BI to Actual Input (AI), accumulate the gradient change. The result is the Integrated Gradient Value (IGV) of each node, for example, the IGV of the node "user historical purchase frequency" is 0.35.

[0106] Node Influence Factor (NIF) is obtained by normalization:

[0107] Absolute Value Transformation (AVT): take the absolute value of IGV (|IGV|); Softmax Normalization (SN): NIF_i = e^{|IGV_i|} / Σ_j e^{|IGV_j|}. The resulting NIF value ranges from 0 to 1 and the sum is 1, representing the relative importance of the node. For example: node "ad relevance score": NIF = 0.28; node "current network delay": NIF = 0.03.

[0108] Generate a Semantically Weighted Dynamic Feature Topology Network (SWDFTN):

[0109] Node weight injection: write NIF values as node attributes to TEFT, e.g. node ID:205's metadata adds a field weight:0.28; Edge weight amplification: amplify the weight of edges connecting high NIF nodes (Amplification Factor, AF=1.2); Topology compression: reduce the 256-dimensional embedding to 3-dimensional by t-SNE algorithm for visualization. The final network is stored in graph database (e.g. Neo4j) format, containing: 150 nodes (including ID, name, type, NIF value); 2300 edges (including source node, target node, transition probability value). This network can directly serve ad conversion prediction and attribution analysis, for example, the top 5% nodes with the highest NIF value (such as "user intent recognition confidence") are pushed to the strategy engine as key decision factors.

[0110] S203, input the dynamic feature topology network into an adversarial training framework, wherein a generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, and a discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the hidden space difference between the real conversion path and the virtual conversion path, and finally outputs an ad conversion probability spatiotemporal distribution map; specifically, it can include:

[0111] S2031, based on the dynamic feature topology network, extracting topology structure features through a graph attention encoder, and generating a virtual conversion path sequence by fusing a long short-term memory network;

[0112] The dynamic feature topology network is input into the generator module of the adversarial training framework. The network is composed of nodes with semantic weights (representing user attributes, ad features, etc.) and edges with weights (representing feature transition probabilities). The generator first uses a graph attention encoder (GAE) to process the network. The core of GAE is a multi-head attention mechanism (e.g. 8 heads), each head independently calculates the attention coefficient between nodes. Specifically, for each target node (such as a node representing a "25-35 year old male user"), the encoder calculates the association strength between it and its neighbor nodes (such as a node representing "clicked a car ad"). The strength is determined by three parts: the node's own weight (such as a user node weight of 0.85), the edge weight (such as a transition probability of 0.7), and the similarity of node features calculated through a learnable parameter matrix (such as a 256x256 matrix). Each attention head outputs a weighted aggregated neighbor feature vector (dimension 128), and the outputs of the 8 heads are concatenated and fused through a linear layer (output dimension 256) to form the topology structure feature vector of the node. This process traverses all nodes, and finally generates a topology representation of the entire graph (dimension: node number x 256).

[0113] Topological features need to be combined with temporal behaviors to generate paths. The system treats each user session as a time series (e.g., touchpoint 1: exposure to ad A (timestamp T1), touchpoint 2: click on ad B (T2),..., touchpoint N: conversion (TN)). Long Short-Term Memory (LSTM) networks are introduced to handle such sequences. LSTM units (e.g., hidden layer dimension 128) receive inputs step-by-step in time steps. The input at each time step is composed of two parts: 1) features of the current touchpoint event (e.g., ad type encoding, page dwell time, dimension 50); 2) topological features of the node corresponding to this touchpoint (dimension 256). LSTM selectively remembers long-term dependencies (e.g., early exposure effects) and short-term patterns (e.g., consecutive clicks) through mechanisms of Input Gate, Forget Gate (threshold initialized to 0.6), Output Gate, and Cell State. For example, when processing the “add to cart” touchpoint, the Forget Gate might reduce the memory strength of the “browse home page” event 5 minutes ago (output value 0.3), while the Input Gate strengthens the association of the current event with the “high purchase propensity” topological feature (output value 0.9). LSTM outputs a Hidden State (dimension 128) at each time step, which encodes the path context up to the current touchpoint.

[0114] The generation of Virtual Conversion Path Sequences (VCPS) is a self-recursive process. The system takes the topological features and event features of the starting event (e.g., “first ad exposure”) as initial inputs, feeding them into LSTM to get the first Hidden State H1. A policy network (e.g., two fully connected layers, output dimension equal to the number of event types) in the generator receives H1, outputting a probability distribution (e.g., {“click on ad A”: 0.4, “close page”: 0.5, “jump to detail page”: 0.1}). The next virtual event type is sampled (e.g., using Gumbel-Softmax sampling technique, temperature parameter 0.8) according to this distribution. The event type is encoded as a feature vector and concatenated with the topological features of the corresponding node in the graph as the input for the next time step LSTM. This process iterates until a “conversion” (e.g., purchase) event is generated or a preset maximum path length (e.g., 20 steps) is reached. The final output is a virtual user path composed of artificially constructed event types and their timestamps, e.g., [exposure to AdX(T0), click on AdY(T0+5s), browse product page 120s(T0+65s),..., payment success(T0+600s)].

[0115] S2032, a dual-channel discriminator module is constructed, wherein the first channel calculates the Mahalanobis distance of the real conversion path and the virtual conversion path in the latent space, and the second channel verifies the path logic constraint compliance, and outputs a dual-channel difference matrix;

[0116] The discriminator adopts a dual-channel architecture for multi-dimensional verification. The first channel focuses on latent space similarity measurement. The real conversion path (from historical logs) and the virtual conversion path (from the generator) are first sent to a feature extractor with shared weights (e.g., a graph attention encoder with the same structure as the generator GAE, but not sharing parameters), and mapped to a unified latent space (dimension 256). In this space, the first channel calculates the Mahalanobis distance between the two path representation vectors. Mahalanobis distance is different from Euclidean distance, as it takes into account the correlation between features. The discriminator maintains a trainable covariance matrix (dimension 256 by 256), which is learned during training by a large number of real paths (e.g., 1 million), representing the distribution structure of the latent space features. The distance calculation formula is: real path vector V_real minus virtual path vector V_virt, transpose the result, multiply the inverse of the covariance matrix, and then multiply (V_real - V_virt). The output is a scalar distance value D_maha (range 0 to positive infinity), and the smaller the value, the more similar the two paths are in the latent space.

[0117] The second channel focuses on Path Logical Constraint Compliance (PLCC) verification. The system pre-defines a set of business rules for a set of ad conversion paths (Rule Base Version 2.1), including temporal logic, causal logic, and statistical constraints. For example: Rule 1: "A user cannot generate a conversion before clicking on an ad" (strict temporal); Rule 2: "The conversion probability from 'add to cart' to 'payment success' is usually higher than 20%" (statistical constraint); Rule 3: "The same user repeatedly triggers the same exposure event within a short period of time (e.g., 1 minute) is invalid" (business logic). The second channel includes a rule engine and a lightweight temporal convolutional network (TCN). The rule engine directly performs symbolic matching on the path event sequence, and violates the hard rule (such as rule 1) and is marked as a serious violation (Penalty Score = 1.0). The TCN (such as 3 layers, convolution kernel size 3) processes the continuous features of the path (such as the time interval sequence, the event type code sequence), and learns the soft constraint pattern. The TCN outputs a violation probability score P_violate (between 0 and 1). The final score of PLCC S_plcc = hard violation score + P_violate (the larger the value, the more unreasonable the logic).

[0118] The Dual-Channel Difference Matrix (DCDM) is the core output of the discriminator. The matrix has a dimension of 2 by N (N is the number of path pairs processed in the current batch). The first row of the matrix stores the sequence of Mahalanobis distance values (D_maha) calculated by the first channel. The second row of the matrix stores the sequence of logical compliance scores (S_plcc) calculated by the second channel. For example, when processing a batch containing 128 real-virtual path pairs, the DCDM is a 2 by 128 matrix. Each value in the matrix is normalized (e.g., D_maha divided by the maximum value in the batch, S_plcc divided by 1.0). This matrix provides an explicit, differentiable signal for subsequent generator optimization: the goal of the generator is to generate virtual paths that make the D_maha values in the DCDM as small as possible (similar in the hidden space) and the S_plcc values as small as possible (logical and reasonable).

[0119] S2033, iteratively optimizing the generator parameters using the dual-channel difference matrix, and when the misjudgment rate of the discriminator for real / virtual conversion paths continuously decreases by a preset number of times below a threshold value, determining that the generator has reached a convergence state;

[0120] The optimization cycle of adversarial training is started. The generator generates a batch (Batch Size = 128) of virtual paths, and the discriminator processes the corresponding pairs of real and virtual paths, outputting a DCDM matrix (dimension 2 by 128). The generator parameter optimization is based on the first row of the DCDM (Mahalanobis distance D_maha). The system defines the generator loss function as the batch average of D_maha (Mean_D_maha). Through the backpropagation algorithm, the gradient of the loss function to all trainable parameters inside the generator (such as the weight matrix of the attention encoder, the unit parameters of the LSTM, and the connection weights of the policy network) is calculated. An adaptive optimizer (such as the Adam optimizer, learning rate 0.0001, first-order moment decay rate Beta1 = 0.9, and second-order moment decay rate Beta2 = 0.999) is used to update the parameters according to the gradient, with the goal of reducing Mean_D_maha and making the virtual path closer to the real path in the latent space.

[0121] The discriminator parameter optimization is more complex. Its loss function consists of two parts: 1) Discriminative Loss: requires the discriminator to correctly distinguish between real and virtual paths (label: real = 1, virtual = 0). After the discriminator maps the path to the latent space, it outputs a judgment probability P_real through a fully connected layer (output dimension 1) and a Sigmoid activation function. The discriminative loss uses binary cross entropy (BCE). 2) Regularization Term: based on the second row of the DCDM (S_plcc), encourages the discriminator to give a higher P_real to logically reasonable paths (whether real or virtual). The total loss of the discriminator = BCE loss + λ * S_plcc (λ is a weighting coefficient, such as 0.5). The discriminator parameters are also updated through backpropagation and the Adam optimizer, with the goal of improving both classification accuracy and logical sensitivity.

[0122] Convergence Criterion is the key step. After each round of training, the Misclassification Rate (MCR) is evaluated on an independent validation set (contains unseen real paths). MCR is defined as the proportion of real paths that are wrongly classified as "virtual" or virtual paths that are wrongly classified as "real". Two thresholds are set: a continuous round threshold (e.g., 10 consecutive rounds) and an MCR threshold (e.g., 0.15). The system maintains a counter (Counter), which is incremented by 1 when the validation MCR ≤ 0.15 in a certain round; otherwise, the counter is reset to zero. Only when the counter reaches 10, is the generator considered to have reached a Converged State. This mechanism ensures that the model meets the requirements in stability and generalization ability, preventing overfitting or training oscillation. After reaching convergence, the generator stops updating, and its ability to generate virtual paths is considered to have highly approximated real user behavior patterns.

[0123] S2034, the converged generator performs Monte Carlo sampling in the feature embedding space to output the ad conversion probability spatiotemporal distribution heat map.

[0124] Monte Carlo Sampling is performed using the converged generator to evaluate the conversion probability. The sampling is performed in the Feature Embedding Space, which is defined by the graph attention encoder of the generator. The target sampling area is divided by space (such as a city grid: 1km x 1km) and time (such as 15-minute intervals). For each spatiotemporal unit (e.g., "Zhongguancun, Haidian District, Beijing, 2023-10-25 14:00-14:15"), the following steps are performed: 1) According to the historical data distribution of the area in that period, a large number of (e.g., 10,000) virtual user seeds are generated. Each seed user contains basic features (e.g., typical age, gender, device type distribution sampled by mapping the area grid number). 2) The feature vectors of the seed users are input into the generator (converged GAE and LSTM) to simulate their complete decision-making path from the first ad exposure. 3) Record whether each path eventually reaches the "conversion" event.

[0125] Conversion Probability Calculation is based on the sampling results. For each spatio-temporal unit, the number of times of final conversion Count_conv in all (e.g., 10000 times) simulation paths is counted. The Ad Conversion Probability (ACP) of the unit is calculated as: ACP = Count_conv / total sampling times (e.g., 10000). For example, if 1200 paths finally convert in 10000 simulations, then ACP = 0.12 (i.e., 12%). This probability value comprehensively reflects the conversion possibility of the user group in the specific advertising environment (encoded in the dynamic feature topology network) in the specific geographical location and specific time period. The sampling times (e.g., 10000) directly affect the accuracy of the probability estimation, and the confidence interval can be estimated by the central limit theorem.

[0126] Finally, the Spatio-Temporal Heatmap of Conversion Probability is generated. The system constructs a three-dimensional grid data structure: two dimensions represent geographical space (e.g., longitude and latitude, resolution 1 km), and the third dimension represents time (e.g., 15-minute slices). Each grid cell stores the calculated ACP value (e.g., 0.12). Through a visualization engine (e.g., a WebGL-based renderer), these probability values are mapped to colors. A gradient color system (Color Map) is usually used, for example: dark blue represents low probability (ACP < 0.05), light green represents medium probability (0.05 ≤ ACP < 0.1), yellow represents higher probability (0.1 ≤ ACP < 0.15), and red represents high probability (ACP ≥ 0.15). The heat map supports dynamic playback along the time axis, and intuitively displays the high and low changes of the advertising conversion probability in different regions at different times (e.g., the business district presents a high probability "red zone" during the workday, and the residential area presents a "yellow zone" at night). This heat map is the final spatio-temporal distribution map of advertising conversion probability, providing core data basis for subsequent attribution and strategy optimization.

[0127] S204, based on the spatio-temporal distribution map of advertising conversion probability, a real-time feedback attribution calculation unit is deployed to simulate the evolution process of user decision-making paths through Monte Carlo tree search, dynamically update the contribution weights of each touch point, and generate an incremental attribution map with a confidence interval.

[0128] Specifically, the spatio-temporal distribution map of advertising conversion probability can be mapped to a decision state tree, where the tree nodes of the decision state tree represent advertising touch points, and the edge weights of the decision state tree represent conversion transition probabilities.

[0129] The system receives an advertising conversion probability spatio-temporal map (ACPM) generated by an adversarial training framework. The map is essentially a three-dimensional probability matrix with dimensions including a timestamp (accurate to the millisecond level), geographic coordinates (latitude and longitude grid), and advertising touchpoints (such as search ads, information stream ads, and opening screen ads). The construction of a decision state tree (DST) first requires defining tree nodes: each node corresponds to an advertising touchpoint (ATP), and the node attributes include touchpoint type, appearance time window (e.g., 0-5 seconds for the initial touchpoint), and spatial location (e.g., GPS grid number). Tree edges represent the user's path from one touchpoint to the next, and edge weights (EW) are calculated using conversion transition probabilities (CTP) from the spatio-temporal distribution map. Specifically, if the current touchpoint A is located in area L1 at time T1, and the next touchpoint B is located in area L2 at time T2, then the edge weight EW_AB is equal to the transition probability value of ACP from (T1, L1, A) to (T2, L2, B), and is subjected to an exponential decay function (the greater the time difference, the lower the weight) and normalization processing (to ensure that the sum of the edge weights of the child nodes of the same parent node is 1).

[0130] To reduce computational complexity, a hierarchical abstraction strategy is used:

[0131] Time dimension aggregation: The continuous time axis is divided into logical time periods (e.g., early morning peak 9:00-10:00), and similar touchpoints within the same time period are merged into super-nodes.

[0132] Spatial grid clustering: Based on geographic density (e.g., business district, residential area), adjacent grids are merged, and the DBSCAN algorithm (Density-Based Spatial Clustering of Applications with Noise) is used to automatically identify high-density areas and generate aggregated nodes.

[0133] Probability pruning: Set a transition probability threshold (e.g., 0.05), remove edges with probabilities below the threshold, and retain high-probability paths. The final decision state tree satisfies: the root node is the first touchpoint, the leaf node is the conversion event (e.g., purchase button click), the intermediate nodes are arranged in chronological order, and the child nodes of each node are arranged in descending order of edge weight.

[0134] The decision state tree is not static and is continuously updated through a real-time feedback loop: when new user behavior data flows in, an Incremental Reconstruction Module (IRM) is triggered, which uses a Difference-Driven Update (DDU) method: only the affected paths (such as newly added touchpoints or edges with a probability change of more than 10%) are locally reconstructed sub-trees. Global Rebalancing (GR) is performed every 24 hours to recalculate all edge weights and optimize tree levels, avoiding structural distortion caused by long-term data drift. The tree structure is stored in a graph database (such as Neo4j) to support millisecond-level path queries.

[0135] The user decision path evolution is simulated by an incremental Monte Carlo tree search algorithm, and the frequency distribution of each path is recorded.

[0136] Incremental Monte Carlo Tree Search (IMCTS) introduces state caching and parallel backtracking based on traditional MCTS:

[0137] Selection phase (Selection): Starting from the root node, the UCT algorithm (Upper Confidence Bound applied to Trees) is used to select child nodes. The exploration weight parameter C in the UCT formula is set to a dynamic value (initial value 0.5, exponentially decayed to 0.1 with search rounds), balancing exploration (trying low probability paths) and exploitation (selecting high weight paths).

[0138] Expansion phase (Expansion): When visiting unexplored nodes, a new path is randomly expanded according to the edge weight probability distribution of the decision state tree. Importance Sampling (IS) is used during expansion, preferentially expanding path branches with high historical conversion rates.

[0139] Simulation phase (Simulation): Starting from the new node, a virtual user decision path is generated based on the spatial-temporal distribution map of ad conversion probability. The simulation process introduces a Behavioral Noise Model (BNM) to add random jumps (5% probability) to simulate real user irrational behavior.

[0140] Backpropagation: Update Visit Count (VC) and Accumulated Conversion Value (ACV) along the path in reverse. Incremental backpropagation is used: only update the statistics of the path involved in this simulation, avoid full tree traversal.

[0141] Hot Path Cache (HPC): The system maintains a cache pool of high-frequency access paths (e.g. TOP 100 paths), when a new query hits the cache, directly return the result, reduce 70% computing load.

[0142] Adaptive Simulation Depth (ASD): Dynamically adjust the simulation step according to user historical behavior data. For example, luxury goods users have longer decision-making paths (simulation depth 50 steps), fast-moving consumer goods users have shorter paths (simulation depth 20 steps).

[0143] Real-time feedback integration: When the actual conversion event occurs, immediately trigger the Path Verification Thread (PVT) to compare the real path with the simulation path, and correct the probability bias (e.g. if the actual conversion rate of a touch point is 10% higher than the simulation value, increase its weight by 5%).

[0144] After each simulation is completed, record the complete path sequence and update the Path Access Frequency Distribution (PAFD). PAFD is stored in a two-level structure:

[0145] Path Fingerprint Library (PFL): Use MinHash algorithm to compress the path into 128-bit fingerprint for fast duplicate detection.

[0146] Frequency Matrix (FM): A three-dimensional matrix (touch point sequence × time window × geographic area) records the Access Count (AC) and Conversion Count (CC) of each path. Perform Sliding Window Aggregation (SWA) every 10 minutes to clear expired data (e.g. low-frequency paths 30 days ago).

[0147] Calculate the Sharpe value based on the path access frequency distribution, and dynamically update the touch point contribution weight combined with the exponential decay function;

[0148] Shapley Value (SV) is used to fairly allocate the contribution of each touchpoint to the conversion. The calculation formula contains four elements: Coalition Generation: For a path containing N touchpoints, generate all possible subsets of touchpoints (i.e. coalitions), a total of 2^N combinations. For example, path {A, B, C}, the contributions of {A}, {B}, {C}, {A, B}, {A, C}, {B, C}, {A, B, C} need to be calculated. Marginal Contribution (MC): The incremental conversion rate brought by touchpoint i joining coalition S. For example, MC_i(S) = Conversion Rate(S∪{i}) - Conversion Rate(S). Weight Factor (WF): The probability of the occurrence of coalition S, the calculation formula is |S|! (N-|S|-1)! / N! (|S| is the size of the coalition). Weighted Sum: SV_i = Σ[MC_i(S) × WF(S)], sum over all coalitions containing i.

[0149] To reduce the amount of calculation, Monte Carlo Approximation (MCA) is used: randomly sample 1000 coalition combinations instead of full combination calculation, with an error control of ±2%.

[0150] Shapley Value needs to be dynamically adjusted in combination with time decay:

[0151] Decay function design: Weight update formula W_i(t) =α×SV_i + (1-α)×W_i(t-1), where the decay factor α (Alpha) is dynamically generated by the hyperbolic tangent function (tanh): α= 0.5×[tanh( (t_now - t_event) / τ)+ 1]. Parameter τ (Tau) is the decay time constant (default 7 days), t_event is the touchpoint occurrence time. This design ensures that recent events have high weights (α close to 1) and long-term events have low weights (α close to 0).

[0152] Scene adaptive τ: Adjust the τ value according to the product type. For example, the decision cycle of car advertising is long (τ=30 days), and the decision cycle of restaurant advertising is short (τ=1 day).

[0153] The final touch point contribution weight (Contribution Weight, CW) needs to integrate multi-dimensional information: basic weight: the result of Shapley value SV after attenuation; context correction: touch point location weight: first-tier city touch point x 1.2, third-tier city x 0.8; device type weight: mobile touch point x 1.1, PC end x 0.9; behavior intensity weighting: watching 15-second video advertisement: weight x 1.5; clicking but not expanding details: weight x 0.7. Fusion formula: CW_i = [W_i(t) x location coefficient x device coefficient] x behavior intensity coefficient. Update the full touch point weight every 5 minutes in batches.

[0154] Self-service sampling method is used to evaluate the stability of touch point contribution weight, and the attribution weight vector with confidence interval is generated;

[0155] Self-service sampling method (Bootstrap Sampling) evaluates the stability of the weight by resampling:

[0156] Construct a resampling set: randomly sample 1000 paths (sample size equal to the original data set) from the original path library with replacement to form a Bootstrap Sample Set (BSS). Calculate the weight in parallel: calculate the Shapley value (including attenuation function processing) for each BSS independently to obtain the touch point weight vector W_b = [w1_b, w2_b,..., wn_b] of the sample set. Repeat the sample generation: repeat the above process K times (K=500) to generate 500 weight vectors {W1, W2,..., W500}. Calculate the statistical quantity: for each touch point i, arrange its weight values {w1_i, w2_i,..., w500_i} in ascending order in the 500 vectors, and take the 25th and 475th values as the lower bound LB_i and the upper bound UB_i of the 95% confidence interval (Confidence Interval, CI).

[0157] To improve the reliability of the results, an adaptive stopping mechanism is introduced: stability criterion: calculate the mean standard deviation (MSD) of all contact weights, and stop sampling when the MSD changes by <0.01 for 3 consecutive iterations. Confidence interval optimization: if the contact weight interval width (UB_i - LB_i) > 0.1, trigger targeted expansion sampling: add an additional 200 samples to the path related to this contact. For high-value contacts (weight > 0.15), use a 99% confidence interval (take the 5th and 495th values). The final output attribution weight vector (AWV) is in the form: [contact ID, weight mean, lower confidence bound, upper confidence bound]. Example: [ATP123, 0.28, 0.25, 0.31].

[0158] Incremental Computing Engine (ICE): When new data arrives, only the affected contacts (such as contacts that appear within 24 hours) are resampled, and the rest of the contacts use the cached results.

[0159] Distributed execution: 500 Bootstrap sampling tasks are distributed to 10 GPU servers for parallel execution, and the single round of calculation time is compressed from 5 hours to 8 minutes. Abnormal fuse mechanism: when a contact weight mutates (adjacent period change > 30%), automatically trigger full re-computation to avoid local update distortion.

[0160] Convert the attribution weight vector to a dynamic force-directed graph structure, where the node size of the dynamic force-directed graph structure represents the attribution weight, and the edge transparency represents the transfer probability strength. Finally, output the incremental attribution graph.

[0161] Dynamic Force-Directed Graph (DFDG) is constructed based on a physical particle model:

[0162] Node modeling: Each ad touchpoint is modeled as a charged particle, with node size (NS) positively correlated with attribution weight: NS_i = base radius 10 pixels + weight value x 200 pixels. Particle mass is set as a logarithmic function of weight (Mass_i = log(10 x CW_i)) to avoid imbalance of node gravity caused by too large nodes. Edge modeling: Edges represent the transition relationship between touchpoints, with edge opacity (EO) linearly related to transition probability strength CTP: EO_ij = min(0.9, CTP_ij x 2). Edge spring coefficient is set as a constant 0.0003, and damping coefficient is 0.02. Force system design: Repulsion between nodes: F_repel = k_repel / d^2 (d is the distance between nodes, k_repel = 3000); Attraction of edge connection: F_attract = k_attract x d (k_attract = 0.8); Center attraction: To prevent edge nodes from drifting, F_center = -0.01 x d.

[0163] WebGL visualization engine: Browser-side 3D rendering is implemented using the Three.js library, supporting:

[0164] Focus diffusion: When a node is clicked, the edges with strong association to it are highlighted (transparency increased to 0.95), and the weakly associated edges are faded (transparency reduced to 0.2); Time axis dragging: Sliding the time axis dynamically displays weight changes, with node size smoothly transitioning; Confidence interval visualization: When the mouse hovers over a node, a translucent confidence interval ring (inner ring LB_i, outer ring UB_i) is displayed. Incremental update strategy:

[0165] New touchpoint: Added at the initial position (0, 0) and automatically drifted to the equilibrium point by the force system. Weight update: Node size gradually changes to the new value within 0.5 seconds to avoid visual jumps. Edge disappearance: When the transition probability is less than 0.01, the edge transparency linearly decreases to zero within 1 second and is then removed.

[0166] The final output of the incremental attribution map (IAM) contains three layers of information:

[0167] Core topology layer: Force-directed graph showing the relationship between touchpoints, with node size = contribution weight, and edge transparency = transition probability. Spatiotemporal heat layer: Superimpose geographical information with translucent blocks, with color depth representing regional conversion rate (red for high, blue for low). Dynamic indicator layer: Real-time floating window displays key data: Current top 3 high-value touchpoints (weight + confidence interval); Path conversion rate trend (compared with the same period last week); Abnormal touchpoint warning (such as a touchpoint with a 30% weight drop marked with red flashing). The map is connected to the ad delivery system through an API, with incremental data updates every 15 seconds to support real-time strategy adjustments.

[0168] S205, input the incremental attribution map into a strategy generation adversarial network, synthesize a multi-dimensional advertising distribution strategy vector under a constraint condition using a generator of the strategy generation adversarial network, and perform strategy effectiveness verification in combination with historical ROI data using a discriminator of the strategy generation adversarial network, and output a set of adversarial optimization advertising distribution strategies satisfying Pareto optimality.

[0169] Specifically, the node weight and edge transition probability of the incremental attribution map can be encoded as a graph constraint matrix and input into a graph convolutional encoding layer of the strategy generator.

[0170] The incremental attribution map (IAM) is presented in a dynamic force-directed graph structure, in which the node weight (NW) represents the contribution weight (with a value range of 0-1) of each advertising touchpoint (such as a search engine advertisement or a social media push), and the edge transition probability (ETP) represents the probability of a user jumping from touchpoint A to touchpoint B (such as the probability of jumping from an e-commerce banner to a live broadcast room, ETP=0.78). The encoding process consists of three steps:

[0171] Topology feature extraction: all nodes and edges of the IAM are traversed through a graph structure analysis algorithm, and the NW of each node and the ETP of its associated edge are combined to form a two-dimensional vector (such as a node vector=[NW=0.35, average ETP=0.62]). Matrix construction: all node vectors are arranged in the order of graph topology to generate an initial graph constraint matrix (GCM), with a matrix dimension of N×2 (N is the total number of nodes). For example, 200 touchpoints generate a GCM with 200 rows and 2 columns. Historical ROI fusion: map the ROI data (Return on Investment) of historical advertising distribution according to touchpoint categories to additional columns. For example, a third column is added to the GCM to store the average ROI of each type of touchpoint in the past 30 days (such as search advertisement ROI=1.8), forming an enhanced graph constraint matrix (EGCM).

[0172] Workflow of the graph convolutional encoding layer (GCEL) of the strategy generator: neighborhood aggregation: the GCEL takes the EGCM as input and performs third-order neighborhood sampling (sampling radius 3 hops) on each node. For example, for a social media node, the NW, ETP, and ROI features of its associated neighbor nodes such as search advertisements and KOL promotions are aggregated.

[0173] Feature Transformation: Weighted Message Passing (WMP) is adopted to adjust the feature weight of neighbor nodes according to edge ETP. For example, edges with ETP=0.8 are given 0.8 times the feature weight, and low-probability edges (ETP=0.2) only take 0.2 times the weight.

[0174] Output Latent Feature Vector: After three-layer graph convolution operation, each node outputs a 128-dimensional Latent Feature Vector (LFV) that fully describes its topological role and historical performance in the attribution graph.

[0175] Strategy Generator fuses graph constraint matrix and historical ROI data to synthesize a multi-dimensional advertising strategy vector through conditional adversarial generation mechanism.

[0176] The core of the Strategy Generator (SG) is the Conditional Adversarial Generation (CAG) mechanism, which includes the following inputs:

[0177] EGCM encoding results: Node LFV set from GCEL; Historical ROI database: Structured storage of advertising channel cost, conversion rate, user portrait, etc. fields (such as field "short video channel_18-25 year-old women_CPM=5 dollars_conversion rate=12%").

[0178] Strategy vector synthesis process:

[0179] Conditional constraint injection: Historical ROI data is classified into budget constraint conditions (such as total daily budget ≤50,000 dollars) and population coverage conditions (such as young user coverage rate ≥60%) according to business dimensions. These conditions are converted into Condition Vectors (CV) input into SG.

[0180] Feature fusion: The decoder module of SG concatenates node LFV and CV to generate Fused Feature (FF) through fully connected layers. For example, concatenate a certain contact LFV (128-dimensional) with a budget condition CV (10-dimensional) to form a 138-dimensional vector. Strategy vector generation: Based on FF, generate a multi-dimensional advertising strategy vector (Multi-dimensional Strategy Vector, MSV) containing the following typical dimensions:

[0181] Channel Weight (CW): budget proportion of each advertising channel (e.g., CW of information flow advertisement = 0.4, CW of search engine = 0.3); Time Intensity Coefficient (TIC): distribution of 24-hour delivery intensity (e.g., TIC of 8-10 pm = 1.2, TIC of early morning = 0.3); Creative Combination (CC): ratio of text / video / interactive advertisements (e.g., video material proportion = 70%).

[0182] Adversarial generation example: the SG generates a first-round strategy MSV1 = [CW: information flow 0.4, search 0.3; TIC: evening peak 1.2; CC: video 70%]. The discriminator determines that the budget is over the limit, and the SG outputs MSV2 = [CW: information flow 0.35, search 0.25; TIC: evening peak 1.0; CC: video 60%] after adjusting the parameters.

[0183] The strategy discriminator receives the strategy vector and performs three-stage verification in combination with the historical ROI database to output a three-dimensional validity score matrix. The three-stage verification includes: budget constraint verification: comparison of total strategy cost and historical cost distribution; conversion gain verification: difference between expected conversion rate of the strategy and historical benchmark; risk entropy verification: calculation of the Sharpe ratio of the strategy combination;

[0184] The strategy discriminator (SD) uses a three-stage verification framework (TV) to perform the following verification on the input MSV:

[0185] (1) Budget Constraint Verification (BCV)

[0186] Comparison logic: calculate the total cost of the strategy (e.g., 0.35 x total budget 50,000 = 1.75 million dollars for the information flow channel budget proportion in MSV), and compare it with the historical cost distribution (e.g., 25th percentile of the same channel cost in the past 90 days is 15,000, and the 75th percentile is 22,000).

[0187] Scoring rules: if the strategy cost is within the historical 25-75 percentile range, BCV score = 100; lower than 25th percentile score is linearly decreased (e.g., cost 1.2 million, BCV = 70), and higher than 75th percentile is deducted by the overage proportion (e.g., cost 2.5 million, BCV = 40).

[0188] (2) Conversion Gain Verification (CGV)

[0189] Baseline Construction: Baseline Conversion Rate (BCR) of each channel is calculated based on historical ROI data. For example, BCR of Newsfeed Ad = 10%. Gain Calculation: Estimated Conversion Rate of strategy is calculated according to channel weight and time period coefficient in MSV (e.g. TIC = 1.2 in evening peak can make Newsfeed Ad Conversion Rate increase to 12%). Gain value ΔC = (Estimated Conversion Rate - BCR) / BCR (e.g. ΔC = 20% in this example). Score Mapping: ΔC is graded according to historical gain distribution (e.g. CGV = 100 when ΔC > 15%, CGV = 60 when ΔC = 5%).

[0190] (3) Risk Entropy Verification (REV)

[0191] Sharpe Ratio (SR): Measure the conversion gain per unit risk. Formula: SR = (Strategy Estimated Conversion Rate - Risk-free Conversion Rate) / Conversion Rate Volatility Standard Deviation. Risk-free Conversion Rate is the historical minimum value (e.g. 5%), and Volatility Standard Deviation is calculated based on historical 90-day data (e.g. Newsfeed Ad channel standard deviation 2%). Example: If Strategy Estimated Conversion Rate is 12%, then SR = (12% - 5%) / 2% = 3.5. Score Conversion: REV = 100 when SR ≥ 2.0, REV = 50 when SR = 1.0, and REV = 0 when SR < 0 (negative return). Output 3D Score Matrix (3DSM): Each strategy vector MSV corresponds to a three-dimensional score [BCV, CGV, REV], e.g. Strategy A's 3DSM = [80, 90, 75].

[0192] Iterative optimization of strategy generator according to effectiveness score matrix. When the distribution density of multi-dimensional advertising strategy vector on the Pareto frontier reaches saturation, extract the non-dominated solution set as the set of Pareto optimal and antagonistic optimization advertising strategies.

[0193] (1) Iterative optimization loop

[0194] Generator Update: 3DSM returned by SD is input to SG's Loss Function (LF), which is defined as the weighted reciprocal of three-dimensional scores (e.g. LF = 1 / (0.4×BCV + 0.4×CGV + 0.2×REV)). SG updates network weights through backpropagation algorithm (e.g. Adam optimizer) to make newly generated MSV tend to higher scores. Convergence criterion: When the 3DSM comprehensive improvement rate of the generated MSV in the last 10 rounds is <1% (e.g. average score increases from 85 to 85.8), the model is considered to have converged.

[0195] (2) Pareto Front (PF) construction

[0196] Multi-objective optimization: Project all generated MSVs (e.g., 10,000 strategies) into a three-dimensional score space (BCV-CGV-REV coordinate system). Front extraction: Use Non-dominated Sorting (NDS) algorithm: Hierarchical division: Strategies that are not comprehensively superior to any other strategy in all three dimensions are classified into PF-1 layer (optimal front); strategies that are superior to PF-1 layer strategies are classified into PF-2 layer, and so on.

[0197] Density saturation determination: When the number of PF-1 layer strategies ≥ 20% of the total number of strategies (e.g., 2,000), and the proportion of PF-1 layer in new strategies < 5%, determine that the distribution density is saturated.

[0198] (3) Non-dominated Solution Set (NDSS) output

[0199] Business constraint filtering: Select strategies that meet hard conditions (e.g., BCV ≥ 70, CGV ≥ 60, REV ≥ 50) from PF-1 layer. Diversity guarantee: Use Crowding Distance (CD) calculation to retain strategies that are evenly distributed in each target direction (e.g., avoid all strategies concentrating in the high BCV low REV area). Final output: NDSS contains 100-500 strategy vectors, each strategy is labeled with three-dimensional scores. For example: Strategy X: [BCV=85, CGV=92, REV=78] → focuses on conversion gain; Strategy Y: [BCV=95, CGV=80, REV=88] → focuses on budget safety; Strategy Z: [BCV=82, CGV=85, REV=90] → balanced solution.

[0200] Another embodiment of the present application provides an artificial intelligence-based advertisement effect evaluation system, which is shown in Figure 3 , the system can include:

[0201] The acquisition module 301 is configured to synchronously acquire multi-source data containing user behavior data flow and advertisement launching index flow through a distributed acquisition engine, eliminate time offset of the multi-source data by using a timestamp-driven event window alignment algorithm, and generate a spatio-temporal synchronous multi-dimensional data cube.

[0202] The separation module 302 is configured to decouple features of the multi-dimensional data cube, separate a stable feature set and a transient feature set through a cross-attention mechanism, model a nonlinear interaction relationship between the features by using a graph neural network, and output a dynamic feature topology network with weights.

[0203] The generating module 303 is configured to input the dynamic feature topology network into an adversarial training framework, wherein a generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, and a discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space difference between a real conversion path and the virtual conversion path, and finally outputs an advertisement conversion probability spatiotemporal distribution map.

[0204] The simulation module 304 is configured to deploy a real-time feedback attribution calculation unit based on the advertisement conversion probability spatiotemporal distribution map, simulate the evolution process of a user decision path through Monte Carlo tree search, dynamically update the contribution weight of each touch point, and generate an incremental attribution graph with a confidence interval.

[0205] The output module 305 is configured to input the incremental attribution graph into a strategy generation adversarial network, use a generator of the strategy generation adversarial network to synthesize a multi-dimensional advertisement launching strategy vector under a constraint condition, and use a discriminator of the strategy generation adversarial network to verify the effectiveness of the strategy in combination with historical ROI data, and output a set of adversarial optimization advertisement launching strategies that satisfy the Pareto optimality.

[0206] The embodiment of the present application also provides a storage medium, wherein the storage medium stores a computer program, and the computer program is configured to execute the steps in any one of the method embodiments when running.

[0207] The embodiment of the present application also provides an electronic device, which comprises a memory and a processor, the memory stores a computer program, and the processor is configured to execute the computer program to execute the steps in any one of the method embodiments.

[0208] Specifically, the electronic device can further comprise a transmission device and an input and output device, wherein the transmission device is connected to the processor, and the input and output device is connected to the processor.

[0209] The above embodiments according to the drawings illustrate the structure, features and effects of the present application, and the above description is only the preferred embodiment of the present application, but the present application is not limited to the embodiments shown in the drawings, any changes or modifications made according to the concept of the present application, or equivalent embodiments with equivalent changes, shall be within the scope of the present application.

Claims

1. An artificial intelligence-based method for evaluating advertising effectiveness, characterized in that, The method comprises: Synchronously acquiring multi-source data containing user behavior data stream and advertisement delivery index stream through a distributed collection engine, eliminating time offset of the multi-source data by using a timestamp-driven event window alignment algorithm, and generating a spatio-temporally synchronized multi-dimensional data cube, including: aligning original timestamps by using a clock drift compensation algorithm according to user terminal burying point logs and advertisement server interface streams, and generating multi-source data streams with uniform time base; based on the multi-source data streams with uniform time base, a user complete session track is intercepted through an event triggered sliding window, and a spatio-temporal correlation sequence of behavior events and advertisement exposure events is extracted; the spatio-temporal correlation sequence is input into an adaptive grid division engine, event density is aggregated according to dynamic resolution, and an initial spatio-temporal event tensor is generated; a low-rank tensor completion model is applied to the initial spatio-temporal event tensor, missing data blocks are repaired, and a complete multi-dimensional data cube is output; The multi-dimensional data cube is decoupled, stable feature sets and transient feature sets are separated through a cross attention mechanism, and a graph neural network is used to model the nonlinear interaction relationship between features, and a dynamic feature topology network with weights is output; The dynamic feature topology network is input into an adversarial training framework, wherein the generator of the adversarial training framework fuses structured and unstructured features to generate a virtual conversion path, and the discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the hidden space difference between the real conversion path and the virtual conversion path, and finally outputs an advertisement conversion probability spatio-temporal distribution map, including: based on the dynamic feature topology network, topology structure features are extracted through a graph attention encoder, and a virtual conversion path sequence is generated by fusing a long short-term memory network; a double-channel discriminator module is constructed, wherein the first channel calculates the Mahalanobis distance between the real conversion path and the virtual conversion path in the hidden space, and the second channel verifies the compliance degree of the path logic constraint, and outputs a double-channel difference matrix; generator parameters are iteratively optimized using the double-channel difference matrix, and when the misjudgment rate of the discriminator on the real / virtual conversion path continuously decreases by less than a threshold value for a preset number of rounds, it is determined that the generator has reached a convergence state; the converged generator performs Monte Carlo sampling in the feature embedding space, and outputs an advertisement conversion probability spatio-temporal distribution heat map; Based on the advertisement conversion probability spatio-temporal distribution map, a real-time feedback attribution calculation unit is deployed, the evolution process of the user decision path is simulated through Monte Carlo tree search, the contribution weight of each touch point is dynamically updated, and an incremental attribution graph with a confidence interval is generated; The incremental attribution graph is input into a strategy generation adversarial network, a generator of the strategy generation adversarial network synthesizes a multi-dimensional advertisement delivery strategy vector under constraint conditions, a discriminator of the strategy generation adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs a set of adversarial optimization advertisement delivery strategies that satisfy the Pareto optimality.

2. The method of claim 1, wherein, The multi-dimensional data cube is decoupled, stable feature sets and transient feature sets are separated through a cross attention mechanism, and a graph neural network is used to model the nonlinear interaction relationship between features, and a dynamic feature topology network with weights is output, including: The multi-dimensional data cube is sliced into a feature vector set, mutual information entropy between features is calculated through a multi-head cross attention mechanism, and a high-entropy mutual feature pair set is generated; Based on the high-entropy mutual feature pair set, a spectral clustering algorithm is used to divide stable feature subsets and transient feature subsets; A dynamic interaction graph structure is constructed according to the stable feature subsets and the transient feature subsets, wherein a node of the dynamic interaction graph structure represents a feature unit, and an edge weight of the dynamic interaction graph structure represents a feature transition probability; The dynamic interaction graph is input into a time series graph neural network, a feature evolution path is modeled through a gated time convolution module, and a time series enhanced feature topology is output; Gradient importance distillation is performed on the time series enhanced feature topology, a node influence factor is calculated, and a dynamic feature topology network with semantic weights is generated.

3. The method of claim 2, wherein, Based on the advertisement conversion probability spatiotemporal distribution graph, a real-time feedback attribution calculation unit is deployed, the evolution process of a user decision path is simulated through a Monte Carlo tree search, the contribution weights of each touch point are dynamically updated, and an incremental attribution graph atlas with a confidence interval is generated, including: The advertisement conversion probability spatiotemporal distribution graph is mapped into a decision state tree, wherein a tree node of the decision state tree represents an advertisement touch point, and an edge weight of the decision state tree represents a conversion transition probability; The evolution of a user decision path is simulated through an incremental Monte Carlo tree search algorithm, and the frequency distribution of each path is recorded; Based on the path access frequency distribution, a Sharpe value is calculated, and the contribution weights of the touch points are dynamically updated in combination with an exponential decay function; The stability of the touch point contribution weights is evaluated using a bootstrap sampling method, and an attribution weight vector with a confidence interval is generated; The attribution weight vector is converted into a dynamic force guide graph structure, wherein the size of a node of the dynamic force guide graph structure represents the attribution weight, and the edge transparency represents the transition probability strength, and finally an incremental attribution graph atlas is output.

4. The method of claim 3, wherein, The incremental attribution graph atlas is input into a strategy generation adversarial network, a generator of the strategy generation adversarial network synthesizes a multi-dimensional advertisement launching strategy vector under constraint conditions, a discriminator of the strategy generation adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs a set of adversarial optimization advertisement launching strategies that satisfy Pareto optimality, including: The node weights and edge transition probabilities of the incremental attribution graph atlas are encoded into a graph constraint matrix, which is input into the graph convolution encoding layer of the strategy generator; The strategy generator fuses the graph constraint matrix and the historical ROI data, and synthesizes a multi-dimensional advertisement launching strategy vector through a conditional adversarial generation mechanism; The strategy discriminator receives the strategy vector, performs three-order verification in combination with the historical ROI database, and outputs a three-dimensional effectiveness score matrix, wherein the three-order verification includes: budget constraint verification: strategy total cost distribution comparison with historical cost; conversion gain verification: difference between strategy expected conversion rate and historical benchmark; risk entropy verification: Sharpe ratio calculation of strategy combination; According to the effectiveness score matrix, the strategy generator is iteratively optimized, and when the distribution density of the multi-dimensional advertisement launching strategy vector reaches saturation on the Pareto frontier, a non-dominated solution set is extracted as the set of adversarial optimization advertisement launching strategies that satisfy Pareto optimality.

5. An artificial intelligence-based advertisement effect evaluation system, characterized by, The system comprises: The acquisition module is used to synchronously acquire multi-source data, including user behavior data streams and advertising performance metrics streams, through a distributed acquisition engine. It utilizes a timestamp-driven event window alignment algorithm to eliminate time offsets in the multi-source data, generating a spatiotemporally synchronized multi-dimensional data cube. Specifically, this includes: aligning the original timestamps using a clock drift compensation algorithm based on user terminal tracking logs and advertising server interface streams to generate a multi-source data stream with a unified time base; capturing the complete user session trajectory through an event-triggered sliding window based on the unified time base multi-source data stream, extracting the spatiotemporal correlation sequence between behavioral events and advertising exposure events; inputting the spatiotemporal correlation sequence into an adaptive grid partitioning engine, aggregating event density according to dynamic resolution, and generating an initial spatiotemporal event tensor; applying a low-rank tensor completion model to the initial spatiotemporal event tensor to repair missing data blocks, and outputting a complete multi-dimensional data cube. The separation module is used to decouple the features of the multidimensional data cube, separate the stable feature set and the transient feature set through the cross attention mechanism, and use the graph neural network to model the nonlinear interaction relationship between features, and output a weighted dynamic feature topology network. A generation module is used to input the dynamic feature topology network into an adversarial training framework. The generator of the adversarial training framework fuses structured and unstructured features to generate virtual conversion paths. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real and virtual conversion paths, ultimately outputting a spatiotemporal distribution map of advertising conversion probabilities. This includes: extracting topological features based on the dynamic feature topology network using a graph attention encoder and fusing a long short-term memory network to generate a sequence of virtual conversion paths; constructing a dual-channel discriminator module, where the first channel calculates the Mahalanobis distance between the real and virtual conversion paths in the latent space, and the second channel verifies the compliance of path logic constraints, outputting a dual-channel difference matrix; iteratively optimizing generator parameters using the dual-channel difference matrix; determining that the generator has reached convergence when the misclassification rate of the discriminator for the real / virtual conversion paths remains below a preset threshold for several rounds; and performing Monte Carlo sampling on the converged generator in the feature embedding space to output a heatmap of the spatiotemporal distribution of advertising conversion probabilities. The simulation module is used to deploy a real-time feedback attribution calculation unit based on the spatiotemporal distribution map of the advertising conversion probability, simulate the evolution of the user decision path through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution map with confidence intervals. The output module is used to input the incremental attribution graph into the strategy generative adversarial network, use the generator of the strategy generative adversarial network to synthesize a multi-dimensional advertising strategy vector under constraints, and use the discriminator of the strategy generative adversarial network to verify the effectiveness of the strategy in combination with historical ROI data, and output a set of adversarial optimized advertising strategies that satisfy Pareto optimality.

6. A storage medium, characterized by The storage medium stores a computer program, wherein the computer program is configured to execute the method of any one of claims 1-4 when it is run.

7. An electronic device comprising a memory and a processor, characterized in that The memory stores a computer program, and the processor is configured to run the computer program to execute the method of any one of claims 1-4.

Images