Method and apparatus for constructing recommendation model, electronic device, and storage medium

Abstract

The application provides a method for constructing a recommendation model, a method for constructing a neural network model, an apparatus, an electronic device, and a computer readable storage medium. The method comprises: performing aggregation processing on a plurality of feature tables corresponding to each application scenario in a recommendation item, and sending the obtained aggregated feature table to a cache space; wherein the recommendation item comprises a plurality of application scenarios corresponding one-to-one to a plurality of recommendation indicators of a to-be-recommended item; based on a user identifier and an item identifier included in a sample data table, reading corresponding user features and item features from the aggregated feature table of the cache space, and splicing the sample data table to form a training sample set; and training a recommendation model of an application scenario based on any one of a plurality of training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set. Through the application, the efficiency of constructing a recommendation model can be improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of artificial intelligence, and in particular to a method for constructing a recommendation model, a method for constructing a neural network model, an apparatus, an electronic device, and a computer readable storage medium. BACKGROUND

[0002] Artificial intelligence (AI) is a comprehensive technology of computer science, which enables machines to have the functions of perception, reasoning and decision-making by studying the design principles and implementation methods of various intelligent machines. Artificial intelligence technology is a comprehensive discipline, involving a wide range of fields, such as natural language processing technology and machine learning / deep learning. With the development of technology, artificial intelligence technology will be applied in more fields and play an increasingly important role.

[0003] In the related art, a neural network model, such as a recommendation model, is constructed based on artificial intelligence. Through the recommendation model, users can discover information that may interest them in an information overload environment, and the information is pushed to users who are interested in them.

[0004] However, in the related art, a large amount of computer resources is consumed to construct a recommendation model, and the efficiency of constructing a recommendation model is too low. SUMMARY

[0005] Embodiments of the present application provide a method for constructing a recommendation model, a method for constructing a neural network model, an apparatus, an electronic device, and a computer readable storage medium, which can pre-aggregate a plurality of feature tables corresponding to application scenarios, and improve the efficiency of constructing a recommendation model.

[0006] The technical solutions of the embodiments of the present application are as follows:

[0007] The embodiments of the present application provide a method for constructing a recommendation model, comprising:

[0008] Aggregating a plurality of feature tables corresponding to each application scenario in a recommendation project, and sending the obtained aggregated feature table to a cache space;

[0009] The recommendation project includes a plurality of application scenarios corresponding one-to-one to a plurality of recommendation indicators of a to-be-recommended item, and a recommendation model of each application scenario is used to predict a corresponding recommendation indicator.

[0010] Based on the user identifier and the item identifier included in the sample data table, the corresponding user features and item features are read from the aggregated feature table of the cache space, and are spliced with the sample data table to form a training sample set.

[0011] train the recommendation model of the application scenario based on any of the training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set.

[0012] The plurality of training algorithms are used to train the recommendation model of the application scenario.

[0013] In the technical solution, after the training sample set is formed, the following steps are further included:

[0014] The feature identifier of each training sample of the training sample set is primary key coded to obtain a primary key coded value of the feature identifier.

[0015] The feature identifier of each training sample is secondary key coded to obtain a secondary key coded value of the feature identifier.

[0016] The primary key coded value and the secondary key coded value are spliced to obtain an index coded value of the feature identifier.

[0017] The feature identifier of the training sample is updated to the index coded value to obtain an updated training sample, so that the recommendation model of the application scenario is trained based on the updated training sample.

[0018] Embodiments of the present application provide a method for constructing a neural network model, comprising:

[0019] The plurality of feature tables corresponding to each application scenario in the application project are aggregated, and the obtained aggregated feature table is sent to a cache space.

[0020] The application project includes a plurality of application scenarios corresponding to a plurality of application indicators, and the neural network model of each application scenario is used to predict the corresponding application indicator.

[0021] Based on the feature identifier included in the sample data table, the corresponding features are read from the aggregated feature table of the cache space and spliced with the sample data table to form a training sample set.

[0022] The neural network model of the application scenario is trained based on any of the training algorithms and the training sample set, so that the neural network model can fit the features in the training sample set.

[0023] The plurality of training algorithms are used to train the neural network model of the application scenario.

[0024] Embodiments of the present application provide a device for constructing a recommendation model, comprising:

[0025] an aggregating module, configured to aggregate a plurality of feature tables corresponding to each application scenario in a recommendation item, and send an aggregated feature table obtained to a cache space; wherein the recommendation item comprises a plurality of application scenarios corresponding to a plurality of recommendation indexes of a to-be-recommended item one by one, and a recommendation model of each application scenario is configured to predict a corresponding recommendation index;

[0026] a splicing module, configured to read corresponding user features and item features from the aggregated feature table in the cache space based on user identifiers and item identifiers included in a sample data table, and splice the sample data table to form a training sample set;

[0027] a training module, configured to train the recommendation model of the application scenario based on any training algorithm of a plurality of training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set; wherein the plurality of training algorithms are configured to train the recommendation model of the application scenario.

[0028] In the technical solution, the aggregating module is further configured to perform the following processing for each application scenario in a recommendation item:

[0029] aggregate and deduplicate at least part of features of a plurality of feature tables corresponding to the application scenario to obtain an aggregated feature table of the application scenario;

[0030] combine each feature identifier in the aggregated feature table to obtain a feature metadata table of the application scenario.

[0031] In the technical solution, the aggregating module is further configured to aggregate all features of a plurality of feature tables corresponding to the application scenario.

[0032] In the technical solution, the aggregating module is further configured to determine, from a plurality of feature tables corresponding to each application scenario in a recommendation item, features that are common to a plurality of training algorithms for training a recommendation model of the application scenario;

[0033] aggregate the common features to obtain an aggregated feature table of the application scenario.

[0034] In the technical solution, the splicing module is further configured to, when corresponding user features or item features are not read from the aggregated feature table in the cache space, read the corresponding user features or item features from a plurality of feature tables corresponding to the application scenario, and splice the sample data table to form a training sample set.

[0035] In the technical solution, when the application scenario has a new feature table, the aggregation module is further configured to splice the new feature table and the aggregated feature table of the application scenario to obtain a new aggregated feature table, and

[0036] Incrementally update the cache space based on the new aggregated feature table.

[0037] In the technical solution, the aggregation module is further configured to, when each new period of each application scenario arrives, aggregate a new feature table corresponding to the new period to obtain an aggregated feature table of the new period.

[0038] Splice the aggregated feature table of each new period to obtain the aggregated feature table of the application scenario.

[0039] In the technical solution, the aggregation module is further configured to, based on the aggregated feature table of the new period, incrementally update the cache space.

[0040] Read, in the cache space, an aggregated feature table of a historical period corresponding to the new period, and use the aggregated feature table of the historical period as the aggregated feature table of the new period.

[0041] The historical period corresponding to the new period is a period before the new period.

[0042] In the technical solution, the splicing module is further configured to, when each new period of each application scenario arrives, perform the following processing:

[0043] Based on the user identifier and the item identifier included in the sample data table of the new period, read corresponding user features and item features from the aggregated feature table of the new period in the cache space.

[0044] Splice the user features, the item features, and the sample data table of the new period to obtain a cache feature of the new period.

[0045] In the technical solution, the splicing module is further configured to, based on the cache feature of the new period, incrementally update the cache space.

[0046] Read, from the cache space, a plurality of cache features of historical periods corresponding to the new period.

[0047] Splice the plurality of cache features and the cache feature of the new period to obtain a training sample set of the application scenario.

[0048] The historical periods are periods before the new period.

[0049] In the technical solution, the aggregation module is further configured to perform mapping processing on the feature identifiers in the obtained aggregated feature table to obtain a shaping value of the feature identifier.

[0050] The feature identifier in the aggregated feature table is updated as the shaping value to obtain a compressed aggregated feature table.

[0051] The compressed aggregated feature table is sent to a cache space.

[0052] In the technical solution, the training module is further configured to perform primary key encoding on the feature identifier of each training sample in the training sample set to obtain a primary key encoding value of the feature identifier.

[0053] The feature identifier of each training sample is subjected to secondary key encoding to obtain a secondary key encoding value of the feature identifier.

[0054] The primary key encoding value and the secondary key encoding value are spliced to obtain an index encoding value of the feature identifier.

[0055] The feature identifier of the training sample is updated as the index encoding value to obtain an updated training sample, and the recommendation model of the application scenario is trained based on the updated training sample.

[0056] Embodiments of the present application provide a device for constructing a neural network model, comprising:

[0057] An aggregation module is configured to perform aggregation processing on a plurality of feature tables corresponding to each application scenario in an application project and send an aggregated feature table obtained to a cache space; wherein the application project comprises a plurality of application scenarios corresponding to a plurality of application indicators, and a neural network model of each application scenario is used to predict a corresponding application indicator.

[0058] A splicing module is configured to read corresponding features from the aggregated feature table in the cache space based on feature identifiers included in a sample data table, and splice the sample data table to form a training sample set.

[0059] A training module is configured to train a neural network model of an application scenario based on any training algorithm of a plurality of training algorithms and the training sample set, so that the neural network model can fit features in the training sample set; wherein the plurality of training algorithms are used to train the neural network model of the application scenario.

[0060] Embodiments of the present application provide an electronic device for recommendation model construction, comprising:

[0061] A memory is configured to store executable instructions.

