Computational logic processing method, electronic device and readable storage medium

Abstract

This application relates to the field of computer software and discloses a method for processing computational logic, an electronic device and a readable storage medium. The computational logic processing method provided by this application is used in an electronic device including a server side and a client side, in which the client side obtains input data and configuration data and sends them to the server side, the server side analyzes the configuration data, generates a static computation subgraph, connects the input data and the static computation subgraph to generate a dynamic computation subgraph, and finally executes the dynamic computation subgraph to obtain a computation result, thereby realizing the decoupling of the computational logic and the input data, realizing the reuse of the computational logic, and improving the development efficiency of software developers. In addition, the computational logic is realized, configured, managed and operated in an independent manner, so that errors in the realization of the computational logic are independent of the application module, thereby improving the maintainability of the application module.

Description

[Technical Field]

[0001] This application claims priority to a Chinese patent application filed with the China Patent Office on October 18, 2021, bearing application number 202111211756.7 and entitled "Computational logic processing method, electronic device and readable storage medium," the entire contents of which are incorporated herein by reference.

[0002] This application relates to the field of financial software, and in particular to methods of processing computational logic, electronic devices and readable storage media. [Background technology]

[0003] Currently, in both the field of online transaction processing and the field of big data processing, the computational logic used in data processing processes, such as computational processes, computational rules, and computational formulas, are often realized by encoding them in a programming language, and the realization of computational logic by encoding methods places high demands on computational logic developers.In addition, the realization of the same computational logic in different data processing applications is diverse, which is disadvantageous to the maintenance of data processing applications.

[0004] In the field of insurance business, some combinational calculation logic is relatively complex, for example, it includes various calculation logics such as decision tree calculation, arithmetic operations, aggregation calculation, calculation condition rules, etc., and the calculation steps of the combinational calculation logic may also change according to the rules. Furthermore, in the calculation process of the logical combinational calculation logic, for example, when creating a new insurance product, it is necessary to newly create new calculation logic, etc., and there are problems in that coding such complex combinational calculation logics is difficult to develop and the work efficiency is low. Summary of the Invention

[0005] The present embodiments provide a method for processing computational logic, an electronic device, and a readable storage medium to solve the problem in the prior art that computational logic must be tightly coupled to an application module and implemented by coding.

[0006] According to a first aspect, embodiments of the present invention provide a method for processing computational logic for use in an electronic device, including a server side and a client side, the method comprising: The client side acquires input data for describing data values ​​required to execute the computational logic, and configuration data for describing the placement information of the computational logic during business processing and the relational information between the computational logics, and transmits the acquired data to the server side; The server side analyzes the configuration data and generates a static computation subgraph, in which the static computation subgraph has computation logic as a node and data flow directions between the computation logics as edges; The server side connects the input data and the static computation subgraph to generate a dynamic computation subgraph; The server side includes executing the dynamic computation subgraph and obtaining the computation result. In a possible implementation of the first aspect, the server side analyzes the configuration data and generates a static computation subgraph, The server side serializes the calculation logic having a hierarchical structure, The server side includes generating a static computation subgraph based on the serialized result.

[0007] In a possible implementation of the first aspect, the server side generates a static computation subgraph based on the serialized result by: The server side involves generating a static computation subgraph based on the serialized result using flow-based programming techniques.

[0008] In a possible implementation of the first aspect, the server side connects input data and a static computation subgraph to generate a dynamic computation subgraph, The server side includes determining, based on the data parameters of the computation logic in the static computation sub-graph, corresponding data values ​​in the input data and connecting the data values ​​to the data parameters.

[0009] In a possible implementation of the first aspect, the server side executes the dynamic computation subgraph and obtains the computation result by: The server side executes a dynamic computation subgraph to obtain an initial computation result, formats the initial computation result based on the format placement information in the configuration data, obtains the formatted data, and uses the formatted data as the computation result.

[0010] In a possible implementation according to the first aspect above, the computational logic includes at least one of a formula, an extension function, a variable, a filter, and a decision tree.

