Advertisement effect evaluation method and system based on artificial intelligence

Abstract

The invention discloses an artificial intelligence-based advertisement effect evaluation method and system, and the method comprises the steps: synchronously obtaining multi-source data containing a user behavior data flow and an advertisement putting index flow through a distributed collection engine, and generating a time-space synchronous multi-dimensional data cube; performing feature decoupling on the multi-dimensional data cube, and outputting a dynamic feature topology network with a weight; inputting the dynamic feature topology network into an adversarial training framework, and finally outputting an advertisement conversion probability space-time distribution diagram; based on the advertisement conversion probability space-time distribution map, deploying an attribution calculation unit for real-time feedback, and generating an incremental attribution map with a confidence interval; and inputting the incremental attribution atlas into a strategy generation adversarial network, and outputting an adversarial optimization advertisement putting strategy set meeting Pareto optimum. According to the embodiment of the invention, the accuracy and real-time performance of advertisement effect evaluation can be improved.

Description

Technical Field

[0001] The present invention belongs to the field of artificial intelligence technology, and in particular to an advertising effect evaluation method and system based on artificial intelligence. Background Art

[0002] With the rapid development of digital advertising, traditional advertising effectiveness evaluation methods, which rely primarily on manual statistics or simple data analysis models, struggle to cope with massive, multi-source, and high-dimensional advertising data. Existing technologies often cannot effectively handle temporal and spatial variations in data, resulting in inaccurate attribution results. Furthermore, advertising strategy optimization often lacks the ability to dynamically adjust, making it difficult to adapt to real-time changes in user behavior and market conditions. Summary of the Invention

[0003] The purpose of the present invention is to provide an advertising effect evaluation method and system based on artificial intelligence to address the deficiencies in the prior art and to improve the accuracy and real-time performance of advertising effect evaluation.

[0004] One embodiment of the present application provides an artificial intelligence-based advertising effectiveness evaluation method, the method comprising: Through the distributed collection engine, multi-source data, including user behavior data streams and advertising delivery indicator streams, is synchronously acquired. A timestamp-driven event window alignment algorithm is used to eliminate time offsets in multi-source data, generating a spatiotemporally synchronized multidimensional data cube. Decoupling the features of the multidimensional data cube, separating the stable feature set and the transient feature set through a cross-attention mechanism, and using a graph neural network to model the nonlinear interaction relationship between the features, outputting a weighted dynamic feature topology network; 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. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, and ultimately outputs a spatiotemporal distribution map of the advertising conversion probability. Based on the spatiotemporal distribution graph of ad conversion probabilities, a real-time feedback attribution calculation unit is deployed. The Monte Carlo tree search is used to simulate the evolution of the user's decision path, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals. The incremental attribution graph is input into a strategy-generating adversarial network, and a multi-dimensional advertising delivery strategy vector is synthesized under constraints using the generator of the strategy-generating adversarial network. The discriminator of the strategy-generating adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

[0005] Optionally, the method of synchronously acquiring multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine, eliminating time offsets of the multi-source data using a timestamp-driven event window alignment algorithm, and generating a spatiotemporally synchronized multidimensional data cube includes: Based on user terminal tracking logs and ad server interface streams, a clock drift compensation algorithm is used to align original timestamps, generating a multi-source data stream with a unified time base. Based on multi-source data streams with a unified time base, the system intercepts the user's complete session trajectory through an event-triggered sliding window, extracting the spatiotemporal correlation sequence between behavioral events and ad exposure events. The spatiotemporal correlation sequence is fed into the adaptive meshing engine, and the event density is aggregated at a dynamic resolution to generate the initial spatiotemporal event tensor; Apply a low-rank tensor completion model to the initial spatiotemporal event tensor to repair missing data blocks and output a complete multidimensional data cube.

[0006] Optionally, the multidimensional data cube is subjected to feature decoupling, a stable feature set and a transient feature set are separated through a cross-attention mechanism, and a graph neural network is used to model the nonlinear interaction relationship between features to output a weighted dynamic feature topology network, including: Slice the multidimensional data cube into a set of feature vectors, calculate the mutual information entropy between features through a multi-head cross-attention mechanism, and generate a set of high-entropy interactive feature pairs; Based on the set of high entropy interaction feature pairs, the spectral clustering algorithm is used to divide the stable feature subset and the transient feature subset; A dynamic interaction graph structure is constructed based on the stable feature subset and the transient feature subset, wherein the nodes of the dynamic interaction graph structure represent feature units, and the edge weights of the dynamic interaction graph structure represent feature transition probabilities; The dynamic interaction graph is input into the temporal graph neural network, the feature evolution path is modeled through the gated temporal convolution module, and the temporal enhanced feature topology is output; Gradient importance distillation is performed on the temporal enhanced feature topology to calculate the node influence factors and generate a dynamic feature topology network with semantic weights.

[0007] Optionally, 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 latent space differences between the real conversion path and the virtual conversion path, and ultimately outputs a spatiotemporal distribution map of advertising conversion probabilities, including: Based on the dynamic feature topology network, the graph attention encoder is used to extract topological structure features and the long short-term memory network is integrated to generate a virtual transformation path sequence. Construct a dual-channel discriminator module, where the first channel calculates the Mahalanobis distance between the real transformation path and the virtual transformation path in the latent space, and the second channel verifies the path logical constraint compliance and outputs a dual-channel difference matrix; The generator parameters are iteratively optimized using a dual-channel difference matrix. When the discriminator's misjudgment rate for real / virtual conversion paths remains below a threshold for a preset number of rounds, the generator is considered to have reached a convergence state. The converged generator performs Monte Carlo sampling in the feature embedding space and outputs a heat map of the spatiotemporal distribution of ad conversion probabilities.

[0008] Optionally, based on the spatiotemporal distribution graph of advertising conversion probabilities, a real-time feedback attribution calculation unit is deployed to simulate the evolution of user decision paths through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals, including: Map the spatiotemporal distribution graph of advertising conversion probability into a decision state tree, where the tree nodes of the decision state tree represent advertising touchpoints and the edge weights of the decision state tree represent conversion transfer probabilities; The incremental Monte Carlo tree search algorithm is used to simulate the evolution of user decision paths and record the frequency distribution of visits to each path. Calculate the Shapley value based on the path access frequency distribution, and dynamically update the contact contribution weights in combination with the exponential decay function; A bootstrap sampling method is used to evaluate the stability of contact contribution weights and generate an attribution weight vector with confidence intervals. The attribution weight vector is converted into 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 strength of the transition probability. Finally, an incremental attribution graph is output.

[0009] Optionally, the incremental attribution graph is input into a strategy-generating adversarial network, and a generator of the strategy-generating adversarial network is used to synthesize a multi-dimensional advertising delivery strategy vector under constraints. The discriminator of the strategy-generating adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs an adversarial optimization advertising delivery strategy set that satisfies Pareto optimality, including: Encode the node weights and edge transition probabilities of the incremental attribution graph into a graph constraint matrix and input it into the graph convolutional encoding layer of the policy generator; The strategy generator integrates the graph constraint matrix and historical ROI data to synthesize a multi-dimensional advertising strategy vector through a conditional adversarial generation mechanism; The strategy discriminator receives the strategy vector, performs three-level validation based on the historical ROI database, and outputs a three-dimensional effectiveness score matrix. The three-level validation includes: budget constraint validation: comparing the total strategy cost with the historical cost distribution; conversion gain validation: the difference between the strategy's expected conversion rate and the historical benchmark; and risk entropy validation: calculating the Sharpe ratio of the strategy portfolio. The strategy generator is iteratively optimized according to the effectiveness score matrix. When the distribution density of the multidimensional advertising delivery strategy vector on the Pareto front reaches saturation, the non-dominated solution set is extracted as the adversarial optimization advertising delivery strategy set that satisfies Pareto optimality.

[0010] Another embodiment of the present application provides an artificial intelligence-based advertising effectiveness evaluation system, the system comprising: The acquisition module is used to synchronously acquire multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine, eliminate the time offset of multi-source data using a timestamp-driven event window alignment algorithm, and generate a multi-dimensional data cube that is synchronized in time and space; A separation module is used to decouple the features of the multidimensional data cube, separate the stable feature set and the transient feature set through a cross-attention mechanism, and use a graph neural network to model the nonlinear interaction relationship between the features and output a weighted dynamic feature topology network; A generation module is configured to input 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 iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, ultimately outputting a spatiotemporal distribution map of the advertising conversion probability; A simulation module is used to deploy a real-time feedback attribution calculation unit based on the spatiotemporal distribution graph of advertising conversion probabilities, simulate the evolution of user decision paths through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals; The output module is used to input the incremental attribution graph into a strategy-generating adversarial network, use the generator of the strategy-generating adversarial network to synthesize a multi-dimensional advertising delivery strategy vector under constraints, and the discriminator of the strategy-generating adversarial network combines historical ROI data to verify the effectiveness of the strategy, and output an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

[0011] Yet another embodiment of the present application provides a storage medium, wherein the storage medium stores a computer program, wherein the computer program is configured to execute any of the above methods when run.

[0012] Yet another embodiment of the present application provides an electronic device, comprising a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute any of the above methods.