[0062] The processor is configured to execute the executable instructions stored in the memory to implement the method for constructing a recommendation model provided in the embodiments of the present application.

[0063] The embodiments of the present application provide an electronic device for constructing a neural network model, and the electronic device comprises:

[0064] The memory is configured to store executable instructions.

[0065] The processor is configured to execute the executable instructions stored in the memory to implement the method for constructing a neural network model provided in the embodiments of the present application.

[0066] The embodiments of the present application provide a computer readable storage medium storing executable instructions, which are used to cause a processor to execute the method for constructing a recommendation model provided in the embodiments of the present application.

[0067] The embodiments of the present application provide a computer readable storage medium storing executable instructions, which are used to cause a processor to execute the method for constructing a neural network model provided in the embodiments of the present application.

[0068] The embodiments of the present application have the following beneficial effects:

[0069] By aggregating a plurality of feature tables corresponding to each application scenario, the obtained aggregated feature table is sent to a cache space, so that the training algorithm can reuse the aggregated feature table, train the neural network model of the application scenario, reduce the waste of computer resources, and improve the efficiency of constructing the neural network model. BRIEF DESCRIPTION OF DRAWINGS

[0070] Figure 1 FIG. 1 is a schematic diagram of an application scenario of a recommendation system provided in the embodiments of the present application;

[0071] Figure 2 FIG. 2 is a structural schematic diagram of an electronic device for constructing a recommendation model provided in the embodiments of the present application;

[0072] Figures 3-4 FIG. 3 is a flow schematic diagram of a method for constructing a neural network model provided in the embodiments of the present application;

[0073] Figure 5 FIG. 4 is a flow schematic diagram of splicing a cache feature provided in the embodiments of the present application;

[0074] Figure 6 FIG. 5 is a flow schematic diagram of a method for constructing a recommendation model provided in the embodiments of the present application;

[0075] Figure 7 FIG. 6 is a flow schematic diagram of offline feature splicing provided in the embodiments of the present application;

[0076] Figure 8 is a flowchart of a first-level cache provided by an embodiment of the present application;

[0077] Figure 9 is a flowchart of a period-specific feature aggregation provided by an embodiment of the present application;

[0078] Figure 10 is a flowchart of a spliced historical feature provided by an embodiment of the present application;

[0079] Figure 11 is a flowchart of a two-level index provided by an embodiment of the present application. DETAILED DESCRIPTION

[0080] In order to make the purposes, technical solutions and advantages of the present application clearer, the present application will be described in further detail below with reference to the accompanying drawings, and the described embodiments should not be regarded as limiting the present application, and all other embodiments obtained by those of ordinary skill in the art without making creative efforts fall within the scope of protection of the present application.

[0081] In the following description, the terms "first\second" are merely to distinguish similar objects, and do not represent a specific order of the objects. Understandably, the "first\second" can be interchanged in a specific order or sequence as allowed, so that the embodiments of the present application described herein can be implemented in an order other than that illustrated or described herein.

[0082] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the present application belongs. The terms used herein are merely for the purpose of describing the embodiments of the present application and are not intended to limit the present application.

[0083] Before the embodiments of the present application are described in further detail, the terms and phrases involved in the embodiments of the present application are explained, and the terms and phrases involved in the embodiments of the present application are applicable to the following explanations.

[0084] 1) Feature splicing: machine learning modeling process front-end preparation work, including original features and sample preparation, feature distribution in multiple storage locations, and no association with samples, which cannot be directly input into algorithm training, and need to splice samples and features before model training.

[0085] 2) Storage compression: business scenario feature key (feature identifier) is often stored in the form of characters. In order to better understand the features, the string will be longer, and the feature quantity used in most modeling scenarios is particularly large. If all are stored in the form of characters during splicing, it will bring a large storage overhead. The feature key is reshaped and mapped through a certain hash algorithm to generate a reshaped value with smaller storage space.

[0086] 3) Feature Index Hash: After the features (derived from the feature table) and the samples (derived from the sample data table) are spliced, the feature key needs to be encoded to generate a corresponding index, which is directly input to the model for training. In order to improve the performance of feature index generation, a hash method is used to generate a hash value, and the time complexity is O(1), thereby greatly improving the performance.

[0087] 4) Multi-period cache: Algorithm training often needs to splice samples with multiple periods of features. In order to enrich sample size and achieve better modeling effect, when multiple periods are spliced, if full splicing is performed each time, the performance is particularly low, and cache optimization is needed. The historical spliced period data can be cached to be used for subsequent incremental splicing.

[0088] 5) Sample: The sample in the embodiment of the application represents original identification data, for example, the sample includes user identification, item identification, label, weight, and other identification data. Correspondingly, the feature in the embodiment of the application represents entity data associated with the sample, for example, the feature includes user portrait features, item click features, and text statistical features.

[0089] 6) Data cleaning: The provided original data is processed to facilitate subsequent feature extraction. Data cleaning includes data splicing. Since the provided data is scattered in multiple files, data splicing needs to be performed according to the corresponding key value.

[0090] The neural network model described in the embodiment of the application can be applied to various fields, for example, can be an image recognition neural network, a text recommendation neural network, and the like. That is, the neural network model in the embodiment of the application is not limited to a certain field.

[0091] The embodiment of the application provides a method for constructing a recommendation model, a method and device for constructing a neural network model, an electronic device, and a computer readable storage medium, which can pre-aggregate a plurality of feature tables corresponding to an application scenario, and improve the efficiency of constructing a recommendation model.

[0092] The method for constructing a neural network model provided in the embodiment of the application can be implemented by a terminal / server alone; or can be implemented by a terminal and a server in cooperation, for example, the terminal alone bears the method for constructing a neural network model described below, or the terminal sends a training request for a neural network model to the server, the server executes the method for constructing a neural network model according to the received training request for the neural network model, and sends the generated neural network model to the terminal, so as to predict a corresponding application index through the neural network model.

[0093] The electronic device for neural network model construction provided by the embodiments of the present application can be various types of terminal devices or servers, wherein the server can be a standalone physical server, a server cluster or a distributed system composed of multiple physical servers, or a cloud server providing cloud computing services; the terminal can be a smart phone, a tablet computer, a notebook computer, a desktop computer, a smart speaker, a smart watch, etc., but is not limited thereto. The terminal and the server can be connected directly or indirectly through wired or wireless communication, which is not limited in the present application.

[0094] Taking the server as an example, for example, it can be a server cluster deployed in the cloud, which opens artificial intelligence cloud services (AI as a Service, AIaaS) to users, the AIaaS platform will split several common AI services, and provide independent or packaged services in the cloud. This service mode is similar to an AI theme mall, all users can access and use one or more artificial intelligence services provided by the AIaaS platform through the application programming interface.

[0095] For example, one of the artificial intelligence cloud services can be a neural network model construction service, that is, the server in the cloud encapsulates the neural network model construction program provided by the embodiments of the present application. The developer calls the neural network model construction service in the cloud service through the terminal (running the client, for example, the configuration client) to enable the server deployed in the cloud to call the encapsulated neural network model construction program, read the corresponding features from the aggregated feature table in the cache space, and splice with the sample data table to form a training sample set, and train the neural network model of the application scenario based on any training algorithm and the training sample set, to respond to the training request for the neural network model, and use the neural network model for prediction of the corresponding application index. The neural network model can be an image neural network model, a text neural network model, etc.

[0096] In an implementation scenario, in order to construct the image recognition neural network model, the server or the terminal can perform aggregation processing on a plurality of feature tables corresponding to each application scenario in the image recognition project, and send the obtained aggregated feature table to the cache space. The image project includes a plurality of application scenarios corresponding to a plurality of prediction indicators of the object to be recognized. The image recognition neural network model of each application scenario is used to predict the corresponding prediction indicator. Based on the object identifier included in the sample data table, the corresponding object feature is read from the aggregated feature table in the cache space, and the sample data table is spliced to form a training sample set. Based on any one of a plurality of training algorithms and the training sample set, the image recognition neural network model of the application scenario is trained, so that the image recognition neural network model can fit the object feature in the training sample set. The plurality of training algorithms are used to train the image recognition neural network model of the application scenario, so as to predict the corresponding prediction indicator through the image recognition neural network model.

[0097] For example, in a face recognition system, the function of constructing the neural network model provided by the embodiment of the present application is called. The image recognition project includes a front face recognition scenario and a side face recognition scenario. For example, for a front face, based on the front face identifier included in the sample data table, the corresponding front face feature is read from the aggregated feature table in the cache space, and the sample data table is spliced to form a training sample set. Based on any one of a plurality of training algorithms and the training sample set, the front face recognition neural network model of the front face recognition scenario is trained, so as to predict the corresponding front face indicator through the front face recognition neural network model, such as the probability of belonging to the front face of a certain user. The embodiment of the present application can combine the front face recognition neural network model and the side face recognition neural network model to perform front face recognition and side face recognition on pedestrians who need to pass through the access control, so as to improve the accuracy of face recognition and strengthen the safety factor of the access control.