[0011] In a possible implementation of the first aspect above, the input data is in JSON format, and the configuration data is described in a combination of YAML and DSL.

[0012] According to a second aspect, embodiments of the present invention provide an electronic device, the electronic device comprising: a memory for storing instructions to be executed by one or more processors of the electronic device; and a processor for executing the processing method of the computational logic of any one of the first aspect and possible realizations thereof, the processor being one of the processors of the electronic device.

[0013] According to a third aspect, embodiments of the present application provide a readable storage medium having instructions stored thereon that, when executed on an electronic device, cause the electronic device to perform a method of processing computational logic according to any one of the first aspect and possible implementations thereof.

[0014] According to a fourth aspect, an embodiment of the present application is characterized in that it is a computer program product comprising computer programs / instructions which, when executed by a processor, implement a method for processing computational logic according to the first aspect and any one of the various possible implementations according to the first aspect.

[0015] The computational logic processing method provided in the embodiments of the present application is used in an electronic device including a server side and a client side, in which the client side obtains input data and configuration data and sends them to the server side, the server side analyzes the configuration data to generate a static computation subgraph, then connects the input data and the static computation subgraph to generate a dynamic computation subgraph, and finally executes the dynamic computation subgraph to obtain the computation result, thereby realizing the decoupling of the computational logic and the input data, realizing the reuse of the computational logic, and improving the development efficiency of software developers. In addition, the computational logic is realized, configured, managed, and operated in an independent manner, so that errors in the realization of the computational logic are independent of the application module, thereby improving the maintainability of the application module. [Brief explanation of the drawings]

[0016] [Figure 1] FIG. 1 is a scene diagram illustrating the processing of computational logic according to some embodiments of the present application. [Figure 2] FIG. 2 is a schematic diagram illustrating some example computational logic according to some embodiments of the present application. [Figure 3] FIG. 3 is a diagram illustrating a hardware configuration of an electronic device according to some embodiments of the present application. [Figure 4] FIG. 4 is a flowchart illustrating a method of operation of computational logic according to some embodiments of the present application. [Figure 5] FIG. 5 is a schematic diagram illustrating the format of input data according to some embodiments of the present application. [Figure 6]FIG. 6 is a diagram illustrating an example of configuration data for calculating insurance premiums, according to some embodiments of the present application. DETAILED DESCRIPTION OF THE INVENTION

[0017] Exemplary embodiments of the present application include, but are not limited to, computational logic processing methods, electronic devices, and readable storage media.

[0018] As used herein, the term "module" should be understood to refer to or include, or be part of, an application-specific integrated circuit (ASIC), electronic circuitry, processors (shared, dedicated, or group) and / or memory that execute one or more software or firmware programs, combinatorial logic circuitry, and / or other suitable hardware components that provide the described functionality.

[0019] In each embodiment of the present application, the processor may be a microprocessor, a digital signal processor, a microcontroller, etc., and / or any combination thereof. It should be understood that, according to other aspects, the processor may be a single-core processor, a multi-core processor, etc., and / or any combination thereof.

[0020] It should be understood that the computational logic processing method of the present application is applicable to a situation where a computational logic flow consisting of various kinds of computational logic is calculated.

[0021] Hereinafter, the embodiments of the present application will be described in more detail with reference to the drawings. 1 illustrates a scenario in which a computation logic flow consisting of various computation logics is computed according to some embodiments of the present application. As shown in FIG. 1, a user 100 provides input data and configuration data to an application module 200. The application module 200 receives the input data and configuration data and transmits them to a computation engine 300 for computation. The computation engine 300 returns the computation results obtained after the computation to the application module 200. The application module 200 performs subsequent processing based on the returned computation results or presents them to the user 100.

[0022] Computational Logic (CL) refers to elements related to calculations required to realize business functions in a business application, and may include, but is not limited to, calculation processes, calculation rules, and calculation formulas. Specifically, some basic computational logics include, for example, calculation formulas, extension functions, variables, filters, and decision trees. Computational logics typically include data parameters, and the computational logic performs calculations based on the assignment of the data parameters to obtain specific computational logic results.

