Feature processing method, system and device

Abstract

The invention provides a feature processing method, system and device, and the method comprises the steps: obtaining object metadata of a to-be-constructed feature object in response to a configuration operation of a feature configuration page of a feature management module; constructing a feature object based on the object metadata through a feature management module; and performing feature processing on the first transaction data for feature processing through a feature operation module based on the object metadata of the feature object to obtain a feature result. The object metadata of the feature object can be directly obtained only by depending on the feature configuration page of the feature management module, the efficiency and accuracy of feature configuration and feature construction are improved, then transaction data are processed through the feature operation module according to the feature metadata, feature processing logic and the feature metadata are strongly bound, and the processing efficiency is improved. When feature metadata are adjusted, feature processing logic is rapidly and synchronously updated, real-time alignment of feature results and user requirements is maintained, and the real-time performance, accuracy and reliability of feature processing are improved.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and in particular to a feature processing method, system, and apparatus. Background Technology

[0002] In applications with extremely high timeliness requirements, such as risk event identification, dynamic changes in user behavior data often imply potential risk signals. To promptly capture abnormal behavior, the system needs to quickly calculate a series of characteristic indicators reflecting the risk status based on real-time user behavior data (e.g., "number of transactions by a user in the last minute" reflects abnormal transaction frequency, and "total amount of publicly disclosed loans on the same device in the last 10 minutes" reveals device-level multiple borrowing risk). These features, calculated in real time, essentially constitute the "digital fingerprint" of risk identification. Only through efficient and accurate feature processing can the accuracy of risk event identification be ensured, avoiding missed or incorrect risk assessments due to feature lag or calculation errors. Summary of the Invention

[0003] This disclosure aims to at least partially address one of the technical problems in the related art.

[0004] One aspect of this disclosure proposes a feature processing method that allows direct acquisition of object metadata of feature objects by relying solely on the feature configuration page of the feature management module, thereby improving the efficiency and accuracy of feature configuration and feature construction. Furthermore, the feature operation module processes transaction data based on the feature metadata, making the feature processing logic strongly bound to the feature metadata. When the feature metadata is adjusted, the feature processing logic is quickly and synchronously updated, maintaining real-time alignment between feature results and user needs, and improving the real-time performance, accuracy, and reliability of feature processing.

[0005] A first aspect of this disclosure provides a feature processing method, the method comprising: In response to configuration operations on the feature configuration page of the feature management module, obtain the object metadata of the feature object to be built; The feature object is constructed by the feature management module based on the object metadata; The feature processing module performs feature processing on the first transaction data used for feature processing based on the object metadata of the feature object to obtain the feature result.

[0006] A second aspect of this disclosure provides a feature processing system, the system comprising a feature management module and a feature execution module, wherein: the feature management module is configured to, in response to a configuration operation on a feature configuration page, obtain object metadata of a feature object to be constructed, and construct the feature object based on the object metadata; the feature execution module is configured to, based on the object metadata of the feature object, perform feature processing on first transaction data for feature processing to obtain feature results.

[0007] A third aspect of this disclosure provides a feature processing apparatus, the apparatus comprising: The acquisition module is used to obtain the object metadata of the feature object to be built in response to the configuration operation on the feature configuration page of the feature management module; The construction module is used to construct the feature object based on the object metadata through the feature management module; The processing module is used to process the first transaction data for feature processing based on the object metadata of the feature object through the feature running module to obtain the feature result.

[0008] A fourth aspect of this disclosure provides an electronic device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, it implements the feature processing method as proposed in the first aspect of this disclosure.

[0009] The fifth aspect of this disclosure provides a non-transitory computer-readable storage medium having a computer program stored thereon that, when executed by a processor, implements the feature processing method as proposed in the first aspect of this disclosure.

[0010] A sixth aspect of this disclosure provides a computer program product in which, when instructions in the computer program product are executed by a processor, a feature processing method as described in a first aspect of this disclosure is performed.

[0011] The technical solutions provided by the above embodiments of this disclosure bring at least the following beneficial effects: In response to configuration operations on the feature configuration page of the feature management module, the system obtains the object metadata of the feature object to be constructed. Based on this object metadata, the feature management module constructs the feature object. Then, based on the object metadata, the feature execution module processes the first transaction data used for feature processing to obtain the feature result. Therefore, firstly, directly obtaining object metadata through the feature configuration page reduces the operational cost and error probability of manually writing object metadata for feature objects, allowing non-technical personnel to participate in feature definition and significantly improving the efficiency and accuracy of feature configuration. Secondly, the feature management module constructs feature objects based on unified metadata, ensuring consistency in basic attributes such as data format and field meaning among all features, providing a standardized foundation for subsequent cross-scenario feature reuse and avoiding redundant development. Finally, the feature execution module processes the first transaction data based on the feature metadata, strongly binding the feature processing logic to the feature metadata. This effectively reduces logical deviations during feature processing and allows for rapid synchronization and updating of the processing logic when the feature metadata is adjusted, maintaining real-time alignment between the feature result and user needs. This improves the real-time performance, accuracy, and reliability of feature processing, providing efficient, reliable, and reusable feature support for subsequent feature application stages.

[0012] Additional aspects and advantages of this disclosure will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this disclosure. Attached Figure Description

[0013] The above and / or additional aspects and advantages of this disclosure will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, in which: Figure 1 This is a schematic flowchart of a feature processing method provided in an embodiment of the present disclosure; Figure 2 This is a schematic flowchart of another feature processing method provided in an embodiment of the present disclosure; Figure 3 This is a schematic flowchart of another feature processing method provided in an embodiment of the present disclosure; Figure 4 This is a schematic flowchart of another feature processing method provided in an embodiment of the present disclosure; Figure 5 This is a schematic flowchart of another feature processing method provided in an embodiment of the present disclosure; Figure 6 This is a schematic diagram of the structure of a feature processing system provided in an embodiment of the present disclosure; Figure 7 A schematic diagram of the management-operation separation system architecture provided in this disclosure; Figure 8This is a schematic diagram of the structure of a feature processing device provided in an embodiment of the present disclosure; Figure 9 This is a schematic diagram of the structure of an electronic device shown in an exemplary embodiment of the present disclosure. Detailed Implementation