[0098] In an implementation scenario, in order to construct the text recommendation neural network model, the server or the terminal can perform aggregation processing on a plurality of feature tables corresponding to each application scenario in the text recommendation project, and send the obtained aggregated feature table to the cache space. The image project includes a plurality of application scenarios corresponding to a plurality of recommendation indicators of the text to be recommended. The text recommendation neural network model of each application scenario is used to predict the corresponding recommendation indicator. Based on the user identifier and the text identifier included in the sample data table, the corresponding user feature and the text feature are read from the aggregated feature table in the cache space, and the sample data table is spliced to form a training sample set. Based on any one of a plurality of training algorithms and the training sample set, the text recommendation neural network model of the application scenario is trained, so that the text recommendation neural network model can fit the object feature in the training sample set. The plurality of training algorithms are used to train the text recommendation neural network model of the application scenario, so as to predict the corresponding recommendation indicator through the text recommendation neural network model.

[0099] For example, in a news recommendation system, the function of constructing the neural network model provided by the embodiments of the present application is called, and the text recommendation item includes a news click rate prediction scenario and a news exposure rate prediction scenario. For example, for news click rate, based on the user identifier and the news identifier included in the sample data table, the corresponding user features and news features are read from the aggregated feature table in the cache space, and are spliced with the sample data table to form a training sample set. Based on any training algorithm of a plurality of training algorithms and the training sample set, a click rate prediction model for the news click rate scenario is trained to predict the corresponding click rate through the click rate prediction model. The embodiments of the present application can combine the click rate prediction model and the exposure rate prediction model to predict the click rate and the exposure rate of the news, and determine whether to recommend the news based on the click rate and the exposure rate of the news, so as to improve the accuracy of news recommendation and recommend news that is more in line with the interests of users to users.

[0100] The recommendation model will be described in detail below. Referring to Figure 1 , Figure 1 is a schematic diagram of an application scenario of the recommendation system 10 provided by the embodiments of the present application. The terminal 200 is connected to the server 100 through the network 300. The network 300 can be a wide area network or a local area network, or a combination of the two.

[0101] The terminal 200 (running a client, for example, a configuration client) can be used to obtain a training request for the recommendation model. For example, after the user inputs a plurality of feature tables corresponding to the application scenario in the client, the terminal automatically obtains the training request for the recommendation model.

[0102] In some embodiments, the client running in the terminal can be implanted with a recommendation model construction plug-in to locally implement the method of constructing the recommendation model in the client. For example, after the terminal 200 obtains the training request for the recommendation model, the recommendation model construction plug-in is called to implement the method of constructing the recommendation model. The corresponding user features and item features are read from the aggregated feature table in the cache space, and are spliced with the sample data table to form a training sample set. Based on any training algorithm and the training sample set, the recommendation model for the application scenario is trained to respond to the training request for the recommendation model. Subsequently, the corresponding recommendation indicators are predicted according to the recommendation model, for example, the exposure rate of the goods is predicted through the recommendation model, and whether to recommend the goods is determined based on the exposure rate of the goods, thereby helping users to discover goods that may interest them.

[0103] In some embodiments, after the terminal 200 acquires the training request for the recommendation model, the terminal 200 calls the recommendation model construction interface of the server 100 (which can be provided in the form of a cloud service, i.e., a recommendation model construction service), the server 100 reads the corresponding user features and item features from the aggregated feature table in the cache space, and splices the sample data table to form a training sample set, and trains the recommendation model of the application scenario based on any training algorithm and the training sample set to respond to the training request for the recommendation model.

[0104] The structure of the electronic device for recommendation model construction provided by the embodiments of the present application is described below. Referring to Figure 2 , Figure 2 FIG. 5 is a structural schematic diagram of an electronic device 500 for recommendation model construction provided by the embodiments of the present application, which is taken as an example of a server, Figure 2 The electronic device 500 for recommendation model construction shown in FIG. 5 includes at least one processor 510, a memory 550, and at least one network interface 520. The various components in the electronic device 500 are coupled together through a bus system 530. It can be understood that the bus system 530 is used to realize the connection and communication between the components. The bus system 530 includes not only a data bus, but also a power bus, a control bus, and a status signal bus. However, for the purpose of clear illustration, all the buses are marked as the bus system 530 in Figure 2 .

[0105] The processor 510 can be an integrated circuit chip with signal processing capability, such as a general-purpose processor, a digital signal processor (DSP), or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor.

[0106] The memory 550 includes a volatile memory or a non-volatile memory, and can also include both volatile and non-volatile memories. The non-volatile memory can be a read-only memory (ROM), and the volatile memory can be a random access memory (RAM). The memory 550 described in the embodiments of the present application is intended to include any suitable type of memory. The memory 550 can optionally include one or more storage devices that are physically separate from the processor 510.

[0107] In some embodiments, the memory 550 can store data to support various operations, examples of which include programs, modules, and data structures or subsets or supersets thereof, which are exemplarily described below.

[0108] The operating system 551 includes system programs for processing various basic system services and performing hardware-related tasks, such as a framework layer, a core library layer, a driver layer, and the like, for implementing various basic services and processing hardware-based tasks;

[0109] The network communication module 553 is configured to reach other computing devices via one or more (wired or wireless) network interfaces 520, exemplary network interfaces 520 including Bluetooth, wireless fidelity (WiFi), and universal serial bus (USB), and the like;

[0110] In some embodiments, the apparatus for constructing a recommendation model provided by the embodiments of the present application can be implemented in a software manner, for example, can be a recommendation model construction plug-in in the terminal described above, can be a recommendation model construction service in the server described above. Of course, it is not limited thereto, and the apparatus for constructing a recommendation model provided by the embodiments of the present application can be provided in various software embodiments, including various forms of application programs, software, software modules, scripts, or codes.

[0111] Figure 2 An apparatus 555 for constructing a recommendation model stored in the memory 550 is shown, which can be software in the form of programs and plug-ins, for example, a recommendation model construction plug-in, and includes a series of modules, including an aggregation module 5551, a splicing module 5552, and a training module 5553; wherein the aggregation module 5551, the splicing module 5552, and the training module 5553 are configured to implement the recommendation model construction function provided by the embodiments of the present application.

[0112] As described above, the method for constructing a neural network model provided by the embodiments of the present application can be implemented by various types of electronic devices, for example, a server. Referring to Figure 3 , Figure 3 is a flowchart of the method for constructing a neural network model provided by the embodiments of the present application, which is described in combination with Figure 3 the steps shown.

[0113] In the following steps, an application item represents a specific application task, for example, face recognition, text recommendation, and the like. An application scenario represents a scenario corresponding to a subtask under the application item, for example, a front face recognition scenario and a side face recognition scenario under face recognition. A feature table includes a plurality of feature key-value pairs.

[0114] In step 101, the plurality of feature tables corresponding to each application scenario in the application item are aggregated, and the obtained aggregated feature table is sent to a cache space.

[0115] The application project includes a plurality of application scenes corresponding to a plurality of application indexes, and the neural network model of each application scene is used to predict the corresponding application index.

[0116] For example, the central processing unit (CPU) of the server pre-acquires a plurality of feature tables corresponding to each application scene in the application project from the file system, and performs pre-aggregation processing on the plurality of feature tables to obtain an aggregated feature table of the application scene, and sends the aggregated feature table to the cache space (high-speed memory, database, etc.) for subsequent reuse of the aggregated feature table, thereby avoiding the need to splice the feature table each time training is performed and reducing the computational complexity.

[0117] In some embodiments, the aggregation processing on the plurality of feature tables corresponding to each application scene in the recommended project includes: performing the following processing for each application scene of the application project: performing aggregation processing and deduplication processing on at least part of the features of the plurality of feature tables corresponding to the application scene to obtain an aggregated feature table of the application scene.

[0118] For example, since the aggregated feature table is a wide table, in order to facilitate subsequent rapid determination of the features that need to be spliced in the aggregated feature table, the feature identifiers in the aggregated feature table can be combined to obtain a feature metadata table of the application scene, which includes feature identifiers, sources of features (from which feature table the feature comes from), positions of features in the aggregated feature table, and the like. Subsequently, the features can be indexed from the feature metadata table. When a feature is indexed, it means that the feature exists in the aggregated feature table, and the feature is read from the aggregated feature table.

[0119] In some embodiments, the aggregation processing on at least part of the features of the plurality of feature tables corresponding to the application scene includes: performing aggregation processing on all features of the plurality of feature tables corresponding to the application scene.

[0120] For example, the central processing unit reads all features of the plurality of feature tables and aggregates all features to obtain an aggregated feature table containing all features. Therefore, as long as no new feature table is added, subsequent splicing operations can directly read features from the aggregated feature table, i.e., the aggregated feature table does not miss any feature in the feature table.

[0121] In some embodiments, the aggregation processing on at least part of the features of the plurality of feature tables corresponding to the application scene includes: determining, from the plurality of feature tables corresponding to each application scene in the application project, features that are common to a plurality of training algorithms for training a recommendation model of the application scene; and performing aggregation processing on the common features to obtain an aggregated feature table of the application scene.

[0122] For example, since the features used by each training algorithm are not the same, the features commonly used by multiple training algorithms can be pre-aggregated, that is, the features with higher usage frequency are aggregated to obtain an aggregated feature table of the application scenario, so as to improve the reading frequency of the features in the aggregated feature table and reduce the size of the aggregated feature table, so that the features in the aggregated feature table can be quickly read subsequently.

[0123] In some embodiments, when the application scenario has a new feature table, the method further includes: splicing the new feature table and the aggregated feature table of the application scenario to obtain a new aggregated feature table, and incrementally updating the cache space based on the new aggregated feature table.

