Behavior analysis and precision recommendation system based on deep learning

Abstract

The application belongs to the technical field of deep learning and recommendation data processing, and particularly relates to a behavior analysis and accurate recommendation system based on deep learning. The system converts continuous behavior records of a user into a behavior event sequence containing a behavior object identifier, a behavior type, an interval, a duration feature, an exposure source mark and an object attribute vector, constructs a directed time sequence behavior graph according to the behavior sequence, attribute similarity and continuous operation relationship, and generates a graph representation through a dynamic graph neural network; further, the graph representation is separated into a long-term preference vector, a short-term intention vector and a noise residual vector by a causal intention decoupling module, and candidate object recommendation scores are generated by combining behavior fluctuation information and noise residual information for gate fusion. The system can reduce the interference of exposure sources, popular objects and accidental clicks on interest representation, so that the recommendation scores are more in line with the relationship between stable preferences and current intentions.

Description

Technical Field

[0001] This invention belongs to the field of deep learning and recommendation data processing technology, specifically a behavior analysis and accurate recommendation system based on deep learning. Background Technology

[0002] Deep learning-based behavior analysis and recommendation technologies typically use user historical behavior logs as a training foundation. Behaviors such as browsing, dwelling, saving, conversion, and skipping are arranged into behavior sequences according to their occurrence time. The behavior object identifier, behavior type, object attributes, and time interval are then converted into vectors and input into the recommendation model. In conventional implementations, models often use sequence neural networks, attention networks, or vector recall models to uniformly encode user behavior, forming user interest vectors. These interest vectors are then compared with candidate object vectors for similarity calculation or rating prediction. While such approaches can utilize temporal information from continuous behaviors, they often compress behaviors from different sources, intensities, and causes into the same latent space. The transition relationships between behaviors, the associations of object attributes, and the differences in exposure sources are not simultaneously modeled.

[0003] Existing recommendation systems often construct user interests by using click counts, dwell time, favorites, and conversion records as positive signals, and skipping, brief pauses, or closing as negative signals, then weighting these to form training labels or loss functions. For continuous behavior of the same user, conventional solutions typically extract recent behavior segments according to time windows and select historical behaviors more relevant to the current recommendation through attention weights. This approach mainly relies on the frequency and sequence position of behavior to determine the strength of interest. For repeated triggers of the same object, passive clicks from the same exposure source, and concentrated exposure from popular objects, it usually only handles these situations through filtering rules or weight decay, making it difficult to form a separable expression of behavioral causes within the model.

[0004] Deep learning recommendation techniques similar to the above approaches also incorporate graph neural networks. These networks construct graph nodes from users, objects, and attributes, and graph edges from user behavior, object similarity, and attribute associations. User and object representations are obtained through neighborhood aggregation. Some approaches further introduce contrastive learning, using different behavioral segments of the same user or similar user behaviors as positive samples to enhance representation consistency. While these techniques can preserve more relational structure than ordinary sequence models, graph edges are often still directly generated from historical co-occurrence or attribute similarity. Exposure location, recommendation source, persistent behavioral features, and behavioral segment boundaries lack unified constraints, potentially leading to graph aggregation results that are still influenced by popular objects, high-frequency behaviors, and accidental behaviors.

[0005] The main technical problem with existing technologies is that continuous user behavior simultaneously includes long-term preferences, short-term intentions, and noisy behaviors. Conventional deep recommendation models lack a structured mechanism to distinguish the causes of these behaviors, easily incorporating pseudo-relevance formed by exposure sources, popular objects, repeated pushes, or accidental clicks into the user interest representation, causing long-term preference vectors and short-term intention vectors to become mixed. Consequently, when user behavior jumps, involves short-term exploration, or is passively exposed, the model may mistakenly use unstable behaviors as recommendation criteria, causing candidate object ratings to deviate from the true behavior transfer relationship, and making it difficult to reconcile the recommendation results between short-term fluctuations and the maintenance of long-term preferences. Summary of the Invention

[0006] The purpose of this invention is to provide a behavior analysis and accurate recommendation system based on deep learning, which can solve the problems in the background art mentioned above.

[0007] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0008] A deep learning-based behavior analysis and accurate recommendation system includes a behavior event sequence construction module, a temporal behavior graph generation module, a graph representation learning module, a causal intent decoupling module, and a recommendation scoring module. The behavior event sequence construction module converts continuous user behavior records into a behavior event sequence containing behavior object identifier, behavior type, behavior occurrence interval, behavior duration characteristics, exposure source marker, and object attribute vector; The temporal behavior graph generation module generates a directed temporal behavior graph based on the order of behaviors, the similarity of object attributes, and the relationship of continuous operations. The graph representation learning module outputs graph representations based on a dynamic graph neural network. The causal intent decoupling module decomposes the graph representation into a long-term preference vector, a short-term intent vector, and a noise residual vector. The recommendation scoring module performs gated fusion of the long-term preference vector and the short-term intent vector based on behavioral fluctuation information and noise residual information, and generates a recommendation score for the candidate object.

[0009] Preferably, the behavior event sequence construction module includes an event cleaning process and an event encoding process. The event cleaning process merges redundant behaviors according to the repeated triggering relationship of the same behavior object in a continuous short period of time, and writes the number of repetitions, the last trigger time, and the longest duration into the behavior intensity field. The event encoding process maps behavior type, behavior duration characteristics, behavior occurrence interval, exposure source marker, and object attribute vector to the same event vector space, and generates behavior segment identifiers and segment boundary identifiers according to the sequential dependencies of the user's continuous operation chain.

[0010] Preferably, the temporal behavior graph generation module uses users, behavior objects, and object attributes as graph nodes, and behavior triggering edges, attribute association edges, and continuous transition edges as directed edges; The behavior triggering edge carries behavior type embedding, behavior intensity field and behavior occurrence interval embedding, the attribute association edge carries object attribute similarity embedding, and the continuous transfer edge carries adjacent behavior segment identifier, segment boundary identifier and transfer direction encoding; All types of directed edges are written into the edge sequence cache in chronological order, and the edge sequence cache is used to construct a hierarchical adjacency tensor and an edge weight decay sequence.

[0011] Preferably, the graph representation learning module includes an edge type gating aggregation process and a temporal attention aggregation process. The edge type gating aggregation process reads the edge embeddings of the behavior triggering edge, the attribute association edge, and the continuous transition edge, and writes the graph node self-features, the neighborhood features of the same type of edge, and the neighborhood features of cross-type edge into the neighborhood aggregation vector. The time attention aggregation process weights the neighborhood aggregation vector according to the behavior occurrence interval embedding, behavior intensity field and behavior segment identifier, and shares the update state of the dynamic graph neural network between adjacent behavior segments to form segment-level user representation and object-level candidate representation.

[0012] Preferably, it also includes a self-supervised contrastive training module, which constructs behavioral objects in adjacent stable behavioral segments of the same user as positive sample pairs, constructs behavioral objects with the same exposure source marker but without forming subsequent effective behaviors as hard-to-bear sample pairs, and configures segment consistency constraints on the positive sample pairs and the hard-to-bear sample pairs according to the behavioral segment identifier. The self-supervised contrastive training module also performs masking reconstruction on the behavior type embedding, retains the exposure source marker of the hard negative sample pair as the contrast grouping key, and writes the reconstructed object attribute vector into the representation subspace corresponding to the behavior fragment identifier.

[0013] Preferably, the temporal behavior graph generation module further includes an exposure edge masking process, which generates an exposure interference edge set based on the exposure source marker, the first occurrence position of the behavior object in the behavior event sequence, the behavior intensity field corresponding to the behavior object, and the number of adjacent attribute-related edges. The edge weight decay sequence superimposes the masking identifier of the exposure interference edge set on the behavior trigger edge and the continuous transfer edge, and encodes and corrects the adjacent position of the masked directed edge according to the transfer direction. The original image view and the perturbation image view are formed by the hierarchical adjacency tensor before and after masking, respectively.