[0014] Embodiments of this disclosure are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this disclosure, and should not be construed as limiting this disclosure.

[0015] It should be noted that the acquisition, storage, use, and processing of data in this application comply with relevant laws and regulations and do not violate public order and good morals.

[0016] It should also be noted that the information (including but not limited to user personal information, transaction information, etc.), data (including but not limited to data used for analysis, data stored, data displayed, etc.) and signals involved in this application are all authorized by the user or fully authorized by all parties, and the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0017] In related technologies, the feature processing flow is as follows: First, based on the feature processing logic, a database query statement (such as SQL (Structured Query Language) statement) is written to pull a large batch of detailed data that meets the conditions from the business database into the application server's memory; then, the data is traversed in the application memory and processed and calculated according to different feature processing logics (such as counting, summing, averaging, etc.) to finally obtain the feature result; finally, the result is returned to the risk control engine to participate in the rule calculation.

[0018] However, such a design has at least the following drawbacks: 1. Excessive Database Load: Frequent, large-scale data queries place enormous I / O (Input / Output) pressure and computational load on the business database. Especially during peak business periods, these queries can easily compete with online services for database resources, thus threatening the stability of core business operations.

[0019] 2. Severe network bandwidth consumption: The process of transferring a large amount of raw detailed data from the database to the application server requires a lot of network bandwidth resources, which becomes a constraint on the further expansion of the system.

[0020] 3. Increased risk of application server memory overflow: When processing massive amounts of data, application servers need to load it into memory for computation. In high-concurrency scenarios, this process can easily exhaust all memory resources, triggering an Out of Memory error and ultimately causing service crashes.

[0021] 4. Long response delay makes it difficult to achieve real-time response: Due to the long process chain of "data retrieval - memory computation", the overall time consumption is long, making it difficult to achieve millisecond-level real-time response. This cannot meet the needs of modern risk control scenarios with extremely high timeliness requirements.

[0022] 5. Tight system coupling, poor scalability and maintainability: The processing logic of metrics is usually tightly coupled to the business code in the form of hard code. Whenever a feature metric or feature object needs to be added, modified, or taken offline, a process of development, testing, and full deployment is required. This not only leads to slow business response but also makes the system rigid, difficult to maintain and expand.

[0023] In view of at least one of the above-mentioned problems, this disclosure proposes a feature processing method, system and apparatus.

[0024] The feature processing methods, systems, and apparatus of this disclosure are described below with reference to the accompanying drawings.

[0025] Figure 1 This is a schematic flowchart of a feature processing method provided in an embodiment of the present disclosure.

[0026] This disclosure illustrates the example of a feature processing method configured in a feature processing device, which can be applied to any electronic device to enable the electronic device to perform feature processing functions.

[0027] Among them, electronic devices can be any device with computing capabilities, such as personal computers, mobile terminals, servers, etc. Mobile terminals can be hardware devices with various operating systems, touch screens and / or displays, such as mobile phones, tablets, personal digital assistants, wearable devices, etc.

[0028] like Figure 1 As shown, the feature processing method includes the following steps S110 to S130: Step S110: In response to the configuration operation on the feature configuration page of the feature management module, obtain the object metadata of the feature object to be constructed.

[0029] The configuration operations can take the form of, but are not limited to, mouse click input, keyboard input, voice input, etc.

[0030] It should be noted that the feature management module may have a feature configuration page that allows for user interaction. For example, such as... Figure 2 As shown, the feature configuration page displays the object metadata that needs to be configured for the feature object to be built, including feature identifier, feature scenario information, tool name, statistical variable information, key dimension information, time period, filtering conditions, etc.

[0031] Among them, the feature identifier can be used to uniquely identify the corresponding feature object.

[0032] Among them, the feature scenario can be used to indicate the scenario in which the corresponding feature object is applied, such as the feature scenario being mobile banking-transfer scenario, offline transfer scenario, loan scenario, etc.

[0033] The tool name can be used to indicate the feature processing logic corresponding to the feature object.

[0034] Among them, statistical variables can be used to indicate the variables that need to be statistically analyzed for the corresponding characteristic objects, such as transaction amount, transaction time, etc.

[0035] Among them, key dimensions can be used to link the transaction behavior of the same user, such as ID card number, mobile phone number, account number, etc.

[0036] The time period can be used to indicate the length of the time window corresponding to the relevant feature object, such as 5 minutes, 5 hours, etc.

[0037] Among them, the filtering conditions can be, for example, whether the transaction region corresponding to the transaction data matches the preset region, etc. This disclosure does not restrict the setting of filtering conditions.

[0038] It should be noted that the above example of the feature configuration page is merely exemplary. In practical applications, the page elements included in the feature configuration page can be other than those specified in this disclosure.

[0039] It should also be noted that the number of feature objects to be constructed can be, but is not limited to, one, and this disclosure does not impose any restrictions on this.

[0040] In this embodiment of the disclosure, the user can perform configuration operations on the feature configuration page of the feature management module for the feature object to be constructed. Thus, the execution entity of this disclosure can respond to the user's configuration operations and obtain the object metadata of the feature object to be constructed.

[0041] Step S120: Construct feature objects based on object metadata through the feature management module.

[0042] As an example, in response to a user's click on the submit component on the feature configuration page of the feature management module, the feature management module constructs a feature object that matches the object metadata based on the object metadata.

[0043] Optionally, in some embodiments, the feature object can be cached locally after it has been constructed.

