Joint modeling method and device based on large language model

Abstract

The embodiment of the invention provides a joint modeling method and device based on a large language model. The method comprises the steps that a user behavior sequence is obtained, the user behavior sequence comprises a plurality of target operation behaviors of a user, and at least one target operation behavior comprises an interaction behavior for target content; based on a static representation table, querying a first behavior representation corresponding to a first target operation behavior in the plurality of target operation behaviors, the static representation table storing a mapping relationship between the plurality of operation behaviors and the behavior representation; encoding the target operation behavior of which the first behavior representation is not queried by the first large language model to obtain a second behavior representation; and obtaining a click prediction result of the user on the target content based on the first behavior representation and the second behavior representation through a click rate prediction model.

Description

Technical Field

[0001] The embodiments of this specification relate to the field of computer technology, and specifically, to a joint modeling method and device based on a large language model. Background Art

[0002] With the continuous progress of artificial intelligence technology, the application of LLM (Large Language Model) is increasing. The CTR (Click-Through Rate) joint modeling based on LLM aims to estimate the probability that a user clicks on an advertisement or recommended content by using the user features extracted by LLM. Among them, LLM is used to better understand and extract the text features in the user behavior sequence, and convert them into behavior representations as the input of the downstream CTR model to assist the CTR model in accurately predicting the click-through rate.

[0003] Under the influence of the Scaling Law, the CTR model based on LLM tends to add longer texts to the user sequence to improve the prediction performance of the model. However, long texts will also significantly slow down the training and inference speed of the model. Especially when encoding the texts of long user sequences in industrial scenarios, it requires a large amount of GPU (Graphics Processing Unit) resources, and even encounters OOM (Out Of Memory) errors, resulting in the inability to train. Summary of the Invention

[0004] The embodiments of this specification provide a joint modeling solution based on a large language model, which can effectively reduce the occupancy of graphics card resources by retrieving behavior representations instead of partial calculations.

[0005] In a first aspect, the embodiments of this specification provide a joint modeling method based on a large language model, including: obtaining a user behavior sequence, where the user behavior sequence includes multiple target operation behaviors of the user, and at least one of the target operation behaviors includes an interaction behavior with a target content; querying, based on a static representation table, a first behavior representation corresponding to a first target operation behavior among the multiple target operation behaviors, where the static representation table stores a mapping relationship between multiple operation behaviors and behavior representations; for the target operation behaviors for which the first behavior representation is not queried, encoding them by a first large language model to obtain a second behavior representation; and obtaining a click prediction result of the user for the target content based on the first behavior representation and the second behavior representation through a click-through rate prediction model.

[0006] In some embodiments, for the target operation behavior for which the first behavior representation is not queried, it is encoded by the first large language model to obtain a second behavior representation, including: for the target operation behavior for which the first behavior representation is not queried, it is encoded by the lower layer network of the first large language model to obtain a second behavior representation; through the click-through rate prediction model, based on the first behavior representation and the second behavior representation, the click prediction result of the user for the target content is obtained, including: based on the first behavior representation and the second behavior representation, feature extraction is performed by the upper layer network of the first large language model to obtain the user behavior features corresponding to the user behavior sequence; the user behavior features are input into the click-through rate prediction model to obtain the click prediction result of the user for the target content.

[0007] In some embodiments, after the user behavior features are input into the click-through rate prediction model to obtain the click prediction result of the user for the target content, the method further includes: based on the click prediction result and the click label of the obtained user behavior sequence, training the upper layer network of the first large language model.

[0008] In some embodiments, the static representation table is constructed offline in the following manner: based on the user behavior sequences of multiple sample users, multiple operation behaviors are obtained; the operation behaviors are input into the first large language model to obtain the behavior representations corresponding to the operation behaviors; based on the multiple operation behaviors and the behavior representations corresponding to the operation behaviors, the static representation table is constructed.

[0009] In some embodiments, before querying the first behavior representation corresponding to the first target operation behavior among the multiple target operation behaviors based on the static representation table, the method further includes: based on the scale of at least one of the static representation tables to be loaded, determining the storage mode corresponding to the static representation table, and loading the obtained static representation table into the video memory of the graphics card according to the storage mode.

[0010] In some embodiments, the determining the storage mode corresponding to the static representation table based on the scale of at least one of the static representation tables to be loaded and loading the obtained static representation table into the video memory of the graphics card according to the storage mode includes: in the case where the scale of at least one of the static representation tables to be loaded belongs to the first scale, determining the storage mode corresponding to the static representation table as the single-machine copy mode, and storing the static representation table in the video memory of each graphics card.

[0011] In some embodiments, determining a storage mode corresponding to the static characterization table based on the scale of at least one of the static characterization tables to be loaded, and loading the obtained static characterization table into the video memory of the graphics card according to the storage mode includes: when the scale of at least one of the static characterization tables to be loaded belongs to a second scale, determining that the storage mode corresponding to the static characterization table is a global sharding mode; dividing at least one of the static characterization tables, and respectively storing each shard of the divided static characterization table into the video memories of multiple graphics cards.

[0012] In some embodiments, dividing at least one of the static characterization tables, and respectively storing each shard of the divided static characterization table into the video memories of multiple graphics cards includes: respectively storing multiple different static characterization tables into the video memories of multiple graphics cards; or, dividing the static characterization table by row dimension to obtain multiple first shards, and respectively storing the first shards into the video memories of multiple graphics cards, each first shard respectively including a mapping relationship between different operation behaviors and behavior characterizations; or, dividing the static characterization table by column dimension to obtain multiple second shards, and respectively storing the second shards into the video memories of multiple graphics cards, each second shard respectively including data of different dimensions of the behavior characterizations in the mapping relationship between the same operation behavior and behavior characterizations.

[0013] In some embodiments, determining a storage mode corresponding to the static characterization table based on the scale of the static characterization table to be loaded, and loading the obtained static characterization table into the video memory of the graphics card according to the storage mode includes: when the scale of at least one of the static characterization tables to be loaded belongs to a third scale, determining that the storage mode corresponding to the static characterization table is a remote sharing mode; storing the obtained static characterization table at a storage location outside the graphics card, and caching a part of the static characterization table into the video memory of the graphics card.