[0013] Compared with the existing technology, the present invention provides an artificial intelligence-based advertising effect evaluation method, which synchronously obtains multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine to generate a multidimensional data cube synchronized in time and space; decouples the features of the multidimensional data cube to output a dynamic feature topology network with weights; inputs the dynamic feature topology network into an adversarial training framework to ultimately output a spatiotemporal distribution map of advertising conversion probabilities; based on the spatiotemporal distribution map of advertising conversion probabilities, deploys an attribution calculation unit with real-time feedback to generate an incremental attribution map with confidence intervals; inputs the incremental attribution map into a strategy-generating adversarial network to output an adversarial optimization advertising delivery strategy set that meets Pareto optimality, thereby improving the accuracy and real-time performance of advertising effect evaluation. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] Figure 1 A hardware structure block diagram of a computer terminal for an artificial intelligence-based advertising effectiveness evaluation method provided by an embodiment of the present invention; Figure 2 A flowchart of an artificial intelligence-based advertising effectiveness evaluation method provided by an embodiment of the present invention; Figure 3 A schematic structural diagram of an artificial intelligence-based advertising effectiveness evaluation system provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0015] The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and are not to be construed as limiting the present invention.

[0016] The embodiment of the present invention first provides an artificial intelligence-based advertising effectiveness evaluation method, which can be applied to electronic devices such as computer terminals, specifically ordinary computers, etc. The following describes the method in detail using the example of running on a computer terminal. Figure 1 The hardware structure block diagram of a computer terminal for an artificial intelligence-based advertising effect evaluation method provided by an embodiment of the present invention. Figure 1 As shown, the computer device includes a processor, a memory, and a network interface connected via a system bus, wherein the memory may include a non-volatile storage medium and an internal memory.

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

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

[0019] See also Figure 2 , an embodiment of the present invention provides an advertising effect evaluation method based on artificial intelligence, which may include the following steps: S201: Synchronously acquire multi-source data, including user behavior data streams and advertising delivery indicator streams, through a distributed acquisition engine. A timestamp-driven event window alignment algorithm is used to eliminate time offsets in the multi-source data, generating a spatiotemporally synchronized multidimensional data cube. Specifically, a clock drift compensation algorithm can be used to align original timestamps based on user terminal embedding logs and advertising server interface streams, generating a multi-source data stream with a unified time base. During the system initialization phase, tracking loggers deployed on user terminals (such as mobile apps and web pages) continuously record user behavior events (such as clicks, browsing time, and page jumps). Simultaneously, the ad platform's server interface stream outputs ad delivery metrics (such as CPM, CTR, and CPC) in real time. These two data sources have inherent time skew: user terminal clocks may drift due to device sleep, and millisecond-level time differences exist between server clusters. To address this, 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 of no more than 1 millisecond. All user tracking logs are appended with a local timestamp (LT) when they are sent, while the ad server records a server timestamp (ST) when packets are 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 delay (LT) and time delay (RT) of a mobile device might deviate by +350 milliseconds, while the time delay (ST) and time delay (RT) of an advertising server might deviate by -120 milliseconds. The system maintains a dynamic offset matrix for each data source, compensating the original timestamp in real time (adding or subtracting the corresponding offset). The final output is a Corrected Timestamp (CT) that is strictly synchronized with the reference time. This process is performed thousands of times per second, ensuring that time deviations in massive data streams are compressed to the millisecond level.

[0020] The key to clock drift compensation lies in the continuous updating of dynamic offsets. The system deploys a heartbeat calibration agent on each data collection node (user device or server). This agent sends a synchronization request packet to the NTP server at a fixed interval (e.g., 30 seconds). It records the local time the request is sent (T1), the time the NTP server receives the request (T2), the time the NTP server responds (T3), and the time the agent receives the response (T4). The offset matrix is ​​dynamically updated by calculating the round-trip delay (RTD = (T4 - T1) - (T3 - T2)) and the clock offset (CO = [(T2 - T1) + (T3 - T4)] / 2). To mitigate network jitter, the system uses an exponentially weighted moving average (EWMA) algorithm to smooth historical offset data. For example, the newly calculated offset CO_new is merged with the historical value CO_old using a weighting factor α = 0.2: CO_updated = α × CO_new + (1 - α) × CO_old. A maximum allowable time difference threshold (MAX_DeltaT = 500 milliseconds) is also set. If the calculated offset exceeds the threshold, an anomaly alarm is triggered and a switch to the backup NTP server cluster is initiated. All corrected timestamps (CT) are appended with a unique session ID (SID), forming a time-aligned multisource data stream with a unified time base, laying the foundation for subsequent event correlation.

[0021] In practical applications, extreme scenarios must be handled, such as large time jumps caused by a user's device in airplane mode. The system adds an Event Sequence Number (ESN) to the tracking log. When it detects an abnormal time interval between adjacent event timestamps (e.g., exceeding one hour) and discontinuous sequence numbers, the Time Backtrace Validator module is activated. This module combines the last valid network time reported by the device, local event density (e.g., the number of events triggered per second), and the server-side received time series. Using the Dynamic Time Warping (DTW) algorithm, it matches multi-dimensional temporal features to reconstruct a reasonable timeline. For example, a user browses an ad and then loses connection for 10 minutes, generating three local click events. The system automatically interpolates and generates compensated timestamps based on the event operation interval (e.g., a 2-second click interval) and the last recorded network time on the server. Ultimately, the Time Sync Error Rate (TBER) for all data streams is kept below 0.01%, ensuring precise alignment of cross-platform behavior and ad exposure events.

[0022] Based on multi-source data streams with a unified time base, the system intercepts the user's complete session trajectory through an event-triggered sliding window, extracting the spatiotemporal correlation sequence between behavioral events and ad exposure events. The time-synchronized data stream enters the Session Trajectory Builder. This engine defines session start events as: a user opening the app, redirecting to an ad landing page from an external link, or a timeout of 30 minutes (i.e., a session timeout of TS = 1800 seconds) since the last event. When a start event is detected, a dynamic sliding window (DSW) is immediately created. The window length (WL) is initialized to a default value of 300 seconds but expands in real time based on user behavior. For example, when a user triggers the "Add to Cart" event, the window automatically extends to 600 seconds to accommodate potential decision delays. During the window period, the engine continuously captures two types of key data: 1) User Behavior Sequence, including page scroll depth, click coordinates, and dwell time; 2) Ad Exposure Sequence, including ad slot ID, creative hash, and exposure duration. Each event carries a corrected timestamp (CT) and geohash (GH).

[0023] The core of spatiotemporal correlation is the Event Chain Fusion Algorithm. This algorithm first arranges all events in ascending time order within a sliding window, and then performs three levels of correlation: Temporal proximity association: If the interval between the end of ad exposure and the start of the behavioral event is less than the threshold ΔT1 = 200 milliseconds, it is considered a direct trigger (e.g., clicking the buy button immediately after the ad is closed); Spatial overlap association: When the ad floating layer covers the page button, the intersection over union (IoU) of the two in the screen coordinate system is calculated. If IoU>0.6 and the event interval <ΔT2=1 second, a strong spatial association is established; behavioral pattern association: The pre-trained Hidden Markov Model (HMM) is used to identify behavioral patterns (such as "ad exposure → page scrolling → multiple price comparisons → click to buy") and output the state transition probability matrix.

[0024] Finally, a spatio-temporal association sequence (STAS) is generated, whose data structure is: [timestamp CT, event type, advertisement ID, behavior type, geographic coordinate GH, association strength value AS (0~1)].