[0044] Step S130: The feature processing module performs feature processing on the first transaction data used for feature processing based on the object metadata of the feature object to obtain the feature result.

[0045] It should be noted that this disclosure does not limit the number of feature operation modules; there may be one or more.

[0046] The first transaction data refers to the data used for feature processing. It should be noted that this disclosure does not limit the amount of the first transaction data.

[0047] Optionally, in some embodiments, the first transaction data may include information such as the transaction scenario, transaction amount, transaction time, transaction area code, transaction user information (such as ID card, name, contact information, etc.), payer's bank card number, and payee's bank card number.

[0048] In this embodiment of the disclosure, after the feature object is constructed, the feature processing module can perform feature processing on the first transaction data used for feature processing based on the constructed feature object and the object metadata of the feature object, thereby obtaining the feature result.

[0049] In the case where the object metadata includes a tool name, which indicates the corresponding feature processing logic, and the number of feature objects is at least one, to clearly illustrate how the feature execution module processes the first transaction data for feature processing based on the object metadata of the feature objects to obtain the feature result, as one possible implementation is as follows: Figure 3 As shown, the feature results can be obtained by following the steps S131 to S132: Step S131: Using the feature running module, a first target feature object matching the first transaction data is determined from at least one feature object based on the object metadata of at least one feature object.

[0050] It should be noted that this disclosure does not limit the number of the first target feature objects; that is, the first target feature objects can be one or more.

[0051] As one possible implementation, such as Figure 4As shown, the implementation process of step S131 may include the following steps S1311 to S1312: Step S1311: For any feature object, the feature execution module determines whether the first transaction data matches the object metadata of the feature object.

[0052] Optionally, in some embodiments, when the object metadata also includes feature scene information, statistical variable information, key dimension information, and filtering conditions, for any feature object, when the first transaction data meets the first condition, the feature running module determines that the first transaction data matches the object metadata of the feature object.

[0053] The first condition includes one or more combinations of the following: 1. Matching the scenario to which the first transaction data belongs with the characteristic scenario information; 2. The first transaction data meets the filtering criteria; 3. The first transaction data does not have a null value under the variable indicated by the statistical variable information; 4. The first transaction data is not null in the dimension indicated by the key dimension information.

[0054] As an example, suppose the first condition includes: the scenario to which the first transaction data belongs matches the feature scenario information; the first transaction data meets the filtering conditions; the value of the first transaction data under the variable indicated by the statistical variable information is not empty; and the value of the first transaction data under the dimension indicated by the key dimension information is not empty. When the first transaction data meets all of the above conditions, it can be determined that the first transaction data matches the object metadata of the feature object. It should be noted that the above example of the first condition is merely exemplary. In practical applications, the first condition can also be other combinations of the above four conditions, and this disclosure does not limit this.

[0055] It should also be noted that, in practical applications, the first condition can be set as needed, and this disclosure does not impose any restrictions on it.

[0056] Therefore, by using scenario matching, filter condition satisfaction, and the non-emptiness of statistical variables and key dimensions as core judgment criteria, we can ensure that the first transaction data and the target scenario of the feature object are highly consistent from the business scenario level. We can also filter out data that meets the basic processing requirements through filter conditions. At the same time, by using the non-emptiness verification of statistical variables and key dimensions, we can eliminate invalid processing caused by missing core fields from the source, avoid feature distortion, and improve the accuracy of feature matching. This multi-condition combination judgment method can retain the flexibility of the matching logic (the combination of conditions can be flexibly adjusted according to user needs) and enhance business adaptability. It can also replace fuzzy judgment with clear quantitative standards, making the matching process more objective and interpretable, reducing resource waste caused by matching deviations, and providing a high-quality and highly adaptable data foundation for subsequent feature processing.

[0057] In step S1312, in response to the matching of the first transaction data with the object metadata of the feature object, the feature object is determined to be the first target feature object through the feature running module.

[0058] In this embodiment of the disclosure, when the first transaction data matches the object metadata of the feature object, the feature object can be determined as the first target feature object through the feature execution module.

[0059] Therefore, the metadata of the feature objects can be automatically matched and verified with the first transaction data one by one, and the feature objects that are successfully matched are identified as the first target feature objects. This not only helps to improve the accuracy and suitability of the selected first target feature objects, but also avoids complex manual screening or multiple rounds of logical judgment, simplifies the process of determining target feature objects, reduces the operation threshold and decision-making cost, and also makes the screening process traceable.

[0060] Step S132: The feature processing module uses the feature processing logic indicated by the tool name in the object metadata of the first target feature object to process the first transaction data to obtain the feature result.

[0061] It is understandable that the feature processing logic may be complex. For example, in the feature processing logic of "finding the maximum average value", it can be broken down into the following four atomic operations: 1. summation; 2. calculation of the number of data to be summed; 3. calculation of the average value; 4. comparison and filtering. In order to realize the feature processing of the first transaction data, as a possible implementation method, the feature execution module calls the first target script in the target memory to execute at least one atomic operation corresponding to the feature processing logic to perform feature processing on the first transaction data and obtain the feature result.

[0062] The feature processing logic can be the logic indicated by the tool name in the object metadata of the first target feature object. It should be noted that the number of atomic operations corresponding to the feature processing logic can be, but is not limited to, one; this disclosure does not impose any limitation on this.

[0063] The target storage device could be, for example, Redis (Remote Dictionary Server).

[0064] The target memory can store a first target script, which can encapsulate the specific implementation code of the corresponding atomic operations. The first target script can be, for example, a Lua script.

[0065] In this embodiment of the disclosure, the feature processing logic can be used to call the first target script stored in the target memory to execute at least one atomic operation corresponding to the feature processing logic, thereby performing feature processing on the first transaction data and obtaining the feature result corresponding to the first transaction data.