[0014] Preferably, the causal intention decoupling module includes an interference variable encoding process, a preference component separation process, and a residual backfilling process. The interference variable encoding process encodes the exposure source marker, object popularity marker, and display position marker as interference variables. The preference component separation process extracts long-term preference vectors from the graph representation shared across behavioral segments, extracts short-term intention vectors from the graph representation of the current behavioral segment, and uses object-level candidate representations as reconstruction references. The residual backfilling process writes the graph representation portion that has not been reconstructed by the long-term preference vector and the short-term intention vector into the noisy residual vector.

[0015] Preferably, it also includes a joint training module, which writes the sample pair loss output by the self-supervised contrastive training module, the behavior transfer prediction loss output by the graph representation learning module, the component orthogonality loss output by the causal intention decoupling module, the adversarial loss of the interference variable, and the fragment alignment loss between the original graph view and the perturbed graph view into the same training objective, and performs batch division according to the behavior fragment identifier and the contrast grouping key, so that positive sample pairs, hard negative sample pairs, exposure interference edge set, object-level candidate representation and noise residual vector participate in the constraint in the same parameter update.

[0016] Preferably, the recommendation scoring module includes a credibility calculation process and a candidate object matching process. The credibility calculation process generates intent credibility based on the proportion of noise residual vector in continuous behavior segments, the interference discriminability corresponding to the adversarial loss of the interference variable, the segment alignment loss between the original image view and the perturbed image view, and the segment consistency of the short-term intent vector. The candidate object matching process calculates the matching values ​​between the candidate object attribute vector and the long-term preference vector and the short-term intent vector, and generates gating fusion weights and candidate object recommendation scores according to the intent credibility.

[0017] Preferably, it also includes a feedback update module, which writes the newly generated behavioral event into the corresponding behavioral segment identifier and determines the matching relationship between the newly generated behavioral event and the long-term preference vector, short-term intention vector and noise residual vector; When the newly generated behavioral event matches the noise residual vector but is inconsistent with the stable behavioral segment, update the edge weight decay sequence, the exposure interference edge set, and the intent credibility. When the newly generated behavioral event continuously matches the short-term intent vector, the gating fusion weight, candidate object recommendation score, and corresponding perturbation graph view are updated.

[0018] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. By uniformly constructing a sequence of behavioral events using behavioral object identifiers, behavioral types, behavioral intervals, behavioral persistence features, exposure source markers, and object attribute vectors, and further generating a directed temporal behavioral graph containing behavioral trigger edges, attribute association edges, and continuous transition edges, the model can preserve the sequential relationships of behaviors, object attribute relationships, and continuous operation relationships in the same representation process. The dynamic graph neural network aggregates the hierarchical adjacency tensor and edge weight decay sequences, and then the causal intent decoupling module decomposes the graph representation into long-term preference vectors, short-term intent vectors, and noise residual vectors, preventing exposure interference, accidental triggers, and stable preferences from being mixed into the same interest vector. The recommendation and scoring module performs gated fusion of the long-term preference vector and the short-term intent vector based on the noise residual vector, behavioral fluctuation information, and intent credibility. This preserves the influence of short-term intent when behaviors are continuous and consistent, and reverts to long-term preference constraints when behaviors are discrete or the proportion of noise increases, making the candidate object scores more consistent with the user behavior transition structure.

[0019] 2. The self-supervised contrastive training module constructs positive sample pairs from objects in adjacent stable behavior segments and hard negative sample pairs from objects that do not form subsequent effective behaviors under the same exposure source. It combines behavior type occlusion reconstruction, exposure edge masking, and alignment training of the original image view and the perturbation image view to enable the model to distinguish between true preference associations and surface associations caused by exposure conditions during the training phase. The joint training module incorporates behavior transfer prediction, component orthogonality, adversarial variables, and segment alignment into the same training objective, forming a constrained closed loop between graph representation learning, causal intent decoupling, and recommendation scoring. The feedback update module writes new behaviors into the corresponding behavior segments and updates the edge weight decay sequence, exposure interference edge set, and gated fusion weights according to their matching relationships with the long-term preference vector, short-term intent vector, and noise residual vector. This allows the model to continue correcting the scoring bias caused by early noisy behaviors in subsequent recommendations. Attached Figure Description

[0020] Figure 1 This is a flowchart illustrating the overall processing flow of a deep learning-based behavior analysis and precise recommendation system. Figure 2 Flowchart for constructing behavioral event sequences and generating directed temporal behavioral graphs; Figure 3 Flowchart for training in graph representation learning, exposure interference masking, and causal intent decoupling; Figure 4 A flowchart illustrating the closed-loop process of recommending, scoring, and updating feedback for candidate candidates. Detailed Implementation

[0021] In one embodiment, reference Figure 1This system provides a deep learning-based behavior analysis and accurate recommendation system, including a behavior event sequence construction module, a temporal behavior graph generation module, a graph representation learning module, a causal intent decoupling module, and a recommendation scoring module. The behavior event sequence construction module converts continuous user behavior records into behavior event sequences containing behavior object identifiers, behavior types, behavior occurrence intervals, behavior persistence features, exposure source markers, and object attribute vectors. The temporal behavior graph generation module generates a directed temporal behavior graph based on behavior sequence relationships, object attribute similarity relationships, and continuous operation relationships. The graph representation learning module outputs graph representations based on dynamic graph neural networks. The causal intent decoupling module decomposes the graph representations into long-term preference vectors, short-term intent vectors, and noise residual vectors. The recommendation scoring module performs gated fusion of the long-term preference vectors and the short-term intent vectors based on behavior fluctuation information and noise residual information, and generates candidate objects. Recommended rating; In specific implementation, the behavior event sequence construction module reads browsing, dwell, favorite, conversion, skip, and close records generated by the same user within a continuous time range from historical behavior logs, maps each record to a unified behavior event, uses behavior object identifier to identify the operated object, behavior type to distinguish the nature of the operation, behavior occurrence interval to represent the time distance of the current behavior relative to the previous behavior, behavior persistence feature to represent the length of behavior dwell or interaction, exposure source tag to distinguish the source of natural access, recommended display, search trigger, or associated display, and object attribute vector to represent object category, tag, content theme, and structural attributes. After unified encoding, a behavior event sequence arranged by time is formed, thereby avoiding the semantic inconsistency problem caused by directly inputting discrete logs into the deep learning model. This embodiment converts heterogeneous behavior records into a unified data structure that can be jointly processed by subsequent graph learning and intent decoupling.

[0022] In this embodiment, the temporal behavior graph generation module performs graph processing on the sequence of behavior events, treating users, behavior objects, and object attributes as graph nodes. The behavior triggering relationship between users and behavior objects, the continuous transition relationship between behavior objects, and the attribute association relationship between behavior objects and object attributes are treated as different types of directed edges, with the direction and order of edges determined according to the behavior occurrence time. For consecutive behaviors generated by the same user, the system establishes continuous transition edges between adjacent behavior objects, attribute association edges for behavior objects belonging to the same object attribute set, and behavior triggering edges for behaviors directly triggered by the user, thus preserving the sequential relationship of behaviors, the similarity relationship of object attributes, and the continuous operation relationship simultaneously in the graph structure. The graph representation learning module uses a dynamic graph neural network to perform neighborhood aggregation on the above-mentioned directed temporal behavior graph. During each aggregation, it reads the current features of graph nodes, the type features of adjacent directed edges, the time decay features of edges, and the object attribute features of adjacent nodes, writing the aggregation results into the user representation and object representation, so that the model no longer generates interest vectors solely based on the frequency of behavior occurrence. This embodiment incorporates behavior transition paths and attribute association paths into the recommendation representation generation process through the graph structure.

[0023] In this embodiment, the causal intent decoupling module receives the graph representation output by the dynamic graph neural network and decomposes the graph representation into a long-term preference vector, a short-term intent vector, and a noise residual vector. The long-term preference vector is generated by object attributes and behavior transition patterns that remain consistent across multiple stable behavior segments. The short-term intent vector is generated by behavior objects and behavior types that appear consecutively and are close in time within the current behavior segment. The noise residual vector is generated by the remaining graph representation that cannot be reconstructed by the long-term preference vector and the short-term intent vector. The recommendation scoring module reads behavior fluctuation information and noise residual information. When the continuity of object attributes within the current behavior segment is high and the noise residual information is low, the fusion weight of the short-term intent vector in the candidate object score is increased. When the behavior object jumps, the exposure source is concentrated, or the noise residual information increases, the fusion weight of the long-term preference vector in the candidate object score is increased. Thus, the recommendation score is no longer determined by a single click or a single interest vector, but by the constraint relationship between long-term preference, short-term intent, and noise residual. This embodiment enables the candidate object score to be adjusted as behavior stability changes.