[0014] In some embodiments, querying a first behavior characterization corresponding to a first target operation behavior among the multiple target operation behaviors based on the static characterization table includes: querying a first behavior characterization corresponding to the first target operation behavior among the multiple target operation behaviors based on a part of the static characterization table stored in the graphics card; in response to the first behavior characterization not being found, querying the first behavior characterization corresponding to the first target operation behavior from the static characterization table in the storage location outside the graphics card, and caching the queried first behavior characterization into a part of the static characterization table in the video memory.

[0015] In some embodiments, the method further includes: in response to the size of the partial static representation table reaching a preset threshold, emptying the behavior representations in the partial static representation table based on an elimination mechanism.

[0016] In some embodiments, the priority order for storing the obtained static representation table in a storage location outside the graphics card is: memory, solid-state drive, Redis (Remote Dictionary Server), distributed file system, mechanical hard drive.

[0017] In a second aspect, an embodiment of the present specification provides a computing device, including a memory and a processor. Among them, executable code is stored in the memory, and when the processor executes the executable code, the method described in any implementation manner of the first aspect is implemented.

[0018] In the solution provided in the above embodiments of the present specification, the user's operation behaviors are processed into behavior representations in advance and stored in the static representation table. In this way, during joint training, retrieving the behavior representations corresponding to the operation behaviors is used to replace the calculation, and for the operation behaviors for which no behavior representations are retrieved, the first large language model is used for online encoding to obtain the corresponding behavior representations, which can not only reduce the peak value of video memory usage during the encoding stage of the behavior representations, but also accelerate the inference and training processes, and can achieve efficient joint modeling inference and training of LLM and CTR under the condition of limited GPU resources. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] To more clearly illustrate the technical solutions of the multiple embodiments disclosed in this specification, the following will briefly introduce the drawings required for the description of the embodiments. Obviously, the drawings in the following description are only the multiple embodiments disclosed in this specification. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0020] Figure 1 is a schematic diagram of a current LLM-based CTR model process shown in this specification;

[0021] Figure 2 is a flowchart of the construction process of the static representation table shown in the embodiments of this specification;

[0022] Figure 3 is a flowchart of a joint modeling method based on a large language model shown in the embodiments of this specification;

[0023] Figure 4 is a schematic diagram of a joint modeling framework shown in the embodiments of this specification;

[0024] Figure 5 is a schematic diagram of a multi-level storage mode shown in the embodiments of this specification;

[0025] Figure 6 It is a schematic structural diagram of a joint modeling device based on a large language model shown in the embodiments of this specification. Detailed implementation manners

[0026] In order to enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of this specification. Obviously, the described embodiments are only a part of the embodiments of this specification, rather than all the embodiments. Based on the embodiments in this specification, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of this specification.