[0066] Understandably, using the first target script as an example with Lua scripts, the lightweight nature of Lua scripts allows for faster execution of atomic operations, enabling efficient processing of the first transaction data. This is especially beneficial in high-frequency trading scenarios, reducing data processing latency and improving the flexibility and efficiency of feature processing. Secondly, encapsulating atomic operations as independent Lua scripts and storing them in the target memory not only facilitates individual modification, testing, and reuse of each operation, preventing modifications to a single operation from affecting the overall processing logic, but also allows relevant personnel to quickly adapt to new processing requirements by adjusting the scripts, thereby reducing the cost of feature iteration.

[0067] Therefore, by identifying the first target feature object through matching the object metadata of the feature object, feature processing logic that is highly compatible with the current first transaction data can be directly selected, avoiding invalid processing. This ensures the matching degree between feature results and user needs from the source and reduces resource waste. Secondly, by calling the corresponding feature processing logic based on the tool name in the object metadata of the target feature object, a strong association between processing rules and feature objects can be achieved. There is no need to manually switch or write processing code, which reduces operational complexity and maintains the consistency of feature processing logic, avoiding human error. Finally, this feature matching and feature processing mode can support rapid response to the feature requirements of different transaction data. When the business needs to add or adjust features, only the object metadata of the corresponding feature object needs to be updated. There is no need to reconstruct the entire processing flow, which can significantly improve the scalability and iteration efficiency of the feature system, improve the accuracy, flexibility and efficiency of feature processing, and quickly provide high-quality feature support for downstream businesses.

[0068] It should be noted that after obtaining the feature results, these results can be saved. One possible approach to saving the feature results is to generate a unique key for the first transaction data based on the object's metadata; then, based on this unique key, the feature results of the first transaction data can be stored.

[0069] In this embodiment of the disclosure, a unique key for the first transaction data can be generated based on the object metadata.

[0070] As an example, a unique key for the first transaction data can be generated based on the values ​​corresponding to key dimension information in the object's metadata. For instance, if the key dimension information in the object's metadata is "ID number," its corresponding value in the first transaction data can serve as the unique key for that first transaction data.

[0071] As another example, multiple key pieces of information can be extracted from object metadata and first transaction data; these key pieces of information are then concatenated to obtain the unique key of the first transaction data. For instance, when object metadata includes feature identifiers, feature scene information, and key dimension information, the values ​​of the feature identifiers, feature scene information, and key dimension information in the first transaction data can be concatenated to obtain the unique key of the first transaction data. For example, if the feature identifier is value A, the feature scene code corresponding to the feature scene information is B, and the key dimension information is "ID number" with a value of C in the first transaction data, then concatenating these pieces of information would yield a unique key for the first transaction data, such as ABC. It should be noted that the above examples of unique keys are merely illustrative; other forms are possible in practical applications, and this disclosure does not impose any limitations on them.

[0072] Therefore, in this disclosure, the feature results of the first transaction data can be stored based on a unique key. For example, the feature results of the first transaction result can be stored using hash data results.

[0073] Therefore, by generating unique keys through object metadata, each feature result corresponding to the first transaction data can have a unique identifier, fundamentally avoiding storage redundancy and overwriting problems caused by data duplication or identifier confusion, and improving the accuracy of feature result storage and the uniqueness of data storage. Secondly, the unique key is directly associated with the object metadata, which makes it easy to quickly trace back to the corresponding transaction data and feature configuration information when querying or calling feature results in the future. This can effectively reduce the difficulty of data traceability and improve the traceability and query efficiency of feature results.

[0074] It is understood that, even when the feature results are stored in the target memory, the feature results can still be queried. Therefore, in one possible implementation of this disclosure embodiment, such as... Figure 5 As shown, steps S510 to S530 can also be implemented: Step S510: In response to receiving the second transaction data for feature query, the feature running module determines a second target feature object that matches the first transaction data from at least one feature object based on the object metadata of at least one feature object.

[0075] It should be noted that the method for determining the second target feature is similar to the method for determining the first target feature object in step S131, and will not be elaborated here.

[0076] It should also be noted that this disclosure does not limit the number of the second target feature objects; there may be one or more.

[0077] Step S520: The feature execution module queries the target storage based on the object metadata of the second target feature object to obtain the target feature result.

[0078] As one possible implementation, a feature execution module can generate a unique key for the second transaction data based on the object metadata of the second target feature object; then, based on the unique key, the target storage can be queried to obtain the target feature result corresponding to the unique key.

[0079] As an example, a unique key for the second transaction data can be generated based on the values ​​corresponding to key dimension information in the object's metadata. For instance, if the key dimension information in the object's metadata is "ID number," its corresponding value in the second transaction data can serve as the unique key for that second transaction data.

[0080] As another example, multiple key pieces of information can be extracted from the object metadata and the second transaction data, and then concatenated to obtain the unique key of the second transaction data.

[0081] Step S530: The feature query result is determined by the feature execution module based on the target feature result.

[0082] As an example, the feature execution module can be used to determine the target feature results as feature query results and return them to the querying user.

[0083] As an example, when there is at least one target feature result, the feature execution module can call the second target script in the target memory to perform a lightweight calculation on at least one target feature result, obtain the calculation result, and determine the calculation result as the feature query result.

[0084] The target memory may store a second target script, which can be a script file used to perform lightweight calculations (such as simple operations, data conversion, basic verification, and other low-complexity processing) and output the calculation results. The second target script may be, for example, a Lua script.