[0024] In this embodiment, the candidate recommendation score can be calculated using the following gating fusion formula: ; in, This represents the recommendation rating that user u gives to candidate object o. Represents the long-term preference vector. Represents a short-term intent vector. Represents the noise residual vector. Represents the attribute vector of candidate objects. Indicates the gating fusion weights, Indicates noise deduction weight, superscript This represents the vector transpose operation; for example, when a user's current behavior segment continuously browses similar objects and the noise residual vector has low similarity to the candidate object attribute vector, A smaller value can be chosen to give the short-term intent vector a larger weight in the score, when the user's current behavior is triggered by the recommended exposure set and the noise residual vector has a high similarity to the candidate object attribute vector. A larger value can be taken, and by Noise-related objects are deducted. This embodiment incorporates long-term preference retention, short-term intention response and noise suppression into the same scoring process through a calculable fusion formula.

[0025] In one embodiment, reference Figure 2 The behavior event sequence construction module includes an event cleaning process and an event encoding process. The event cleaning process merges redundant behaviors according to the repeated triggering relationship of the same behavior object in a continuous short period of time, and writes the number of repetitions, the last trigger time, and the longest duration into the behavior intensity field. The event encoding process maps the behavior type, behavior duration characteristics, behavior occurrence interval, exposure source marker, and object attribute vector to the same event vector space, and generates behavior segment identifiers and segment boundary identifiers according to the sequential dependencies of the user's continuous operation chain. In specific implementation, the event cleaning process uses the user identifier and behavior object identifier as a joint index to read the time interval and triggering order between adjacent behavior events. When the same behavior object is triggered multiple times in a continuous short period of time, multiple original behaviors are merged into one aggregated behavior event, while retaining the number of repetitions, the last trigger time, the longest duration, the highest behavior intensity type, and the exposure source change records. If the same behavior object appears browsing and favorites in succession, browsing is used as the preceding trigger, and favorites are written into the behavior intensity field as a higher intent behavior, avoiding excessive amplification of the model input by repeated browsing. This embodiment reduces the interference of accidental repeated behaviors on interest representation by merging redundant triggers.

[0026] In this embodiment, the event encoding process converts behavior types into behavior type embeddings, segments and normalizes behavior persistence features and behavior occurrence intervals, maps exposure source markers to source embeddings, maps object attribute vectors to object attribute subspaces, and then concatenates or projects the above encoding results onto the same event vector space. Behavior segment identifiers are determined based on the time interval, object attribute transitions, and behavior type changes in a continuous operation chain. When the time interval between adjacent behaviors exceeds a preset segmentation condition, the object attribute transition span is too large, or the behavior type changes from positive interaction to continuous skipping, a new behavior segment identifier is generated, and a segment boundary identifier is written between adjacent segments. To avoid rigid segment division caused by using a single time threshold, the segment boundary can be calculated by the behavior occurrence interval, attribute change distance, and consecutive negative feedback counts. This embodiment enables the subsequent model to distinguish between stable behavior segments and skipping behavior segments.

[0027] In this embodiment, the boundary score of the behavior segment can be calculated using the following formula: ; in, The score represents the score that forms a segment boundary between the i-th behavioral event and the previous behavioral event. Indicates compression to to Interval mapping function, This indicates the interval between normalized behavior occurrences. This represents the distance between the attribute vector of the current behavior object and the attribute vector of the previous behavior object. Indicates the intensity of continuous negative behavior. This indicates consistency in continuous positive behavior. , , , This represents the weights involved in training; for example, when the time interval between adjacent actions is short, object attributes are similar, and consecutive positive actions have high consistency. When the value is close to a lower value, the corresponding behavior remains in the same segment. However, when the time interval between behaviors is long, the object attributes span a large range, and the intensity of consecutive negative behaviors increases, the behavior becomes more pronounced. When the value approaches a higher value, the corresponding behavior is classified into a new behavior segment. This embodiment provides a data basis for separating long-term preferences and short-term intentions through multi-factor boundary judgment.

[0028] In one embodiment, the temporal behavior graph generation module uses users, behavior objects, and object attributes as graph nodes, and behavior trigger edges, attribute association edges, and continuous transition edges as directed edges. The behavior trigger edges carry behavior type embeddings, behavior intensity fields, and behavior occurrence interval embeddings; the attribute association edges carry object attribute similarity embeddings; and the continuous transition edges carry adjacent behavior segment identifiers, segment boundary identifiers, and transition direction encodings. All types of directed edges are written to an edge sequence cache in chronological order, and the edge sequence cache is used to construct a hierarchical adjacency tensor and an edge weight decay sequence. Specifically, user nodes are used to aggregate continuous behaviors related to a single user, behavior object nodes are used to carry object attribute vectors and triggered states, and object attribute nodes are used to represent categories, topics, tags, and structured attributes. Behavior trigger edges point from user nodes to behavior object nodes, attribute association edges establish associations between behavior object nodes and object attribute nodes, and continuous transition edges point from the previous behavior object node to the next behavior object node, thereby forming a directed temporal behavior graph containing user, object, and attribute dimensions. This embodiment can express user behavior triggering, object attribute attribution, and continuous behavior transitions in the same graph.

[0029] In this embodiment, the edge sequence cache stores various directed edges according to user identifier, behavior segment identifier, and behavior occurrence order. Each edge records edge type, start node, end node, time sequence number, behavior type embedding, behavior intensity field, behavior occurrence interval embedding, object attribute similarity embedding, segment boundary identifier, and transition direction encoding. When constructing the hierarchical adjacency tensor, the system writes behavior triggering edges into the behavior layer adjacency matrix, attribute association edges into the attribute layer adjacency matrix, and continuous transition edges into the transition layer adjacency matrix, while retaining layer indices of different edge types in the same tensor. When constructing the edge weight decay sequence, the system calculates time decay based on the distance between the behavior occurrence time and the current recommendation time, and adjusts the edge weights based on the behavior intensity field and segment boundary identifier, so that recently stable behaviors obtain higher usable weights, and that jump behaviors that cross segment boundaries are subject to boundary constraints. In this embodiment, multiple types of relationships are converted into structured tensor inputs that can be read by dynamic graph neural networks.

[0030] In a preferred embodiment, the edge weight of a continuous transition edge can be calculated using the following formula: ; in, This represents the weight of the continuous transition edge from behavior object i to behavior object j. Indicates edge type Determined basic weights, Indicates the time decay coefficient. This represents the normalized time interval between two actions. This indicates the behavior intensity field corresponding to the object in the next behavior. The following line represents the segment boundary score. Indicates the moderating weight of behavioral intensity. This indicates the segment boundary adjustment weight; for example, when two actions are close in time, the latter action has a higher intensity and does not cross the segment boundary, A higher weight is obtained when two actions are far apart in time and the latter action is after the segment boundary. By achieving a lower weight, this embodiment enables continuous transition relationships to be controlled simultaneously by time distance, behavior intensity, and fragment boundaries.

[0031] In one embodiment, reference Figure 3 The graph representation learning module includes an edge type-gated aggregation process and a temporal attention aggregation process. The edge type-gated aggregation process reads the edge embeddings of behavior-triggered edges, attribute-associated edges, and continuous transition edges, respectively, and writes the graph node self-features, neighborhood features of similar edges, and neighborhood features of cross-type edges into the neighborhood aggregation vector. The temporal attention aggregation process weights the neighborhood aggregation vector according to the behavior occurrence interval embedding, the behavior intensity field, and the behavior segment identifier, and shares the update state of the dynamic graph neural network between adjacent behavior segments, forming segment-level user representations and object-level candidate representations. In specific implementation, edge types... The edge-type gating aggregation process establishes behavior trigger neighborhoods, attribute association neighborhoods, and continuous transition neighborhoods for each graph node, and configures independent transformation matrices for different neighborhoods. This ensures that trigger information from user behavior, similarity information from object attributes, and path information from temporal transitions are not directly mixed during the input stage. Subsequently, edge type gating determines the aggregation ratio of various types of edges based on the matching relationship between the current node's self-features and the features of various neighborhoods, and writes the neighborhood features of similar edges and cross-type edges into the neighborhood aggregation vector. This embodiment avoids single-neighborhood aggregation causing popular objects or high-frequency attributes to occupy the graph representation.