[0023] The user 100 may be someone familiar with software item operations or a professional software developer. The user 100 provides prepared input data and configuration data to the application module 200. Here, the input data is a specific data value used as an assignment value for a data parameter in a computational logic. The configuration data is used to configure a complex business process that includes various computational logics and includes related configuration information and data parameters for the various computational logics. However, the configuration data does not include data values ​​used in the specific calculations of the computational logics. Separating the configuration data from the input data enables decoupling of the computational logic and the input data, thereby enabling the reuse of business processes, avoiding repeated development of the same business process, and improving the work efficiency of software developers.

[0024] The application module 200 is configured to acquire input data and configuration data provided by the user 100. The acquisition method may be various, including, but not limited to, acquisition via an interface, acquisition in file format, or acquisition according to a user selection. For example, the application module 200 may provide an input data interface and a configuration data interface to the user 100, and the user 100 may input relevant data through the input data interface and the configuration data interface. After the user 100 has completed the input, the input data interface and the configuration data interface may submit the data entered by the user to the application module 200. The user 100 may store the input data and configuration data in a data file in advance and submit the data file to the application module 200, which may then parse the data file to obtain the input data and configuration data. The application module 200 may provide the user 100 with multiple predefined configuration data templates, and the configuration data template selected or modified by the user 100 may be used as the configuration data.

[0025] After receiving input data and configuration data, the application module 200 transmits the input data and configuration data to the calculation engine 300 for calculation. The calculation engine 300 may perform abstraction processing on various calculation logics, and may obtain calculation results by substituting the input data into the calculation logic defined in the configuration data. The input data processed by the calculation engine 300 may have different data structures, including, but not limited to, a hierarchical structure, a list structure, etc.

[0026] 2 shows examples of some calculation logics that can be supported by the calculation engine 300, including List, Item (list item), Filter, Dtree (decision tree), Var (variable), Expr (expression), etc., where the calculation logic of an expression may further include function calculation logic such as max (maximum value), min (minimum value), sum (total), sumif (sum of numbers matching a condition), round (rounding), etc. The user 100 may use one or more of these calculation logics in the configuration data, and when using multiple calculation logics, the user 100 may configure the multiple calculation logics in the configuration data in the form of a calculation logic flow.

[0027] Finally, the calculation engine 300 returns the calculation result of the calculation logic to the application module 200, which then performs subsequent processing. The application module 200 may use the calculation result as input data for subsequent processing, or may directly present the calculation result to the user.

[0028] The method provided by the technical means of the present application executes configuration data and input data including computational logic on a independently installed computation engine 300, thereby enabling computational logic originally distributed across multiple application modules 200 to be centrally executed on the computation engine 300. The computational logic operations are centrally implemented on the computation engine 300, eliminating the need for software developers to repeatedly implement computational logic for each application module 200, thereby reducing the software developer's workload and improving the development efficiency of software applications. Furthermore, the computation engine 300 centrally manages the implementation and execution of computational logic, improving the maintainability of software applications. If an error is found in the implementation of computational logic, it is sufficient to correct it on the computation engine 300, and the corrected, accurate implementation can be applied to multiple application modules 200, making maintenance of the application modules 200 more convenient.

[0029] 3 is a block diagram illustrating a hardware configuration of an electronic device 30 for implementing a computational logic processing method according to some embodiments of the present application. In the embodiment shown in FIG. 2, the electronic device 30 may include one or more processors 301, system control logic 302 connected to at least one of the processors 301, system memory 303 connected to the system control logic 302, non-volatile memory (NVM) 304 connected to the system control logic 302, and a network interface 306 connected to the system control logic 302.

[0030] In some embodiments, processor 301 may include one or more single-core or multi-core processors. In some embodiments, processor 301 may include any combination of general-purpose and special-purpose processors (e.g., graphics processors, application processors, baseband processors, etc.). In embodiments in which electronic device 30 employs an enhanced base station (Evolved Node B, eNB) or a Radio Access Network (RAN) controller, processor 301 may be configured to perform various applicable embodiments. For example, processor 301 may be used to execute computational logic processing methods.