[0124] For example, when the central processor detects that the file system has a new feature table, the aggregated feature table of the application scenario can be read from the cache space, and the new feature table can be read from the file system. The new feature table and the aggregated feature table of the application scenario are spliced to obtain a new aggregated feature table. The cache space is newly updated based on the new aggregated feature table to replace the old aggregated feature table.

[0125] In some embodiments, the aggregation processing of the multiple feature tables corresponding to each application scenario in the application project includes: when each new period of each application scenario arrives, the new feature table corresponding to the new period is aggregated to obtain an aggregated feature table of the new period; and the aggregated feature tables of each new period are spliced to obtain the aggregated feature table of the application scenario.

[0126] For example, the feature tables in each application scenario have corresponding update periods, such as monthly update periods, weekly update periods, and daily update periods. When each new period of each application scenario arrives, the multiple feature tables corresponding to the new period are aggregated to obtain an aggregated feature table of the new period. For example, for each month, the feature tables of the monthly update period are aggregated to obtain an aggregated feature table of each month; for each week, the feature tables of the weekly update period are aggregated to obtain an aggregated feature table of each week; and for each day, the feature tables of the daily update period are aggregated to obtain an aggregated feature table of each day. The aggregated feature tables of each new period are spliced to obtain the aggregated feature table of the application scenario. For example, the aggregated feature tables of June, the first week, and June 1 are aggregated to obtain the aggregated feature table of the application scenario on June 1, so that for the daily update period, it is not necessary to aggregate all the feature tables in the application scenario every day, and the computing resources are reduced.

[0127] In some embodiments, after the central processing unit obtains the aggregated feature table of the new cycle, it incrementally updates the cache space based on the aggregated feature table of the new cycle; when no new cycle of each application scenario has arrived, before splicing the aggregated feature table of each new cycle, the method further includes: reading the aggregated feature table of the historical cycle corresponding to the new cycle from the cache space and using it as the aggregated feature table of the new cycle; wherein, the historical cycle corresponding to the new cycle is the cycle before the new cycle.

[0128] The aggregated feature table for the new cycle serves as the aggregated feature table for the historical cycle corresponding to the next new cycle. When a new cycle for any application scenario has not yet arrived, the aggregated feature table for the historical cycle corresponding to the new cycle is read from the cache space and used as the aggregated feature table for the new cycle. For example, for a monthly update cycle, when the update time for each month has not yet arrived, the most recent monthly aggregated feature table (the aggregated feature table for the historical cycle) is read from the cache space and used as the aggregated feature table for this month. This process is repeated to concatenate the aggregated feature tables for each new cycle to obtain the aggregated feature table for the application scenario.

[0129] See Figure 4 , Figure 4 This is an optional flowchart illustrating a method for constructing a neural network model provided in an embodiment of this application. Figure 4 Show Figure 3 Step 101 in the process can be done through Figure 4 Steps 1011 to 1013 shown are implemented as follows: In step 1011, the feature identifiers in the obtained aggregated feature table are mapped to obtain integer values ​​of the feature identifiers; in step 1012, the feature identifiers in the aggregated feature table are updated to integer values ​​to obtain a compressed aggregated feature table; in step 1013, the compressed aggregated feature table is sent to the cache space.

[0130] For example, since the aggregated feature table is a wide table, the feature identifiers are relatively long for ease of understanding, resulting in a large storage space for the aggregated feature table. To save storage space, the feature identifiers in the aggregated feature table can be mapped to integer values, reducing the length of the feature identifiers. The feature identifiers in the aggregated feature table are then updated to integer values, resulting in a compressed aggregated feature table. This compressed aggregated feature table is then sent to the cache space, thereby reducing the cache space occupied by the aggregated feature table and improving its read capability.

[0131] In step 102, based on the feature identifiers included in the sample data table, the corresponding features are read from the aggregated feature table in the cache space and concatenated with the sample data table to form a training sample set.

[0132] The sample data table includes a plurality of samples, and each sample includes a plurality of feature identifiers. Before the splicing operation is performed, the developer can input the sample data table and the training algorithm in the terminal, the terminal automatically acquires a training request based on the sample data table and the training algorithm, and sends the training request based on the sample data table and the training algorithm to the server. After the server receives the training request based on the sample data table and the training algorithm, the corresponding features are read from the aggregated feature table in the cache space based on the feature identifiers included in the sample data table, and are spliced with the sample data table to form a training sample set, thereby realizing reuse of the aggregated feature table and quickly performing the splicing operation of the sample data table.

[0133] In some embodiments, when the corresponding features are not read from the aggregated feature table in the cache space, the corresponding features are read from a plurality of feature tables corresponding to the application scenario and are spliced with the sample data table to form a training sample set.

[0134] For example, the central processor first reads the features corresponding to the sample data table from the feature table in the cache space, and when the features corresponding to the sample data table are not read from the feature table in the cache space, the plurality of feature tables corresponding to the application scenario are read from the file system, and the features corresponding to the sample data table are read from the plurality of feature tables, avoiding reading the features from the file system every time. By reading the features from the cache space, the reading rate of the features can be greatly improved.

[0135] In some embodiments, based on the feature identifiers included in the sample data table, the corresponding features are read from the aggregated feature table in the cache space and are spliced with the sample data table, including: when each new period of each application scenario arrives, the following processing is performed: based on the feature identifiers included in the sample data table of the new period, the corresponding features are read from the aggregated feature table of the new period in the cache space; and the features are spliced with the sample data table of the new period to obtain cached features of the new period.

[0136] For example, modeling in most application scenarios requires samples of multiple historical periods to construct sufficient training data, so that the algorithm learns more knowledge and improves robustness. For example, a model needs to be updated every month (30 periods), so 30 periods of sample data need to be recorded. When any period of the 30 periods arrives, the corresponding features are read from the aggregated feature table of the period in the cache space based on the feature identifiers included in the sample data table of the period, and the features are spliced with the sample data table of the period to obtain cached features of the period.

[0137] In some embodiments, after the central processor obtains the cache feature of the new period, the cache space is incrementally updated based on the cache feature of the new period; a plurality of cache features of historical periods corresponding to the new period are read from the cache space; and the plurality of cache features are spliced with the cache feature of the new period to obtain a training sample set of the application scenario; wherein the historical periods are periods before the new period.

[0138] In some embodiments, the cache feature of the new period is used as the cache feature of a historical period corresponding to the next new period. As shown in FIG. 30, after the central processor obtains the cache feature of the 30th period (the cache feature of the new period), the cache features of the 1st-29th periods are obtained from the cache space, and the cache features of the 1st-30th periods are spliced to obtain a training sample set of the application scenario. Figure 5

[0139] In some embodiments, after the training sample set is formed, the feature identifier of each training sample in the training sample set is primary key encoded to obtain a primary key encoded value of the feature identifier; the feature identifier of each training sample is secondary key encoded to obtain a secondary key encoded value of the feature identifier; the primary key encoded value and the secondary key encoded value are spliced to obtain an index encoded value of the feature identifier; and the feature identifier of the training sample is updated to the index encoded value to obtain an updated training sample, so that the recommendation model of the application scenario is trained based on the updated training sample.

[0140] For example, after obtaining the training sample set, the central processor encodes each training sample in the training sample set to obtain a format for model training, and compresses the training sample to reduce the storage space of the training sample. By primary key encoding and secondary key encoding of the feature identifier of the training sample (i.e., 2-level encoding), an index encoded value of the feature identifier is obtained, which can effectively reduce the collision rate of the encoding, i.e., the index encoded value can uniquely represent the feature identifier.

[0141] In step 103, the neural network model of the application scenario is trained based on any training algorithm of the plurality of training algorithms and the training sample set, so that the neural network model can fit the features in the training sample set.

[0142] ​The plurality of training algorithms are used to train the neural network model of the application scenario, and the training algorithms include hyperparameters, loss functions, and the like of the model. After the central processor obtains the training sample set, the neural network model of the application scenario can be trained based on any one of the plurality of training algorithms and the training sample set, to construct the neural network model of the application scenario, and the corresponding application index is predicted through the neural network model of the application scenario. For example, the neural network model of the application scenario includes a frontal face recognition neural network model and a side face recognition neural network model, the frontal face recognition neural network model is used to predict the category of the frontal face (the probability of belonging to the frontal face of a certain user), and the side face recognition neural network model is used to predict the category of the side face (the probability of belonging to the side face of a certain user).

[0143] The method for constructing a recommendation model provided in the embodiments of the present application is described below in combination with an exemplary application and implementation of a server provided in the embodiments of the present application. Referring to Figure 6 , Figure 6 is a flowchart of the method for constructing a recommendation model provided in the embodiments of the present application, which is described in combination with the steps shown in Figure 6 .

[0144] In the following steps, the recommended item represents a specific recommended object, such as news, goods, videos, and the like.

[0145] In step 201, the plurality of feature tables corresponding to each application scenario in the recommended item are aggregated, and the obtained aggregated feature table is sent to the cache space.

[0146] The recommended item includes a plurality of application scenarios corresponding to a plurality of recommendation indexes of a to-be-recommended item one by one, and the recommendation model of each application scenario is used to predict the corresponding recommendation index.

[0147] For example, the central processor of the server pre-acquires the plurality of feature tables corresponding to each application scenario in the recommended item from the file system, and performs pre-aggregation processing on the plurality of feature tables to obtain the aggregated feature table of the application scenario, and sends the aggregated feature table to the cache space, so as to reuse the aggregated feature table in the subsequent process, avoid splicing the feature table every time, and reduce the computational complexity.