[0027] CTR prediction refers to using a CTR model to predict the probability that a user will click after seeing a certain advertisement or recommended content, which is an important task in the fields of online advertising, recommendation systems, etc. When making predictions, traditional CTR models usually analyze the user's behavioral data (such as clicks, browsing, etc.) to predict the user's click-through rate. With the development of large model technology, there is currently a CTR model based on LLM, such as Figure 1 shown in the schematic diagram of the model process. This model uses LLM to understand the text features in the user behavior sequence (such as the text description of the user behavior, the user's comments, etc.), and converts these text information into a representation that can be understood by the model, as the input of the subsequent CTR model. In this way, since LLM can understand and capture the deep semantics in the text, it can provide more semantic information for the traditional CTR model, making the model more accurate in analyzing user behavior.

[0028] In traditional CTR recommendations, inputting a diverse long-text user behavior sequence into the model can enhance the recommendation performance. However, longer texts will significantly slow down the training and inference speed of the large language model. To avoid the large amount of computing resources occupied by LLM when encoding longer user behavior sequences, the current LLM-based CTR methods can only adapt to smaller language models and shorter user sequence inputs.

[0029] To address the performance bottleneck problem encountered by the above-mentioned LLM-based CTR model when processing long user sequences, the embodiments of this specification propose a joint modeling method based on large language models. This method is proposed based on the hierarchical architecture idea of decoupling the encoding of user behaviors and the learning of complex interaction relationships between behaviors, thereby improving the performance of the LLM in processing long user sequences. In this method, first, a user behavior sequence containing multiple target operation behaviors is obtained. Then, based on the static representation table, the first behavior representation corresponding to the first target operation behavior among the multiple target operation behaviors is queried. And for the target operation behaviors for which the first behavior representation is not queried, they are encoded by the first large language model to obtain the second behavior representation. Finally, through the click-through rate prediction model, based on the first behavior representation and the second behavior representation, the click prediction result of the user on the target content is obtained. In this way, the operation behaviors in the user behavior sequence are processed into reusable behavior representations in advance and stored in the static representation table, and the retrieval of the behavior representations corresponding to the operation behaviors is used to replace part of the calculations of the large language model during the inference and training processes of the model, which can reduce the peak usage of video memory and accelerate the inference and training of the model.

[0030] To facilitate the understanding of the solution provided by the embodiments of this specification, the above-mentioned hierarchical architecture idea and the construction process of the static representation table will be described first below.

[0031] A series of consecutive interactions and operations of a user in a certain platform or system can be regarded as a user behavior sequence. The user behavior sequence contains many fine-grained individual operation behaviors. An operation behavior refers to a specific action or operation performed by the user. At least one operation behavior in the user behavior sequence contains an interaction behavior with the target content (item), and the target content is an advertisement, a product, or other recommended content for which the click-through rate is to be predicted. The operation behavior can be, for example, a click operation on a certain product link, picture, or advertisement, a browsing behavior of the user browsing a certain product detail page, video, article, etc., a search behavior of the user searching for a certain product on an e-commerce platform or entering a query term in a search engine, and the actual payment or purchase action of the user. Exemplarily, in a shopping scenario, the user behavior sequence can be a sequence of operation behaviors including the user first searching, then clicking, and finally purchasing on a shopping website, as well as other operation behaviors with a time sequence relationship occurring during this period.

[0032] Generally speaking, the time span of the user behavior sequence is long, and there are a large number of repetitions in the behavior sequences within and between users. For example, user A purchases cola on a shopping website on November 12, user A purchases cola on a shopping website on December 11, user B purchases cola on a shopping website, user C purchases cola on a shopping website... It can be seen that there are usually repeated operation behaviors in the user behavior sequences of the same or different users.

[0033] In this way, when the LLM encodes the user behavior sequence, the same operation behavior will be encoded multiple times, resulting in a waste of computing resources. Even when only the order of operation behaviors in the user behavior sequence changes, the entire user behavior sequence still needs to be re-encoded and recalculated, leading to a waste of computing resources and low efficiency.

[0034] Inspired by the hierarchical architecture concept, in the embodiments of this specification, the encoding of user operation behaviors is decoupled from the learning of complex interaction relationships between behaviors. In other words, the encoding process of each operation behavior is separated from the learning process of the behavior patterns in the entire user behavior sequence, enabling the learning of high-level behavior interaction features to be independent of low-level behavior text encoding, thereby reducing the computational complexity during the encoding stage. Specifically, it can be achieved by pre-collecting the user behavior sequences of sample users, extracting individual reusable operation behaviors from them, encoding them using a large language model to obtain behavior representations and storing them in a static representation table. When processing the user behavior sequence subsequently, the behavior representations corresponding to the operation behaviors can be queried from the static representation table, and the behavior pattern features in the user behavior sequence can be learned through the combination of the queried behavior representations, without the need to re-encode and learn the entire user behavior sequence. In this way, the same operation behavior only needs to be encoded once during the entire joint modeling process.

[0035] Next, the construction process of the static representation table will be further described. The static representation table is used to store the mapping relationship between multiple operation behaviors and behavior representations. As an implementation method, the static representation table can be constructed offline in the following way: Based on the user behavior sequences of multiple sample users, obtain multiple operation behaviors; input the operation behaviors into the first large language model to obtain the behavior representations corresponding to the operation behaviors; based on the multiple operation behaviors and the behavior representations corresponding to them, construct the static representation table.

[0036] In practice, in different systems or platforms, the behavior space of user operations and interactions is limited and enumerable. Therefore, the user behavior sequences of multiple sample users can be collected from the user behavior data (such as logs, historical records, point collection data) of different systems or platforms, and multiple operation behaviors can be extracted from them. The first large language model that has been pre-trained is used to encode each individual operation behavior separately to obtain behavior representations (Embeddings). The first large language model used here can be any open-source LLM model or a partial layer structure of the LLM model. In this way, the mapping relationship between multiple operation behaviors and their corresponding behavior representations can be obtained, and this mapping relationship can be saved in an offline database to obtain the static representation table.

[0037] In different fields (such as clicks, favorites, adding to the shopping cart, etc.) and different platforms or systems, the characteristics of user behaviors that the model focuses on are not the same. The prediction of the CTR model tends to focus on the probability that a user clicks on a certain product or other recommended content. For the CTR prediction scenario, in one embodiment, the following method can be used to pre-construct a text set containing multiple user behavior sequences (abbreviated as the behavior set): 1) Trace user historical operations based on product design: First, list all possible behaviors (such as button clicks, page stays, swipes, etc.) according to product function modules or user operation logs, and then domain experts (such as product managers, data analysts) screen out the behavior subset valuable for business analysis to ensure that the final behavior set has a high degree of relevance and predictive value; 2) Directly map the events of user interaction with the platform into text behaviors: The interaction events between users and the platform (such as clicks, browsing, adding to the cart, comments, etc.) can be directly collected through data embedding, and these events are directly converted into text descriptions. This method does not rely on complex reasoning processes and can quickly construct a basic data set of user behaviors, which is suitable for scenarios that require real-time or large-scale processing; 3) Use text corpora (such as posts, comments, or evaluations published by users, etc.) for behavior extraction: User behaviors in unstructured text can be extracted through methods such as manual annotation extraction and NLP (Natural Language Processing) entity recognition. At this time, the behavior information contained in the text can be effectively extracted through means such as keyword recognition and sentiment analysis, so as to generate a behavior set. In addition, the extraction task can also be completed by constructing prompts (Prompts) and leveraging mature LLMs. In other implementation manners, a sound user behavior knowledge base can be accumulated based on expert experience, and further, user behaviors (including interactions with products) are mapped through text to construct a behavior set.

[0038] The following combines Figure 2 to illustrate the construction process of a static representation table in an example. In this example, the text describing the operation behavior can be regarded as an entity, and the operation behavior can also be called an atomic behavior. The user behavior data containing user behavior sequences usually exists in the form of logs. The finest-grained and atomic-level atomic behaviors can be extracted from the existing logs to generate a set of atomic behaviors, that is, a behavior entity set. For a sample user u ∈ U, define the user behavior sequence of this sample user as s u , s u consisting of N behavior sequences in different fields, denoted as s u = [s un |0 < n < N]. s u can also include the name of the target content interacted by the sample user (such as product A in "purchasing product A"). Among them, each behavior sequence s unOn average, it contains M atomic behaviors s un = [b unm | 0 < m < M], H can be defined as the set of atomic behaviors b of all sample users unm , which is also called the set of behavior entities H:

[0039] H = {b unm | u ∈ U, 0 < m < M, 0 < n < N} (1)

[0040] To make full use of the powerful semantic understanding ability of LLMs and the learned world knowledge, the user behavior sequence can be converted into a text form that is easy for the large language model to receive. Each atomic behavior in the user behavior sequence can be further tokenized into tokens at the input layer of the LLM. It can be to disassemble the atomic behavior b in the set of user behavior entities H into K tokens {t k | 0 < k < K} through the tokenizer corresponding to the pre-trained LLM model. These tokens can extract the corresponding representations through the pre-trained LLM model and be aggregated into the behavior representation e corresponding to this atomic behavior b , for example, it can be aggregated by the mean pooling method as follows:

[0041]

[0042] After that, all atomic behaviors b and the corresponding behavior representations e b are combined into key-value pairs to construct a static representation table T:

[0043] T = {(b, e b ) | b ∈ H} (3)