[0031] In some embodiments, system control logic 302 may include any suitable interface controller to provide any suitable interface to at least one of processors 301 and / or any suitable device or component that communicates with system control logic 302.

[0032] In some embodiments, system control logic 302 may include one or more memory controllers to provide an interface connected to system memory 303. System memory 303 may be used to load and store data and / or instructions. For example, system memory 303 may load instructions for parsing computational logic in embodiments of the present invention, or may store input data, configuration data, etc.

[0033] In some embodiments, the system memory 303 of the electronic device 30 may include any suitable volatile memory, such as a suitable Dynamic Random Access Memory (DRAM).

[0034] NVM memory 304 may include one or more tangible, non-transitory computer-readable media for storing data and / or instructions. In some embodiments, NVM memory 304 may include any suitable non-volatile memory, such as flash memory, and / or any suitable non-volatile storage device, for example, at least one of a hard disk drive (HDD), a compact disc (CD) drive, and a digital versatile disc (DVD) drive. In some embodiments, NVM memory 304 may be used to store input data and configuration data obtained by application modules.

[0035] NVM memory 304 may comprise some storage resources on the apparatus in which electronic device 30 is implemented or may be accessed by the device, but is not necessarily part of the device. For example, NVM memory 304 may be accessed over a network via network interface 306.

[0036] In particular, system memory 303 and NVM memory 304 may include temporary and permanent copies, respectively, of instructions 305. Instructions 305 may include instructions that, when executed by at least one of processors 301, cause electronic device 30 to perform the method shown in Figure 3. In some embodiments, instructions 305, hardware, firmware, and / or software components thereof may be located in addition to or alternatively to system control logic 302, network interface 306, and / or processor 301.

[0037] The network interface 306 may include a transceiver for providing a wireless interface to the electronic device 30 and may further communicate with any other suitable devices (e.g., a front-end module, an antenna, etc.) over one or more networks. In some embodiments, the network interface 306 may be integrated with other components of the electronic device 30. For example, the network interface 306 may be integrated with at least one of the system memory 303, the NVM memory 304, and a firmware device (not shown) having instructions of the processor 301, which, when executed by at least one of the processors 301, may cause the electronic device 30 to implement the methods illustrated in the method embodiments. In this embodiment, the network interface 306 may be used to receive input data and configuration data sent from application modules.

[0038] Network interface 306 may further include any suitable hardware and / or firmware to provide a multiple-input, multiple-output wireless interface. For example, network interface 306 may be a network adapter, a wireless network adapter, a telephone modem, and / or a wireless modem.

[0039] In some embodiments, at least one of the processors 301 may be packaged together with one or more controller logic for the system control logic 302 to form a System In a Package (SiP). In some embodiments, at least one of the processors 301 may be integrated on the same die as one or more controller logic for the system control logic 302 to form a System on Chip (SoC).

[0040] The electronic device 30 may further include an input / output (I / O) device 307. The I / O device 307 may include a user interface that allows a user to interact with the electronic device 30. The design of the peripheral component interface also allows peripheral components to interact with the electronic device 30. 3 may not constitute a specific limitation of electronic device 30. In other embodiments of the present application, electronic device 30 may include more or fewer components than shown, may combine some components, may separate some components, or may have different component arrangements. The components shown may be implemented in hardware or software, or a combination of software and hardware. Hereinafter, referring to the structure shown in Figure 3 above, the technical means of the present application will be introduced in detail based on Figure 4 in conjunction with specific scenarios. As shown in Figure 3, in some embodiments of the present application, the technical means of the computational logic processing method includes the following steps:

[0041] S401: The client side provides input data and configuration data to the server side. The client side is used to obtain input data and configuration data for computing the computational logic, and may be a module or component in a software application. The server side is used to receive the input data and configuration data sent from the client side, and perform corresponding computational logic operations based on the input data and configuration data to obtain computation results. The hardware devices corresponding to the server side and the client side may be electronic devices 30.