[0032] In this embodiment, the temporal attention aggregation process takes the behavior occurrence interval embedding, behavior intensity field, and behavior segment identifier as inputs, and weights different temporal positions in the neighborhood aggregation vector. Neighborhoods within the same stable behavior segment and with higher behavior intensity receive higher attention, while neighborhoods crossing segment boundaries or with longer occurrence intervals receive lower attention. When the dynamic graph neural network shares update states between adjacent behavior segments, it does not directly copy all hidden states of the previous segment. Instead, it uses the long-term preference candidate part of the previous segment as memory input and the short-term behavior part of the current segment as update input, and uses segment boundary identifiers to control the memory retention ratio. The segment-level user representation is obtained by aggregating multiple behavior objects and behavior types within the same segment, and the object-level candidate representation is obtained by aggregating candidate object attribute nodes, historical adjacent object nodes, and behavior trigger edges. This embodiment enables the deep learning representation to simultaneously retain short-term continuity within segments and stable preference cues between segments.

[0033] In one embodiment, a self-supervised contrastive training module is also included. This module constructs positive sample pairs from adjacent stable behavior segments of the same user, and constructs hard-to-bear sample pairs from behavior objects with the same exposure source marker that have not formed subsequent effective behaviors. It also configures segment consistency constraints on positive and hard-to-bear sample pairs based on the behavior segment identifier. The self-supervised contrastive training module also performs masking reconstruction on the behavior type embedding, retains the exposure source marker of the hard-to-bear sample pairs as the contrast grouping key, and writes the reconstructed object attribute vector into the representation subspace corresponding to the behavior segment identifier. In specific implementation, adjacent stable behavior segments are determined by behavior segments with low segment boundary scores, smooth object attribute transitions, and continuous positive behaviors. Positive sample pairs are composed of behavior objects with similar object attributes and behavior intensity not lower than the segment mean selected from adjacent stable behavior segments. Hard-to-bear sample pairs are selected from behavior objects that appear under the same exposure source but have not been collected, converted, stayed for a long time, or followed by subsequent adjacent behaviors. This allows the model to face objects with similar exposure conditions but different actual subsequent behaviors during training. This embodiment makes the training samples closer to the scenario of distinguishing between exposure pseudo-correlation and real preference correlation.

[0034] In this embodiment, the behavior type occlusion reconstruction process randomly occludes some behavior type embeddings within the same behavior segment, retaining the behavior object attribute vector, behavior occurrence interval embedding, and exposure source label. The model is required to reconstruct the occluded behavior type based on the graph neighborhood and segment context. If an object is clicked only because of the same exposure source, but no stable behavior is subsequently formed, the model cannot rely solely on the exposure source label to determine if it is a high-intent behavior during reconstruction. It must combine object attributes, continuous transition edges, and behavior intensity fields. The comparison grouping key is used to ensure that hard negative sample pairs and positive sample pairs are under comparable exposure conditions, avoiding misinterpreting feedback differences caused by different exposure sources as preference differences. The reconstructed object attribute vector is written into the representation subspace corresponding to the behavior segment identifier, so that objects within the same segment maintain local consistency and objects across segments remain comparable. The representation obtained by training in this embodiment can reduce the direct dependence on the exposure source.

[0035] In one embodiment, the temporal behavior graph generation module further includes an exposure edge masking process. The exposure edge masking process generates an exposure interference edge set based on the exposure source marker, the first appearance position of the behavior object in the behavior event sequence, the behavior intensity field corresponding to the behavior object, and the number of adjacent attribute-related edges. The edge weight decay sequence superimposes the masking identifier of the exposure interference edge set on the behavior trigger edge and the continuous transfer edge, and corrects the adjacent position of the masked directed edge according to the transfer direction encoding. The original graph view and the perturbation graph view are formed by the hierarchical adjacency tensor before and after masking, respectively. In specific implementation, the exposure edge masking process retrieves behavior objects that appear in a concentrated manner under the same exposure source marker. When the behavior object has an early first appearance position in the behavior event sequence, no subsequent stable transfer, a low behavior intensity field, and a high number of adjacent attribute-related edges, the corresponding behavior trigger edge and continuous transfer edge are marked as suspected exposure interference edges. For the same object that is repeatedly triggered by recommendation display but lacks collection, conversion, or stable stay, the system adds its behavior trigger edge to the exposure interference edge set to avoid the object being repeatedly reinforced in graph aggregation. In this embodiment, the structural interference formed by passive exposure is identified at the graph connection level.

[0036] In this embodiment, the masking identifier does not directly delete the corresponding directed edge, but reduces the weight of the identified edge in the edge weight decay sequence to participate in the perturbation graph view aggregation, while preserving the complete connection relationship in the original graph view. When a continuous transition edge is masked, the system checks whether there is an alternative stable transition path between the preceding and following behavior objects according to the transition direction encoding. If there are nodes of the same attribute or intermediate behavior objects within the same stable behavior segment between the preceding and following behavior objects, the adjacent position is corrected in the perturbation graph view through adjacent stable transition edges to avoid the behavior segment being broken due to masking a single edge. The original graph view is used to preserve the complete graph structure of historical behaviors, and the perturbation graph view is used to train the model to maintain the consistency of segment representation after removing exposure interference. In this embodiment, the dual-view constraint enables the model to identify the representation that depends on the exposure edge and the representation that depends on the stable transition edge.

[0037] In a preferred embodiment, the exposure interference edge determination can be calculated using the following formula: ; in, This indicates the score for determining whether edge e belongs to the exposure interference edge. Indicates the concentration of exposure sources. This indicates the weight of the first occurrence position of a behavior object in a sequence of behavior events. This indicates a behavior intensity field. This indicates the number of adjacent edges associated with a given attribute. Indicates the subsequent stable bearing strength. , , , , This represents the weighting coefficients obtained during training; for example, when an object is displayed from the same exposure source, appears early in the first position, has a low behavior intensity field, has a large number of adjacent attribute association edges, and has no stable subsequent connections. A higher value corresponds to the edge entering the exposure interference edge set. This applies when an object, although originating from recommended displays, exhibits high behavioral intensity and subsequent stable continuity. By obtaining a lower value, the corresponding edge is retained as a normal behavior edge. This embodiment avoids uniformly treating the behavior of all recommended display sources as interference.

[0038] In one embodiment, the causal intent decoupling module includes a disturbance variable encoding process, a preference component separation process, and a residual backfilling process. The disturbance variable encoding process encodes exposure source markers, object heat markers, and display position markers as disturbance variables. The preference component separation process extracts long-term preference vectors from the graph representations shared across behavioral segments, extracts short-term intent vectors from the graph representations of the current behavioral segment, and uses object-level candidate representations as reconstruction references. The residual backfilling process writes the graph representation portions not reconstructed by the long-term preference vectors and short-term intent vectors into a noise residual vector. In specific implementation, the disturbance variable encoding process reads the exposure source markers... The frequency of an object's appearance in the current sample batch, the degree of concentrated display of the object among different users, and the object's display location marker are recorded and mapped as interference variables. During training, adversarial discriminant constraints are used to restrict the long-term preference vector and short-term intent vector from directly carrying interference variable information. In the preference component separation process, the shared parts of multiple adjacent stable behavior segments are input into the long-term preference extraction branch, and the parts of the current behavior segment that change rapidly and are close in time are input into the short-term intent extraction branch. The coverage of the two components is verified by using object-level candidate representations as reconstruction references. This embodiment makes the preference component separation have a clear data source and reconstruction basis.