[0148] In some embodiments, the aggregation processing on the plurality of feature tables corresponding to each application scenario in the recommended item includes: performing the following processing for each application scenario of the recommended item: performing aggregation processing and deduplication processing on at least part of the features of the plurality of feature tables corresponding to the application scenario to obtain the aggregated feature table of the application scenario; the method further includes: combining each feature identifier in the aggregated feature table to obtain a feature metadata table of the application scenario. Subsequently, the feature can be indexed from the feature metadata table, and when the feature is indexed, it indicates that the feature exists in the aggregated feature table, so that the feature is read from the aggregated feature table.

[0149] In some embodiments, the aggregation processing of at least part of the features of the multiple feature tables corresponding to the application scenario includes: aggregation processing of all features of the multiple feature tables corresponding to the application scenario.

[0150] In some embodiments, the aggregation processing of at least part of the features of the multiple feature tables corresponding to the application scenario includes: determining, from the multiple feature tables corresponding to each application scenario in the recommended item, features that are common to multiple training algorithms for training the recommended model of the application scenario; and performing aggregation processing on the common features to obtain an aggregated feature table of the application scenario.

[0151] In some embodiments, when there is a newly added feature table of the application scenario, the method further includes: splicing the newly added feature table and the aggregated feature table of the application scenario to obtain a new aggregated feature table, and performing incremental updating of the cache space based on the new aggregated feature table.

[0152] For example, when the central processor detects that there is a newly added feature table in the file system, the aggregated feature table of the application scenario can be read from the cache space, and the newly added feature table can be read from the file system. The newly added feature table and the aggregated feature table of the application scenario are spliced to obtain a new aggregated feature table. The cache space is updated based on the new aggregated feature table to replace the old aggregated feature table.

[0153] In some embodiments, the aggregation processing of the multiple feature tables corresponding to each application scenario in the recommended item includes: when each new period of each application scenario arrives, performing aggregation processing on a newly added feature table corresponding to the new period to obtain an aggregated feature table of the new period; and performing splicing processing on the aggregated feature table of each new period to obtain an aggregated feature table of the application scenario.

[0154] In some embodiments, after the central processor obtains the aggregated feature table of the new period, the cache space is updated incrementally based on the aggregated feature table of the new period; and before the splicing processing of the aggregated feature table of each new period, the method further includes: reading, from the cache space, an aggregated feature table of a historical period corresponding to the new period and taking the aggregated feature table of the historical period as the aggregated feature table of the new period; wherein the historical period corresponding to the new period is a period before the new period.

[0155] The new-cycle aggregation feature table is the aggregation feature table of the historical cycle corresponding to the next new cycle. When any new cycle of each application scenario has not arrived, the aggregation feature table of the historical cycle corresponding to the new cycle is read from the cache space and used as the aggregation feature table of the new cycle. For example, when the update time of each month has not arrived, the latest monthly aggregation feature table (the aggregation feature table of the historical cycle) of the month is read from the cache space and used as the aggregation feature table of the month, so that the aggregation feature tables of each new cycle are spliced to obtain the aggregation feature table of the application scenario.

[0156] In some embodiments, the obtained aggregation feature table is sent to the cache space, including: performing mapping processing on the feature identifiers in the obtained aggregation feature table to obtain reshaped values of the feature identifiers; updating the feature identifiers in the aggregation feature table to the reshaped values to obtain a compressed aggregation feature table; and sending the compressed aggregation feature table to the cache space.

[0157] In step 202, based on the user identifiers and the item identifiers included in the sample data table, the corresponding user features and item features are read from the aggregation feature table in the cache space and spliced with the sample data table to form a training sample set.

[0158] The sample data table includes a plurality of samples, and each sample includes a plurality of feature identifiers, such as user identifiers and item identifiers. Before the splicing operation, the developer can input the sample data table and the training algorithm on the terminal, the terminal automatically obtains a training request based on the sample data table and the training algorithm, and sends the training request based on the sample data table and the training algorithm to the server. After the server receives the training request based on the sample data table and the training algorithm, the corresponding user features and item features are read from the aggregation feature table in the cache space based on the user identifiers and the item identifiers included in the sample data table, and spliced with the sample data table to form a training sample set, thereby realizing the reuse of the aggregation feature table and quickly performing the splicing operation of the sample data table.

[0159] In some embodiments, when the corresponding user features or item features are not read from the aggregation feature table in the cache space, the corresponding user features or item features are read from a plurality of feature tables corresponding to the application scenario and spliced with the sample data table to form a training sample set.

[0160] For example, the central processing unit (CPU) first reads the user features or item features corresponding to the sample data table from the feature table in the cache space. If the user features or item features corresponding to the sample data table are not read from the feature table in the cache space, it then reads multiple feature tables corresponding to the application scenario from the file system, and reads the user features or item features corresponding to the sample data table from the multiple feature tables. This avoids having to read the user features or item features from the file system every time. By reading the user features or item features from the cache space, the feature reading speed can be greatly improved.

[0161] In some embodiments, based on the user identifier and item identifier included in the sample data table, the corresponding user features and item features are read from the aggregated feature table of the cache space and concatenated with the sample data table. This includes: when each new cycle of each application scenario arrives, the following processing is performed: based on the user identifier and item identifier included in the sample data table of the new cycle, the corresponding user features and item features are read from the aggregated feature table of the new cycle of the cache space; the user features and item features are concatenated with the sample data table of the new cycle to obtain the cache features of the new cycle.

[0162] For example, in most application scenarios, modeling requires samples from multiple historical periods to construct enough training data so that the algorithm can learn more knowledge and improve its robustness. For example, a model that updates daily needs samples for one month (30 periods). This requires recording sample data for 30 periods. When any of the 30 periods arrives, based on the user and item identifiers included in the sample data table for that period, the corresponding user and item features are read from the aggregated feature table for that period in the cache space. The user and item features are then concatenated with the sample data table for that period to obtain the cached features for that period.

[0163] In some embodiments, after the central processing unit obtains the cache features of the new cycle, it incrementally updates the cache space based on the cache features of the new cycle; it reads multiple cache features of the historical cycle corresponding to the new cycle from the cache space; it concatenates the multiple cache features with the cache features of the new cycle to obtain the training sample set of the application scenario; wherein, the historical cycle is the cycle before the new cycle.

[0164] The cache characteristics of the new cycle serve as the cache characteristics of the historical cycle corresponding to the next new cycle. For example... Figure 5 As shown, after the central processing unit obtains the cache features of the 30th cycle (the cache features of the new cycle), it retrieves the cache features of the 1st to 29th cycles from the cache space, and concatenates the cache features of the 1st to 30th cycles to obtain the training sample set for the application scenario.

[0165] In some embodiments, after the training sample set is formed, the method further includes: performing primary key encoding on the feature identifier of each training sample in the training sample set to obtain a primary key encoding value of the feature identifier; performing secondary key encoding on the feature identifier of each training sample to obtain a secondary key encoding value of the feature identifier; splicing the primary key encoding value and the secondary key encoding value to obtain an index encoding value of the feature identifier; and updating the feature identifier of the training sample to the index encoding value to obtain an updated training sample, so as to train the recommendation model of the application scenario based on the updated training sample.

[0166] In step 203, the recommendation model of the application scenario is trained based on any training algorithm of the plurality of training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set.

[0167] The plurality of training algorithms are used to train the recommendation model of the application scenario, and the training algorithm includes the hyperparameters, loss function, etc. of the model. After the central processing unit obtains the training sample set, the recommendation model of the application scenario can be trained based on any training algorithm of the plurality of training algorithms and the training sample set, so as to construct the recommendation model of the application scenario, and predict the corresponding recommendation index through the recommendation model of the application scenario. For example, the recommendation model of the application scenario includes a click rate prediction model and an exposure rate prediction model, the click rate prediction model is used to predict the click rate of an advertisement, and the exposure rate prediction model is used to predict the exposure rate of an advertisement.

[0168] In the following, an exemplary application of the embodiments of the present application in an actual application scenario will be described.

[0169] In the related art, before the model is trained, feature splicing is required. Feature splicing is an important module of machine learning modeling, and the modeling scene in the industry often faces a large sample and feature scale, and multiple algorithms need to be run in parallel. The splicing performance has a great influence on the modeling efficiency. The feature splicing technology includes online real-time splicing and offline splicing.

[0170] The online real-time splicing generates labels through real-time user behavior. For example, in a click rate scene, the user clicks as a positive sample, and the exposure without clicking as a negative sample, and then the features are associated to generate the input required for algorithm training. However, the online real-time splicing is not suitable for scenes where sample labels are determined in real time, does not support multi-period historical cache reuse, new scenes, algorithm hot start, and historical data splicing.

[0171] Although the offline splicing supports historical data analysis to generate samples. However, for modeling scenes, multiple algorithms need to be run in parallel to update the model every day, and more than 90 historical periods are required for each sample splicing. Moreover, the sample and the feature are in the order of hundreds of millions, and the performance requirement is very high. The offline splicing cannot meet the large-scale splicing demand, is not suitable for multi-algorithm parallelism, and the feature splicing cannot reuse the cache.