[0085] For example, suppose the feature indicated by the feature object is "the maximum transaction amount in the last 5 minutes", where 5 minutes is the time window length of the feature object. When the feature processing logic of "maximum transaction amount" is called to process the transaction data, feature extraction (or feature processing) is performed according to one maximum transaction amount per minute. The feature result is obtained and saved. Thus, in subsequent applications, if the target feature result is found to include the maximum transaction amount corresponding to target time 1, the maximum transaction amount corresponding to target time 2, and the maximum transaction amount corresponding to target time 3, a lightweight calculation can be performed on the above three maximum transaction amounts. That is, the maximum value among the above maximum transaction amounts is selected as the calculation result, and this calculation result can be determined as the feature query result. Therefore, by performing lightweight calculations on the target feature results, the original feature data can be transformed into derived results that better suit the query requirements (such as summation, mean calculation, etc.), without the need for secondary processing in downstream business, directly improving the practicality of feature query results. Taking the second target script as an example, Lua scripts are lightweight and execute quickly. They directly calculate feature results within the target memory, avoiding the process of transferring a large amount of raw feature data to external modules for processing, significantly reducing data transmission loss and computational latency, and helping to improve query response efficiency. Furthermore, by having the lightweight calculation task be completed by the Lua script on the memory side, rather than occupying the resources of the core business module, the system's computing power pressure is effectively distributed, reducing system load pressure. At the same time, the script is reusable and easy to modify, and can flexibly adapt to the computational needs of different query scenarios. This can reduce the cost of function iteration and ensure the stable operation of the core system, further enhancing the flexibility and efficiency of the feature query process.

[0086] In summary, identifying the second target feature object through object metadata matching enables precise location of feature logic adapted to the second transaction data. This ensures that subsequent queries return target feature results highly aligned with current needs, avoiding irrelevant or erroneous data and improving the accuracy and usability of feature query results. Secondly, directly querying the target storage based on the object metadata of the target feature object eliminates the need to re-execute the feature processing flow, reducing data computation and processing steps and shortening query response time. This is particularly beneficial in high-frequency query scenarios, improving overall business processing efficiency. Finally, the query process reuses object metadata from the feature construction and storage stages, ensuring consistency in the core logic of feature processing, storage, and querying. This avoids result deviations caused by differences in data caliber across multiple stages, maintaining the stability and reliability of feature results from generation to query, and providing efficient and accurate data support for downstream decision-making.

[0087] The feature processing method of this disclosure, in response to a configuration operation on the feature configuration page of the feature management module, obtains the object metadata of the feature object to be constructed; the feature management module constructs the feature object based on the object metadata; and the feature execution module processes the first transaction data used for feature processing based on the object metadata of the feature object to obtain the feature result. First, directly obtaining the object metadata through the feature configuration page reduces the operational cost and error probability of manually writing the object metadata of the feature object, allowing non-technical personnel to participate in feature definition, significantly improving the efficiency and accuracy of feature configuration. Second, the feature management module constructs the feature object based on unified metadata, ensuring consistency of all features in basic attributes such as data format and field meaning, providing a standardized foundation for subsequent cross-scenario feature reuse and avoiding redundant development. Finally, the feature execution module processes the first transaction data based on the feature metadata, strongly binding the feature processing logic to the feature metadata. This effectively reduces logical deviations during feature processing and allows for rapid synchronization and updating of the processing logic when the feature metadata is adjusted, maintaining real-time alignment between the feature result and user needs, improving the real-time performance, accuracy, and reliability of feature processing, and providing efficient, reliable, and reusable feature support for subsequent feature application stages.

[0088] This disclosure also proposes a feature processing system.

[0089] Figure 6 This is a schematic diagram of the structure of a feature processing system provided in an embodiment of the present disclosure.

[0090] like Figure 6 As shown, the feature processing system 600 includes a feature management module 610 and a feature execution module 620, wherein: The feature management module 610 can be used to obtain the object metadata of the feature object to be built in response to the configuration operation on the feature configuration page, and can build the feature object based on the object metadata.

[0091] The feature processing module 620 can be used to process the first transaction data for feature processing based on the object metadata of the feature object to obtain the feature result.

[0092] It should be noted that the relevant explanations in the feature processing method also apply to this embodiment, and will not be repeated here.

[0093] Optionally, in some embodiments, the feature processing system 600 may also include a message queue.

[0094] Furthermore, in the case where the feature processing system 600 also includes a message queue, in one possible implementation of this embodiment, the feature management module 610 can be used to obtain the object metadata of the feature object to be constructed in response to a configuration operation on the feature configuration page, and can construct the feature object based on the object metadata. Then, the object metadata of the feature object is sent to the feature running module 620 through the message queue. Correspondingly, the feature running module 620 can be used to obtain the object metadata of the feature object from the message queue and cache the object metadata of the feature object locally. Thus, in response to receiving the first transaction data for feature processing, the object metadata of the feature object is loaded from the local cache to perform feature processing on the first transaction data for feature processing to obtain the feature result.

[0095] The number of message queues can be, but is not limited to, one; this disclosure does not impose any restrictions on this.

[0096] It should be noted that the relevant explanations and descriptions in the feature processing method are also applicable to the feature processing system provided in the embodiments of this disclosure, and can achieve the same technical effect. Here, the parts and beneficial effects that are the same as those in the method embodiments will not be described in detail.

[0097] To clearly illustrate the feature processing method and feature processing system disclosed herein, the following explanation is provided with reference to examples.

[0098] As an example, the feature processing method of this disclosure is applied to a management-running separated system architecture, which can be used for real-time feature computation, such as... Figure 7 As shown, the management-running separated system architecture includes a real-time feature management terminal (referred to as the feature management module in this disclosure), at least one real-time feature running terminal, a message queue, a database, and Redis.

[0099] It should be noted that by extracting the real-time feature processing logic, it is encapsulated into two independent microservices, namely the real-time feature management end and the real-time feature execution end, to achieve functional decoupling and system modularization.