[0042] In some embodiments of the present application, the user 100 may simultaneously provide the client side with input data and corresponding configuration data, or may provide only the input data to the client side and the configuration data may be generated by the client side. Here, the client side may generate the configuration data in various ways. For example, the client side may generate the configuration data using a pre-developed configuration data template as is, or may generate the configuration data based on the results of modifications made to the configuration data template by the user 100.

[0043] In addition, the client side may provide the user 100 with a corresponding input interface and configuration interface to facilitate the user 100 to input relevant data. The input interface and configuration interface may be a graphical interface, and may further provide a graphical guide process for the relevant data input process, thereby guiding the user 100 to complete the input of input data and configuration data, and reducing the possibility of errors occurring in the input process.

[0044] In some embodiments of the present application, the format of the input data may have various formats, including, but not limited to, XML format, JSON format, etc. After receiving the input data provided by the user 100, the client side may convert the input data into a unified data format used by the client side. For example, if the input data provided by the user 100 is in XML format, the client side may convert the input data from XML format to JSON format. The client side may also directly use the format of the input data. For example, if the input data provided by the user 100 is in JSON format, the client side may use the JSON format input data as is.

[0045] FIG. 5 shows an example of the format of input data in some embodiments of the present application. As shown in FIG. 5, [key] represents the name of a specific data parameter in the input data, and the name of the data parameter may be written using any character string. For example, the name of one data parameter is "username." Here, the data parameter corresponds to a data parameter of the same name in the configuration data, and the data value corresponding to the data parameter in the input data is used to substitute for the parameter of the same name in the configuration data in the calculation process of the computational logic. [value] represents the data value corresponding to the data parameter, and the data value may be a character string consisting of any letters and numbers.

[0046] The input data may define multiple data parameters and corresponding data values. In Figure 5, they are represented in the form "...":"...". Items are keywords in the input data and are used to describe data organized in a hierarchical structure in the input data. [id] in items is a unique identifier that represents one item, and the corresponding item can be determined by the unique identifier, which may be a string of any letters and numbers. The meanings of [key] and [value] in items are almost the same as those above, except for the different scope of their effect: [key] and [value] in items are only used within the scope of items, while the above [key] and [value] are used throughout the entire scope of the input data.

[0047] Configuration data can also be expressed in a variety of formats, such as XML or JSON. To facilitate the description of computational logic and the corresponding computation graph, some embodiments of this application use a combination of YAML and a DSL to describe configuration data. YAML is a data-centric configuration file language that provides a universal data serialization format, making it very convenient for humans to read and write data. YAML supports three data structures: objects, sequences, and scalars. An object is a collection of key / value pairs, a sequence is a set of ordered values, and a scalar is a single, non-subdivisible value. The basic grammar rules of the YAML language are case-sensitive, use indentation to represent hierarchical relationships, and do not allow the use of tabs for indentation; only spaces are allowed. The number of indented spaces is not significant, as long as elements of the same hierarchy are aligned to the left.

[0048] A Domain Specific Language (DSL) is a computer language that is specialized for a certain business domain, such as finance or insurance. DSLs allow domain experts to describe all business activities and rules in a business domain in a simple programming style, thereby improving the readability of software code and enabling better communication between software developers and domain experts.

[0049] In this embodiment, configuration data is configured by combining YAML and DSL, providing simple grammar characteristics for configuring configuration data in the financial and insurance fields, making it easy to learn and master, reducing the learning curve for users 100, and improving the efficiency of users 100 in developing configuration data.

[0050] FIG. 6 illustrates an example of configuration data for calculating insurance premiums in some embodiments of the present application. As shown in FIG. 6, app is used to describe the name corresponding to the configuration data, i.e., "policy premium calculation." The name of the configuration data is typically used to support visualization of the calculation process of the calculation logic. The main keyword, immediately following the app keyword, is used to indicate the start of the calculation process of the calculation logic. The calculation process of the calculation logic may include multiple calculation steps, which are defined using the steps keyword. A calculation step may include various types of calculation logic, such as the calculation logic list in the figure. The calculation logic has a corresponding name. In some embodiments of the present application, the name of the calculation logic may be explicitly or implicitly given. For example, the name of the calculation logic list in the figure is displayed as "name:policies," and the name of the calculation logic var in the figure is implicitly given rather than directly given. Similarly, the name of the calculation logic may also be used to support visualization of the calculation process of the calculation logic.