[0172] To address the aforementioned issues, this application proposes a high-performance splicing method. This method employs a multi-level caching mechanism, namely, a first-level cache and a second-level cache. Specifically: 1) The first-level cache is divided according to the algorithm's application scenario and the features used. Since similar algorithms in the same application scenario share many features, an outer pre-aggregation can be performed to generate an aggregated feature table. Subsequently, each algorithm prioritizes using aggregated features from this table when executing its specific splicing logic, avoiding the need for each algorithm to join samples with all feature tables, thus saving computational resources. Aggregated features occupy a significant amount of storage, and loading features in subsequent computation stages is time-consuming. To address this, feature keys (feature identifiers) are mapped to integers for compression optimization. 2) The second-level cache caches the results of splicing across multiple periods (cached features) during specific algorithm splicing. For example, in scenarios where the model updates daily, it is often necessary to splice samples from more than three months. Full splicing cannot achieve daily updates. The splicing results of historical sample periods are cached in plaintext, and new period samples only require incremental splicing, effectively solving the performance problem. Finally, the concatenated features need to be encoded before the algorithm can be trained. The concatenated feature key for multiple periods is encoded using hash encoding. Compared with full feature statistical encoding, the performance of the embodiment of this application is significantly improved.

[0173] This application's embodiments can be applied to various machine learning modeling scenarios. It allows for offline configuration of algorithm-related samples, features, and the number of periods to be concatenated, completing sample and feature concatenation and encoding to generate algorithm training data (training samples). Modeling is performed according to application scenarios. Algorithms in the same application scenario use highly overlapping features, allowing for a first-level cache based on the scenario dimension. Algorithm sets within a scenario can share the aggregated feature table of the first-level cache. A second-level cache is set within the algorithm's internal concatenation mechanism. For example, in a daily model update, if the features remain unchanged, only incremental concatenation of new periods is needed to achieve routine concatenation calculations.

[0174] like Figure 7 As shown, Figure 7Is the process schematic diagram of offline feature splicing provided by the embodiment of the application, and the feature splicing three elements: algorithm, sample, and feature. Based on the feature used by the algorithm, the sample is spliced with the feature (similar to the join operation in the database), the sample is joined with all the feature tables, the splicing result is generated, and is input to the algorithm for training process. Because the algorithm is parallel, a large number of join operations are needed, and the performance is poor. First, the join operation of multiple billion-level tables is already very time-consuming, and each algorithm needs to be calculated once. For example, in scenario 1, algorithm 1 and algorithm 2 actually have most of the features overlapping, or the features are exactly the same, only the algorithm parameters are different. In order to verify the effect, each algorithm needs to perform multi-table feature join. If k cycles are needed, such operation needs to be repeated k times in the splicing of each algorithm, and the required computing resources and high time consumption are unbearable.

[0175] To solve the above problem, the first level cache in the multi-level cache is used for pre-aggregation in the embodiment of the application, so as to avoid the waste of computing resources caused by the need of each algorithm to join the sample with all the feature tables. As shown in Figure 8 Figure 8 The process schematic diagram of the first level cache provided by the embodiment of the application, the same modeling application scenario has the following characteristics: there are many algorithms, and the features used by the algorithms have high coincidence degree, and some feature processing logic can be placed in the front-end common module. The pre-aggregation is performed on all features (the features are distributed in the feature table, and the feature table is loaded to obtain the features) under the application scenario (for example, scenario 1 is a commodity click rate prediction scenario, and scenario 2 is a commodity exposure rate prediction scenario), the metadata table (records the feature information of each period, for example, the identifier of the aggregated features) and the aggregated feature table (contains all feature sets under the scenario, that is, a wide table containing all aggregated features) of the aggregated features are generated. When splicing calculation is performed, the aggregated feature information is checked from the metadata table, that is, the features are loaded from the aggregated feature table for splicing, if there are new features, the bypass logic is performed, the new features are loaded from the original feature table, and then the new features are spliced with the aggregated features, so that multiple algorithms can share the pre-aggregated feature table, instead of joining with multiple external wide tables.

[0176] Pre-aggregation of features based on application scenarios can undoubtedly greatly improve the splicing performance of subsequent algorithms, and multiple algorithms can reuse the aggregated feature table to reduce the time-consuming of multi-table join. However, the application scenario often has the operations of adding, deleting, and modifying features. For a new aggregated period, the new features can be added to the cache, but the features of the historical period cannot be recalculated because the cache is being used by the online task, and the risk caused by recalculation is great. In this regard, the following solutions are proposed in the embodiment of the application:

[0177] I. The historical period cache that has been aggregated remains unchanged, and the use of the cache for online splicing is ensured not to be affected by recalculation.​

[0178] Second, the processing of deleted features is simple. If the original feature is offline, the historical period in the aggregation feature table does not change, and the deleted feature aggregated in the new period will not appear in the splicing result. For new features and modified features, because the spliced features in the historical cache have been generated and cannot be recalculated, add the accompanying task, and add the new features and modified features to the accompanying task-configuration meta information. The calculation, storage, etc. of this part of the feature is isolated from the main process, and the calculation state is maintained through the configuration meta database. For example, the main task is A, the accompanying task is B, the meta data table of the main task is meta_A, the meta data table of the accompanying task is meta_B, there are four features: feature_1, feature_2, feature_3, feature_4, feature_1 and feature_2 are regularized in the main task aggregation result, feature_3 is a new feature, and feature_4 is a modified feature. The A task aggregation feature table is merge_A, and the B task aggregation feature table is merge_B. When the splicing calculation is performed, meta_A and meta_B are loaded at the same time, the new feature feature_3 and the modified feature feature_4 are obtained from meta_B, the features are loaded from merge_B, and the features feature_1 and feature_2 are obtained from meta_A and merge_A. The historical period feature can be obtained from the correct place, and the calculation and storage of the two sets of tasks are isolated, which does not affect the online task execution.

[0179] Third, storage and calculation are isolated, and two sets of mechanisms are maintained to deal with feature addition, deletion, modification, and historical cache period data consistency problems.

[0180] Regarding the feature aggregation optimization strategy: feature pre-aggregation is a pre-process of the subsequent calculation task. If the model is updated, the aggregation task also needs to be high-performance. In the application scenario, the original features are often divided into: month, week, day. If only full aggregation is used, the task needs to be calculated regularly every day to aggregate all features. The aggregated features are distributed in multiple different wide tables, and also need to perform multi-table join operations. Moreover, the tables are 10 billion+ in size, and the feature quantity is more than 10,000 according to the scene dimension. Several dozen external tables need to be spliced, and the storage reaches 10T. Calculating the full amount every day wastes resources and is unacceptable in terms of time consumption.

[0181] To this end, as shown in Figure 9 , a feature aggregation optimization method is provided. Figure 9is a flowchart of a periodical feature aggregation provided by an embodiment of the present application. The embodiment of the present application divides original features according to update periods, and has a set of aggregation tasks for days, weeks and months respectively. The month feature table only needs to be calculated once a month, and the week feature table only needs to be calculated once a week, so as to respectively aggregate features of corresponding periods, and then start a day-level merging task. Therefore, features in all tables do not need to be joined, but only the aggregated features of the month, week and day result tables (aggregated feature tables, such as a month aggregated feature table, a week aggregated feature table and a day aggregated feature table) are merged. Through this way of calculation, performance can be greatly improved.

[0182] In order to verify the effect of periodical feature aggregation, month feature aggregation, week feature aggregation, day feature aggregation, periodical aggregation and full-amount aggregation are experimented, and experimental results shown in Table 1 are obtained.

[0183] Table 1

[0184]

[0185] Based on actual application scenario data verification, performance of full-amount aggregation and periodical aggregation using month, week and day periodical feature tables is compared, and performance is improved by more than 15 times, which well solves the feature aggregation performance problem in the actual application scenario.

[0186] Regarding storage optimization: pre-aggregation optimization has a significant effect on performance improvement. Since features used by all algorithms in a scene are aggregated, the storage of aggregated features is particularly large. The feature table has more than 1 billion records, more than 1000 features, and more than 50T aggregated tables are generated every day, so the time consumption of subsequent calculation links is extremely high, and a large amount of computer resources are required. Through analysis, it is found in the embodiment of the present application that the storage is mainly high in feature key proportion. In order to make the feature description more understandable, the feature key is often long in naming. To this end, the feature key hierarchical shaping coding method is used to replace the string, and (pkey, skey, value) is used to identify a feature. In the coding, the pkey can be allocated a coding interval, the skey corresponds to the pkey, and the feature interval of each skey is allocated from 0 to coding. Through experiments, compared with plaintext feature storage, the feature key hierarchical shaping coding optimization of the embodiment of the present application is more than 70%.

[0187] Regarding multi-period caching: In most application scenarios, modeling requires samples from multiple historical periods, and sufficient training data is constructed to enable the algorithm to learn more knowledge and improve robustness. For example, a daily update model requires 3 months (90 periods) of samples, and in addition to training the algorithm, several days may be required for splicing in the splicing link. Two cases are considered here, 1) routine algorithm, no change in features, daily routine splicing, training, and prediction; and 2) features are gradually added in model iteration.

[0188] For the first case, the embodiment of the present application adopts a spliced historical feature plaintext cache mode, which significantly improves efficiency, as shown in Figure 10 Figure 10 is a process diagram provided by the embodiment of the present application for splicing historical features. The new period features are spliced incrementally, the historical period features are spliced cache data, combined with the new period features, and then uniformly encoded to generate the feature format for algorithm training. The performance improvement of this method is very obvious. The spliced result (spliced cache feature) of the historical period and the feature is cached in plaintext pair, and the new period directly loads the cache without re-executing the calculation of each period.