[0025] To handle high-concurrency scenarios, the system utilizes a distributed session state machine (DSSM). Each user session is assigned a unique partition key (partition key = user ID + session ID), and event streams are stored by partition in a Kafka message queue. The triggering and closing of sliding windows is dynamically managed by the Event Stream Processor. When there are no new events within a window for five consecutive seconds (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 trajectory compression is triggered. This compression process utilizes a critical path extraction algorithm, retaining event nodes with a correlation coefficient greater than 0.3 with the conversion target (such as order placement and registration) while eliminating irrelevant noise events (such as accidental clicks). Ultimately, each session outputs a weighted spatiotemporal correlation sequence, which serves as the atomic unit for subsequent analysis.

[0026] The spatiotemporal correlation sequence is fed into the adaptive meshing engine, and the event density is aggregated at a dynamic resolution to generate the initial spatiotemporal event tensor; The core task of the Adaptive Grid Partitioning Engine is to address data sparsity. After receiving a spatiotemporal association sequence (STAS), the engine first establishes a three-dimensional coordinate system: the X-axis represents the time dimension (unit: minutes), the Y-axis represents the geographic space dimension (with 7-bit Geohash precision, approximately a 150-meter grid), and the Z-axis represents the event type dimension (encoded as a 32-dimensional one-hot vector). The initial grid resolution is fixed (e.g., 1-minute time buckets, 1 square kilometer geographic grids), but it dynamically adjusts based on event density: Time dimension: During peak hours (e.g., 20:00-22:00), when the number of events in a 1-minute bucket exceeds a threshold (e.g., 1000 events), it is automatically split into 30-second sub-buckets. Spatial dimension: For urban business districts (e.g., Geohash prefix wx4g), when the grid event density is greater than 50 events per square kilometer, the Geohash accuracy is increased to 8 bits (approximately 38-meter grids). Event dimension: Principal Component Analysis (PCA) is used for dimensionality reduction, retaining the 16 principal components with a cumulative variance contribution rate greater than 85%.

[0027] Dynamic resolution adjustment relies on the Density Peak Detection algorithm. This algorithm calculates the 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. To define a density peak point, it must simultaneously meet the conditions: LD > 2 times the average density (LD_threshold = 2 × LD_mean) and DD > the system-set distance threshold (e.g., DD_min = 5 km). When a peak point is detected, the engine performs quadtree splitting centered on this point: divides the current grid into 4 sub-grids (in the time or space dimension) and recalculates the density of the sub-grids. For example, for a business district grid with LD = 120 times per cubic kilometer in the 19:30 bucket (far exceeding the mean of 40 times), it is split into 4 sub-grids of 500 × 500 meters. The reverse process also exists: if the LD of a sub-grid is < LD_mean × 0.5 for 3 consecutive periods, it is merged into the parent grid.

[0028] After grid aggregation, an Initial Spatio-Temporal Event Tensor (ISET) is generated. The tensor has a four-dimensional structure: [time bucket index × geographical grid index × main component of event type × statistical metric]. Statistical metrics include: Base Count (Event Count, EC); Conversion Rate (CR = number of conversion events / total number of events); Mean Association Strength (MAS).

[0029] The tensor filling uses the Nearest Neighbor Interpolation method: for new cells generated due to grid splitting, inherit 80% of the data from the parent cell and add 20% of the neighborhood mean. The final output tensor size is dynamically variable, with a typical scale of [number of time buckets T = 1440] × [number of geographical grids G = 5000] × [event dimensions E = 16] × [number of metrics M = 3], and efficient storage is achieved through tensor slicing technology.

[0030] Apply a low-rank tensor completion model to the initial spatio-temporal event tensor to repair missing data blocks and output a complete multi-dimensional data cube.

[0031] The Initial Space-Time Event Tensor (ISET) suffers from missing data (e.g., no buried point data in remote grids). The system uses the Low-Rank Tensor Completion Model (LRTCM) to repair this problem. The model assumes that the complete tensor can be decomposed into a Tucker decomposition of three low-rank matrices: the product of a core tensor and factor matrices. The model sets the rank parameters (R_time=10, R_geo=8, R_event=5) and solves the problem iteratively using the Alternating Least Squares (ALS) method.

[0032] The completion process includes three stages of optimization: Missing data marking: Create a binary mask tensor to mark grid events as missing when the number of events is below a trust threshold (e.g., EC < 5); Weighted regularization optimization: Add a spatio-temporal smoothness constraint to the objective function to penalize drastic changes in adjacent grids; Incremental update: When a new real-time data stream is added, only the affected grids (within a 5-kilometer radius covered by the new event) are partially completed to reduce computational effort. The completion effect is evaluated through a dual verification mechanism: 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, requiring RMSE < 0.15; external validation: compare the ad conversion rate of the completed area with the results of a manual sampling survey, with the error threshold set to ±5%.

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

[0034] S202: Decouple the multidimensional data cube into features, separate the stable feature set and the transient feature set through a cross-attention mechanism, and use a graph neural network to model the nonlinear interaction between the features, outputting a weighted dynamic feature topology network. Specifically, this may include: S2021, slices the multidimensional data cube into feature vector sets, calculates the mutual information entropy between features through a multi-head cross-attention mechanism, and generates a set of high-entropy interactive feature pairs; The input source is a multidimensional data cube, whose three-dimensional structure corresponds to the time dimension (user behavior sequence), the spatial dimension (ad touchpoint location), and the feature dimension (behavioral and advertising metrics). The system first uses a sliding window slicing technique to extract data segments along the time axis at a fixed step size (e.g., every 5 minutes). Each segment is flattened into a feature vector containing hundreds of feature values, such as user click-through rate, exposure duration, and conversion signals at all spatial locations within that time period. These feature vectors form a feature vector set (FVS). The system then initiates a multi-head cross attention mechanism (MCAM). This mechanism comprises multiple parallel computation heads (typically 8-16), each of which independently calculates correlations across different feature subspaces. For example, one attention head focuses on user behavior characteristics (such as page dwell time and scroll depth), while another focuses on ad features (such as creative type and bidding strategy). Within each head, a feature similarity matrix (SM) is calculated using the query (Q), key (K), and value (V) triple vectors. Specifically, two feature vectors (such as "ad click-through rate" and "page bounce rate") are mapped to Q and K vectors respectively, and their dot product results are normalized by Softmax to generate the attention weight (AW), which reflects the correlation strength of the two features in the current context.

[0035] Based on the attention weights, the system further calculates the mutual information entropy (MIE) between features. Mutual information entropy measures the statistical dependence between two feature variables. For example, if the MIE value between "ad exposure frequency" and "add-to-cart behavior" is above a threshold (e.g., 0.35), it indicates a strong correlation between the two. The calculation uses a nonparametric estimation method: First, a joint probability distribution table (JPDT) is constructed using the attention weights to record the co-occurrence frequency of feature pairs. The entropy value (EV) is then calculated based on the JPDT. Each attention head outputs a high-entropy candidate set (HECS), consisting of the top ten percent of feature combinations ranked by MIE value (e.g., "search keyword match - conversion rate" pairs). 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 (ranging from 0 to 1), for example the entry “Feature A-ID: CTR (click-through rate), Feature B-ID: CPA (cost per acquisition), MIE: 0.78”.

[0036] To improve computational efficiency, the system employs a dynamic pruning strategy (DPS). During the attention weight calculation phase, if the Euclidean distance (ED) between two feature vectors exceeds a preset radius (e.g., 3.5 standard deviations), the subsequent MIE calculation is skipped. A feature importance cache (FIC) is also introduced, allowing historical high-frequency, high-entropy feature pairs (e.g., "ad location-user device type") to directly reuse cached results, reducing real-time computational effort. The resulting HEIFPS set serves as the core input for subsequent feature decoupling. Its data format is a sparse matrix (SMX), where row / column indices correspond to feature IDs and matrix element values ​​are MIE scores.

[0037] S2022, based on the set of high entropy interaction feature pairs, uses the spectral clustering algorithm to divide the stable feature subset and the transient feature subset; High Entropy Interaction Feature Pair Sets (HEIFPS) essentially describe a nonlinear network of interactions between features. This network is modeled as a weighted undirected graph (WUG): nodes (ND) represent individual features (such as "user region"), edges (ED) connect feature pairs with high MIE values, and edge weights (EW) are the MIE values ​​(e.g., 0.68). The core of the Spectral Clustering Algorithm (SCA) is to partition the graph into two subgraphs: the Stable Feature Subset (SFS) and the Transient Feature Subset (TFS). First, the Laplacian Matrix (LM) of the graph is constructed: its diagonal elements represent the node degrees (DG), i.e., the sum of the edge weights, and the off-diagonal elements represent the negative edge weights. For example, the DG value of the node "Ad Creative ID" is the sum of its MIEs with all other features.

[0038] Perform eigendecomposition (ED) on the Laplacian matrix and extract the eigenvectors (EV) corresponding to the first k smallest eigenvalues ​​(SEV). Here, k is fixed at 2, corresponding to two clusters. The second smallest eigenvector (SSEV) is used as the splitting basis: nodes are sorted by SSEV component value and then subjected to a binary cut (BC). For example, nodes with component values ​​greater than 0 are classified as SFS, while nodes with component values ​​less than 0 are classified as TFS. Stable features (SFS) are typically time-invariant (such as user profile attributes), with dense association networks and balanced weights. Transient features (TFS) fluctuate significantly over time (such as real-time bidding prices), with sparse association networks and concentrated weights. Modularity optimization (MO) is incorporated into the actual splitting process: Modularity scores (MS, ranging from -1 to 1) are calculated at different cut points, and the cut that maximizes MS is selected (target MS>0.4).

[0039] To enhance robustness, the system performs multi-scale validation (MSV). Using different similarity thresholds (e.g., MIE > 0.3, > 0.5, > 0.7), the HEIFPS set is reconstructed and the spectral clustering process is repeated. If the consistency rate (CR) of the feature subsets at each scale exceeds 85% (e.g., "user age" always belongs to the SFS, and "current time period" always belongs to the TFS), the result is considered reliable. Ultimately, two feature subsets are output: the SFS, which contains a list of nodes (e.g., the feature ID list [101, 205, 307]) and their type label "stable," and the TFS, which contains a list of nodes (e.g., [402, 518]) and the label "transient."

[0040] S2023, constructing a dynamic interaction graph structure based on the stable feature subset and the transient feature subset, wherein the nodes of the dynamic interaction graph structure represent feature units, and the edge weights of the dynamic interaction graph structure represent feature transition probabilities; Based on the partitioned SFS and TFS, the system constructs a dynamic interaction graph (DIG). The node set (NS) contains all unit features (UFs), and each node stores feature metadata (MD): feature ID, name (such as "impression_count"), type (stable / transient), and statistics (mean, variance). The edge set (ES) is generated according to the Causal Inference Principle (CIP): the transfer entropy (TE) algorithm is used to calculate the direction and strength of influence between features. For example, the transfer entropy value (e.g., 0.42) from "number of ad impressions" (node ​​A) to "page dwell time" (node ​​B) is used as the edge weight, indicating the causal influence of A on B.

[0041] The dynamic nature is reflected in the time-varying property (TVP) of edge weights. The system calculates the transfer entropy by sliding with a time window (e.g., 1 hour): Data alignment: Extract the eigenvalue sequence of SFS and TFS within the window (e.g. [1.2, 0.8, 1.5]); Probability estimation: Calculate the joint probability distribution through kernel density estimation (KDE). Entropy calculation: 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)] outputs the entropy value. This result is used to update the edge weight matrix (EWM) in real time. For example, at time t, the weight of edge A→B is updated to 0.39. A weight decay mechanism (WDM) is also established: historical weights decay exponentially (with a decay factor of 0.95) to ensure that the graph structure reflects the latest dynamics.