[0051] In some embodiments of the present application, the computation logic may further include sub-computation logic, which performs subsequent processing on the output data of the computation logic. As shown in FIG. 6, a computation logic list includes sub-computation logic items, which can process the output data of the list. The computation logic list may also include multiple sub-computation logic items, and each item may be executed in parallel to improve execution efficiency. Here, to specify items involved in parallel computation, a filter keyword may be used to filter conditions. Items that satisfy the filtering condition will perform the corresponding calculation. The name of the filter in FIG. 6 is "calc own damage part," and the filtering condition is whether the data parameter code in the item is equal to the predefined value OD_COMP. Code is a data parameter defined in the input data. If the filtering condition is met, i.e., the code value is OD_COMP, the dynamic computation graph named "own damage part" is executed.

[0052] The dynamic computation graph is defined with the graphs keyword, and the computation logic for completing various insurance premium calculations is defined in the dynamic computation graph. This includes var, decisiontree, and expr, with the calculation logic round being further used in expr. As can be seen from the content of the figure, an insurance premium calculation process includes calculating the insurance premium rate and the insurance premium. The insurance premium rate calculation is completed using the computation logic decisiontree, and the insurance premium calculation is completed using the computation logic expr. The value SumInsuredRate corresponding to the computation logic decisiontree is a reference name for the defined data in the external data source. The external data source may be, for example, an Excel file, which defines various calculation formulas and corresponding data for calculating insurance premium rates. Each calculation formula and the corresponding result data are provided with a corresponding reference name for external access.

[0053] In some embodiments of the present application, the configuration data may include a computational configuration related to the computational process of the computational logic, or a specific configuration corresponding to a specific computational logic. A specific configuration corresponds only to a specific computational logic, and other computational logics do not correspond to the specific configuration. For example, for the computational logic "decisiontree," a typical configuration method involves configuring it in an Excel file. The content of the Excel file must include the specific configuration required to build a decision tree, while the computational logic "expr" does not have the specific configuration required to build a decision tree.

[0054] S402: The server side analyzes the configuration data and constructs a static computation subgraph. After receiving the configuration data sent from the client side, the server side analyzes the configuration data and constructs a static computation subgraph based on the analysis result.

[0055] In some embodiments of the present application, the server side analyzes the configuration data by serializing the hierarchical computation logic in the configuration data and then constructing a static computation subgraph based on the serialized result. The serialization here refers to converting the hierarchical computation logic into sequential computation logic. For example, a hierarchical computation logic list may include multiple steps, one of which includes item computation logic. After analyzing the configuration data on the server side, the computation logic list and items can be serialized into an ordered array (i.e., an actual calculation procedure). The array obtained after serialization is used to construct a static computation subgraph using flow-based programming (FBP). Flow-based programming is a dataflow programming paradigm and a component-based software engineering method. Flow-based programming views a software application as a set of processes, with processes communicating with each other through connections and processes being accessed and connected through ports. This approach is similar to communication over a computer network. Flow-based programming transforms data using different components, which are essentially modules or functions of a package, and data flow is communicated between components by an inter-process communication system. In flow-based programming, a software application is represented as a directed graph, with the processes within it being represented as nodes of the directed graph and the connections between processes being represented as edges of the directed graph.

[0056] Here, the static computation subgraph is a directed graph with computation logic as nodes and the direction of data flow between computation logic as edges. The static computation subgraph is not the final computation link and some information is missing. For example, to perform parallel computation on a computation logic item, it is necessary to know the input data corresponding to the item, but the input data is not included in the configuration data. Furthermore, to execute the computation graph (graph) using a filter (filter), it is necessary to know whether the input data corresponding to the graph contains the data parameter (code) and whether the data value of (code) is equal to the preset value (OD_COMP).