[0044] If the total token length of s u is marked as l u , each atomic behavior b unm on average contains K tokens, l u = N × M × K. For a certain target content (such as a commodity) i ∈ I, the text title feature of this commodity i is denoted as t i , the total token length of t i is l i . The text feature of the commodity sometimes appears in the user behavior sequence s u , and it can also be added to H separately. Since the text title feature of the commodity usually changes little, while the atomic behaviors in the user behavior sequence grow rapidly, so l i is much shorter than l u , which means reducing l uThe influence can more effectively improve the encoding efficiency of the LLM model. Through the above-mentioned behavior entity extraction process, the LLM encoding object is abstracted from the token level of the user behavior sequence to the behavior feature level of a single atomic behavior, that is, one atomic behavior corresponds to one behavior representation, thus significantly reducing the overall encoding length and increasing the reusability of user behaviors.

[0045] Next, a specific embodiment will be used to illustrate the method shown in this specification. Figure 3 It is a flowchart of the joint modeling method based on the large language model in the embodiments of this specification. This method can be executed by any device, platform or device cluster with computing and processing capabilities, including steps S301 - S304 shown below.

[0046] As Figure 3 shown, in step S301, obtain the user behavior sequence.

[0047] Among them, the user behavior sequence contains multiple target operation behaviors of the user, and at least one target operation behavior contains an interaction behavior with the target content. For example, when the target content for predicting the click-through rate is product B, the target operation behaviors include operations such as clicking, browsing, or purchasing product B.

[0048] In different embodiments, the ways to obtain the user behavior sequence are different. The specific acquisition methods can refer to the previous description, and this embodiment will not elaborate on them. For example, the user behavior sequence can be obtained from the user's behavior logs.

[0049] It should be noted that the joint modeling method shown in this embodiment can be used in the model training stage or the model inference stage. When used in the model training stage, the user behavior sequence can be obtained from a pre-constructed training sample set. When used in the model inference stage, the user behavior sequence can be obtained from the behavior logs of the user whose click probability is to be predicted.

[0050] Then, in step S302, based on the static representation table, query the first behavior representation corresponding to the first target operation behavior among multiple target operation behaviors.

[0051] Among them, the static representation table stores the mapping relationship between multiple operation behaviors and behavior representations. The construction process of the static representation table refers to the previous description. The static representation table can be pre-stored in the video memory of the graphics card or stored remotely in other locations.

[0052] [[ID=2B]]In this step, for each target operation behavior in the user behavior sequence, query the behavior representation corresponding to the target operation behavior in the static representation table. If found, the target operation behavior is called the first operation behavior, and the corresponding behavior representation is determined as the first behavior representation.

[0053] In step S303, for the target operation behavior not found with the first line representation, it is encoded by the first large language model to obtain the second line representation.

[0054] In the case where the behavior representation corresponding to the target operation behavior is not stored in the static representation table, the first large language model can perform online encoding on the target operation behavior. For example, first use a tokenizer to convert the target operation behavior into multiple tokens, and then the first large language model extracts representations from the multiple tokens and performs mean pooling to obtain the second line representation.

[0055] Among them, the first large language model used here can be any pre-trained LLM model or a partial layer structure of the LLM model, such as the lower layer network of the LLM model.

[0056] Then, in step S304, through the click-through rate prediction model, based on the first line representation and the second line representation, the click prediction result of the user on the target content is obtained.

[0057] Among them, the click prediction result is the probability that the model predicts the user will click on the target content. In practice, it can be that the first line representation and the second line representation are concatenated in the order of the target operation behavior corresponding to them in the user behavior sequence to obtain the total behavior representation, and then the total behavior representation and the target content are input into the click-through rate prediction model for prediction to obtain the click prediction result. It can also be that the total behavior representation and the target content are input into the second large language model, and the second large language model further extracts the user behavior features, and the user behavior features are input into the click-through rate prediction model for prediction to obtain the click prediction result. This embodiment does not limit the specific implementation method.

[0058] The solution of the above embodiment provides a hybrid mode of two ways of characterization calculation and characterization query to convert the operation behaviors in the user behavior sequence into corresponding behavior characterizations during the joint modeling phase. Among them, the characterization calculation method inputs the operation behaviors in the user behavior sequence into the LLM model to online calculate the corresponding behavior characterizations; the characterization query method refers to querying the behavior characterizations corresponding to the operation behaviors in the user behavior sequence through a static characterization table processed offline. In practical applications, according to business requirements, a part of the behavior features can be configured in the calculation group and another part of the behavior features can be configured in the query group. For example, the operation behaviors with a large number of repeated occurrences are configured in the query group to reduce repeated calculations, and the operation behaviors with a small number of occurrences are configured in the calculation group to avoid occupying the storage space caused by the storage of behavior characterizations, so as to combine the advantages of the two modes. Finally, the behavior characterizations obtained by different methods are merged and passed to the subsequent CTR model. This not only improves the flexibility of the system, but also allows selecting the most suitable characterization generation method according to different business scenarios and data characteristics to obtain better modeling effects.

[0059] In one implementation, to adapt to different conversion methods of behavior features, in addition to obtaining behavior characterizations through the hybrid mode of the above calculation group and query group, the following two modes are also provided:

[0060] Pure calculation mode: When all behavior characterizations are configured in the calculation group, all behavior characterizations are generated by calculation through the LLM model. The advantage of this mode lies in its dynamicity and real-time nature, and it can update characterizations according to user behaviors without an offline processing process. For example, in response to being in the calculation mode, for each target operation behavior in the user behavior sequence, it is encoded by a pre-trained first large language model to obtain the behavior characterization. In practical applications, operation behaviors that are difficult to extract can also be configured in the calculation group to directly calculate the behavior characterizations.

[0061] Pure query mode: When all behavior characterizations are configured in the query group, all behavior characterizations are obtained by querying through the static characterization table. The main features of this mode are high efficiency and scalability, which are suitable for processing large-scale data query requirements and can save real-time computing resources. For example, in response to being in the query mode, for each target operation behavior in the user behavior sequence, based on the static characterization table, the behavior characterization corresponding to the target operation behavior is queried.