[0039] In this embodiment, the residual backfilling process performs component reconstruction on the graph representation, projecting the long-term preference vector and short-term intention vector back into the graph representation space and comparing them with the original graph representation. The parts that cannot be explained by the two components are written into the noise residual vector. If the matching degree between the noise residual vector and the embedding of the interference variable is high, the training process reduces the discriminability of interference in the long-term preference vector and short-term intention vector through the adversarial loss of the interference variable, and retains the noise residual vector for subsequent score deduction. To prevent the long-term preference vector and short-term intention vector from expressing the same information, the component separation process also applies orthogonal constraints to the two vectors, making the long-term preference vector biased towards cross-segment stable properties, and the short-term intention vector biased towards continuous transfer in the current segment. This embodiment avoids the repeated expression of long-term preferences and short-term intentions in the same latent space.

[0040] In one embodiment, a joint training module is also included. This module writes the sample pair loss output by the self-supervised contrastive training module, the behavior transfer prediction loss output by the graph representation learning module, the component orthogonality loss output by the causal intention decoupling module, the adversarial loss of the perturbation variable, and the fragment alignment loss between the original image view and the perturbed image view into the same training objective. The module then performs batch partitioning according to the behavior fragment identifier and the contrast grouping key, so that positive sample pairs, hard negative sample pairs, exposure perturbation edge set, object-level candidate representation, and noise residual vector participate in the constraint in the same parameter update. Specifically, the sample pair loss is used to narrow the representation distance of positive sample pairs and widen the representation distance of hard negative sample pairs. The behavior transfer prediction loss is used to constrain the current object representation to predict the next stable receiving object. The component orthogonality loss is used to limit the overlap between long-term preference vectors and short-term intention vectors. The adversarial loss of the perturbation variable is used to reduce the direct encoding of the preference component on the exposure source and display position. The fragment alignment loss is used to constrain the representation consistency between the original image view and the perturbed image view on stable behavior fragments. In this embodiment, all training constraints point to the same representation separation objective.

[0041] In this embodiment, the joint training objective can be represented by the following formula: ; in, Indicates total training loss. Indicates the sample pair loss. Indicates the predicted loss from behavioral shift. Indicates the orthogonal loss of the components. This indicates that the confounding variable counteracts the loss. Indicates fragment alignment loss, , , , This represents the training weights; for example, when the model scores a candidate object highly in the original view but represents a deviating segment in the perturbation view, This increases and drives the model to reduce its dependence on exposure interference edges. As the inner product of the long-term preference vector and the short-term intention vector increases, This embodiment increases and promotes the expression of behavioral information at different levels by using a unified loss function to coordinate graph learning, comparative training, and causal decoupling.

[0042] In this embodiment, batch partitioning is performed according to behavioral segment identifiers and comparison grouping keys. Samples with the same exposure source label and in similar recommendation contexts are assigned to the same comparison group, and samples in adjacent stable behavioral segments are assigned to the same segment batch. In a single parameter update, the system simultaneously reads positive sample pairs, hard negative sample pairs, exposure interference edge sets, object-level candidate representations, and noise residual vectors, so that the model is subject to preference proximity constraints, pseudo-correlation separation constraints, graph structure perturbation constraints, and residual deduction constraints within the same update cycle. If the number of hard negative samples in a certain batch is insufficient, the system supplements samples from historical objects with the same exposure source but without subsequent stable successors, instead of randomly sampling from completely unrelated objects, to avoid overly simplistic training tasks. This embodiment improves the technical correlation between training constraints and reduces the interference of invalid negative samples on the model.

[0043] In one embodiment, reference Figure 4 The recommendation scoring module includes a credibility calculation process and a candidate object matching process. The credibility calculation process generates intent credibility based on the proportion of noise residual vector in continuous behavior segments, the interference discriminability corresponding to the adversarial loss of the interference variable, the segment alignment loss between the original image view and the perturbed image view, and the segment consistency of the short-term intent vector. The candidate object matching process calculates the matching value between the candidate object attribute vector and the long-term preference vector and the short-term intent vector, respectively, and generates gating fusion weights and candidate object recommendation scores according to the intent credibility. In specific implementation, the proportion of noise residual vector in continuous behavior segments is determined by the relationship between the residual norm and the graph representation norm. The interference discriminability is determined by the discrimination results of the interference variable discriminator on the exposure source mark, object heat mark, and display position mark. The segment alignment loss is determined by the representation distance between the original image view and the perturbed image view under the same segment identifier. The segment consistency of the short-term intent vector is determined by the degree of continuous matching between adjacent behavior objects and the short-term intent vector in the current segment. This embodiment provides quantifiable credibility input for gating fusion.

[0044] In this embodiment, the candidate object matching process calculates a long-term preference matching value and a short-term intent matching value for each candidate object. The long-term preference matching value is used to characterize the similarity between the candidate object's attribute vector and the cross-segment stable preference, while the short-term intent matching value is used to characterize the similarity between the candidate object's attribute vector and the current behavior segment transition direction. The gating fusion weight is controlled by the intent credibility. When the intent credibility is high, the short-term intent matching value obtains a higher fusion ratio, and when the intent credibility is low, the long-term preference matching value obtains a higher fusion ratio. The candidate object recommendation score also reads the similarity between the noise residual vector and the candidate object's attribute vector, and subtracts candidate objects that are highly correlated with the residual to avoid noise behavior being directly converted into recommendation output. In this embodiment, each input to the candidate object score comes from the aforementioned graph learning and decoupling process.

[0045] In this embodiment, the credibility of the intent can be calculated using the following formula: ; in, This indicates the credibility of user u's current short-term intent. This indicates the consistency of the short-term intent vector within the current behavioral segment. This represents the proportion of the noise residual vector in the continuous action segment. This represents the discriminability of the interference variable against the adversarial loss. This represents the segment alignment loss between the original view and the perturbation view. , , , This represents the weights obtained during training; for example, when the behavioral objects within the current segment are continuous and match the short-term intent vector, the proportion of noise residuals is low, interference variables are difficult to distinguish, and the alignment of the two-view segments is stable. Take the higher value when the current segment is mainly triggered by the same exposure source and the perturbation view deviates from the original view. By taking a lower value, the gating fusion weight in this embodiment can change with the credibility of the behavior.

[0046] In one embodiment, a feedback update module is further included. This module writes newly generated behavioral events into corresponding behavioral segment identifiers and determines the matching relationship between the newly generated behavioral events and long-term preference vectors, short-term intent vectors, and noise residual vectors. When a newly generated behavioral event matches a noise residual vector but is inconsistent with a stable behavioral segment, the edge weight decay sequence, exposure interference edge set, and intent credibility are updated. When a newly generated behavioral event continuously matches a short-term intent vector, the gating fusion weight, candidate object recommendation score, and corresponding perturbation graph view are updated. In a specific implementation, after a new behavioral event enters the system, the behavioral event sequence construction module checks the time interval, object attribute distance, behavior type, and exposure source marker according to the most recent behavioral segment of the same user. If the new behavior is continuous with the current stable segment, it is written into the original behavioral segment identifier. If the new behavior crosses the segment boundary condition, a new behavioral segment identifier is generated. Subsequently, the feedback update module calculates the matching relationship between the new behavior object attribute vector and the long-term preference vector, short-term intent vector, and noise residual vector, and writes the matching results into the user state cache. This embodiment enables subsequent recommendations to use new feedback to correct the current representation without reconstructing all historical data.

[0047] In this embodiment, when a newly generated behavioral event matches the noise residual vector but is inconsistent with the stable behavioral segment, the system checks the exposure source marker, behavior intensity field, and subsequent continuity of the new behavior. If the new behavior source is concentrated and lacks attribute continuity with the stable segment, the system increases the probability that the relevant behavior triggering edge and continuous transfer edge will enter the exposure interference edge set, and updates the masking identifier in the edge weight decay sequence. At the same time, the system recalculates the intent credibility based on the updated noise residual ratio and segment alignment loss, thus constraining the influence of short-term intent in the candidate object recommendation score. When a newly generated behavioral event continuously matches the short-term intent vector, the system writes the new behavioral object into the stable transfer path of the current perturbation graph view, updates the gating fusion weights, and recalculates the candidate object recommendation score. The feedback update in this embodiment follows the same graph structure and intent decoupling logic, and does not introduce update rules inconsistent with the aforementioned model.