[0042] Small-world Network Restructuring (SWNR) is used to optimize the graph structure. First, weak links with weights below a threshold (e.g., 0.1) are removed to reduce noise. Next, cross-subset hub edges (HE) are added: nodes with the highest degree centrality (DC) in both the SFS and TFS (e.g., "user interest tags" in SFS, "real-time bidding ranking" in TFS) are selected, and bidirectional links are forced to be added, with an initial weight of 0.5. The resulting DIG is stored as an adjacency list (AL). Example format: Node ID: 102 [Type: stable]; Neighbor List: → Node ID: 305 [Weight: 0.76]; → Node ID: 411 [Weight: 0.58].

[0043] 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; The Dynamic Interaction Graph (DIG) is used as input, and its Temporal Graph Neural Network (TGNN) consists of three layers of processing: 1. Graph Convolutional Layer (GCL): This model uses a variant of the Graph Attention Network (GATv2). Each node aggregates neighbor information using a weighted summation of the information through the Attention Mechanism (AM). For example, a node's "click-through rate" aggregates the feature vectors of its neighbors' "impressions" (weighted 0.7) and "ad position" (weighted 0.3). The output is a node embedding vector (NEV) with a dimension of 256.

[0044] 2. Gated Temporal Convolution Module (GTCM): Processes the evolution of node features on the timeline. The module contains two parallel branches: The Causal Convolution Branch (CCB) uses a one-dimensional convolution kernel (width 3) to slide along time, extracting local patterns (e.g., "increased conversion rate within 5 minutes of exposure"). The Gating Mechanism Branch (GMB) uses a sigmoid function to generate a gating value (range 0-1) 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 element-wise multiplied (EM) to form a Temporal Enhanced Feature (TEF). For example, for the "Add to Cart Rate" node, the output is a sequence of evolution vectors for 24 time steps.

[0045] 3. Topology Fusion Layer (TFL): The spatial topological relationships output by GCL are fused with the temporal evolution features output by GTCM. A Gated Recurrent Unit (GRU) is used as the fusion layer: NEV is used as the initial state and TEF is used as the input sequence, and the node states are iteratively updated. The final output is a Temporal Enhanced Feature Topology (TEFT), which is a three-dimensional tensor: Dimension 1: node ID (150 features in total); Dimension 2: time step (length 24); Dimension 3: feature embedding (dimension 256).

[0046] This topology fully captures the nonlinear interactions of features in the spatiotemporal dimensions (e.g., “how does user click behavior affect conversion decisions over time after ad creatives are changed”).

[0047] S2025, performs gradient importance distillation on the temporal enhanced feature topology, calculates the node influence factor, and generates a dynamic feature topology network with semantic weights.

[0048] 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: Construct a baseline input (BI): take the average of all features (e.g., click-through rate = 1.2%). Define a prediction function (PF): input the TEFT into a fully connected layer (128 neurons) to output the conversion probability. Path integral (PI): accumulate the gradient change along a straight line from BI to the actual input (AI). The result is the integrated gradient value (IGV) of each node. For example, the IGV for the node "Number of historical user purchases" is 0.35.

[0049] The node influence factor (NIF) is obtained through normalization: Absolute Value Transformation (AVT): Take the absolute value of the IGV (|IGV|); Softmax Normalization (SN): NIF_i = e^{|IGV_i|} / Σ_j e^{|IGV_j|}. The resulting NIF value ranges from 0 to 1 and sums to 1, representing the relative importance of the node. For example: the node "Ad Relevance Score": NIF = 0.28; the node "Current Network Latency": NIF = 0.03.

[0050] Generate a Semantically Weighted Dynamic Feature Topology Network (SWDFTN): Node weight injection: NIF values ​​are written into TEFT as node attributes. For example, a new field weight: 0.28 is added to the metadata for node ID: 205. Edge weight enhancement: Edges connecting nodes with high NIF values ​​are amplified (Amplification Factor, AF=1.2). Topology compression: 256-dimensional embeddings are reduced to 3 dimensions using the t-SNE algorithm for easier visualization. The final network is stored in a graph database (such as Neo4j) and contains: 150 nodes (with ID, name, type, and NIF value); 2,300 edges (with source node, target node, and transition probability). This network can be directly used for ad conversion prediction and attribution analysis. For example, the top 5 percent of nodes with the highest NIF values ​​(e.g., "User Intent Recognition Confidence") are pushed to the policy engine as key decision factors.

[0051] S203: Input 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. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, and ultimately outputs a spatiotemporal distribution map of advertising conversion probabilities. Specifically, this may include: S2031, based on the dynamic feature topology network, extracts topological structure features through the graph attention encoder and integrates the long short-term memory network to generate a virtual transformation path sequence; The dynamic feature topology network is fed into the generator module of the adversarial training framework as input. This network consists of semantically weighted nodes (representing user attributes, ad features, etc.) and weighted edges (representing transition probabilities between features). The generator first processes this network using a graph attention encoder (GAE). The core of the GAE is a multi-head attention mechanism (e.g., eight heads), each of which independently computes attention coefficients between nodes. Specifically, for each target node (e.g., the node representing "25-35-year-old male user"), the encoder calculates the strength of its association with neighboring nodes (e.g., the node that "clicked on a car ad"). This strength is determined by three components: the node's own weight (e.g., a user node weight of 0.85), edge weights (e.g., a transition probability of 0.7), and node feature similarity calculated using a learnable parameter matrix (e.g., a 256 by 256 matrix). Each attention head outputs a weighted aggregated neighbor feature vector (128 dimensions). The outputs of the eight heads are concatenated and fused through a linear layer (with an output dimension of 256) to form the node's topological structure feature vector. This process traverses all nodes and finally generates a topological representation of the entire graph (dimension: number of nodes multiplied by 256).

[0052] Topological features must be combined with temporal behavior to generate paths. The system treats each user session as a time series (for example, 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 process this sequence. LSTM units (e.g., hidden layer dimension 128) receive input stepwise. The input for each time step consists of two components: 1) features of the current touch event (e.g., ad type code, page dwell time, dimension 50); 2) topological features of the node corresponding to the touch event (dimension 256). Through the input gate, forget gate (threshold initialized to 0.6), output gate, and cell state mechanism, LSTM selectively memorizes long-term dependencies (such as the influence of early exposure) and short-term patterns (such as consecutive clicks). For example, when processing the "Add to Cart" touchpoint, the forget gate might reduce the memory strength of the "Browse Homepage" event from five minutes ago (output value 0.3), while the input gate strengthens the association between the current event and the "high purchase propensity" topological feature (output value 0.9). The LSTM outputs a hidden state (dimension 128) at each time step, which encodes the path context up to the current touchpoint.

[0053] The generation of a virtual conversion path sequence (VCPS) is an autoregressive process. The system takes the topological and event features of the starting event (e.g., "first ad exposure") as initial input and feeds them into an LSTM to generate the first hidden state, H1. The policy network in the generator (e.g., two fully connected layers with an output dimension equal to the number of event types) receives H1 and outputs a probability distribution (e.g., {"Click on Ad A": 0.4, "Close the page": 0.5, "Go to details page": 0.1}). Based on this distribution, the next virtual event type is sampled (e.g., using Gumbel-Softmax sampling with a temperature parameter of 0.8). This event type is encoded as a feature vector and concatenated with the topological features of the corresponding node in the graph to serve as the input to the LSTM at the next time step. This process iterates until a "conversion" event (e.g., purchase) is generated or the preset maximum path length (e.g., 20 steps) is reached. The final output is a virtual user path consisting of a sequence of manually constructed event types and their timestamps, for example: [exposure to AdX (T0), click on AdY (T0+5s), browse product page for 120s (T0+65s), ..., successful payment (T0+600s)].