[0062] As an implementation, the lower-layer network and the upper-layer network of the same large language model can be used to encode operation behaviors and learn the user behavior interaction patterns respectively. That is, the lower-layer network is used to encode operation behaviors to obtain behavior representations, and the upper-layer network is used to learn the complex interactions between behaviors and generate comprehensive user behavior features. Among them, the lower-layer network refers to the first few layers of the large language model close to the input end, which is responsible for extracting basic and fine-grained features from the input. The upper-layer network refers to the last few layers of the large language model far from the input end, which is responsible for processing more complex patterns and abstract information, and can capture information such as long-distance dependencies and complex interactions between behaviors and output more comprehensive and abstract features.

[0063] The following will specifically describe this implementation mode in combination with Figure 4 this.

[0064] Refer to Figure 4 the LLM+CTR joint modeling framework shown in the figure. In the offline processing stage, which can be executed by other devices or servers, after extracting the behavior entity set from the user behavior sequence of the sample user, the operation behaviors in the behavior entity set are input into the pre-trained lower-layer LLM model (i.e., the lower-layer network of the first large language model) for extraction to obtain behavior representations, and a static behavior representation table is constructed. Then, in the joint modeling stage, the previously offline constructed static representation table needs to be loaded into the current device, such as loaded into the video memory of the graphics card, to construct a static representation layer for easy query. After obtaining the user behavior sequence to be predicted, first, based on the static representation table in the static representation layer, query the first behavior representation corresponding to the first target operation behavior among multiple target operation behaviors. For the target operation behaviors for which the first behavior representation is not queried, they are encoded by the lower-layer network of the first large language model to obtain the second behavior representation; then, based on the first behavior representation and the second behavior representation, the trainable upper-layer LLM (i.e., the upper-layer network of the first large language model) performs feature extraction to obtain the user behavior features corresponding to the user behavior sequence. For example, the first behavior representation and the second behavior representation are merged in the order of the target operation behaviors corresponding to them in the user behavior sequence and then input into the upper-layer network of the first large language model; next, the user behavior features are input into the click-through rate prediction model to obtain the click prediction result of the user for the target content. In this way, the decoupling of behavior encoding and the learning of interactions between behaviors is achieved.

[0065] In some embodiments, the provided joint modeling method based on a large language model is used to train a joint model based on LLM+CTR. In this embodiment, on the basis of the above embodiment, it further includes step S305: training the upper-layer network of the first large language model based on the click prediction result and the click label of the obtained user behavior sequence.

[0066] For example Figure 4As shown, the lower - layer network of the first large - language model is pre - trained, and the upper - layer network of the first large - language model is trainable. During training, the weights of the lower - layer network can be frozen, so that the first large - language model focuses on learning the interaction patterns between user behaviors during the training process. Exemplarily, the click prediction result can be a probability value between 0 and 1, and the click label can be a label of 0 or 1. The closer the click prediction result is to 1, the more likely the user is to click on the target content; the closer it is to 0, the less likely the user is to click on the target content. During training, a loss function is constructed based on the difference between the click prediction result and the click label. The loss function is used to determine the gap between the actual output and the expected output. This embodiment does not limit the specific loss function used. It can specifically aim to minimize the training loss and adjust the network parameters in the upper - layer network through backpropagation. When the network iteration end condition is reached, the network training ends. This embodiment does not limit the preset stop training conditions. Among them, the condition can be that the iteration reaches a certain number of times, or the loss value of the loss function is less than a certain threshold. In addition, the network parameters of the CTR model can also be adjusted in this process.

[0067] In the representation query method during the training stage, it is necessary to load the pre - constructed static representation table into the video memory to construct a static representation layer. However, limited by the memory capacity, it is necessary to design a data loading and storage strategy according to the scale of the static representation table to effectively utilize resources.

[0068] In one implementation, based on the scale of at least one static representation table to be loaded, determine the storage mode corresponding to the static representation table, and load the obtained static representation table into the video memory of the graphics card according to the storage mode.

[0069] It should be noted that multiple static representation tables can be constructed through user behavior sequences from different sources such as different platforms or systems. Since the number of operation behaviors included in user behavior sequences from different sources is different, the scales of the constructed static representation tables are also different. Each time one or more static representation tables are constructed, the storage mode of the static representation table can be determined according to its scale. The scale of the static representation table depends on the number of mapping relationships in the static representation table (i.e., the number of operation behaviors or behavior characteristics). The more mapping relationships it contains, the larger the scale of the static representation table.

[0070] Such as Figure 5As shown in the figure, this embodiment proposes a multi-level storage mode for the static representation layer, including the single-machine copy mode, the global sharding mode, and the remote sharing mode. It can be understood that these storage modes can coexist in the video memory. For example, the static representation table 1 can be stored in the single-machine copy mode, and the static representation table 2 can be stored in the global sharding mode. The full amount of the shards of the static representation table 1 and the static representation table 2 can be stored in a certain GPU. The following will be combined with Figure 5 (In Figure 5 the static representation table is abbreviated as the representation table) to introduce each mode in detail.

[0071] Single-machine copy mode:

[0072] When the scale of at least one static representation table to be loaded belongs to the first scale, determine that the storage mode corresponding to the static representation table is the single-machine copy mode, and store the static representation table in the video memory of each graphics card.

[0073] The first scale is a small scale. It should be noted that there is no fixed standard for the division of whether it belongs to the first scale, the second scale, or the third scale. Different judgment methods can be adopted in different embodiments. It can be judged whether the static representation table belongs to the first scale, the second scale, or the third scale according to the memory size of the graphics card and the memory size occupied by the static representation table. For example, when the user behavior sequences of multiple sample users used to generate the static representation table are short sequences, the number of corresponding entities and behavior features is relatively small. When the offline-generated static representation table can be fully loaded into the video memory of each GPU, it is determined that the scale of the static representation table belongs to the first scale. In this case, as Figure 5 (a) shows, each GPU will retain a copy of the same full amount of the static representation table. Therefore, the representation query during the training process can be completed locally without communicating with other GPUs. In the single-machine copy mode, since the same full amount of representations are retained in the video memory of each GPU, there is a certain storage redundancy problem, and it is only recommended to use in short-sequence scenarios.