[0048] In a preferred embodiment, continuous user behavior records can come from historical logs and real-time logs of the same recommendation system. Historical logs are used to build behavioral event sequences, temporal behavioral graphs, and initial deep learning models offline, while real-time logs are used to update behavioral segment identifiers, edge weight decay sequences, exposure interference edge sets, and gating fusion weights. During offline construction, the system generates historical behavioral event sequences according to the user dimension and extracts graph samples containing multiple stable behavioral segments and several exposure interference edges in each training batch. During real-time updates, the system only performs incremental updates on user nodes, behavioral object nodes, object attribute nodes, and adjacent edges related to new behavioral events, while retaining the existing representations of other graph nodes and edges, reducing fluctuations in the overall graph representation caused by a single new behavior. This embodiment keeps the historical training and real-time feedback updates using the same data structure.

[0049] In this embodiment, the object attribute vector can be composed of the object's category identifier, topic identifier, tag identifier, text vector, or structured attribute vector. Before entering the temporal behavior graph, the system performs dimensional alignment on attributes from different sources. When an object has multiple attributes, the object attribute nodes establish attribute association edges with the behavior object nodes respectively, and the number of adjacent attribute association edges reflects the connection density of the object in the attribute space. If a popular object is connected to a large number of attribute association edges and frequently appears under the same exposure source, the exposure edge masking process combines the number of adjacent attribute association edges and the subsequent stable connection strength to determine whether it belongs to the source of interference, rather than simply reducing the weight based on the popularity label. In this embodiment, object attributes participate in both candidate matching and exposure interference determination.

[0050] In one embodiment, the long-term preference vector is not generated based on a simple average of all historical behaviors, but on attribute association paths, continuous transition edge patterns, and positive behavior intensity that recur across multiple stable behavior segments. Specifically, the system extracts cross-segment shared components from segment-level user representations and distinguishes them from the unique components of the current segment through component orthogonal loss to form the long-term preference vector. The short-term intent vector is generated based on behavior sequences within the current behavior segment that are close in time distance, have continuous behavior object attributes, and progressive behavior intensity. The system also determines the object representations that contribute significantly to the transition direction in the current segment through a time attention aggregation process. The noise residual vector consists of graph representations that cannot be reconstructed by the above two vectors. In this embodiment, the three vectors have different sources and are mutually constrained.

[0051] In this embodiment, component orthogonality constraints can be achieved by taking a lower value for the inner product of the long-term preference vector and the short-term intent vector. During training, the inner product is calculated after normalization of the two vectors, and the absolute value of the inner product is written into the component orthogonality loss. If the model writes the short-term popular clicks of the current segment into both the long-term preference vector and the short-term intent vector, the absolute value of the inner product increases and a training penalty is generated, causing the long-term preference branch to return to the cross-segment stable attribute and the short-term intent branch to retain the current segment transition direction. The residual backfilling process recalculates the unexplained part after each round of training and compares this part with the embedded interference variables. If the residual mainly corresponds to the exposure source and display position, it is used as a deduction input in the scoring stage. This embodiment reduces the mixed expression of long-term preference and short-term intent.

[0052] In a preferred embodiment, the original graph view and the perturbation graph view are input into the same dynamic graph neural network or two graph learning branches with shared parameters. The original graph view retains all behavior triggering edges, attribute association edges, and continuous transition edges, while the perturbation graph view applies masking labels to the edges in the exposure interference edge set and performs adjacency position correction. During training, the two views generate fragment-level user representations and object-level candidate representations, respectively. The joint training module only performs fragment alignment on stable behavior fragments and does not require all noise fragments to remain consistent in the two views. For local structural changes caused by masked edges, the system supplements the graph path with adjacent stable transition edges and attribute association edges, so that the perturbation graph view still has an aggregable neighborhood. In this embodiment, dual-view training can distinguish between stable behavior structures and exposure interference structures.

[0053] In this embodiment, before a candidate object enters the recommendation scoring process, the system reads the candidate object attribute vector, historical adjacent object representation, and attribute association edge representation from the object-level candidate representation, and calculates the matching relationship with the long-term preference vector, short-term intent vector, and noise residual vector, respectively. If the candidate object matches both the long-term preference vector and the short-term intent vector, and has a low match with the noise residual vector, the recommendation score is high. If the candidate object mainly matches the short-term intent vector but has low intent credibility, the gating fusion weight is recycled to the long-term preference vector. If the candidate object has a high match with the noise residual vector, the score deduction item is increased. In this embodiment, the candidate object scoring is not a one-way similarity calculation, but a constrained matching between preference, intent, and noise.

[0054] In one embodiment, to ensure stable model updates, the feedback update module sets a delayed confirmation cache for newly generated behavioral events. Short-stay, quick-closing, or single-jump behaviors first enter the pending confirmation state. Only when subsequent behaviors form a continuous transition edge with it, the intensity of positive behaviors increases, or the attributes remain continuous with stable behavioral segments, are they written into the short-term intent update branch. If subsequent behaviors have no connection with it and the exposure sources are concentrated, they are transferred to the noise residual update branch, and the exposure interference edge set is updated. The delayed confirmation cache does not change the temporal order of the behavioral event sequence, but only changes the timing of new behaviors participating in the gating fusion weight update, so that early accidental behaviors will not immediately dominate the candidate object recommendation score. In this embodiment, the feedback update can take into account both real-time performance and behavioral credibility.

[0055] In this embodiment, after the system training is completed, it can run in two processes: offline training and online inference. The offline training process generates behavioral event sequences, temporal behavior graphs, graph representation learning parameters, causal intent decoupling parameters, joint training parameters, and initial recommendation scoring parameters. The online inference process reads the user's most recent behavior fragments and candidate object sets, incrementally updates the local edge sequence cache of the directed temporal behavior graph, and calculates the candidate object recommendation score based on the long-term preference vector, short-term intent vector, noise residual vector, and intent credibility. The online inference process does not re-execute the complete training; it only updates the fragment-level user representations, perturbation graph views, and gating fusion weights related to new behaviors, keeping the model output consistent with the training constraints. This embodiment transforms the complex training mechanism into an executable incremental recommendation process.

[0056] In a preferred embodiment, the behavior event sequence construction module can also exclude abnormal logs, including records that lack behavior object identifiers, lack behavior occurrence times, have behavior types that cannot be mapped, or have empty object attribute vectors. For records that lack behavior persistence features but have clear behavior types and behavior object identifiers, the system retains the event and writes the behavior persistence features into the default identifier, without directly deleting it. For records that lack exposure source markers, the system writes them into unknown source embeddings and reduces their weight as exposure interference edges during the exposure edge masking process. In this embodiment, the data cleaning process does not destroy the integrity of the behavior sequence due to the absence of a single field, while maintaining caution in subsequent interference judgment.

[0057] In one embodiment, the input node features of the dynamic graph neural network are composed of user history segment representations, behavior object attribute vectors, object attribute node vectors, and edge type embeddings. When the network is updated, the edge sequence cache is read in chronological order, and each time only the newly added edges in the current time segment and the first-order or second-order neighbors affected by them are processed. Edge type gating aggregation first generates candidate aggregation results of different edge types, and then the gating vector determines the writing ratio of each candidate aggregation result. Temporal attention aggregation weights the aggregation results of the same node at different time positions to generate a dynamic graph representation of the current segment. In this embodiment, the graph representation learning process can reflect the temporal changes of behavior, rather than statically aggregating all historical neighbors.

[0058] In this embodiment, the adversarial training of the interference variable can be configured with an interference discrimination branch. This branch attempts to discriminate the exposure source marker, object popularity marker, and display location marker based on the long-term preference vector and short-term intent vector. The main model then reduces the ability of this discrimination branch to recover the interference variable from the preference component through inverse constraints. The noise residual vector does not participate in this adversarial elimination but retains the interference-related components and uses them for recommendation score deduction. This ensures that the system does not simply delete interference information but migrates the interference information from the preference component to the residual component. This embodiment reduces spurious correlations in the preference vector while retaining residual information that can be used to identify noisy candidate objects.