[0189] For the second case mentioned, the model iteration features are gradually added, for example, 300 features are selected as the baseline, and in iterative optimization, the selected features are gradually analyzed and added to the model. The spliced features of the historical cache do not have this new feature. For this, the cache data of the historical period is reused, and for the new features, only the spliced features of the new features are calculated in each period, combined with the spliced cache, and then re-cached. This method has several times the performance improvement compared to full re-splicing.

[0190] For spliced feature encoding performance optimization: In the last link of feature splicing, the spliced feature key needs to be converted into the format of algorithm training. A statistical method can be used, that is, the full feature key (such as reading interest -> entertainment, sports, gossip, etc. Category features, age, etc. Discrete features, and consumption times, etc. Continuous features) is first counted, and a global unique index is assigned to each feature key.

[0191] However, the full statistical encoding operation is very time-consuming, that is, all historical period sample features need to be merged, and then the feature key of each sample is expanded. On this basis, the spark (a fast general-purpose computing engine designed for large-scale data processing) uses the groupByKey operator to implement the aggregation statistical operation. In a large data volume scenario, there are hundreds of millions of samples, and on average, each sample has hundreds of feature keys, and the expanded feature key reaches ten billion. It may also involve problems such as uneven distribution of feature keys and data skew. ​

[0192] To this end, the embodiment of the present application replaces the statistical encoding by a hash method. Considering that the hash function is essentially a mapping relationship, the full-amount encoding time of O(n) complexity can be optimized to O(1). For the feature index encoding task, the embodiment of the present application uses a hash function with uniform distribution and low collision rate to generate the mapping relationship, which essentially improves the encoding calculation performance while ensuring low collision rate. The features include category features and continuous features. The discrete expression of the category features is {feature dimension, category ID, feature value}, such as {reading interest, entertainment, 0.3}. The continuous expression of the continuous features is {dimension, feature value}, such as {ctr, 0.1}. In order to adapt to the expression structure of the category features and the continuous features, the embodiment of the present application uses the [pkey, skey, value] structure to express the features. Each feature is expressed by two indexes, such as the category feature {reading interest, entertainment, 0.3} which can be expressed by [(pkey, reading interest), (skey, entertainment), (value: 0.3)], and the continuous feature which is expressed by [(pkey, ctr), (skey, *), (value: 0.3)].

[0193] As shown in Figure 9 , Figure 9 is a flowchart of the two-level index provided by the embodiment of the present application. The pkey of "gender" is encoded to obtain 121, and the skey of "male" is encoded to obtain 234, so that the index encoding value of the original feature "gender is male" is "234121". Therefore, in the encoding link, the pkey and skey can be encoded in stages, which greatly reduces the collision rate. On the basis of ensuring that the pkey does not collide, the skey can have a certain collision rate. The skey often belongs to a category of features, and the impact of the collision is not so great.