[0074] Global sharding mode:

[0075] When the scale of at least one static representation table to be loaded belongs to the second scale, determine that the storage mode corresponding to the static representation table is the global sharding mode; divide at least one static representation table, and store each shard of the divided static representation table in the video memory of multiple graphics cards respectively.

[0076] The second scale is a medium scale between the first scale and the third scale. It is possible to determine whether the static representation table belongs to the second scale based on the memory size of the graphics card and the memory occupied by the static representation table. For example, when the user behavior sequences of multiple sample users used to generate the static representation table are medium-length sequences, the offline-generated static representation table is relatively large, and the generated static representation table cannot be stored in the video memory of a single GPU. Even if it can be stored, it will occupy the video memory space available for training. Since the batch_size of the training sample set cannot be increased, the training speed will be affected. At this time, it is determined that the scale of the static representation table belongs to the second scale. For this reason, the global sharding mode divides each representation table from multiple dimensions and loads the shards of the representation table into different GPUs respectively, so as to ensure that there is only one full-scale representation table globally and avoid storage redundancy, as Figure 5 shown in (b). Among them, the division dimensions of each feature table include the table dimension, the row dimension, and the column dimension.

[0077] Division by table dimension: Store multiple different static representation tables in the video memories of multiple graphics cards respectively. When there are multiple static representation tables to be loaded, store different representation tables in the video memories of multiple GPUs respectively. Considering that the sizes of static representation tables corresponding to different features are different, the uniform distribution strategy can be used to avoid the problem of uneven load, so as to dynamically adjust the GPUs assigned to them according to the sizes of each representation table, and avoid the overloading of the computing load of some GPUs while the computing resources of other GPUs are idle, resulting in performance bottlenecks or low training efficiency.

[0078] Division by row dimension: Divide the static representation table by row dimension to obtain multiple first shards, and store the first shards in the video memories of multiple graphics cards respectively. Each first shard contains the mapping relationship between different operation behaviors and behavior representations respectively. Division by row dimension is to shard according to the number of mapping relationships in the representation table (i.e., the number of behavior representations), and disperse and load the first shards into different GPUs. Suppose there are 2000 behavior representations in a certain representation table. The division by row dimension is to split it into two first shards, place the first shard where the mapping relationships (i.e., key-value pairs) corresponding to the first 1000 behavior representations are located on GPU_0, and place the first shard where the mapping relationships corresponding to the last 1000 behavior representations are located on GPU_1. During the training process, if the serial number corresponding to the behavior representation is between 0 and 1000, query it from GPU_0; if it is between 1000 and 2000, query it from GPU_1. Since the access frequencies of different features are different in the actual scenario, division by row dimension is likely to lead to uneven communication volume, which in turn affects the performance of collective communication.

[0079] Partitioning by column dimension: The static representation table is partitioned by column dimension to obtain multiple second shards, and the second shards are respectively stored in the video memories of multiple GPUs. Each second shard contains different dimensional data of the behavior representation in the mapping relationship between the same operation behavior and the behavior representation. Partitioning by column dimension is to shard according to the Embedding length in the representation table (i.e., the dimension of the behavior representation), and the behavior representation is a vector with dimensions. For example, if the total Embedding length is 128 (i.e., the dimension of the behavior representation is 128), the first 64 dimensions and the last 64 dimensions of the behavior representation need to be placed on different GPUs. This method can ensure that the representation table is evenly split without causing uneven load problems. During the training process, this method needs to communicate with all GPUs, and the communication will be relatively balanced. However, when the Embedding length is relatively small, partitioning by column still needs to communicate with all GPUs, which will affect the training speed. At this time, it may be more appropriate to store a complete backup on each GPU, that is, the single-machine replica mode.

[0080] These partitioning strategies can be adjusted according to actual needs and hardware configurations to effectively utilize the memory and computing resources of different machines and obtain better query efficiency.

[0081] Remote sharing mode:

[0082] When the scale of at least one static representation table to be loaded belongs to the third scale, determine that the storage mode corresponding to the static representation table is the remote sharing mode; store the obtained static representation table in a storage location outside the GPU, and cache part of the static representation table in the video memory of the GPU.

[0083] The third scale is a large scale. It can be judged whether the static representation table belongs to the third scale according to the memory size of the GPU and the memory size occupied by the static representation table. For example, when the user behavior sequences of multiple sample users used to generate the static representation table are ultra-long sequences or when GPU resources are insufficient, the static representation table cannot be loaded into the GPU video memory through the global sharding mode, and additional storage resources need to be used for storage. In the remote sharing mode, the full static representation table is stored on the remote medium, and only part of the representation table is cached inside each GPU. Considering the read and write speeds of different storage resources, the priority order for storing the obtained static representation table in a remote storage location outside the GPU is: memory, solid-state disk, Redis, DFS (Distributed File System), mechanical disk. When the current medium is not sufficient to store the full representation table, the next-level medium will be selected in turn for storage.

[0084] In one embodiment, step S302 may be as follows: Based on a partial static representation table stored in the graphics card, query the first behavior representation corresponding to the first target operation behavior among multiple target operation behaviors; in response to the failure to query the first behavior representation, query the first behavior representation corresponding to the first target operation behavior from the static representation table at a storage location outside the graphics card, and cache the queried first behavior representation into the partial static representation table in the video memory.

[0085] Before the training starts, in order to reduce memory occupancy, only a smaller representation table, that is, a partial static representation table in the static representation table, may be cached on each GPU. This initial partial representation table may be randomly intercepted from the static representation table. During the training process, each GPU will first query the behavior representation corresponding to each target operation behavior in the cached partial static representation table. If a hit occurs, the corresponding behavior representation will be directly used; if the query fails, the query will be performed from the full static representation table stored remotely, and the mapping relationship corresponding to the queried first behavior representation will be cached in the GPU.

[0086] In one embodiment, it may also be possible to, in response to the scale of the partial static representation table reaching a preset threshold, clear the behavior representations in the partial static representation table based on an elimination mechanism.