[0100] The real-time feature management terminal is responsible for the full lifecycle management of feature objects, including creation, deployment, decommissioning, review, and access control. Users can predefine feature templates on the feature configuration page based on the different calculation logics involved in the feature object (such as frequency statistics, summation, etc.) (referred to as processing logic in this disclosure). Thus, various feature objects can be quickly configured through feature templates. Each feature object can include a unique feature ID (Identity document, referred to as feature identifier in this disclosure), time window length, statistical variable information, and feature version, etc., and the configuration information of these feature objects can be persistently stored in a relational database. The real-time feature management terminal can push information to at least one real-time feature execution terminal through a real-time message queue.

[0101] The real-time feature processing endpoint can be used for real-time feature processing and feature result querying. It can consume feature configuration update messages from the real-time feature management endpoint to refresh the local cache in real time, ensuring rapid loading of the object metadata required for feature processing or querying.

[0102] The feature processing implementation process can be as follows: The real-time feature execution terminal provides a feature processing API (Application Programming Interface), and through this interface, receives the first transaction data as input parameters. Then, the interface quickly filters the first target feature object to be processed from the local cache based on the first transaction data, and encapsulates it with the first transaction data into the format required for feature processing. It calls the predefined Lua script in Redis to execute at least one atomic operation corresponding to the feature processing logic of the first target feature object, performs feature processing on the first transaction data to obtain feature results, and generates a unique key for the first transaction data based on the object metadata of the first target feature object. Based on this unique key, the feature results are stored in Redis using the corresponding data storage structure.

[0103] For example, using the user's ID number as the unique key, its data storage structure can be as follows: ${ID number}: { "Feature A": { / / Frequency statistical feature "v": 1, / / Data version number "d": { / / Data content "202510211026": 1, "202510211028": 100 } }, "Feature B": { / / Summation-type feature "v": 1, "d": { "202510211027": 200, "202510211029": 1000 } } } It should be noted that the above storage structure is merely exemplary, and other forms are possible in practical applications, which are not limited in this disclosure.

[0104] The feature query process can be as follows: The real-time feature runtime provides a query API and receives the second transaction data as input parameters through this interface. Then, the real-time feature runtime can extract the second target feature object that meets the conditions from the local cache based on the second transaction data, generate a unique key for the second transaction data according to the object metadata of the second target feature object, and call a query function written in Lua script in Redis. This query function is then called to query Redis based on the unique key to obtain the target feature result. Next, the Lua script in Redis is called to assemble the target feature result, i.e., to perform lightweight computation and aggregation on the target feature result, returning the feature query result. Finally, the application encapsulates the feature query result and returns it to the caller.

[0105] It should be noted that the technical solutions disclosed herein can be applied to application scenarios with some preset events (such as risk events, non-risk events, etc.), and this disclosure does not limit its application scenarios.

[0106] The management-operation separation system architecture disclosed herein can solve the problems of high feature computation latency, poor flexibility, and insufficient scalability in related technologies, and has at least the following beneficial effects: I. Significantly improve the agility of feature deployment and system maintainability. By adopting a microservice architecture that separates "management" and "operation," and introducing a feature-templated and configuration-based management approach, 1.1 Facilitates Agile Development and Deployment: Relevant staff do not need to write code; they can define new features simply by selecting templates and configuring parameters through the management interface. This shortens the launch cycle of new features from the traditional "days" to "minutes," greatly improving the ability to respond to rapidly changing user needs.

[0107] 1.2 Reduced maintenance costs: The microservice architecture achieves functional decoupling. The real-time feature management end is responsible for business logic, while the real-time feature execution end focuses on high-performance computing. Both can be upgraded and expanded independently, which can reduce the complexity of the system and the later maintenance costs.

[0108] 1.3 Dynamic hot update: By broadcasting configuration changes through a message queue, new feature releases or modifications to existing features can take effect within seconds without restarting the computing service, ensuring the system's continuous 24 / 7 service capability.

[0109] II. Achieving high availability and elastic scalability of the system Both the real-time feature management end and the real-time feature execution end adopt distributed components (i.e., database, message queue, cache), and the real-time feature execution end is stateless (configuration information is refreshed to the local cache through message consumption). This design: 2.1 Strong Horizontal Scalability: The real-time feature runtime nodes are stateless, and their required feature configuration information comes from the real-time feature management terminal and is loaded through local caching. Therefore, the number of real-time feature runtime instances can be easily increased or decreased horizontally according to real-time data traffic pressure, achieving elastic scaling of computing power and easily coping with traffic peaks.

[0110] 2.2 High Availability: Multiple dependent components, such as Redis, message queues, and relational databases, can all be deployed in a high-availability mode. The failure of a single runtime or one of the components will not cause the entire system to crash; other healthy nodes can automatically take over the computing tasks, resulting in extremely high overall system availability.

[0111] III. Provides ultimate performance with high concurrency. During the feature processing stage, the adoption of an atomic computation scheme based on Redis Lua scripts and a specific data structure design provides the following advantages: Extreme performance and low latency: Moving the computational logic to the data storage layer (Redis) effectively avoids the latency caused by multiple network round trips in the "read-compute-write" pattern of related technologies. A single API call completes all computations, resulting in millisecond-level latency for feature processing, meeting the stringent timeliness requirements of real-time risk control decisions.

[0112] Built-in version control and flexibility: The design includes a data version field, providing a technical foundation for canary releases, rollbacks, and smooth upgrades of feature data. A unified data structure reserves room for expansion to support more complex operators (such as sliding window averaging).

[0113] IV. Provide efficient and aggregated feature query services During the feature query phase, the feature query results can be returned by calling Redis Lua custom functions with light aggregation, which can reduce network I / O and improve query efficiency. The data aggregation and calculation in the feature query process can be completed inside the Redis server, and only the final result is returned to the application, which can effectively reduce the number of network communications and data transmission volume, and reduce query latency.

[0114] To implement the above-described feature processing method, this disclosure also provides a feature processing apparatus.