[0059] In a preferred embodiment, when generating positive sample pairs, the self-supervised contrastive training module may also require that two behavioral objects in adjacent stable behavioral segments have an attribute inheritance relationship on a continuous transition edge path, and that the behavioral intensity fields corresponding to the two objects are higher than the low-intent behavior of the segment. When generating hard negative sample pairs, it may also require that the hard negative sample object and the positive sample object have the same exposure source marker or the same display position marker, but lack subsequent stable inheritance. Thus, contrastive learning does not treat any different objects as negative samples, but focuses on constraining objects with similar exposure conditions but different behavioral results. The training task of this embodiment is more focused on solving the problem of exposure pseudo-correlation mixed into interest representation.

[0060] In one embodiment, the joint training module checks whether stable behavior segments, perturbation graph views, and hard negative sample pairs are complete in the batch before each round of parameter update. If a user lacks sufficient stable behavior segments, the user's sample only participates in the behavior transition prediction loss and the perturbation variable adversarial loss, and does not participate in the cross-segment positive sample pair loss. If a candidate object lacks attribute association edges, the system uses the object attribute vector itself as the basic input of the object-level candidate representation, and adds attribute association edges after subsequent log completion. During training, each loss term is dynamically enabled according to sample availability, but the definition and technical meaning of the loss term are not changed. The model in this embodiment can maintain trainability under incomplete behavior data.

[0061] In this embodiment, after the recommendation scoring module outputs the candidate object recommendation scores, it can generate a candidate object list according to the scores from high to low, and exclude objects that have entered the exposure interference edge set and have a high match with the noise residual vector from the main recommendation positions; for candidate objects that have a high match with the long-term preference vector but a low match with the short-term intention vector, the system retains their scores when the intention credibility is low and reduces their relative ranking when the intention credibility is high; for candidate objects that have a high match with the short-term intention vector and maintain fragment consistency in the perturbation graph view, the system retains their short-term intention contribution in the score; the recommendation ranking in this embodiment is consistent with the aforementioned intention credibility and noise residual deduction.

[0062] In one embodiment, multiple users' behavioral event sequences can share object attribute nodes and object-level candidate representations during the training phase, but long-term preference vectors, short-term intent vectors, noise residual vectors, and intent credibility are all generated according to the user dimension. When different users generate behaviors on the same object, the system shares object-level attribute information through object attribute nodes and distinguishes the behavioral context of each user through user nodes and behavioral fragment identifiers. If an object is triggered by the same exposure source among most users but lacks stable continuity, the exposure edge masking process can improve its exposure interference edge judgment score at the object level. If an object has stable continuity among a certain user, the behavior trigger edge corresponding to that user can still retain a high weight. In this embodiment, shared object knowledge and individual behavioral differences can coexist.

[0063] In this embodiment, the data flow between the modules of the system is as follows: the behavior event sequence construction module outputs the behavior event sequence and behavior segment identifiers; the temporal behavior graph generation module reads the behavior event sequence and outputs hierarchical adjacency tensors, edge weight decay sequences, original graph views, and perturbation graph views; the graph representation learning module outputs graph representations, segment-level user representations, and object-level candidate representations; the causal intent decoupling module outputs long-term preference vectors, short-term intent vectors, and noise residual vectors; the self-supervised contrastive training module outputs sample pair losses and reconstructed object attribute vectors; the joint training module updates each learning parameter; the recommendation scoring module outputs candidate object recommendation scores; and the feedback update module writes new behavior events back to the behavior event sequence and graph structure. In this embodiment, each module has clear inputs and outputs, forming a closed loop from behavior modeling to score updating.

[0064] In a preferred embodiment, for users with fewer behavior records, the system still constructs behavior event sequences and local temporal behavior graphs according to the same process. However, during the causal intent decoupling process, the direct update magnitude of short-term intent vectors is reduced, and object attribute vectors are matched with shared object-level candidate representations in the group to supplement candidate object representations. When subsequent behaviors gradually form stable behavior segments, the weight of short-term intent vectors is gradually increased based on segment consistency. This processing is still based on the behavior event sequence, temporal behavior graph, causal intent decoupling, and gating fusion framework, without introducing independent popular recommendation logic. This embodiment maintains the consistency of the technical route when behavior samples are insufficient and avoids the rapid solidification of a small number of noisy behaviors in the early stages into recommendation criteria.

[0065] In one embodiment, the system can categorize the trained model parameters into basic graph learning parameters, causal intent decoupling parameters, joint training constraint parameters, and recommendation scoring parameters. The basic graph learning parameters are used to generate graph representations from hierarchical adjacency tensors. The causal intent decoupling parameters are used to separate long-term preference vectors, short-term intent vectors, and noise residual vectors. The joint training constraint parameters are used to calculate sample pair loss, behavior transfer prediction loss, component orthogonality loss, adversarial loss of interfering variables, and fragment alignment loss. The recommendation scoring parameters are used to generate gated fusion weights based on intent credibility. During model deployment, the above parameters are called according to the same user behavior fragment cache and object attribute cache, without changing the data dependencies established during training. This embodiment ensures that the computational paths are consistent between the training and inference phases.

[0066] In this embodiment, when a user continuously generates new behavioral events, the feedback update module does not directly overwrite the long-term preference vector. Instead, it writes the new behavioral events into the current behavioral segment or the new behavioral segment, and updates the short-term intent vector based on the attribute continuity and transfer relationship between the new behavior and the stable behavioral segment. When multiple new behaviors maintain the same attributes and positive behavior intensity within a continuous time period, the system improves the segment consistency of the short-term intent vector and reduces the proportion of the long-term preference vector in the gating fusion weight. When multiple new behaviors come from the same exposure source and lack stable transfer, the system increases the proportion of the noise residual vector and reduces the short-term intent credibility. In this embodiment, the new behavior feedback enters the scoring process through segment consistency and residual proportion.

[0067] In a preferred embodiment, when the candidate object set is large, the system can first use the object attribute vector and the long-term preference vector to perform coarse matching to filter out candidate objects that do not conflict with the long-term preferences, and then use the short-term intent vector, intent credibility, and noise residual vector for fine scoring. The coarse matching is only used as a candidate reduction process and does not replace the final recommendation score. The final score is still determined by the long-term preference matching value, the short-term intent matching value, and the noise residual deduction item. If a candidate object has a low similarity to the long-term preferences in the coarse matching stage but a high match with the short-term intent vector, the system can still retain it to participate in the fine scoring when the intent credibility is high, so as to avoid the long-term preferences from excessively restricting the short-term continuous intent. This embodiment improves the candidate object processing flow without changing the core scoring mechanism.

[0068] In this embodiment, behavioral fluctuation information can be composed of behavioral segment boundary scores, changes in object attribute distance, intensity of continuous negative behavior, and proportion of noise residuals, and is used as input for the recommendation scoring module to generate gating fusion weights. When behavioral fluctuation information shows that user behavior rapidly jumps between multiple object attributes, the system increases the fusion ratio of long-term preference vectors and increases the constraint of noise residual deduction terms. When behavioral fluctuation information shows that users continuously generate positive behavior on the same object attribute path, the system increases the fusion ratio of short-term intent vectors. This process only changes the scoring fusion relationship and does not change the candidate object attribute vectors themselves. In this embodiment, the impact of behavioral fluctuations on the recommendation results has a clear calculation path.

[0069] In one embodiment, the system performs time-order preservation processing on the model training data. Behavioral events in the training samples must not use future behaviors to construct the input of the current behavioral fragment. Subsequent behaviors are only used to form training labels, stabilize judgments, or predict behavioral transfer targets. When generating positive and hard-negative sample pairs, the system maintains the temporal relationship between the sample pairs and the current recommendation time to prevent future behaviors from leaking into the current graph representation. When the feedback update module processes real-time logs, it also only uses the current behavior update edge weight decay sequence, exposure interference edge set, and intent credibility. This embodiment ensures that the model has a consistent temporal causal order during the training and inference phases.