[0087] In practice, the scale of the static representation table depends on the number of mapping relationships in the static representation table (i.e., the number of behavior representations or operation behaviors), and the preset threshold may be the maximum value of the number of mapping relationships. Exemplarily, when the number of behavior representations cached on the GPU reaches the maximum value, the elimination mechanism will be triggered. For example, the behavior representations in the cache are sorted through the Least Recently Used (LRU) and Least Frequently Used (LFU) elimination mechanisms. The fewer the number of uses, the higher the sorting. Then, a part of the behavior representations with higher sorting is cleared. Since the elimination process is relatively slow, a prefetch process may also be separately started during the training process, in parallel with the elimination mechanism, to retrieve the behavior features corresponding to the next operation behavior in advance to avoid retrieval time consumption.

[0088] The solution provided in the above embodiment extracts the behavior representation corresponding to the finest-grained operation behavior in the user behavior sequence through representation preprocessing, designs the storage data structure of the zigzag tensor, and realizes the storage and query of long-sequence behavior representations through a multi-level storage and representation splitting strategy, thereby training a joint model based on LLM+CTR, which can efficiently process the user behavior sequence of long texts and is helpful for model deployment in industrial scenarios.

[0089] As Figure 6 shown, the embodiments of this specification also provide a joint modeling device based on a large language model, including:

[0090] A sequence acquisition module 601, configured to acquire a user behavior sequence, where the user behavior sequence includes multiple target operation behaviors of the user, and at least one target operation behavior includes an interaction behavior with respect to target content;

[0091] A static query module 602, configured to query a first behavior representation corresponding to a first target operation behavior among multiple target operation behaviors based on a static representation table, where the static representation table stores a mapping relationship between multiple operation behaviors and behavior representations;

[0092] An online encoding module 603, configured to perform encoding on a target operation behavior for which the first behavior representation is not queried by a first large language model to obtain a second behavior representation;

[0093] A behavior prediction module 604, configured to obtain a click prediction result of the user with respect to the target content based on the first behavior representation and the second behavior representation through a click-through rate prediction model.

[0094] In one embodiment, the online encoding module 603 is specifically configured to: perform encoding on a target operation behavior for which the first behavior representation is not queried by a low-level network of the first large language model to obtain a second behavior representation; the behavior prediction module 604 is specifically configured to perform feature extraction on the first behavior representation and the second behavior representation by a high-level network of the first large language model to obtain user behavior features corresponding to the user behavior sequence; and input the user behavior features into the click-through rate prediction model to obtain a click prediction result of the user with respect to the target content.

[0095] In one embodiment, the apparatus further includes: a model training module (not shown in the figure), configured to train a high-level network of the first large language model based on the click prediction result and a click label of the acquired user behavior sequence.

[0096] In one embodiment, the static representation table is constructed offline in the following manner: based on the user behavior sequences of multiple sample users, multiple operation behaviors are acquired; the operation behaviors are input into the first large language model to obtain behavior representations corresponding to the operation behaviors; and a static representation table is constructed based on the multiple operation behaviors and the behavior representations corresponding to the operation behaviors.

[0097] In one embodiment, the static query module 602 is further configured to, before querying a first behavior representation corresponding to a first target operation behavior among multiple target operation behaviors based on the static representation table, determine a storage mode corresponding to the static representation table based on the scale of at least one static representation table to be loaded, and load the acquired static representation table into the video memory of the graphics card according to the storage mode.

[0098] In one embodiment, the static query module 602 is specifically configured to: when the scale of at least one static representation table to be loaded belongs to the first scale, determine that the storage mode corresponding to the static representation table is the single-machine replica mode, and store the static representation table in the video memory of each graphics card.

[0099] In one embodiment, the static query module 602 is specifically configured to: when the scale of at least one static representation table to be loaded belongs to the second scale, determine that the storage mode corresponding to the static representation table is the global sharding mode; divide at least one static representation table, and store each shard of the divided static representation table in the video memory of multiple graphics cards respectively.

[0100] In one embodiment, the static query module 602 is specifically configured to: store multiple different static representation tables in the video memory of multiple graphics cards respectively; or, divide the static representation table by row dimension to obtain multiple first shards, and store the first shards in the video memory of multiple graphics cards respectively, where each first shard contains the mapping relationship between different operation behaviors and behavior representations; or, divide the static representation table by column dimension to obtain multiple second shards, and store the second shards in the video memory of multiple graphics cards respectively, where each second shard contains different-dimensional data of behavior representations in the mapping relationship between the same operation behavior and behavior representations.

[0101] In one embodiment, the static query module 602 is specifically configured to: when the scale of at least one static representation table to be loaded belongs to the third scale, determine that the storage mode corresponding to the static representation table is the remote sharing mode; store the obtained static representation table in a storage location outside the graphics card, and cache part of the static representation table in the video memory of the graphics card.

[0102] In one embodiment, the static query module 602 is specifically configured to: based on part of the static representation table stored in the graphics card, query the first behavior representation corresponding to the first target operation behavior among multiple target operation behaviors; in response to the failure to query the first behavior representation, query the first behavior representation corresponding to the first target operation behavior from the static representation table in the storage location outside the graphics card, and cache the queried first behavior representation into the part of the static representation table in the video memory.

[0103] In one embodiment, the static query module 602 is further configured to: in response to the scale of part of the static representation table reaching a preset threshold, clear the behavior representations in part of the static representation table based on the elimination mechanism.

[0104] In one embodiment, the priority order of storing the obtained static representation table in a storage location outside the graphics card is: memory, solid-state disk, Redis, distributed file system, mechanical disk.

[0105] The embodiments of this specification also provide a computer-readable storage medium, on which a computer program is stored. When the computer program is executed on a computer, the computer is caused to execute as Figure 3 the described method.

[0106] The embodiments of this specification also provide a computing device, including a memory and a processor. The memory stores executable code, and when the processor executes the executable code, the method described as Figure 3 is implemented.

[0107] The embodiments of this specification also provide a computer program product, including a computer program / instructions. When the computer program / instructions are executed by a processor, the steps of the method described as Figure 3 are implemented.

[0108] Those skilled in the art should be able to realize that, in one or more of the above examples, the functions described in the multiple embodiments disclosed in this specification can be implemented by hardware, software, firmware, or any combination thereof. When implemented using software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or codes on a computer-readable medium.