[0194] The embodiment of the present application uses feature data in actual business for testing. The mapping interval of the pkey is 5-10 times the number of pkey dimensions, and the mapping interval of the skey is 2-5 times the number of maximum skey, which can ensure a low collision rate. The efficiency of the splicing feature encoding performance optimization scheme of the embodiment of the present application is very high (calculation conversion), which can exclude the stage from becoming a system bottleneck (can handle billion-dimensional features), is easy to maintain (does not need Key-ID mapping data, especially in online services, avoids data export, state management, etc.

[0195] In summary, the high-performance splicing method provided in the embodiments of the present application can solve the large-scale sample and feature splicing performance problem. Through multi-level cache, incremental splicing, and effective reuse of public modules, it is avoided that each algorithm needs to join the sample with all the features table; for the aggregated features, the feature key coding is used for effective compression storage, so as to reduce the loading overhead of the subsequent calculation link of the aggregated features; the index is generated by hashing the spliced features, so as to avoid the high time consumption of full aggregation calculation, and the performance is improved by more than 5 times, and the calculation resources of the splicing link in the multi-algorithm experiment are greatly reduced.

[0196] Thus, the method for constructing a recommendation model provided in the embodiments of the present application has been described in combination with the exemplary application and implementation of the server provided in the embodiments of the present application. The embodiments of the present application also provide a device for constructing a recommendation model. In actual application, each functional module in the device for constructing a recommendation model can be cooperatively implemented by hardware resources of an electronic device (such as a terminal device, a server, or a server cluster), such as a processor and other computing resources, communication resources (such as those used to support various communication modes such as optical cable and cellular), and a memory. Figure 2 The device 555 for constructing a recommendation model stored in the memory 550 is shown, which can be software in the form of programs and plug-ins, for example, software modules designed using software programming languages such as C / C++, Java, etc., special software modules in application software or large software systems designed using software programming languages such as C / C++, Java, etc., application program interfaces, plug-ins, cloud services, and other implementation manners, which are exemplarily described below.

[0197] Example 1: The device for constructing a recommendation model is a mobile terminal application program and module

[0198] The device 555 for constructing a recommendation model in the embodiments of the present application can be provided as a software module designed using software programming languages such as C / C++, Java, etc., and embedded into various mobile terminal applications based on systems such as Android or iOS (stored as executable instructions in the storage medium of the mobile terminal and executed by the processor of the mobile terminal), so as to directly use the computing resources of the mobile terminal itself to complete the task of constructing a recommendation model, and periodically or aperiodically transmit the processing result to a remote server through various network communication modes, or save it locally on the mobile terminal.

[0199] Example 2: The device for constructing a recommendation model is a server application program and platform

[0200] The device 555 for constructing a recommendation model in the embodiments of the present application can be provided as a special software module in application software or large software systems designed using programming languages such as C / C++, Java, etc., and run on a server side (stored in a storage medium of the server side in the form of executable instructions and run by a processor of the server side), and the server uses its own computing resources to complete related information recommendation tasks.

[0201] The embodiments of the present application can also be provided as a customized, easy-to-interact Web interface or other user interfaces (UIs) on a distributed, parallel computing platform composed of multiple servers, forming an information recommendation platform for individuals, groups or units, etc.

[0202] Example Three, the device for constructing a recommendation model is a server-side application program interface (API) and plug-in

[0203] The device 555 for constructing a recommendation model in the embodiments of the present application can be provided as an API or plug-in on the server side, called by a user to execute the method for constructing a recommendation model in the embodiments of the present application, and embedded into various application programs.

[0204] Example Four, the device for constructing a recommendation model is a mobile device client-side API and plug-in

[0205] The device 555 for constructing a recommendation model in the embodiments of the present application can be provided as an API or plug-in on the mobile device side, called by a user to execute the method for constructing a recommendation model in the embodiments of the present application.

[0206] Example Five, the device for constructing a recommendation model is a cloud-side open service

[0207] The device 555 for constructing a recommendation model in the embodiments of the present application can be provided as a cloud service for constructing a recommendation model developed for a user, for an individual, group or unit to obtain a recommendation list.

[0208] The device 555 for constructing a recommendation model includes a series of modules, including an aggregation module 5551, a splicing module 5552 and a training module 5553. The following continues to describe the scheme for implementing the construction of a recommendation model by the modules in the device 555 for constructing a recommendation model provided in the embodiments of the present application.

[0209] In some embodiments, the aggregation module 5551 is further configured to perform the following processing for each application scenario of a recommendation item: performing aggregation processing and de-duplication processing on at least part of the features of the multiple feature tables corresponding to the application scenario to obtain an aggregated feature table of the application scenario; and combining each feature identifier in the aggregated feature table to obtain a feature metadata table of the application scenario.

[0210] In some embodiments, the aggregation module 5551 is further configured to aggregate all features of the plurality of feature tables corresponding to the application scenario.

[0211] In some embodiments, the aggregation module 5551 is further configured to determine, from the plurality of feature tables corresponding to each application scenario in the recommended items, features that are common to a plurality of training algorithms for training a recommended model of the application scenario; and aggregate the common features to obtain an aggregated feature table of the application scenario.

[0212] In some embodiments, the splicing module 5552 is further configured to, when corresponding user features or item features are not read from the aggregated feature table of the cache space, read corresponding user features or item features from the plurality of feature tables corresponding to the application scenario, and splice the sample data table to form a training sample set.

[0213] In some embodiments, when there is a new feature table of the application scenario, the aggregation module 5551 is further configured to splice the new feature table and the aggregated feature table of the application scenario to obtain a new aggregated feature table, and perform incremental update on the cache space based on the new aggregated feature table.

[0214] In some embodiments, the aggregation module 5551 is further configured to, when each new period of each application scenario arrives, aggregate a new feature table corresponding to the new period to obtain an aggregated feature table of the new period; and splice the aggregated feature table of each new period to obtain the aggregated feature table of the application scenario.

[0215] In some embodiments, the aggregation module 5551 is further configured to perform incremental update on the cache space based on the aggregated feature table of the new period; and read, from the cache space, an aggregated feature table of a historical period corresponding to the new period as the aggregated feature table of the new period; wherein the historical period corresponding to the new period is a period before the new period.

[0216] In some embodiments, the splicing module 5552 is further configured to, when each new period of each application scenario arrives, perform the following processing: read, from the aggregated feature table of the new period of the cache space, corresponding user features and item features based on user identifiers and item identifiers included in the sample data table of the new period; and splice the user features, the item features, and the sample data table of the new period to obtain a cache feature of the new period.

[0217] In some embodiments, the splicing module 5552 is further configured to perform incremental updating on the cache space based on the cache feature of the new period; read a plurality of cache features of historical periods corresponding to the new period from the cache space; splice the plurality of cache features and the cache feature of the new period to obtain the training sample set of the application scenario; and the historical period is a period before the new period.

[0218] In some embodiments, the aggregation module 5551 is further configured to perform mapping processing on the feature identifier in the obtained aggregation feature table to obtain a shaping value of the feature identifier; update the feature identifier in the aggregation feature table to the shaping value to obtain a compressed aggregation feature table; and send the compressed aggregation feature table to the cache space.

[0219] In some embodiments, the training module 5553 is further configured to perform primary key encoding on the feature identifier of each training sample in the training sample set to obtain a primary key encoding value of the feature identifier; perform secondary key encoding on the feature identifier of the each training sample to obtain a secondary key encoding value of the feature identifier; splice the primary key encoding value and the secondary key encoding value to obtain an index encoding value of the feature identifier; update the feature identifier of the training sample to the index encoding value to obtain an updated training sample, and train the recommendation model of the application scenario based on the updated training sample.

[0220] Embodiments of the present application provide a computer program product or a computer program, which includes computer instructions stored in a computer readable storage medium. A processor of a computer device reads the computer instructions from the computer readable storage medium, and the processor executes the computer instructions to cause the computer device to perform the method for constructing a recommendation model or the method for constructing a neural network model according to the embodiments of the present application.

[0221] Embodiments of the present application provide a computer readable storage medium storing executable instructions, wherein the executable instructions, when executed by a processor, will cause the processor to perform the method for constructing a recommendation model or the method for constructing a neural network model according to the embodiments of the present application, for example, the method for constructing a neural network model as shown in Figures 3-4 the method for constructing a recommendation model as shown in Figure 6 .

[0222] In some embodiments, the computer readable storage medium can be a memory such as FRAM, ROM, PROM, EPROM, EEPROM, flash memory, magnetic surface memory, optical disc, or CD-ROM; or various devices including one or any combination of the above memories.

[0223] In some embodiments, executable instructions can be in the form of programs, software, software modules, scripts, or code that is written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages; and that is deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment.

[0224] By way of example, executable instructions can, but need not, correspond directly with files in a file system, can be stored in a portion of a file that holds other programs or data, e.g., one or more scripts stored in a markup language document, in a single file dedicated to the program in question, or in multiple coordinated files, e.g., files that store one or more modules, sub programs, or portions of code.

[0225] By way of example, executable instructions can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.

[0226] The above description is only for the preferred embodiments of the present application, and not intended to limit the scope of protection of the present application. Any modification, equivalent replacement and improvement made within the spirit and scope of the present application shall fall within the scope of protection of the present application.

Claims

1. A method of constructing a recommendation model, the method comprising: The method comprises: aggregating a plurality of feature tables corresponding to each application scenario in a recommendation item, and sending the obtained aggregated feature table to a cache space; wherein the recommendation item comprises a plurality of application scenarios corresponding to a plurality of recommendation indicators of a to-be-recommended item one by one, and a recommendation model of each application scenario is used to predict a corresponding recommendation indicator; based on the user identifier and the item identifier included in the sample data table, reading corresponding user features and item features from the aggregated feature table of the cache space, and splicing the sample data table to form a training sample set; training the recommendation model of the application scenario based on any one of a plurality of training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set; wherein the plurality of training algorithms are used to train the recommendation model of the application scenario; when there is a new feature table of the application scenario, splicing the new feature table and the aggregated feature table of the application scenario to obtain a new aggregated feature table, and performing incremental update on the cache space based on the new aggregated feature table.

2. The method of claim 1, wherein the aggregation of a plurality of feature tables corresponding to each application scenario in a recommendation item comprises: for each application scenario of the recommendation item, the following processing is performed: aggregate and de-duplicate at least part of the features of the plurality of feature tables corresponding to the application scenario to obtain an aggregated feature table of the application scenario; the method further comprises: combining each feature identifier in the aggregated feature table to obtain a feature metadata table of the application scenario.

3. The method of claim 2, wherein, the aggregation of at least part of the features of the plurality of feature tables corresponding to the application scenario comprises: aggregate all features of the plurality of feature tables corresponding to the application scenario.

4. The method of claim 2, wherein, the aggregation of at least part of the features of the plurality of feature tables corresponding to the application scenario comprises: determine the features common to a plurality of training algorithms for training the recommendation model of the application scenario from the plurality of feature tables corresponding to each application scenario in the recommendation item; aggregate the common features to obtain an aggregated feature table of the application scenario.

5. The method of claim 4, wherein, the method further comprises: when the corresponding user features or item features are not read from the aggregated feature table of the cache space, read the corresponding user features or item features from the plurality of feature tables corresponding to the application scenario, and splice the sample data table to form a training sample set.

6. The method of claim 1, wherein, the aggregation of a plurality of feature tables corresponding to each application scenario in a recommendation item comprises: when each new cycle of each application scenario arrives, aggregate the new feature table corresponding to the new cycle to obtain an aggregated feature table of the new cycle; splicing the aggregated feature table of each new cycle to obtain an aggregated feature table of the application scenario.

7. The method of claim 6, wherein, the method further comprises: based on the aggregated feature table of the new cycle, performing incremental update on the cache space; When any new period of each application scenario does not arrive, the splicing of the aggregation feature table of each new period further includes: reading the aggregation feature table of the historical period corresponding to the new period in the cache space and taking it as the aggregation feature table of the new period; wherein the historical period corresponding to the new period is the period before the new period.

8. The method of claim 1, wherein, Based on the user identifier and the item identifier included in the sample data table, the corresponding user feature and the item feature are read from the aggregation feature table of the cache space, and are spliced with the sample data table to form a training sample set. When each new period of each application scenario arrives, the following processing is performed: Based on the user identifier and the item identifier included in the sample data table of the new period, the corresponding user feature and the item feature are read from the aggregation feature table of the new period of the cache space; the user feature, the item feature and the sample data table of the new period are spliced to obtain the cache feature of the new period.

9. The method of claim 8, wherein, The method further includes: Based on the cache feature of the new period, the cache space is incrementally updated; The method further includes: reading a plurality of cache features of the historical period corresponding to the new period from the cache space; splicing the plurality of cache features with the cache feature of the new period to obtain a training sample set of the application scenario; wherein the historical period is the period before the new period.

10. The method of claim 1, wherein, The method further includes: performing mapping processing on the feature identifier in the obtained aggregation feature table to obtain a reshaped value of the feature identifier; updating the feature identifier in the aggregation feature table to the reshaped value to obtain a compressed aggregation feature table; sending the compressed aggregation feature table to the cache space.

11. A method of constructing a neural network model, the method comprising: The method includes: performing aggregation processing on a plurality of feature tables corresponding to each application scenario in an application project, and sending the obtained aggregation feature table to a cache space; wherein the application project includes a plurality of application scenarios corresponding to a plurality of application indicators, and a neural network model of each application scenario is used to predict a corresponding application indicator; based on the feature identifier included in the sample data table, the corresponding feature is read from the aggregation feature table of the cache space, and is spliced with the sample data table to form a training sample set; based on any training algorithm of a plurality of training algorithms and the training sample set, the neural network model of the application scenario is trained, so that the neural network model can fit the features in the training sample set; wherein the plurality of training algorithms are used to train the neural network model of the application scenario; when there is a new feature table of the application scenario, the new feature table and the aggregation feature table of the application scenario are spliced to obtain a new aggregation feature table, and the cache space is incrementally updated based on the new aggregation feature table.

12. An apparatus for constructing a recommendation model, the apparatus comprising: The device includes: The aggregation module is configured to aggregate a plurality of feature tables corresponding to each application scenario in the recommended item, and send the obtained aggregated feature table to a cache space; wherein the recommended item comprises a plurality of application scenarios corresponding to a plurality of recommended indexes of a to-be-recommended item one by one, and a recommendation model of each application scenario is configured to predict a corresponding recommended index; The splicing module is configured to read corresponding user features and item features from the aggregated feature table in the cache space based on user identifiers and item identifiers included in the sample data table, and splice the sample data table to form a training sample set; The training module is configured to train the recommendation model of the application scenario based on any training algorithm of a plurality of training algorithms and the training sample set, so that the recommendation model can fit the user features and item features in the training sample set; wherein the plurality of training algorithms are configured to train the recommendation model of the application scenario; The aggregation module is further configured to splice the new feature table and the aggregated feature table of the application scenario when the application scenario has a new feature table, obtain a new aggregated feature table, and perform incremental update on the cache space based on the new aggregated feature table.

13. An electronic device, comprising: The electronic device comprises: a memory configured to store executable instructions; a processor configured to execute the executable instructions stored in the memory to implement the method for constructing a recommendation model according to any one of claims 1 to 10.

14. A computer-readable storage medium, characterized in that, The executable instructions are stored in the memory and are configured to be executed by the processor to implement the method for constructing a recommendation model according to any one of claims 1 to 10.

15. A computer program product comprising computer-executable instructions or a computer program, characterized in that, The computer executable instructions or computer programs are executed by the processor to implement the method for constructing a recommendation model according to any one of claims 1 to 10.

Images