[0115] Figure 8 This is a schematic diagram of the structure of a feature processing device provided in an embodiment of the present disclosure.

[0116] like Figure 8 As shown, the feature processing device 800 includes: an acquisition module 801, a construction module 802, and a processing module 803.

[0117] The acquisition module 801 is used to acquire the object metadata of the feature object to be constructed in response to the configuration operation on the feature configuration page of the feature management module.

[0118] Module 802 is used to construct feature objects based on object metadata through the feature management module.

[0119] The processing module 803 is used to process the first transaction data for feature processing based on the object metadata of the feature object through the feature running module to obtain the feature result.

[0120] In one possible implementation of this disclosure, the object metadata includes a tool name, which indicates the corresponding feature processing logic, and the number of feature objects is at least one; the processing module 803 is configured to: determine a first target feature object matching the first transaction data from at least one feature object based on the object metadata of at least one feature object through the feature running module; and perform feature processing on the first transaction data using the feature processing logic indicated by the tool name in the object metadata of the first target feature object through the feature running module to obtain feature results.

[0121] In one possible implementation of this disclosure, the processing module 803 is configured to: for any feature object, determine whether the first transaction data matches the object metadata of the feature object through the feature running module; in response to the first transaction data matching the object metadata of the feature object, determine the feature object as the first target feature object through the feature running module.

[0122] In one possible implementation of this disclosure, the object metadata further includes feature scene information, statistical variable information, key dimension information, and filtering conditions. The processing module 803 is configured to: determine that the first transaction data matches the object metadata of the feature object in response to the first transaction data satisfying a first condition; wherein the first condition includes one or more combinations of the following: the scene to which the first transaction data belongs matches the feature scene information; the first transaction data satisfies the filtering conditions; the value of the first transaction data under the variable indicated by the statistical variable information is not empty; the value of the first transaction data under the dimension indicated by the key dimension information is not empty.

[0123] In one possible implementation of this disclosure, the processing module 803 is configured to: call the first target script in the target memory through the feature execution module to execute at least one atomic operation corresponding to the feature processing logic, so as to perform feature processing on the first transaction data and obtain feature results.

[0124] In one possible implementation of this disclosure, the feature processing device 800 includes: The generation module is used to generate a unique key for the first transaction data based on the object's metadata.

[0125] The storage module is used to store the characteristic results of the first transaction data based on a unique key.

[0126] In one possible implementation of this disclosure, the number of feature objects is at least one, the feature results are stored in a target memory, and the feature processing device 800 includes: The first determining module is configured to, in response to receiving second transaction data for feature query, determine a second target feature object that matches the second transaction data from at least one feature object based on the object metadata of at least one feature object through the feature running module.

[0127] The query module is used to query the target storage based on the object metadata of the second target feature object through the feature running module to obtain the target feature result.

[0128] The second determination module is used to determine the feature query results based on the target feature results through the feature execution module.

[0129] In one possible implementation of this disclosure, the target feature result is at least one; the second determining module is configured to: call a second target script in the target memory, perform a lightweight calculation on the at least one target feature result to obtain a calculation result; and determine the calculation result as a feature query result.

[0130] It should be noted that the feature processing apparatus provided in this embodiment is capable of achieving the above-mentioned... Figures 1 to 5 All method steps implemented in the method embodiment can achieve the same technical effect. Therefore, the parts that are the same as those in the method embodiment and their beneficial effects will not be described in detail here.

[0131] To implement the above embodiments, this disclosure also proposes an electronic device, wherein the electronic device can be any device with computing capabilities, the electronic device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, it implements the feature processing method proposed in the first aspect of the present disclosure.

[0132] As an example, Figure 9 This is a schematic diagram of the structure of an electronic device 900 as shown in an exemplary embodiment of this disclosure, as follows: Figure 9 As shown, the aforementioned electronic device 900 may further include: The system includes a memory 910 and a processor 920, and a bus 930 connecting different components (including the memory 910 and the processor 920). The memory 910 stores a computer program, and when the processor 920 executes the program, it implements the feature processing method described in the embodiments of this disclosure.

[0133] Bus 930 represents one or more of several bus architectures, including a memory bus or memory controller, a peripheral bus, a graphics acceleration port, a processor, or a local bus using any of the various bus architectures. For example, these architectures include, but are not limited to, the Industry Standard Architecture (ISA) bus, the Micro Channel Architecture (MAC) bus, the Enhanced ISA bus, the Video Electronics Standards Association (VESA) local bus, and the Peripheral Component Interconnect (PCI) bus.

[0134] Electronic device 900 typically includes a variety of electronic device readable media. These media can be any available media that can be accessed by electronic device 900, including volatile and non-volatile media, removable and non-removable media.

[0135] The memory 910 may also include computer system readable media in the form of volatile memory, such as random access memory (RAM) 940 and / or cache memory 950. The server 900 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, the storage system 960 may be used to read and write non-removable, non-volatile magnetic media (…). Figure 9 Not shown; usually referred to as a "hard drive"). Although Figure 9As not shown, a disk drive for reading and writing to a removable non-volatile disk (e.g., a "floppy disk") and an optical disk drive for reading and writing to a removable non-volatile optical disk (e.g., a CD-ROM, DVD-ROM, or other optical media) may be provided. In these cases, each drive may be connected to bus 930 via one or more data media interfaces. Memory 910 may include at least one program product having a set (e.g., at least one) of program modules configured to perform the functions of the embodiments of this disclosure.

[0136] A program / utility 980 having a set (at least one) of program modules 970 may be stored in, for example, memory 910. Such program modules 970 include—but are not limited to—an operating system, one or more application programs, other program modules, and program data. Each or some combination of these examples may include an implementation of a network environment. Program modules 970 typically perform the functions and / or methods described in the embodiments of this disclosure.