[0054] S2032, constructing a dual-channel discriminator module, wherein the first channel calculates the Mahalanobis distance between the real transformation path and the virtual transformation path in the latent space, and the second channel verifies the compliance of the path logical constraints, and outputs a dual-channel difference matrix; The discriminator employs a dual-channel architecture for multi-dimensional validation. The first channel focuses on latent space similarity metrics. The real conversion paths (from historical logs) and the virtual conversion paths (from the generator) are first fed into a weighted feature extractor (e.g., a graph attention encoder with the same structure as the generator's GAE, but without shared parameters), projecting them into a unified latent space (dimension 256). Within this space, the first channel calculates the Mahalanobis distance between the two path representation vectors. Unlike the Euclidean distance, the Mahalanobis distance considers inter-feature correlation. The discriminator maintains a trainable covariance matrix (dimension 256 by 256), learned during training from a large number of real paths (e.g., 1 million). This matrix characterizes the distribution structure of latent space features. The distance is calculated as: the real path vector V_real minus the virtual path vector V_virt, the transposed result, multiplied by the inverse of the covariance matrix, and then multiplied by (V_real - V_virt). The output is a scalar distance value D_maha (range 0 to positive infinity), the smaller the value, the more similar the two paths are in the latent space.

[0055] The second channel focuses on path logical constraint compliance (PLCC) verification. The system pre-defines a set of business rules (Rule Base Version 2.1) for ad conversion paths, encompassing temporal logic, causal logic, and statistical constraints. For example, Rule 1: "A user cannot convert before clicking an ad" (strict temporal order); Rule 2: "The conversion probability from 'Add to Cart' to 'Payment Successful' is typically greater than 20%" (statistical constraint); and Rule 3: "Repeated triggering of the same exposure event by the same user within a short period of time (e.g., 1 minute) is invalid" (business logic). The second channel comprises a rule engine and a lightweight temporal convolutional network (TCN). The rule engine directly performs symbolic matching on the path event sequence. Violations of hard rules (such as Rule 1) are marked as severe violations (Penalty Score = 1.0). The TCN (e.g., 3 layers, convolution kernel size 3) processes the continuous features of the path (e.g., time interval sequences and event type encoding sequences) to learn soft constraint patterns. TCN outputs a violation probability score P_violate (between 0 and 1). The final PLCC score S_plcc = hard violation score + P_violate (a larger value indicates less logically sound).

[0056] The Dual-Channel Difference Matrix (DCDM) is the core output of the discriminator. This matrix has dimensions 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 distances (D_maha) calculated from the first channel. The second row of the matrix stores the sequence of logical plausibility scores (S_plcc) calculated from the second channel. For example, when processing a batch of 128 real-virtual path pairs, the DCDM is a 2 by 128 matrix. Each value in the matrix is ​​normalized (for example, D_maha is divided by the maximum value within the batch, and S_plcc is divided by 1.0). This matrix provides a clear, differentiable signal for subsequent generator optimization: the goal of the generator is to generate virtual paths that minimize D_maha (similar latent space) and S_plcc (logical plausibility) in the DCDM.

[0057] S2033, iteratively optimizing the generator parameters using the dual-channel difference matrix, and determining that the generator has reached a convergence state when the discriminator's misjudgment rate for the real / virtual conversion path is continuously lower than a threshold for a preset number of rounds; The adversarial training optimization loop begins. The generator generates a batch (batch size = 128) of virtual paths. The discriminator processes the corresponding real-path and virtual-path pairs, outputting a DCDM matrix (dimension 2 by 128). Generator parameter optimization is performed based on the first row of the DCDM (the Mahalanobis distance D_maha). The system defines the generator loss function as the batch mean of D_maha (Mean_D_maha). Backpropagation is used to calculate the gradient of the loss function with respect to all trainable parameters within the generator (such as the attention encoder weight matrix, LSTM cell parameters, and policy network connection weights). An adaptive optimizer (such as the Adam optimizer with a learning rate of 0.0001, a first-order moment decay rate of Beta1 = 0.9, and a second-order moment decay rate of Beta2 = 0.999) is used to update the parameters based on the gradients. The goal is to reduce Mean_D_maha and bring the virtual paths closer to the real paths in the latent space.

[0058] Optimizing the discriminator parameters is more complex. Its loss function consists of two parts: 1) Discriminative Loss: This requires the discriminator to correctly distinguish between real and imaginary paths (labeled: real is 1, imaginary is 0). After mapping the paths into a latent space, the discriminator outputs the decision 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) Logical Constraint Regularization Term: Based on the second row of the DCDM (S_plcc), this term encourages the discriminator to give a higher P_real for logically plausible paths (whether real or imaginary). The total discriminator loss = BCE loss + λ * S_plcc (λ is a trade-off coefficient, such as 0.5). The discriminator parameters are also updated through backpropagation and the Adam optimizer, with the goal of simultaneously improving classification accuracy and logical sensitivity.

[0059] Convergence Criterion is a critical step. After each round of training, the misclassification rate (MCR) is evaluated on an independent validation set (containing unseen real paths). The MCR is defined as the proportion of times the discriminator mistakenly classifies a real path as "virtual" or a virtual path 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. When the MCR in a validation round is ≤ 0.15, the counter is incremented; 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 for stability and generalization, preventing overfitting or training oscillation. After reaching convergence, the generator stops updating, and its ability to generate virtual paths is considered to have closely approximated real user behavior patterns.

[0060] S2034: Perform Monte Carlo sampling on the converged generator in the feature embedding space and output a heat map of the spatiotemporal distribution of advertising conversion probabilities.

[0061] Monte Carlo sampling is performed using the converged generator to estimate conversion probability. Sampling occurs in the feature embedding space defined by the generator's graph attention encoder. The target sampling area is divided into spatial (e.g., city grid: 1km x 1km) and temporal (e.g., 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) Based on the historical data distribution for that area and time period, a large number (e.g., 10,000) of virtual seed users (SeedUsers) are sampled. Each seed user contains basic features (e.g., age, gender, and device type, sampled from the typical distribution of the area's grid numbers). 2) The seed user's feature vector is fed into the generator (a converged GAE and LSTM), simulating their complete decision path from the first ad exposure. 3) Whether each path ultimately leads to a "conversion" event is recorded.

[0062] Conversion probability calculation is based on sampling results. For each spatiotemporal unit, the number of conversions that ultimately occurred in all simulated paths (e.g., 10,000) is counted (Count_conv). The ad conversion probability (ACP) for that unit is calculated as: ACP = Count_conv / total number of sampling times (e.g., 10,000). For example, if 1,200 paths in 10,000 simulations ultimately resulted in conversions, the ACP is 0.12 (or 12%). This probability comprehensively reflects the likelihood of conversion for a user group in a specific location and time period, given a specific advertising environment (encoded in the dynamic feature topology network). The number of sampling times (e.g., 10,000) directly affects the accuracy of the probability estimate, and the confidence interval can be estimated using the central limit theorem.

[0063] Finally, a spatio-temporal heatmap of conversion probability is generated. The system constructs a three-dimensional grid data structure: two dimensions represent geographic space (e.g., longitude and latitude, with a resolution of 1km), and the third dimension represents time (e.g., 15-minute slices). Each grid cell stores a calculated average conversion probability (ACP) value (e.g., 0.12). A visualization engine (e.g., a WebGL-based renderer) maps these probability values ​​to colors, typically using a gradient color scheme. For example, dark blue indicates low probability (ACP < 0.05), light green indicates medium probability (0.05 ≤ ACP < 0.1), yellow indicates high probability (0.1 ≤ ACP < 0.15), and red indicates high probability (ACP ≥ 0.15). The heatmap supports dynamic playback along a timeline, visually demonstrating how conversion probability varies across different areas at different times (e.g., business districts exhibit a high probability "red zone" during weekday lunchtime, while residential areas exhibit a "yellow zone" during the evening). This heat map is the final spatiotemporal distribution map of ad conversion probability, providing core data basis for subsequent attribution and strategy optimization.

[0064] S204: Based on the spatiotemporal distribution graph of advertising conversion probabilities, deploy an attribution calculation unit with real-time feedback, simulate the evolution of the user's decision path through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals. Specifically, the spatiotemporal distribution graph of advertising conversion probability can be mapped into a decision state tree, wherein the tree nodes of the decision state tree represent advertising touchpoints, and the edge weights of the decision state tree represent conversion transfer probabilities; The system receives an Advertising Conversion Probability Spatio-temporal Map (ACPM) generated by the adversarial training framework. This map is essentially a three-dimensional probability matrix, whose dimensions include timestamps (accurate to the millisecond), geographic coordinates (latitude and longitude grid), and advertising touchpoints (such as search ads, in-feed ads, and splash screen ads). Construction of a decision state tree (DST) first requires defining tree nodes: each node corresponds to an advertising touchpoint (ATP). Node attributes include touchpoint type, occurrence time window (e.g., 0-5 seconds for initial touchpoint), and spatial location (e.g., GPS grid number). Tree edges represent the paths users take from one touchpoint to the next, and edge weights (EW) are calculated using the conversion transition probabilities (CTPs) in the spatio-temporal map. Specifically, if the current contact A is located in area L1 at time T1 and the next contact 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 processed by an exponential decay function (the greater the time difference, the lower the weight) and normalization (to ensure that the sum of the edge weights of the child nodes of the same parent node is 1).

[0065] To reduce computational complexity, a hierarchical abstraction strategy is adopted: Time dimension aggregation: Divide the continuous time axis into logical time periods (such as the morning rush hour 9:00-10:00), and merge similar contacts within the same time period into super nodes.

[0066] Spatial grid clustering: Merge adjacent grids based on geographic density (such as business districts and residential areas) and use the DBSCAN algorithm (Density-Based Spatial Clustering of Applications with Noise) to automatically identify high-density areas and generate clustered nodes.

[0067] Probabilistic pruning: Set a transition probability threshold (e.g., 0.05) and remove edges below the threshold, retaining high-probability paths. The resulting decision tree satisfies the following criteria: the root node is the first touchpoint, the leaf nodes are conversion events (e.g., clicks on a buy button), intermediate nodes are expanded hierarchically in chronological order, and the child nodes of each node are sorted in descending order by edge weight.

[0068] The decision state tree is not static; it is continuously updated through a real-time feedback loop. When new user behavior data arrives, the Incremental Reconstruction Module (IRM) is triggered. This module uses a Difference-Driven Update (DDU) approach to locally reconstruct subtrees only for affected paths (e.g., newly added touchpoints or edges with a probability change exceeding 10%). Global Rebalancing (GR) is performed every 24 hours to recalculate all edge weights and optimize the tree hierarchy to prevent structural distortion caused by long-term data drift. The tree structure is stored in a graph database (such as Neo4j), supporting millisecond-level path queries.

[0069] The incremental Monte Carlo tree search algorithm is used to simulate the evolution of user decision paths and record the frequency distribution of visits to each path. Incremental Monte Carlo Tree Search (IMCTSS) introduces state caching and parallel backtracking based on traditional MCTS: Selection phase: 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 decaying to 0.1 with each search round), balancing exploration (trying low-probability paths) and exploitation (selecting high-weight paths).

[0070] Expansion: When visiting an unexplored node, a new path is randomly expanded according to the probability distribution of the edge weights in the decision tree. Importance sampling (IS) is used during expansion to prioritize branch paths with high historical conversion rates.

[0071] Simulation: Starting from a new node, a virtual user decision path is generated based on the spatiotemporal distribution of ad conversion probabilities. The simulation process incorporates a behavioral noise model (BNM) and adds random jumps (with a 5% probability) to simulate irrational user behavior.