[0070] In this embodiment, after the system completes the candidate object recommendation scoring, it can also write the scoring results, gating fusion weights, intent credibility, noise residual ratio, and corresponding behavior segment identifiers into an explanatory log. The explanatory log is only used for subsequent model diagnosis and training sample construction, and is not used as a direct recommendation feature input to the current scoring process. When it is found that the high scores of a certain type of object mainly come from noise residual matching or the exposure interference edge set is not updated in time, the training weights of the interference variable adversarial loss and segment alignment loss can be readjusted through offline training. In this embodiment, the model diagnosis information is separated from the recommendation scoring input to avoid the diagnosis results forming a circular dependency in the current recommendation.

[0071] In one embodiment, the deep learning-based behavior analysis and accurate recommendation system forms a complete implementation chain through behavior event sequence construction, temporal behavior graph generation, dynamic graph neural network aggregation, causal intent decoupling, self-supervised contrastive training, exposure edge masking, joint training, credibility gating scoring, and feedback updates. This implementation chain revolves around the technical problem of long-term preferences, short-term intents, and the mixture of noisy behaviors. Each processing step corresponds to the output data of the previous processing step and generates the input data for the next processing step. Behavior event sequences provide unified event vectors, temporal behavior graphs provide relational structures, graph representation learning provides deep representations, causal intent decoupling provides component partitioning, joint training provides constraints, recommendation scoring provides candidate object ranking, and feedback updates provide incremental corrections. In this embodiment, the various processing steps have continuous technical connections and jointly support the generation of recommendation scores.

Claims

1. A deep learning-based behavior analysis and precise recommendation system, characterized in that, It includes a behavioral event sequence construction module, a temporal behavior graph generation module, a graph representation learning module, a causal intent decoupling module, and a recommendation scoring module; The behavior event sequence construction module converts continuous user behavior records into a behavior event sequence containing behavior object identifier, behavior type, behavior occurrence interval, behavior duration characteristics, exposure source marker, and object attribute vector; The temporal behavior graph generation module generates a directed temporal behavior graph based on the order of behaviors, the similarity of object attributes, and the relationship of continuous operations. The graph representation learning module outputs graph representations based on a dynamic graph neural network. The causal intent decoupling module decomposes the graph representation into a long-term preference vector, a short-term intent vector, and a noise residual vector. The recommendation scoring module performs gated fusion of the long-term preference vector and the short-term intent vector based on behavioral fluctuation information and noise residual information, and generates a recommendation score for the candidate object.

2. The deep learning-based behavior analysis and accurate recommendation system according to claim 1, characterized in that, The behavior event sequence construction module includes an event cleaning process and an event encoding process. The event cleaning process merges redundant behaviors according to the repeated triggering relationship of the same behavior object in a continuous short period of time, and writes the number of repetitions, the last trigger time, and the longest duration into the behavior intensity field. The event encoding process maps behavior type, behavior duration characteristics, behavior occurrence interval, exposure source marker, and object attribute vector to the same event vector space, and generates behavior segment identifiers and segment boundary identifiers according to the sequential dependencies of the user's continuous operation chain.

3. The deep learning-based behavior analysis and accurate recommendation system according to claim 2, characterized in that, The time-series behavior graph generation module uses users, behavior objects, and object attributes as graph nodes, and behavior trigger edges, attribute association edges, and continuous transition edges as directed edges. The behavior triggering edge carries behavior type embedding, behavior intensity field and behavior occurrence interval embedding, the attribute association edge carries object attribute similarity embedding, and the continuous transfer edge carries adjacent behavior segment identifier, segment boundary identifier and transfer direction encoding; All types of directed edges are written into the edge sequence cache in chronological order, and the edge sequence cache is used to construct a hierarchical adjacency tensor and an edge weight decay sequence.

4. The deep learning-based behavior analysis and accurate recommendation system according to claim 3, characterized in that, The graph representation learning module includes an edge type gating aggregation process and a temporal attention aggregation process. The edge type gating aggregation process reads the edge embeddings of the behavior triggering edge, the attribute association edge, and the continuous transition edge, and writes the graph node self-features, the neighborhood features of the same type of edge, and the neighborhood features of cross-type edge into the neighborhood aggregation vector. The time attention aggregation process weights the neighborhood aggregation vector according to the behavior occurrence interval embedding, behavior intensity field and behavior segment identifier, and shares the update state of the dynamic graph neural network between adjacent behavior segments to form segment-level user representation and object-level candidate representation.

5. The deep learning-based behavior analysis and accurate recommendation system according to claim 2, characterized in that, It also includes a self-supervised contrastive training module, which constructs positive sample pairs from adjacent stable behavior segments of the same user, constructs difficult-to-bear sample pairs from behavior objects with the same exposure source marker that have not formed subsequent effective behaviors, and configures segment consistency constraints on the positive sample pairs and the difficult-to-bear sample pairs according to the behavior segment identifier. The self-supervised contrastive training module also performs masking reconstruction on the behavior type embedding, retains the exposure source marker of the hard negative sample pair as the contrast grouping key, and writes the reconstructed object attribute vector into the representation subspace corresponding to the behavior fragment identifier.

6. The deep learning-based behavior analysis and accurate recommendation system according to claim 3, characterized in that, The temporal behavior graph generation module also includes an exposure edge masking process, which generates an exposure interference edge set based on the exposure source marker, the first occurrence position of the behavior object in the behavior event sequence, the behavior intensity field corresponding to the behavior object, and the number of adjacent attribute-related edges. The edge weight decay sequence superimposes the masking identifier of the exposure interference edge set on the behavior trigger edge and the continuous transfer edge, and encodes and corrects the adjacent position of the masked directed edge according to the transfer direction. The original image view and the perturbation image view are formed by the hierarchical adjacency tensor before and after masking, respectively.

7. The deep learning-based behavior analysis and accurate recommendation system according to claim 4, characterized in that, The causal intention decoupling module includes a disturbance variable encoding process, a preference component separation process, and a residual backfilling process. The disturbance variable encoding process encodes exposure source markers, object popularity markers, and display location markers as disturbance variables. The preference component separation process extracts long-term preference vectors from the graph representation shared across behavioral segments, extracts short-term intention vectors from the graph representation of the current behavioral segment, and uses object-level candidate representations as reconstruction references. The residual backfilling process writes the graph representation portion that has not been reconstructed by the long-term preference vector and the short-term intention vector into the noisy residual vector.

8. The deep learning-based behavior analysis and accurate recommendation system according to claim 5, characterized in that, It also includes a joint training module, which writes the sample pair loss output by the self-supervised contrastive training module, the behavior transfer prediction loss output by the graph representation learning module, the component orthogonality loss output by the causal intention decoupling module, the adversarial loss of the interference variable, and the fragment alignment loss between the original graph view and the perturbed graph view into the same training objective, and performs batch division according to the behavior fragment identifier and the contrast grouping key, so that positive sample pairs, hard negative sample pairs, exposure interference edge set, object-level candidate representation and noise residual vector participate in the constraint in the same parameter update.

9. The deep learning-based behavior analysis and accurate recommendation system according to claim 8, characterized in that, The recommendation scoring module includes a credibility calculation process and a candidate object matching process. The credibility calculation process generates intent credibility based on the proportion of noise residual vector in continuous behavior segments, the interference discriminability corresponding to the adversarial loss of the interference variable, the segment alignment loss between the original image view and the perturbed image view, and the segment consistency of the short-term intent vector. The candidate object matching process calculates the matching values ​​between the candidate object attribute vector and the long-term preference vector and the short-term intent vector, and generates gating fusion weights and candidate object recommendation scores according to the intent credibility.

10. The deep learning-based behavior analysis and accurate recommendation system according to claim 9, characterized in that, It also includes a feedback update module, which writes the newly generated behavioral event into the corresponding behavioral segment identifier and determines the matching relationship between the newly generated behavioral event and the long-term preference vector, short-term intention vector and noise residual vector; When the newly generated behavioral event matches the noise residual vector but is inconsistent with the stable behavioral segment, update the edge weight decay sequence, the exposure interference edge set, and the intent credibility. When the newly generated behavioral event continuously matches the short-term intent vector, the gating fusion weight, candidate object recommendation score, and corresponding perturbation graph view are updated.

Images