[0109] In some cases, the actions or steps recited in the claims can be executed in a different order than in the embodiments and still achieve the desired result. Additionally, the processes depicted in the figures do not necessarily require the particular order or sequential order shown to achieve the desired result. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0110] The specific embodiments described above further elaborate on the objectives, technical solutions, and beneficial effects of the multiple embodiments disclosed in this specification. It should be understood that the above are only the specific embodiments of the multiple embodiments disclosed in this specification and are not used to limit the protection scope of the multiple embodiments disclosed in this specification. Any modifications, equivalent replacements, improvements, etc. made on the basis of the technical solutions of the multiple embodiments disclosed in this specification shall be included within the protection scope of the multiple embodiments disclosed in this specification.

Claims

1. A joint modeling method based on a large language model, the method comprising: Obtaining a user behavior sequence, where the user behavior sequence includes multiple target operation behaviors of the user, and at least one of the target operation behaviors includes an interaction behavior with target content; Querying, based on a static representation table, a first behavior representation corresponding to a first target operation behavior among the multiple target operation behaviors, where the static representation table stores a mapping relationship between multiple operation behaviors and behavior representations; For the target operation behaviors for which the first behavior representation is not queried, encoding by a first large language model to obtain a second behavior representation; Obtaining, through a click-through rate prediction model, a click prediction result of the user for the target content based on the first behavior representation and the second behavior representation.

2. The method according to claim 1, wherein The step of, for the target operation behaviors for which the first behavior representation is not queried, encoding by a first large language model to obtain a second behavior representation includes: For the target operation behaviors for which the first behavior representation is not queried, encoding by a lower layer network of the first large language model to obtain a second behavior representation; The step of obtaining, through a click-through rate prediction model, a click prediction result of the user for the target content based on the first behavior representation and the second behavior representation includes: Based on the first behavior representation and the second behavior representation, extracting features by a higher layer network of the first large language model to obtain user behavior features corresponding to the user behavior sequence; Inputting the user behavior features into a click-through rate prediction model to obtain a click prediction result of the user for the target content.

3. The method according to claim 2, wherein After the step of inputting the user behavior features into a click-through rate prediction model to obtain a click prediction result of the user for the target content, the method further includes: Training the higher layer network of the first large language model based on the click prediction result and the click label of the obtained user behavior sequence.

4. The method according to claim 1, wherein The static representation table is constructed offline by the following method: Based on the user behavior sequences of multiple sample users, obtaining multiple operation behaviors; Inputting the operation behaviors into the first large language model to obtain behavior representations corresponding to the operation behaviors; Constructing the static representation table based on the multiple operation behaviors and the behavior representations corresponding to the operation behaviors.

5. The method according to claim 1, wherein Before the step of querying, based on a static representation table, a first behavior representation corresponding to a first target operation behavior among the multiple target operation behaviors, the method further includes: Based on the scale of at least one of the static representation tables to be loaded, determining a storage mode corresponding to the static representation table, and loading the obtained static representation table into the video memory of the graphics card according to the storage mode.

6. The method according to claim 5, wherein, The step of, based on the scale of at least one of the static representation tables to be loaded, determining a storage mode corresponding to the static representation table, and loading the obtained static representation table into the video memory of the graphics card includes: In the case where the scale of at least one of the static representation tables to be loaded belongs to a first scale, determining the storage mode corresponding to the static representation table as a single-machine copy mode, and storing the static representation table in the video memory of each graphics card.

7. The method according to claim 5, wherein Determining a storage mode corresponding to the static representation table based on the scale of at least one of the static representation tables to be loaded, and loading the obtained static representation table into the video memory of the graphics card according to the storage mode, includes: When the scale of at least one of the static representation tables to be loaded belongs to the second scale, determining that the storage mode corresponding to the static representation table is the global sharding mode; Dividing at least one of the static representation tables, and storing each shard of the divided static representation table into the video memories of multiple graphics cards respectively.

8. The method according to claim 7, wherein, The dividing at least one of the static representation tables, and storing each shard of the divided static representation table into the video memories of multiple graphics cards respectively, includes: Storing multiple different static representation tables into the video memories of multiple graphics cards respectively; Or, dividing the static representation table by row dimension to obtain multiple first shards, and storing the first shards into the video memories of multiple graphics cards respectively, where each first shard contains a mapping relationship between different operation behaviors and behavior representations; Or, dividing the static representation table by column dimension to obtain multiple second shards, and storing the second shards into the video memories of multiple graphics cards respectively, where each second shard contains data of different dimensions of the behavior representation in the mapping relationship between the same operation behavior and the behavior representation.

9. The method according to claim 5, wherein Determining a storage mode corresponding to the static representation table based on the scale of the static representation table to be loaded, and loading the obtained static representation table into the video memory of the graphics card according to the storage mode, includes: When the scale of at least one of the static representation tables to be loaded belongs to the third scale, determining that the storage mode corresponding to the static representation table is the remote sharing mode; Storing the obtained static representation table to a storage location outside the graphics card, and caching a part of the static representation table to the video memory of the graphics card.

10. The method according to claim 9, wherein Querying a first behavior representation corresponding to a first target operation behavior among the multiple target operation behaviors based on the static representation table, includes: Querying a first behavior representation corresponding to the first target operation behavior among the multiple target operation behaviors based on a part of the static representation table stored in the graphics card; In response to the first behavior representation not being found, querying the first behavior representation corresponding to the first target operation behavior from the static representation table in the storage location outside the graphics card, and caching the queried first behavior representation into a part of the static representation table in the video memory.

11. The method according to claim 10, wherein The method further includes: In response to the scale of the part of the static representation table reaching a preset threshold, clearing the behavior representations in the part of the static representation table based on an elimination mechanism.

12. The method according to claim 9, wherein The priority order of storing the obtained static representation table to a storage location outside the graphics card is: memory, solid state drive, remote dictionary server Redis, distributed file system, mechanical disk.

13. A computing device includes a memory and a processor, wherein, An executable code is stored in the memory, and when the processor executes the executable code, the method according to any one of claims 1-12 is implemented.

Images