[0137] Electronic device 900 can also communicate with one or more external devices 990 (e.g., keyboard, pointing device, display 991, etc.), and with one or more devices that enable a user to interact with electronic device 900, and / or with any device that enables electronic device 900 to communicate with one or more other computing devices (e.g., network card, modem, etc.). This communication can be performed via input / output (I / O) interface 992. Furthermore, electronic device 900 can also communicate with one or more networks (e.g., local area network (LAN), wide area network (WAN), and / or public networks, such as the Internet) via network adapter 993. As shown, network adapter 993 communicates with other modules of electronic device 900 via bus 930. It should be understood that, although not shown in the figures, other hardware and / or software modules can be used in conjunction with electronic device 900, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.

[0138] The processor 920 performs various functional applications and data processing by running programs stored in the memory 910.

[0139] It should be noted that the implementation process and technical principles of the electronic device in this embodiment are explained in the foregoing description of the feature processing method of the present disclosure embodiment, and will not be repeated here.

[0140] To implement the above embodiments, this disclosure also proposes a non-transitory computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the feature processing method proposed in any of the foregoing embodiments of this disclosure.

[0141] To implement the above embodiments, this disclosure also proposes a computer program product that, when the instructions in the computer program product are executed by a processor, performs the feature processing method as proposed in any of the foregoing embodiments of this disclosure.

[0142] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this disclosure. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0143] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this disclosure, "a plurality of" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0144] Any process or method description in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing custom logic functions or processes, and the scope of preferred embodiments of this disclosure includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as will be understood by those skilled in the art to which embodiments of this disclosure pertain.

[0145] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable medium may be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0146] It should be understood that various parts of this disclosure can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0147] Those skilled in the art will understand that all or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0148] Furthermore, the functional units in the various embodiments of this disclosure can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0149] The storage medium mentioned above can be a read-only memory, a disk, or an optical disk, etc. Although embodiments of the present disclosure have been shown and described above, it is to be understood that the above embodiments are exemplary and should not be construed as limiting the present disclosure. Those skilled in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of the present disclosure.

Claims

1. A feature processing method, characterized in that, The method includes: In response to configuration operations on the feature configuration page of the feature management module, obtain the object metadata of the feature object to be built; The feature object is constructed by the feature management module based on the object metadata; The feature processing module performs feature processing on the first transaction data used for feature processing based on the object metadata of the feature object to obtain the feature result.

2. The method according to claim 1, characterized in that, The object metadata includes a tool name, which indicates the corresponding feature processing logic. The number of feature objects is at least one. The feature processing module performs feature processing on the first transaction data for feature processing based on the object metadata of the feature objects to obtain feature results, including: The feature execution module determines a first target feature object that matches the first transaction data from the at least one feature object based on the object metadata of at least one feature object. The feature processing module uses the feature processing logic indicated by the tool name in the object metadata of the first target feature object to process the first transaction data to obtain the feature result.

3. The method according to claim 2, characterized in that, The step of determining a first target feature object matching the first transaction data from the at least one feature object through the feature operation module, based on the object metadata of at least one feature object, includes: For any of the aforementioned feature objects, the feature execution module determines whether the first transaction data matches the object metadata of the feature object; In response to the matching of the first transaction data with the object metadata of the feature object, the feature execution module determines that the feature object is the first target feature object.

4. The method according to claim 3, characterized in that, The object metadata also includes feature scene information, statistical variable information, key dimension information, and filtering conditions. Determining whether the first transaction data matches the object metadata of the feature object includes: In response to the first transaction data satisfying the first condition, it is determined that the first transaction data matches the object metadata of the feature object; The first condition includes one or more combinations of the following: The scenario to which the first transaction data belongs matches the characteristic scenario information; The first transaction data satisfies the filtering conditions; The first transaction data has a non-empty value under the variable indicated by the statistical variable information; The value of the first transaction data under the dimension indicated by the key dimension information is not empty.

5. The method according to claim 2, characterized in that, The step of using the feature processing module to perform feature processing on the first transaction data, employing the feature processing logic indicated by the tool name in the object metadata of the first target feature object, to obtain the feature result includes: The feature execution module calls the first target script in the target memory to execute at least one atomic operation corresponding to the feature processing logic, so as to perform feature processing on the first transaction data and obtain the feature result.

6. The method according to claim 1, characterized in that, The method further includes: Generate a unique key for the first transaction data based on the object metadata; Based on the unique key, the feature results of the first transaction data are stored.

7. The method according to claim 1, characterized in that, The number of the feature objects is at least one, the feature results are stored in the target memory, and the method further includes: In response to receiving second transaction data for feature query, the feature execution module determines a second target feature object that matches the second transaction data from the at least one feature object based on the object metadata of at least one feature object; The feature execution module queries the target storage based on the object metadata of the second target feature object to obtain the target feature result. The feature query result is determined by the feature execution module based on the target feature result.

8. The method according to claim 7, characterized in that, The target feature result is at least one; the step of determining the feature query result based on the target feature result includes: The second target script in the target memory is invoked to perform lightweight calculations on at least one of the target feature results to obtain the calculation results. The calculation result is determined as the feature query result.

9. A feature processing system, characterized in that, The system includes a feature management module and a feature execution module, wherein: The feature management module is used to respond to the configuration operation on the feature configuration page, obtain the object metadata of the feature object to be constructed, and construct the feature object based on the object metadata; The feature processing module is used to process the first transaction data for feature processing based on the object metadata of the feature object to obtain the feature result.

10. A feature processing apparatus, characterized in that, The device includes: The acquisition module is used to obtain the object metadata of the feature object to be built in response to the configuration operation on the feature configuration page of the feature management module; The construction module is used to construct the feature object based on the object metadata through the feature management module; The processing module is used to process the first transaction data for feature processing based on the object metadata of the feature object through the feature running module to obtain the feature result.

Images