[0072] Backpropagation: Updates node visit counts (VC) and accumulated conversion values ​​(ACV) along the path in reverse order. Incremental backpropagation is used: only statistics for the paths involved in the current simulation are updated, avoiding a full tree traversal.

[0073] Hot Path Cache (HPC): The system maintains a cache pool of frequently accessed paths (for example, the top 100 paths). When a new query hits the cache, the result is returned directly, reducing the computing load by 70%.

[0074] Adaptive Simulation Depth (ASD): Dynamically adjusts the number of simulation steps based on historical user behavior data. For example, luxury goods users have longer decision paths (simulation depth of 50 steps), while fast-moving consumer goods users have shorter paths (simulation depth of 20 steps).

[0075] Real-time feedback integration: When an actual conversion event occurs, the Path Verification Thread (PVT) is immediately triggered to compare the actual path with the simulated path and correct probability deviations (for example, if the actual conversion rate of a touchpoint is 10% higher than the simulated value, its weight is increased by 5%).

[0076] After each simulation is completed, the complete path sequence is recorded and the path access frequency distribution (PAFD) is updated. PAFD is stored in a two-level structure: Path Fingerprint Library (PFL): Uses the MinHash algorithm to compress paths into 128-bit fingerprints for fast duplicate detection.

[0077] Frequency Matrix (FM): A three-dimensional matrix (touchpoint sequence × time window × geographic region) that records the number of visits (AC) and conversions (CC) for each path. Sliding Window Aggregation (SWA) is performed every 10 minutes to purge outdated data (e.g., low-frequency paths from 30 days ago).

[0078] Calculate the Shapley value based on the path access frequency distribution, and dynamically update the contact contribution weights in combination with the exponential decay function; The Shapley Value (SV) is used to fairly distribute the contribution of each touchpoint to conversions. The calculation formula includes four elements: Coalition Generation: For a path consisting of N touchpoints, all possible subsets of touchpoints (i.e., coalitions) are generated, totaling 2^N combinations. For example, for the path {A, B, C}, the contributions of {A}, {B}, {C}, {A, B}, {A, C}, {B, C}, and {A, B, C} must be calculated. Marginal Contribution (MC): The incremental conversion rate brought about by touchpoint i joining coalition S. For example, MC_i(S) = Conversion Rate(S∪{i}) - Conversion Rate(S). Weight Factor (WF): The probability of coalition S emerging, calculated as |S|! (N-|S|-1)! / N! (|S| is the coalition size). Weighted sum: SV_i = Σ[MC_i(S) × WF(S)], summed over all coalitions containing i.

[0079] In order to reduce the amount of calculation, the Monte Carlo Approximation (MCA) method is used: 1,000 alliance combinations are randomly sampled instead of the full combination calculation, and the error is controlled within ±2%.

[0080] The Shapley value needs to be dynamically adjusted in combination with time decay: Attenuation function design: The weight update formula is W_i(t) = α × SV_i + (1-α) × W_i(t-1). The attenuation factor α (Alpha) is dynamically generated by the hyperbolic tangent function (tanh): α = 0.5 × [tanh( (t_now - t_event) / τ) + 1]. The parameter τ (Tau) is the decay time constant (default is 7 days), and t_event is the trigger occurrence time. This design ensures that recent events have a high weight (α close to 1) and distant events have a low weight (α close to 0).

[0081] Scenario-adaptive τ: The τ value is adjusted based on the product type. For example, the decision cycle for automotive advertising is long (τ = 30 days), while the decision cycle for catering advertising is short (τ = 1 day).

[0082] The final touchpoint contribution weight (CW) incorporates multiple dimensions: base weight (the result after the Shapley value (SV) is attenuated); contextual correction: touchpoint location weight (1.2 for touchpoints in first-tier cities, 0.8 for touchpoints in third-tier cities); device type weight (1.1 for touchpoints on mobile devices, 0.9 for touchpoints on desktop devices); and behavioral intensity weighting (1.5 for watching a 15-second video ad and 0.7 for clicking on details without expanding them). The fusion formula is: CW_i = [W_i(t) × location coefficient × device coefficient] × behavioral intensity coefficient. All touchpoint weights are updated in batches every 5 minutes.

[0083] A bootstrap sampling method is used to evaluate the stability of contact contribution weights and generate an attribution weight vector with confidence intervals. Bootstrap Sampling evaluates weight stability by resampling: Construct a resampled set: Randomly sample 1000 paths with replacement from the original path library (the sample size is equal to the original dataset) to form a Bootstrap Sample Set (BSS). Parallel weight calculation: Perform Shapley value calculation (including decay function processing) independently for each BSS to obtain the contact weight vector W_b = [w1_b, w2_b, ..., wn_b] for that sample set. Repeat the sample generation process: Repeat the above process K times (K=500) to generate 500 weight vectors {W1, W2, ..., W500}. Statistic calculation: For each contact i, sort its weight values ​​{w1_i, w2_i, ..., w500_i} in ascending order in the 500 vectors. Take the 25th and 475th values ​​as the lower bound LB_i and upper bound UB_i of the 95% confidence interval (CI).

[0084] To improve the reliability of the results, an adaptive stopping mechanism was introduced: The stability criterion: The mean standard deviation (MSD) of all touchpoint weights was calculated. Sampling was stopped when the MSD changed by <0.01 for three consecutive iterations. Confidence interval optimization: If the width of the touchpoint weight interval (UB_i - LB_i) is greater than 0.1, targeted sampling expansion is triggered: 200 additional samples are added to the paths associated with that touchpoint. For high-value touchpoints (weight > 0.15), a 99% confidence interval (based on the 5th and 495th positions) is used. The final output attribution weight vector (AWV) is in the form of [touchpoint ID, mean weight, lower confidence bound, upper confidence bound]. Example: [ATP123, 0.28, 0.25, 0.31].

[0085] Incremental Computing Engine (ICE): When new data arrives, only the affected contacts (such as contacts that occurred within 24 hours) are resampled, and the remaining contacts continue to use cached results.

[0086] Distributed execution: 500 bootstrap sampling tasks were distributed to 10 GPU servers for parallel execution, reducing the computation time per round from 5 hours to 8 minutes. Abnormal circuit breaker mechanism: When a contact weight suddenly changes (changes >30% between cycles), a full recalculation is automatically triggered to avoid local update distortion.

[0087] The attribution weight vector is converted into 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 strength of the transition probability. Finally, an incremental attribution graph is output.

[0088] Dynamic Force-Directed Graph (DFDG) is built based on the physical particle model: Node Modeling: Each ad touchpoint is treated as a charged particle. Node size (NS) is positively correlated with the attribution weight: NS_i = base radius 10 pixels + weight value × 200 pixels. Particle mass is set as a logarithmic function of the weight (Mass_i = log(10 × CW_i)) to avoid gravitational imbalance caused by excessively large nodes. Edge Modeling: Edges represent the transition relationship between touchpoints. Edge opacity (EO) is linearly correlated with the transition probability (CTP): EO_ij = min(0.9, CTP_ij × 2). The edge spring coefficient is set to a constant 0.0003, and the damping coefficient is 0.02. Force system design: Inter-node repulsion: F_repel = k_repel / d² (d is the node distance, k_repel = 3000); Edge connection attraction: F_attract = k_attract × d (k_attract = 0.8); Center attraction: Prevent edge nodes from drifting, F_center = -0.01×d.

[0089] WebGL visualization engine: uses the Three.js library to implement browser-side 3D rendering, supporting: Focus diffusion: When clicking a node, strongly associated edges are highlighted (transparency increases to 0.95), and weakly associated edges are faded (transparency drops to 0.2); Timeline dragging: Sliding the timeline dynamically displays weight changes, with smooth node size transitions; Confidence interval visualization: When the mouse hovers over a node, a semi-transparent confidence interval ring (inner ring LB_i, outer ring UB_i) is displayed. Incremental update strategy: New Contacts: Added with an initial position of (0,0) and automatically drifted to equilibrium using the force system. Weight Update: Node size gradually changes to the new value within 0.5 seconds to avoid visual jumps. Edge Vanishing: When the transition probability is < 0.01, the edge transparency is linearly reduced to zero within 1 second and then removed.

[0090] The final output, the Incremental Attribution Map (IAM), contains three layers of information: The core topology layer: A force-directed graph displays relationships between touchpoints. Node size equals contribution weight, and edge transparency equals transition probability. The spatiotemporal thermal layer: Geographic information is overlaid with semi-transparent blocks of color, with color depth representing regional conversion rates (red indicates high, blue indicates low). The dynamic indicator layer: A real-time floating window displays key data: the current top three high-value touchpoints (weight + confidence interval); path conversion rate trends (compared to the same period last week); and abnormal touchpoint alerts (e.g., a touchpoint with a sudden 30% drop in weight is marked with a flashing red color). The graph connects to the ad delivery system via an API, providing incremental data updates every 15 seconds to support real-time strategy adjustments.

[0091] S205, inputting the incremental attribution graph into a strategy-generating adversarial network, using the generator of the strategy-generating adversarial network to synthesize a multi-dimensional advertising delivery strategy vector under constraints, and the discriminator of the strategy-generating adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputting an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