[0057] S403: The server side connects the input data with the static computation subgraph and determines the computation link. After obtaining the static computation subgraph on the server side, input data is connected to the static computation subgraph to obtain a dynamic computation subgraph, i.e., a computation link, containing complete information. Here, connecting input data to the static computation subgraph means associating a location in the static computation subgraph that requires specific data with accurate data among the input data. For example, since a data parameter in the static computation subgraph requires a specific data value, the data specified by the data parameter name among the input data is associated with the position of the data parameter in the static computation subgraph. The input of accurate data is completed by the computation logic in the static computation subgraph. For example, a computation logic item creates a corresponding number of coroutines according to the number of computation logic items, and completes the connection of the static computation subgraph corresponding to the item. In addition, the computation logic filter determines whether the data value of the data parameter in the input data satisfies the filtering condition, and then determines whether to transmit the data value to the next node in the static computation subgraph or connect it to the corresponding static computation subgraph.

[0058] A node in the dynamic computation subgraph obtained on the server side includes one input port and one output port, and the node receives output data from the previous node via the input port and outputs the computation result after the computation of the computational logic in the node is completed to the next node via the output port, thereby realizing data flow between the nodes.

[0059] S404: The server side executes the calculation link and determines the calculation result. After the server side obtains the calculation link, which is the dynamic calculation subgraph, the dynamic calculation subgraph already has complete information, so there is input data corresponding to the calculation logic in the graph. Therefore, the server side can sequentially execute the calculation logic in the nodes according to the node direction in the dynamic calculation subgraph, and after the execution is completed for all nodes in the dynamic calculation subgraph, the final calculation result can be obtained.

[0060] S405: The server returns the calculation result to the client. Here, the server side may return the calculation result to the client side, and may return the calculation result to the client side as is, or may perform certain processing on the calculation result before returning it to the client side. In some embodiments of the present application, the server side may format the calculation result before returning it to the client side. Specifically, the configuration data may include format placement information for the calculation result, and the server side may format the calculation result based on the format placement information in the configuration data. The formatting process may include, for example, removing intermediate data from the calculation result and converting the names of data parameters in the calculation result. In an embodiment of the present application, the client side provides input data and configuration data to the server side, and if the specific arrangement corresponding to the computational logic in the configuration data, such as the data organization structure of the input data and the data parameter names, meets the corresponding constraints, the computational logic processing process running on the server side is similar to a stateless application and is therefore very suitable for deployment in a serverless architecture mode (serverless).

[0061] Each embodiment of the mechanisms disclosed herein may be implemented in hardware, software, firmware, or a combination of these implementations. Embodiments of the present application may also be implemented as a computer program or program code running on a programmable system, the programmable system including at least one processor, a memory system (including volatile and non-volatile memory and / or storage elements), at least one input device, and at least one output device.

[0062] Program code may be used as input instructions to perform the functions described herein and generate output information. The output information may be applied to one or more output devices, in known fashion. For purposes of this application, a processing system includes any system that has a processor, such as, for example, a Digital Signal Processor (DSP), a microcontroller, an Application Specific Integrated Circuit (ASIC), or a microprocessor.

[0063] The program code may be implemented in a high-level or object-oriented programming language to communicate with a processing system. If desired, the program code may also be implemented in assembly or machine language. In fact, the mechanisms described herein are not limited in scope to any particular programming language. In any case, the language may be a compiled or interpreted language.

[0064] In some cases, the disclosed embodiments may be implemented in hardware, firmware, software, or any combination thereof. The disclosed embodiments may also be implemented as instructions carried on or stored on one or more transitory or non-transitory machine-readable (e.g., computer-readable) storage media and read and executed by one or more processors. For example, the instructions may be distributed over a network or other computer-readable media. As such, a machine-readable medium may include any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer), including, but not limited to, a floppy disk, a compact disk, an optical disk, read-only memory (CD-ROMs), a magneto-optical disk, read-only memory (ROM), random access memory (RAM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-read memory (EEPROM), a magnetic or optical card, flash memory, or tangible machine-readable memory for transmitting information via the Internet in electrical, optical, acoustic, or other forms of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.). As such, a machine-readable medium includes any type of machine-readable medium suitable for storing or transmitting electronic instructions or information in a form readable by a machine (e.g., a computer).

[0065] In the figures, certain structural or method features may be shown in a particular arrangement and / or order. However, it should be understood that such a particular arrangement and / or ordering may not be required. In some embodiments, these features may be arranged in a different manner and / or order than that shown in the illustrative figures. Also, the inclusion of structural or method features in particular figures does not imply that such features are required in all embodiments, and some embodiments may not include these features or may be combined with other features.

[0066] Each unit / module mentioned in each device embodiment of the present application is a logical unit / module. Physically, one logical unit / module may be a single physical unit / module, a part of a single physical unit / module, or a combination of multiple physical units / modules. The physical implementation of these logical units / modules is not the most important aspect; it is the combination of functions realized by these logical units / modules that is the key to solving the technical problem addressed by the present application. Furthermore, in order to emphasize the innovative aspects of the present application, the above device embodiments of the present application do not incorporate units / modules that are not closely related to solving the technical problem addressed by the present application. This does not mean that other units / modules are not present in the above device embodiments.

[0067] It should be noted that in the examples and specification of this patent, relational terms such as "first," "second," etc., are merely used to distinguish one entity or operation from another and do not necessarily require or imply any actual relationship or order between those entities or operations. Furthermore, the terms "comprises," "includes," or any other variations thereof are intended to cover a non-exclusive inclusion, whereby a process, method, article, or device comprising a set of elements not only includes those elements, but also other elements not expressly listed, or further elements inherent in such process, method, article, or device. Absent more limitations, an element qualified by the phrase "comprises ..." does not exclude the presence of other identical elements in a process, method, article, or device that includes the element.

[0068] While the present application has been shown and described with reference to certain preferred embodiments thereof, those skilled in the art will recognize that various changes in form and detail may be made therein without departing from the spirit and scope of the present application.

Claims

1. In a processing system for computational logic including a server side and a client side, the client side acquires input data for describing data values ​​necessary for executing computational logic, and configuration data for describing placement information of the computational logic during business processing and relational information between the computational logics, and transmits the acquired data to the server side; The server side is for analyzing the configuration data and generating a static computation subgraph, and generating the static computation subgraph includes serializing a computation logic having a hierarchical structure and generating the static computation subgraph by a flow-based programming technique based on the serialized result, the computation logic having a hierarchical structure includes a plurality of steps, each step includes a sub-computation logic, the static computation subgraph is represented as a directed graph, the computation logic is a node of the directed graph, and the data flow direction between the computation logics is an edge of the directed graph, The server side is for connecting input data and a static computation subgraph to generate a dynamic computation subgraph, and connecting the input data and the static computation subgraph includes associating a data parameter requiring a data value in the static computation subgraph with a data value corresponding to the data parameter in the input data; The server side executes the dynamic computation subgraph to obtain a computation result.

2. 2. The system of claim 1, wherein the server side is configured to determine a corresponding data value in the input data based on a data parameter of the computation logic in the static computation subgraph and connect the data value to the data parameter.

3. 3. The system of claim 2, wherein connecting the data value to the data parameter comprises assigning the data value to the data parameter in the static computation subgraph.

4. The system of claim 1, wherein the server side is configured to execute the dynamic computation subgraph to obtain an initial computation result, format the initial computation result based on format placement information in the configuration data, and obtain formatted data, wherein the initial computation result is unformatted and includes intermediate data and names of the data parameters.

5. The system according to claim 4, wherein the server side executes the computational logic based on input data corresponding to the computational logic in the dynamic computation subgraph to obtain the elementary computation result.

6. The system of claim 1 , wherein the computational logic includes at least one of a formula, an extension function, a variable, a filter, and a decision tree.

7. 2. The system according to claim 1, wherein the input data is in a JSON format, and the configuration data is described using a combination of YAML and DSL.

Images