[0092] Specifically, the node weights and edge transition probabilities of the incremental attribution graph can be encoded into a graph constraint matrix and input into the graph convolutional encoding layer of the policy generator; The Incremental Attribution Map (IAM) is presented as a dynamic force-directed graph structure, where the node weight (NW) represents the contribution weight of each advertising touchpoint (such as search engine ads and social media push notifications) (range: 0-1). For example, a video ad node weight NW = 0.35 means it contributes 35% of the conversion rate; the edge transition probability (ETP) represents the probability of a user jumping from touchpoint A to touchpoint B (for example, the probability of jumping from an e-commerce banner to a live broadcast room ETP = 0.78). The encoding process is divided into three steps: Topological feature extraction: Using a graph structure parsing algorithm, we traverse all nodes and edges in the IAM, combining the NW of each node with the ETP of its associated edges to form a two-dimensional vector (e.g., node vector = [NW = 0.35, average ETP = 0.62]). Matrix construction: All node vectors are arranged in graph topology order to generate an initial graph constraint matrix (GCM) with dimensions of N × 2 (N is the total number of nodes). For example, 200 touchpoints generate a GCM with 200 rows × 2 columns. Historical ROI integration: Historical advertising ROI (Return on Investment) data is mapped to additional columns by touchpoint category. For example, a third column is added to the GCM to store the average ROI of each touchpoint over the past 30 days (e.g., search ad ROI = 1.8), forming an enhanced graph constraint matrix (EGCM).

[0093] The Graph Convolutional Encoder Layer (GCEL) workflow of the strategy generator is as follows: Neighborhood Aggregation: 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 neighboring nodes, such as those for search ads and KOL promotions, are aggregated.

[0094] Feature transformation: Using the weighted message passing (WMP) mechanism, the feature weights of neighboring nodes are adjusted based on the edge ETP. For example, an edge with an ETP of 0.8 is assigned a feature weight of 0.8, while a low-probability edge (ETP = 0.2) is assigned a weight of only 0.2.

[0095] Output latent vector: After three layers of graph convolution, each node outputs a 128-dimensional latent feature vector (LFV), which fully describes its topological role and historical performance in the attribution graph.

[0096] The strategy generator integrates the graph constraint matrix and historical ROI data to synthesize a multi-dimensional advertising strategy vector through a conditional adversarial generation mechanism; The core of the Strategy Generator (SG) is the Conditional Adversarial Generation (CAG) mechanism, whose input includes: EGCM encoding results: node LFV collection from GCEL; historical ROI database: structured storage of fields such as advertising channel costs, conversion rates, and user profiles (for example, the field "Short Video Channel_18-25 Years Old Female_CPM=$5_Conversion Rate=12%").

[0097] Strategy vector synthesis process: Conditional constraint injection: Historical ROI data is categorized by business dimension into budget constraints (e.g., daily total budget ≤ $50,000) and demographic coverage constraints (e.g., young user coverage ≥ 60%). These constraints are converted into condition vectors (CVs) and input into the SG.

[0098] Feature Fusion: The SG decoder module concatenates the node LFV and CV, generating a fused feature (FF) through a fully connected layer. For example, a touchpoint LFV (128 dimensions) and a budget condition CV (10 dimensions) are concatenated into a 138-dimensional vector. Strategy Vector Generation: Based on the FF, a multi-dimensional advertising strategy vector (MSV) is generated, containing the following typical dimensions: Channel Weight (CW): The proportion of each advertising channel's budget (e.g., CW for information flow advertising = 0.4, CW for search engines = 0.3); Time Intensity Coefficient (TIC): The 24-hour delivery intensity distribution (e.g., TIC = 1.2 for 8-10 pm, TIC = 0.3 for midnight); Creative Combination (CC): The ratio of graphic / video / interactive advertising (e.g., video material accounts for 70%).

[0099] Adversarial generation example: SG's first-round generation strategy is MSV1 = [CW: Information flow 0.4, Search 0.3; TIC: Evening peak 1.2; CC: Video 70%]. The discriminator determines that its budget has exceeded the limit, and SG adjusts the parameters to output MSV2 = [CW: Information flow 0.35, Search 0.25; TIC: Evening peak 1.0; CC: Video 60%].

[0100] The strategy discriminator receives the strategy vector, performs three-level validation based on the historical ROI database, and outputs a three-dimensional effectiveness score matrix. The three-level validation includes: budget constraint validation: comparing the total strategy cost with the historical cost distribution; conversion gain validation: the difference between the strategy's expected conversion rate and the historical benchmark; and risk entropy validation: calculating the Sharpe ratio of the strategy portfolio. The Strategy Discriminator (SD) uses a three-stage verification framework (TV) to perform the following verification on the input MSV: (1) Budget Constraint Verification (BCV) Comparison logic: Calculate the total cost of the strategy (e.g., the proportion of the information flow channel budget in MSV is 0.35 × the total budget is 50,000 = 17,500 US dollars), and compare it with the historical cost distribution (e.g., the 25th percentile cost of the same channel in the past 90 days is 15,000, and the 75th percentile cost is 22,000).

[0101] Scoring rules: If the strategy cost is within the historical 25th-75th percentile range, the BCV score = 100; if it is below the 25th percentile, the score decreases linearly (for example, BCV = 70 when the cost is 12,000 yuan), and if it is above the 75th percentile, points are deducted according to the overspending ratio (for example, BCV = 40 when the cost is 25,000 yuan).

[0102] (2) Conversion Gain Verification (CGV) Benchmarking: Calculate the baseline conversion rate (BCR) for each channel based on historical ROI data. For example, a BCR of 10% for feed ads. Gain calculation: Estimate the strategy's conversion rate based on the channel weight and time period coefficient in the MSV (e.g., a TIC of 1.2 during the evening peak can increase the feed conversion rate to 12%). Gain value ΔC = (estimated conversion rate - BCR) / BCR (in this example, ΔC = 20%). Score mapping: ΔC is graded based on the historical gain distribution (e.g., CGV = 100 for ΔC > 15% and CGV = 60 for ΔC = 5%).

[0103] (3) Risk Entropy Verification (REV) Sharpe Ratio (SR): This measures the conversion gain per unit of risk. The formula is: SR = (strategy expected conversion rate - risk-free conversion rate) / conversion rate standard deviation. The risk-free conversion rate is taken as the historical lowest value (e.g., 5%), and the standard deviation is calculated based on 90 days of historical data (e.g., a 2% standard deviation for information flow channels). For example, if the strategy's expected 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: A 3D Score Matrix (3DSM): Each strategy vector (MSV) corresponds to a 3D score [BCV, CGV, REV]. For example, Strategy A's 3DSM = [80, 90, 75].

[0104] The strategy generator is iteratively optimized according to the effectiveness score matrix. When the distribution density of the multidimensional advertising delivery strategy vector on the Pareto front reaches saturation, the non-dominated solution set is extracted as the adversarial optimization advertising delivery strategy set that satisfies Pareto optimality.

[0105] (1) Iterative optimization loop Generator Update: The 3DSM returned by the SD is fed into the SG's loss function (LF). LF is defined as the weighted inverse of the three-dimensional score (e.g., LF = 1 / (0.4×BCV + 0.4×CGV + 0.2×REV)). The SG updates the network weights using a backpropagation algorithm (e.g., the Adam optimizer) to optimize the newly generated MSVs toward higher scores. Convergence: The model is considered converged when the overall improvement in the 3DSM over 10 consecutive rounds of generated MSVs is less than 1% (e.g., the average score increases from 85 to 85.8).

[0106] (2) Pareto Front (PF) Construction Multi-objective optimization: All generated MSVs (e.g., 10,000 strategies) are projected into a three-dimensional scoring space (BCV-CGV-REV coordinate system). Frontier extraction: A non-dominated sorting (NDS) algorithm is used. Hierarchical division: Strategies that are not fully surpassed by any other strategy in all three dimensions are classified as PF-1 (the optimal frontier); strategies surpassed by PF-1 strategies are classified as PF-2, and so on.

[0107] Density saturation determination: When the number of PF-1 layer strategies is ≥ 20% of the total number of strategies (e.g., 2,000), and the proportion of PF-1 layers in newly added strategies is < 5%, the distribution density is determined to be saturated.

[0108] (3) Non-dominated Solution Set (NDSS) output Business Constraint Filtering: Filter policies from the PF-1 layer to meet hard requirements (e.g., BCV ≥ 70, CGV ≥ 60, REV ≥ 50). Diversity Ensuring: Use crowding distance (CD) calculation to retain policies that are evenly distributed across all target directions (e.g., avoid concentrating all policies in areas with high BCV and low REV). The final output: The NDSS contains 100-500 policy vectors, each annotated with a three-dimensional score. For example: Policy X: [BCV=85, CGV=92, ​​REV=78] → focuses on conversion gain; Policy Y: [BCV=95, CGV=80, REV=88] → focuses on budget security; Policy Z: [BCV=82, CGV=85, REV=90] → a balanced solution.

[0109] Another embodiment of the present invention provides an advertising effect evaluation system based on artificial intelligence, see Figure 3 , the system may include: Acquisition module 301 is used to synchronously acquire multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine, eliminate time offsets of multi-source data using a timestamp-driven event window alignment algorithm, and generate a spatiotemporally synchronized multidimensional data cube; A separation module 302 is configured to perform feature decoupling on the multidimensional data cube, separate a stable feature set from a transient feature set through a cross-attention mechanism, model the nonlinear interaction between features using a graph neural network, and output a weighted dynamic feature topology network; A generation module 303 is configured 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 a virtual conversion path. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, ultimately outputting a spatiotemporal distribution map of ad conversion probabilities. Simulation module 304 is configured to deploy a real-time feedback attribution calculation unit based on the spatiotemporal distribution graph of ad conversion probabilities, simulate the evolution of user decision paths through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals; The output module 305 is used to input the incremental attribution graph into the strategy generation adversarial network, use the generator of the strategy generation adversarial network to synthesize a multi-dimensional advertising delivery strategy vector under constraints, and the discriminator of the strategy generation adversarial network combines historical ROI data to verify the effectiveness of the strategy, and output an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

[0110] An embodiment of the present invention further provides a storage medium storing a computer program, wherein the computer program is configured to execute the steps of any one of the above method embodiments when running.

[0111] An embodiment of the present invention further provides an electronic device, comprising 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 steps in any one of the above method embodiments.

[0112] Specifically, the electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the processor, and the input / output device is connected to the processor.

[0113] The above describes in detail the structure, features and effects of the present invention based on the embodiments shown in the drawings. The above is only a preferred embodiment of the present invention, but the scope of implementation of the present invention is not limited to what is shown in the drawings. Any changes made in accordance with the concept of the present invention, or modifications to equivalent embodiments with equivalent changes, which do not exceed the spirit covered by the description and drawings, should be within the scope of protection of the present invention.

Claims

1. An advertising effect evaluation method based on artificial intelligence, characterized in that: The method comprises: Through the distributed collection engine, multi-source data, including user behavior data streams and advertising delivery indicator streams, is synchronously acquired. A timestamp-driven event window alignment algorithm is used to eliminate time offsets in multi-source data, generating a spatiotemporally synchronized multidimensional data cube. Decoupling the features of the multidimensional data cube, separating the stable feature set and the transient feature set through a cross-attention mechanism, and using a graph neural network to model the nonlinear interaction relationship between the features, outputting a weighted dynamic feature topology network; 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. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, and ultimately outputs a spatiotemporal distribution map of the advertising conversion probability. Based on the spatiotemporal distribution graph of ad conversion probabilities, a real-time feedback attribution calculation unit is deployed. The Monte Carlo tree search is used to simulate the evolution of the user's decision path, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals. The incremental attribution graph is input into a strategy-generating adversarial network, and a multi-dimensional advertising delivery strategy vector is synthesized under constraints using the generator of the strategy-generating adversarial network. The discriminator of the strategy-generating adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

2. The method according to claim 1, characterized in that The method synchronously acquires multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine, eliminates the time offset of the multi-source data using a timestamp-driven event window alignment algorithm, and generates a spatiotemporally synchronized multidimensional data cube, including: Based on user terminal tracking logs and ad server interface streams, a clock drift compensation algorithm is used to align original timestamps, generating a multi-source data stream with a unified time base. Based on multi-source data streams with a unified time base, the system intercepts the user's complete session trajectory through an event-triggered sliding window, extracting the spatiotemporal correlation sequence between behavioral events and ad exposure events. The spatiotemporal correlation sequence is fed into the adaptive meshing engine, and the event density is aggregated at a dynamic resolution to generate the initial spatiotemporal event tensor; Apply a low-rank tensor completion model to the initial spatiotemporal event tensor to repair missing data blocks and output a complete multidimensional data cube.

3. The method according to claim 2, characterized in that The multidimensional data cube is subjected to feature decoupling, a stable feature set and a transient feature set are separated through a cross-attention mechanism, and a graph neural network is used to model the nonlinear interaction relationship between features to output a weighted dynamic feature topology network, including: Slice the multidimensional data cube into a set of feature vectors, calculate the mutual information entropy between features through a multi-head cross-attention mechanism, and generate a set of high-entropy interactive feature pairs; Based on the set of high entropy interaction feature pairs, the spectral clustering algorithm is used to divide the stable feature subset and the transient feature subset; A dynamic interaction graph structure is constructed based on the stable feature subset and the transient feature subset, wherein the nodes of the dynamic interaction graph structure represent feature units, and the edge weights of the dynamic interaction graph structure represent feature transition probabilities; The dynamic interaction graph is input into the temporal graph neural network, the feature evolution path is modeled through the gated temporal convolution module, and the temporal enhanced feature topology is output; Gradient importance distillation is performed on the temporal enhanced feature topology to calculate the node influence factors and generate a dynamic feature topology network with semantic weights.

4. The method according to claim 3, characterized in that 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. The discriminator of the adversarial training framework iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, and finally outputs a spatiotemporal distribution map of advertising conversion probabilities, including: Based on the dynamic feature topology network, the graph attention encoder is used to extract topological structure features and the long short-term memory network is integrated to generate a virtual transformation path sequence. Construct a dual-channel discriminator module, where the first channel calculates the Mahalanobis distance between the real transformation path and the virtual transformation path in the latent space, and the second channel verifies the path logical constraint compliance and outputs a dual-channel difference matrix; The generator parameters are iteratively optimized using a dual-channel difference matrix. When the discriminator's misjudgment rate for real / virtual conversion paths remains below a threshold for a preset number of rounds, the generator is considered to have reached a convergence state. The converged generator performs Monte Carlo sampling in the feature embedding space and outputs a heat map of the spatiotemporal distribution of ad conversion probabilities.

5. The method according to claim 4, characterized in that Based on the spatiotemporal distribution graph of advertising conversion probabilities, a real-time feedback attribution calculation unit is deployed to simulate the evolution of user decision paths through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals, including: Map the spatiotemporal distribution graph of advertising conversion probability into a decision state tree, where the tree nodes of the decision state tree represent advertising touchpoints and the edge weights of the decision state tree represent conversion transfer probabilities; The incremental Monte Carlo tree search algorithm is used to simulate the evolution of user decision paths and record the frequency distribution of visits to each path. Calculate the Shapley value based on the path access frequency distribution, and dynamically update the contact contribution weights in combination with the exponential decay function; A bootstrap sampling method is used to evaluate the stability of contact contribution weights and generate an attribution weight vector with confidence intervals. The attribution weight vector is converted into 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 strength of the transition probability. Finally, an incremental attribution graph is output.

6. The method according to claim 5, characterized in that The incremental attribution graph is input into a strategy-generating adversarial network, and a generator of the strategy-generating adversarial network is used to synthesize a multi-dimensional advertising delivery strategy vector under constraints. The discriminator of the strategy-generating adversarial network verifies the effectiveness of the strategy in combination with historical ROI data, and outputs a Pareto-optimal adversarial optimization advertising delivery strategy set, including: Encode the node weights and edge transition probabilities of the incremental attribution graph into a graph constraint matrix and input it into the graph convolutional encoding layer of the policy generator; The strategy generator integrates the graph constraint matrix and historical ROI data to synthesize a multi-dimensional advertising strategy vector through a conditional adversarial generation mechanism; The strategy discriminator receives the strategy vector, performs three-level validation based on the historical ROI database, and outputs a three-dimensional effectiveness score matrix. The three-level validation includes: budget constraint validation: comparing the total strategy cost with the historical cost distribution; conversion gain validation: the difference between the strategy's expected conversion rate and the historical benchmark; and risk entropy validation: calculating the Sharpe ratio of the strategy portfolio. The strategy generator is iteratively optimized according to the effectiveness score matrix. When the distribution density of the multidimensional advertising delivery strategy vector on the Pareto front reaches saturation, the non-dominated solution set is extracted as the adversarial optimization advertising delivery strategy set that satisfies Pareto optimality.

7. An artificial intelligence-based advertising effectiveness evaluation system, characterized in that: The system comprises: The acquisition module is used to synchronously acquire multi-source data including user behavior data streams and advertising delivery indicator streams through a distributed acquisition engine, eliminate the time offset of multi-source data using a timestamp-driven event window alignment algorithm, and generate a multi-dimensional data cube that is synchronized in time and space; A separation module is used to decouple the features of the multidimensional data cube, separate the stable feature set and the transient feature set through a cross-attention mechanism, and use a graph neural network to model the nonlinear interaction relationship between the features and output a weighted dynamic feature topology network; A generation module is configured to input 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 iteratively optimizes model parameters by comparing the latent space differences between the real conversion path and the virtual conversion path, ultimately outputting a spatiotemporal distribution map of the advertising conversion probability; A simulation module is used to deploy a real-time feedback attribution calculation unit based on the spatiotemporal distribution graph of advertising conversion probabilities, simulate the evolution of user decision paths through Monte Carlo tree search, dynamically update the contribution weight of each touchpoint, and generate an incremental attribution graph with confidence intervals; The output module is used to input the incremental attribution graph into a strategy-generating adversarial network, use the generator of the strategy-generating adversarial network to synthesize a multi-dimensional advertising delivery strategy vector under constraints, and the discriminator of the strategy-generating adversarial network combines historical ROI data to verify the effectiveness of the strategy, and output an adversarial optimization advertising delivery strategy set that meets Pareto optimality.

8. The system according to claim 7, characterized in that The acquisition module is specifically used to: Based on user terminal tracking logs and ad server interface streams, a clock drift compensation algorithm is used to align original timestamps, generating a multi-source data stream with a unified time base. Based on multi-source data streams with a unified time base, the system intercepts the user's complete session trajectory through an event-triggered sliding window, extracting the spatiotemporal correlation sequence between behavioral events and ad exposure events. The spatiotemporal correlation sequence is fed into the adaptive meshing engine, and the event density is aggregated at a dynamic resolution to generate the initial spatiotemporal event tensor; Apply a low-rank tensor completion model to the initial spatiotemporal event tensor to repair missing data blocks and output a complete multidimensional data cube.

9. A storage medium, characterized in that: The storage medium stores a computer program, wherein the computer program is configured to execute the method according to any one of claims 1 to 6 when executed.

10. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to run the computer program to perform the method according to any one of claims 1 to 6.

Images