Page generation methods, systems, devices, equipment, and storage media

Abstract

This disclosure proposes a page generation method, system, apparatus, device, and storage medium, relating to artificial intelligence technologies such as natural language processing. The method includes: acquiring a first task event from a user terminal and parsing the first task event to obtain its task requirements; acquiring a candidate component library and obtaining at least one set of target components corresponding to the task requirements from the candidate component library; constructing target atomic tasks for each of the at least one set of target components and combining the target atomic tasks to obtain a first target combination task corresponding to the task requirements; and generating a first target task page for the first task event based on the first target combination task. This improves the timeliness of acquiring task requirements from the user terminal, improves the efficiency of content generation by packaging and calling components based on atomic tasks, reduces the development cost for the user terminal, and enhances the practicality and applicability of the target task page generation method.

Description

Technical Field

[0001] This disclosure relates to the field of data processing, and in particular to the field of artificial intelligence technologies such as natural language processing. Background Technology

[0002] With the development of technology, more and more types of client applications are appearing in people's work and life. In this scenario, when people use different types of client applications, each client needs to generate and display different types of page content based on the input user needs. In related technologies, different types of client applications can be developed independently, which is costly. Summary of the Invention

[0003] This disclosure presents a page generation method, system, apparatus, device, and storage medium.

[0004] According to a first aspect of this disclosure, a page generation method is proposed, comprising: acquiring a first task event from a user terminal and parsing the first task event to obtain the task requirements of the first task event; acquiring a candidate component library and acquiring at least one set of target components corresponding to the task requirements from the candidate component library; constructing target atomic tasks for each of the at least one set of target components and combining the target atomic tasks to obtain a first target combined task corresponding to the task requirements; and generating a first target task page for the first task event based on the first target combined task.

[0005] According to a second aspect of this disclosure, a page generation system is proposed, comprising: an access layer, an application layer, a component library, a task component, a listening component, and a generation component, wherein the access layer is used to receive user input information from a user terminal; the listening component is used to listen for task events on the user input information from the user terminal to obtain a first task event from the user terminal; the application layer is used to parse the first task event to obtain the task requirements of the first task event; the task component is used to obtain at least one set of target components corresponding to the task requirements from the component library, and construct target atomic tasks for each of the at least one set of target components; and combine the target atomic tasks to obtain a first target combined task corresponding to the task requirements; the generation component is used to generate a first target task page for the first task event based on the first target combined task.

[0006] According to a third aspect of this disclosure, a page generation apparatus is proposed, comprising: a first acquisition module, configured to acquire a first task event from a user terminal and parse the first task event to obtain the task requirements of the first task event; a second acquisition module, configured to acquire a candidate component library and acquire at least one set of target components corresponding to the task requirements from the candidate component library; a construction module, configured to construct target atomic tasks for each of the at least one set of target components and combine the target atomic tasks to obtain a first target combined task corresponding to the task requirements; and a generation module, configured to generate a first target task page for the first task event based on the first target combined task.

[0007] According to a fourth aspect of this disclosure, an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the page generation method proposed in the first aspect above.

[0008] According to a fifth aspect of this disclosure, a non-transitory computer-readable storage medium storing computer instructions is provided, wherein the computer instructions are used to cause the computer to perform the page generation method proposed in the first aspect above.

[0009] According to a sixth aspect of this disclosure, a computer program product is proposed, comprising a computer program that, when executed by a processor, implements the page generation method proposed in the first aspect above.

[0010] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0011] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0012] Figure 1 This is a schematic flowchart of a page generation method according to an embodiment of the present disclosure;

[0013] Figure 2 This is a schematic diagram of a candidate component library according to an embodiment of the present disclosure;

[0014] Figure 3 This is a schematic flowchart of a page generation method according to another embodiment of the present disclosure;

[0015] Figure 4 This is a schematic flowchart of a page generation method according to another embodiment of the present disclosure;

[0016] Figure 5 This is a schematic diagram of a page generation system according to an embodiment of the present disclosure;

[0017] Figure 6 This is a schematic diagram of the structure of a page generation apparatus according to an embodiment of the present disclosure;

[0018] Figure 7 This is a schematic block diagram of an electronic device according to an embodiment of the present disclosure. Detailed Implementation

[0019] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0020] Data processing is a fundamental aspect of systems engineering and automatic control. Data is a form of expression of facts, concepts, or instructions, which can be processed manually or by automated devices. After data is interpreted and given meaning, it becomes information. Data processing involves the acquisition, storage, retrieval, processing, transformation, and transmission of data. The basic purpose of data processing is to extract and derive valuable and meaningful data from large amounts of potentially chaotic and difficult-to-understand data.

[0021] Natural Language Processing (NLP) is an important field within computer science and artificial intelligence. It studies the theories and methods for enabling effective communication between humans and computers using natural language. NLP is a science that integrates linguistics, computer science, and mathematics. Its main applications include machine translation, public opinion monitoring, automatic summarization, opinion extraction, text classification, question answering, text semantic comparison, speech recognition, and Chinese OCR.

[0022] Artificial Intelligence (AI) is a new branch of computer science that studies and develops theories, methods, technologies, and application systems to simulate, extend, and expand human intelligence. It attempts to understand the essence of intelligence and produce intelligent machines that can react in a way similar to human intelligence. Research in this field includes robotics, speech recognition, image recognition, natural language processing, and expert systems. Since its inception, AI has matured in both theory and technology, and its applications have expanded continuously. It is conceivable that future AI-driven technological products will serve as "containers" of human wisdom. AI can simulate the information processes of human consciousness and thought.

[0023] Figure 1 This is a flowchart illustrating a page generation method according to an embodiment of the present disclosure, as shown below. Figure 1 As shown, the method includes:

[0024] S101, obtain the first task event from the user's end, and parse the first task event to obtain the task requirements of the first task event.

[0025] In this embodiment of the disclosure, the user terminal can receive user input information through the interactive interface provided to the user, and generate corresponding page content based on the user input information to be displayed on the interactive interface. In this scenario, the user input information currently received by the user terminal can be monitored.

[0026] Specifically, based on the monitored user input information, the task event that the user terminal needs to execute in response to the input information can be identified, and the task event can be marked as the first task event.

[0027] Furthermore, the first task event can be parsed using a task event parsing algorithm in related technologies. Based on the result of the algorithm processing, the task requirements of each task that the user needs to execute to realize the first task event can be obtained and marked as the task requirements of the first task event.

[0028] This can be understood as follows: by executing the task corresponding to the task requirement, the user terminal can be placed in the scenario corresponding to the first task event, thereby enabling the user terminal to respond to the received user input information in that scenario.

[0029] S102, obtain the candidate component library, and obtain at least one set of target components corresponding to the task requirements from the candidate component library.

[0030] In this embodiment of the disclosure, the server is provided with a callable component library, which can be marked as a candidate component library. The candidate component library includes multiple candidate components that can be called by the client.

[0031] As an example, such as Figure 2 As shown, in Figure 2 The candidate component libraries shown include a directional component sub-library, a basic component sub-library, and a page component sub-library. The directional component sub-library includes... Figure 2 The cash register component and general bubble component shown are included in the basic component sub-library. Figure 2 The displayed instruction components and download components, as well as the page component sub-library, include history button components and new user guide components.

[0032] exist Figure 2 In the scenario shown, all of the above components can serve as callable candidate components for the user end. Based on these callable candidate components, the following can be obtained: Figure 2 The candidate component library is shown.

[0033] In this scenario, at least one component required by the task to be executed corresponding to the task requirement of the first task event can be obtained from the candidate component library and marked as the target component.

[0034] It should be noted that multiple tasks may need to be executed to achieve the task requirements of the first task event. In this scenario, at least one target component called by each of the multiple tasks can be obtained, and the set of at least one target component of each task can be marked as the target component set corresponding to that task, thereby obtaining the at least one target component set corresponding to the task requirements of the first task event.

[0035] As an example, for Figure 2 The candidate component library shown is configured to meet the task requirements of the first task event. Figure 2 The cashier component, download component, and new user guide component shown are candidate components that need to be called by one of the tasks corresponding to this task requirement. Therefore, these three candidate components can be marked as the three target components that need to be called by this task, thus forming one of the target component sets of this task requirement.

[0036] S103, construct at least one target component set for each of its target atomic tasks, and combine the target atomic tasks to obtain the first target combined task corresponding to the task requirements.

[0037] In this embodiment of the disclosure, a method for constructing atomic tasks in the related art can be obtained, and the functions of each target component in any target component set called can be processed according to the construction method to obtain the atomic tasks generated by the component functions of each target component in the target component set, which are then used as the target atomic tasks of the target component set.

[0038] Furthermore, the target atomic tasks of each target component set are combined into atomic tasks according to the preset atomic task combination method, and the combined task is marked as the first target combination task corresponding to the task requirement.

[0039] As an example, such as Figure 3 As shown, the task requirements for the first task event can be derived from... Figure 3 The candidate component library is shown, and three target component sets are obtained. Then, by calling the component functions of each target component in the target component sets, corresponding atomic tasks are generated, thereby obtaining... Figure 3 Atomic tasks 1, 2, and 3 are shown and labeled as target atomic task 1, target atomic task 2, and target atomic task 3.

[0040] Furthermore, target atomic task 1, target atomic task 2, and target atomic task 3 are combined into atomic tasks to obtain... Figure 3 The target combination task shown is the first target combination task corresponding to the task requirement of the first task event in this example.

[0041] It should be noted that, regarding the method for combining the target atomic tasks, the task execution priority between the target atomic tasks can be obtained, and the combination strategy of the target atomic tasks can be determined based on the task execution priority. Then, the target atomic tasks can be combined according to the combination strategy to obtain the first target combined task.

[0042] Additionally, the execution time of each target atomic task can be obtained, and the combination strategy of each target atomic task can be determined based on the execution time. Then, the atomic tasks of each target atomic task can be combined according to the combination strategy to obtain the first target combined task.

[0043] Furthermore, the target atomic tasks can be combined according to other feasible atomic task combination methods, without specific limitations here.

[0044] S104, Based on the first target combined task, generate the first target task page of the first task event.

[0045] In this embodiment of the disclosure, the first task event can be achieved on the user terminal by executing the first target combination task. When the first task event is achieved on the user terminal, the corresponding page content can be displayed on the user terminal's interactive interface. In this scenario, the page can be marked as the first target task page corresponding to the first task event.

[0046] As an example, if the first task event is set as a payment task event, then by executing the first target combination task corresponding to the first task event, the payment task event can be achieved on the user's end, and then the first target task page corresponding to the payment task event can be displayed on the user's interactive interface.

[0047] Optionally, based on the execution of the first target combination task, the corresponding execution result is obtained, and relevant front-end page display information is obtained from the execution result. The front-end page display information is then processed by a preset page generation algorithm, and the corresponding page is obtained as the first target task page of the first task event corresponding to the first target combination task.

[0048] It should be noted that, regarding the acquisition of the first target task page, one can obtain the page generation format corresponding to the preset first target task page, and then organize the front-end page display information according to the obtained page generation format, and then determine the page obtained after organization as the first target task page. Alternatively, one can obtain other preset page generation methods to process the relevant information to obtain the first target task page. No specific limitation is made here.

[0049] The page generation method proposed in this disclosure obtains the first task event from the user's end, parses it to obtain the corresponding task requirements, obtains at least one set of target components corresponding to the task requirements from the candidate component library, constructs target atomic tasks for each set of target components, combines each target atomic task to obtain a first target combined task, and then generates the first target task page corresponding to the first task event based on the first target combined task. In this disclosure, the corresponding task requirements are obtained by parsing the first task event on the user side, realizing the proactive acquisition of task requirements on the user side and improving the timeliness of task requirement acquisition. At least one set of target components for the task requirements is called from the candidate component library, and the target atomic tasks of each set of target components are combined to obtain the first target combination task. Then, the first target task page is generated by executing the first target combination task. The packaging and calling of components based on atomic tasks improves the efficiency of output content generation. In the microservice scenario, the generation and display of the target task page are realized. In the scenario of generating target task pages for different types of user sides, the target task page is generated by calling the functions of each component in the candidate component library, without the need for separate development work for different types of user sides, reducing the development cost of the user side and improving the practicality and applicability of the target task page generation method.

[0050] In the above embodiments, the generation of the first target task page can be combined with... Figure 4 To understand further, Figure 4This is a flowchart illustrating a page generation method according to another embodiment of the present disclosure, as shown below. Figure 4 As shown, the method includes:

[0051] S401: Obtain the first task event from the user's end and parse the first task event to obtain the task requirements of the first task event.

[0052] Optionally, task events can be listened to on the user's end to obtain the first task event on the user's end.

[0053] In this embodiment of the disclosure, task events can be monitored on the user terminal to obtain the first task event on the user terminal. The input information received by the user terminal can be identified and analyzed according to a preset monitoring channel, and the task event monitoring result of the user terminal can be obtained based on the identification and analysis results.

[0054] As an example, such as Figure 3 As shown, it can be done through Figure 3 The access layer shown receives user input information and, through... Figure 3 The event listening module shown Figure 3 The access layer receives user input information, listens to it, analyzes and identifies the listened input information, and then listens to the first task event from the user's end based on the analysis and identification results.

[0055] It should be noted that, through Figure 3 The access layer shown can receive user input information from various types of user terminals. These various types of user terminals may include mini-program user terminals, Wireless Application Protocol (WAP) user terminals, personal computer (PC) user terminals, and mobile application (APP) user terminals, and may also include other types of user terminals, which are not specifically limited here.

[0056] In this scenario, it is possible to Figure 3 The access layer shown listens for task events for various types of user terminals, thereby obtaining the first task event for each type of user terminal.

[0057] Optionally, AIGC can be used to perform event parsing on the first task event to obtain the task requirements corresponding to the first task event.

[0058] In this embodiment of the disclosure, the first task event can be parsed according to a preset event parsing method, and the task requirements corresponding to the first task event can be obtained through the parsing result.

[0059] One possible approach is to input the first task event into Artificial Intelligence Generated Content (AIGC), use the AIGC's model capabilities to parse the first task event, and then obtain the task requirements of the first task event from the AIGC's output.

[0060] As another possible implementation method, it can be achieved through Figure 3 The application layer configuration of the task event parsing method shown parses the first task event to obtain information about the relevant tasks that need to be executed to achieve the first task event, and thus obtains the task requirements of the first task event.

[0061] in, Figure 3 The application layer shown includes various types of service tools. In this scenario, the application layer can obtain the functions that each of the various types of service tools can implement, and select the relevant functions required to achieve the first task event from these functions. Then, based on these relevant functions, it can determine the task requirements for building the task to be executed.

[0062] It should be noted that, Figure 3 The application layer shown may include service tools corresponding to library services (lib services), service tools corresponding to the Wireless Application Protocol ContentDelivery Protocol (wap-con), service tools corresponding to packages in the Node.js package manager (NodePackage Manager, NPM packages), and service tools corresponding to utility modules (Util tools). It may also include other types of service tools, which are not specifically limited here.

[0063] S402, obtain the candidate component library, and obtain at least one set of target components corresponding to the task requirements from the candidate component library.

[0064] Optionally, the task requirements are broken down to obtain at least one atomic task requirement, and for any atomic task requirement, at least one candidate component matching the atomic task requirement is obtained from the candidate component library to form a target component set for the atomic task requirement.

[0065] In this embodiment of the disclosure, the task requirements can be decomposed according to a preset task requirement decomposition algorithm, and then at least one task requirement for constructing an atomic task can be obtained based on the result of the decomposition process, and marked as at least one atomic task requirement obtained after task requirement decomposition.

[0066] This can be understood as follows: for any atomic task requirement, the set of target components required to execute the atomic task corresponding to the atomic task requirement can be obtained from the candidate component library according to the atomic task requirement, and then the target atomic task corresponding to the atomic task requirement can be generated.

[0067] In this scenario, the component functions required to be called by the target atomic task corresponding to the atomic task requirement can be obtained, and at least one candidate component that supports the component function can be obtained from the candidate component library. The at least one candidate component is the component in the candidate component library that matches the atomic task requirement.

[0068] Furthermore, the at least one candidate component can be the at least one target component that the target atomic task corresponding to the atomic task requirement needs to call, and the set of the at least one target component can be marked as the target component set of the atomic task requirement.

[0069] S403, construct at least one target component set for each of its target atomic tasks, and combine the target atomic tasks to obtain the first target combined task corresponding to the task requirements.

[0070] Optionally, obtain at least one set of candidate interfaces for each target component in the target component set, and the candidate interface call direction for each candidate interface.

[0071] In this embodiment of the disclosure, each candidate component in the candidate component library is provided with a calling interface in different directions. The direction of the calling interface can be understood in conjunction with the following example:

[0072] For example, for the first task event that needs to be achieved on both the mini-program client and the PC client, the configuration information of the calling interface may be different when the two events call the component function of the candidate component. In this example, for the candidate component that both need to be called, two calling interfaces can be set on the candidate component. One interface is used to call the component function of the candidate component when the task event on the mini-program client is called, and the other interface is used to call the component function of the candidate component when the task event on the PC client is called.

[0073] In this example, the calling interface used to invoke the component function of the candidate component by the task event of the mini-program client can be marked as the mini-program client calling direction interface of the candidate component, and the calling interface used to invoke the component function of the candidate component by the task event of the PC client can be marked as the PC client calling direction interface of the candidate component, thus obtaining two calling interfaces with different calling directions set on the candidate component.

[0074] Optionally, for any target component, multiple call interfaces set on the target component can be marked as multiple candidate interfaces of the target component, and the set of multiple candidate interfaces can be marked as the candidate interface set of the target component. In addition, the call direction of each candidate interface in the candidate interface set can be marked as the candidate interface call direction.

[0075] Optionally, for any set of target components, the component functions of each target component in the set of target components are invoked according to the direction of the candidate interface invocation, so as to generate the target atomic task corresponding to the set of target components.

[0076] This allows us to obtain the client type of the client and determine the target call interface for each target component from the candidate interface set based on the client type and the direction of the candidate interface call.

[0077] In this embodiment of the disclosure, when calling the same component function for different types of user terminals, the candidate interface call directions of the calling interfaces used may differ.

[0078] In this scenario, for any target component, the user terminal type corresponding to the first task event can be obtained. The user terminal type can include mini-program user terminal type, PC user terminal type, APP user terminal type and WAP user terminal type, and can also include other user terminal types, which are not specifically limited here.

[0079] Among these features, the current operating scenario of the user terminal can be obtained, and the user terminal type can be identified by the operating scenario. For example, if the operating scenario of the user terminal is PC, it can be determined that the user terminal type is PC user terminal type.

[0080] Optionally, for any target component, the target interface call direction that supports the client type is obtained from the candidate interface call directions of the candidate interface set of the target component.

[0081] In this embodiment of the disclosure, for any target component, the call interface configuration information of the candidate interface call direction of each candidate interface set of the target component can be obtained, as well as the configuration information required by the user terminal type to which the user terminal corresponding to the first task event belongs when making component function calls.

[0082] Furthermore, from the call configuration information of each candidate interface call direction, the configuration information corresponding to the user client type to which the user client belongs is selected, and the candidate interface call direction corresponding to the configuration information is determined as the target interface call direction that supports the user client type.

[0083] Optionally, from the candidate interface set, the candidate interface indicating the target interface call direction is obtained as the target call interface of the target component.

[0084] In this embodiment of the disclosure, for any target component, there is a corresponding relationship between the candidate call interface set of the target component and the candidate interface call direction of each candidate call interface set. In this scenario, after obtaining the target interface call direction, the candidate interface corresponding to the target interface call direction can be obtained from the candidate interface set of the target component. The candidate interface is the target call interface used by the target component when making component function calls.

[0085] Optionally, for any set of target components, the component functions of each target component are invoked through the target invocation interface of each target component set to generate the target atomic task corresponding to the set of target components.

[0086] In this embodiment of the disclosure, the component function call of the target component can be realized through the target call interface of the target component. In this scenario, for any set of target components, after the component function of each target component is called through each target call interface, the component function of each target component is processed by atomic task generation according to the atomic task construction method in the related technology, and then the target atomic task generated based on the component function of each target component set is obtained according to the processing result.

[0087] It should be noted that the method for constructing the target atomic task can be based on atomic operations in related technologies, synchronization primitives in related technologies, or other methods that can construct atomic tasks; no specific limitations are made here.

[0088] Optionally, the task execution order of each target atomic task is obtained, and the target atomic tasks are combined according to the task execution order to obtain the first target combined task.

[0089] In this embodiment of the disclosure, each target atomic task has a set task execution order. In this scenario, each target atomic task can be sorted according to the task execution order, and then each target atomic task can be configured to combine tasks according to a preset task combination method. It can be understood that, through the configuration of relevant information, each target atomic task can be composed of composite tasks or workflows based on the configuration of information.

[0090] In this scenario, the composite task or workflow formed by combining the target atomic tasks based on the task execution order can be marked as the first target composite task.

[0091] As an example, such as Figure 3 As shown, it is possible to obtain Figure 3The execution order of target atomic tasks 1, 2, and 3 is shown. Based on this execution order, target atomic tasks 1, 2, and 3 are combined into a composite task. Then, the... Figure 3 The target combination task shown is a first target combination task composed of target atomic task 1, target atomic task 2 and target atomic task 3.

[0092] S404, input the first target combination task into AIGC, and generate the first target task page of the first task event based on the first target combination task using AIGC's model capabilities.

[0093] In this embodiment of the disclosure, the execution of the first target combination task can achieve the first task event, thereby generating the first target task page corresponding to the first task event.

[0094] One possible implementation is to input the first target combination task into AIGC, execute the first target combination task by calling the model capabilities of AIGC, and then obtain the first target task page corresponding to the first task event from the output of AIGC.

[0095] It should be noted that, in this embodiment of the disclosure, the first target task page can be generated separately for the first task events of multiple user terminals.

[0096] As an example, such as Figure 3 As shown, for Figure 3 The shown mini-program client, wireless application protocol client, personal computer client, and mobile application software client can respectively listen to the first task event of each of the four client and obtain the first target combination task of the first task event of each of the four client.

[0097] Furthermore, the four combined first-objective tasks are input into AIGC, and AIGC's model capabilities output the respective first-objective task pages for each of the four user terminals, as follows: Figure 3 Pages 1, 2, 3, and 4 are shown, where page 1 is the first target task page for the mini-program user, page 2 is the first target task page for the wireless application protocol user, page 3 is the first target task page for the personal computer user, and page 4 is the first target task page for the mobile application software user.

[0098] It should be noted that during the generation of the first target task page, a custom plugin of the preset module packaging tool needs to be used during the compilation process to dynamically modify the references during the compilation process, thereby enabling the calling of the component functions of the relevant target components.

[0099] like Figure 3 As shown, during execution Figure 3 During the compilation process of the target combination task shown, it can be done through Figure 3 The custom plugin for the dynamic packaging tool shown dynamically modifies references during the compilation process, thereby enabling component function calls to the relevant target components and generating a package including... Figure 3 The first target task pages shown are page 1, page 2, page 3, and page 4.

[0100] Optionally, the first target task page can be pushed to the user terminal, and the first target task page can be displayed based on the user terminal's interactive interface.

[0101] In this embodiment of the disclosure, after the first target task page is generated, the first target task page can be pushed to the user terminal based on a preset push channel, and the first target task page can be displayed based on a preset interactive interface on the user terminal. The interactive decryption can be a display screen set on the user terminal.

[0102] In this embodiment of the disclosure, during the display of the first target task page on the user terminal, there may be changes in the task events. In this scenario, it is necessary to adjust and update the first target task page displayed on the user terminal.

[0103] Specifically, it can monitor whether there is a change in the first task event on the user's end, and in response to the detection of a change in the first task event, obtain the changed second task event, and obtain the second target combined task corresponding to the second task event based on the candidate component library.

[0104] In this embodiment of the disclosure, while the first target task page is being displayed on the user's device, the task events on the user's device can continue to be monitored to identify whether there are any changes in the first task events on the user's device.

[0105] Optionally, when a change is detected in the first task event on the user's device, the changed task event can be marked as the second task event. For example, if the first task event is set as a payment event, the task event on the user's device may become a payment completion event after the user completes the payment. In this case, the payment completion event can be marked as the changed second task event.

[0106] In this scenario, when the second task event on the user's end is detected, the second target combination task corresponding to the second task event can be obtained based on the candidate component library. The process of obtaining the second target combination task can be understood in conjunction with the process of obtaining the first target combination task described above, and will not be repeated here.

[0107] Optionally, AIGC generates a second target task page for the second task event based on the second target combined task, and dynamically updates the first target task page based on the second target task page.

[0108] In this embodiment of the disclosure, the second target combination task can be input into AIGC, and the second target combination task can be executed through the model capabilities of AIGC, thereby outputting the target task page corresponding to the second target combination task as the second target task page.

[0109] Furthermore, the second target task page is pushed to the user's terminal. The user's terminal can dynamically update the content of the first target task page based on the received second target task page. This can include updating the text content of the first target task page, as well as updating the buttons on the first target task page, etc., without specific limitations here.

[0110] The page generation method proposed in this disclosure obtains the first task event and the changed second task event by listening to task events on the user side, realizing the proactive acquisition of task events on the user side, improving the efficiency of acquiring task events and the efficiency of recognizing changes in task events on the user side. It generates the corresponding first target task page by combining the target atomic tasks of various target component sets to obtain the first target combination task. Component packaging and invocation based on atomic tasks improve the efficiency of content generation. In a microservice scenario, it achieves the generation and display of target task pages. In scenarios where different types of user terminals need to generate their own target task pages, candidate... Each candidate component in the component library is configured with component call interfaces for different calling directions, allowing different types of user terminals to call component functions based on the adapted call interfaces. This enables the generation of target task pages for different types of user terminals without the need for separate development work for different types of user terminals, reducing the development cost of user terminals. By listening to the second task event and generating the second target task page, the dynamic updating of the first target task page is realized, improving the timeliness of content adjustments to the target task page. This achieves dynamic adaptation between the target task page and user terminal requirements, improves the practicality and applicability of the target task page generation method, and optimizes the user experience.

[0111] This disclosure also proposes a page generation system that can be combined with Figure 5 understand, Figure 5 This is a schematic diagram of a page generation system according to an embodiment of the present disclosure, such as... Figure 5 As shown, the page generation system 500 includes an access layer 51, an application layer 52, a component library 53, a task component 54, a listening component 55, and a generation component 56.

[0112] Access layer 51 is used to receive user input information from the user terminal.

[0113] Listening component 55 is used to listen for task events on the user input information on the user terminal in order to obtain the first task event on the user terminal.

[0114] Application layer 52 is used to parse the first task event to obtain the task requirements of the first task event.

[0115] Task component 54 is used to obtain at least one set of target components corresponding to the task requirements from component library 53, and to construct the target atomic tasks of each of the at least one set of target components.

[0116] Furthermore, the target atomic tasks are combined to obtain the first target combined task corresponding to the task requirements.

[0117] Component 56 is used to generate the first target task page of the first task event based on the first target combined task.

[0118] In this embodiment of the disclosure, the access layer 51 is adapted to various types of user terminals. User input information from the user terminal can be received through the access layer 51. In this scenario, the listening component 55 can listen to task events on the access layer 51 and mark the listened task events on the user terminal as the first task event of that user terminal.

[0119] Optionally, the application layer 52 is equipped with various types of service tools. The application layer 52 can parse the first task event and determine the task requirements corresponding to the tasks to be executed to achieve the first task event based on the functions of each of the various service tools.

[0120] Furthermore, task component 54 obtains at least one target component set from component library 53 according to the obtained task requirements, and generates the target atomic task corresponding to the target component set based on the component functions of each target component in any target component set according to the atomic task generation method in related technologies.

[0121] Optionally, the task execution order of each target atomic task is obtained, and the target atomic tasks are combined according to the task execution order. Then, the composite task or workflow obtained after combination is marked as the first target composite task obtained by combining the target atomic tasks.

[0122] like Figure 5 As shown, the page generation system also includes a generation component 56, which can input the first target combination task into AIGC, execute the first target combination task through the model capability of AIGC, and then obtain the first target task page corresponding to the first task event from the output of AIGC.

[0123] The page generation system proposed in this disclosure obtains the first task event and the changed second task event by listening to task events performed on the user terminal, thereby achieving proactive acquisition of task events on the user terminal, improving the efficiency of task event acquisition and the efficiency of identifying changes in task events on the user terminal. It generates the corresponding first target task page by combining the target atomic tasks of various target component sets to obtain the first target combination task. Based on atomic tasks, it packages and calls components, improving the efficiency of content generation. In a microservices scenario, it achieves the generation and display of target task pages. In scenarios where different types of user terminals' target task pages are generated, candidate... Each candidate component in the component library is configured with component call interfaces for different calling directions, allowing different types of user terminals to call component functions based on the adapted call interfaces. This enables the generation of target task pages for different types of user terminals without the need for separate development work for different types of user terminals, reducing the development cost of user terminals. By listening to the second task event and generating the second target task page, the dynamic updating of the first target task page is realized, improving the timeliness of content adjustments to the target task page. This achieves dynamic adaptation between the target task page and user terminal requirements, improves the practicality and applicability of the target task page generation method, and optimizes the user experience.

[0124] An embodiment of this disclosure also proposes a page generation apparatus. Since the page generation apparatus proposed in this disclosure corresponds to the page generation methods proposed in the above embodiments, the implementation methods of the above page generation methods are also applicable to the page generation apparatus proposed in this disclosure, and will not be described in detail in the following embodiments.

[0125] Figure 6 This is a schematic diagram of the structure of a page generation apparatus according to an embodiment of the present disclosure, as shown below. Figure 6 As shown, the page generation device 600 includes a first acquisition module 61, a second acquisition module 62, a construction module 63, and a generation module 64, wherein:

[0126] The first acquisition module 61 is used to acquire the first task event from the user terminal and parse the first task event to obtain the task requirements of the first task event.

[0127] The second acquisition module 62 is used to acquire a candidate component library and acquire at least one set of target components corresponding to the task requirements from the candidate component library;

[0128] The construction module 63 is used to construct at least one set of target components for their respective target atomic tasks, and to combine the target atomic tasks to obtain the first target combined task corresponding to the task requirements.

[0129] The generation module 64 is used to generate the first target task page of the first task event based on the first target combined task.

[0130] In this embodiment of the disclosure, the first acquisition module 61 is further configured to: listen for task events on the user terminal to obtain a first task event on the user terminal; and perform event parsing on the first task event through AIGC to obtain the task requirements corresponding to the first task event.

[0131] In this embodiment of the disclosure, the second acquisition module 62 is further configured to: decompose the task requirements to obtain at least one atomic task requirement after decomposition; and for any atomic task requirement, acquire at least one candidate component matching the atomic task requirement from the candidate component library to form a target component set of the atomic task requirement.

[0132] In this embodiment of the disclosure, the construction module 63 is further configured to: obtain a candidate interface set for each target component in at least one target component set, and a candidate interface call direction for each candidate interface; for any target component set, call the component functions of each target component in the target component set according to the candidate interface call direction to generate a target atomic task corresponding to the target component set; obtain the task execution order of each target atomic task, and combine each target atomic task according to the task execution order to obtain a first target combined task.

[0133] In this embodiment of the disclosure, the construction module 63 is further configured to: obtain the user terminal type to which the user terminal belongs, and determine the target call interface of each target component from the candidate interface set according to the user terminal type and the candidate interface call direction; for any target component set, call the component function of each target component through the target call interface of each target component set to generate the target atomic task corresponding to the target component set.

[0134] In this embodiment of the disclosure, the construction module 63 is further configured to: for any target component, obtain a target interface call direction that supports the client type from the candidate interface call directions of the candidate interface set of the target component; and obtain the candidate interface indicated by the target interface call direction from the candidate interface set as the target call interface of the target component.

[0135] In this embodiment of the disclosure, the generation module 64 is further configured to: input the first target combination task into AIGC, and generate the first target task page of the first task event based on the first target combination task using the model capabilities of AIGC.

[0136] In this embodiment of the present disclosure, the device further includes an adjustment module, configured to: push a first target task page to a user terminal and display the first target task page based on the user terminal's interactive interface; monitor whether there is a change in the first task event on the user terminal; in response to detecting a change in the first task event, obtain the changed second task event and obtain the second target combination task corresponding to the second task event based on the candidate component library; generate a second target task page for the second task event based on the second target combination task through AIGC, and dynamically update the first target task page based on the second target task page.

[0137] The page generation apparatus disclosed herein acquires a first task event from the user terminal, parses it to obtain the corresponding task requirements, obtains at least one set of target components corresponding to the task requirements from a candidate component library, constructs target atomic tasks for each set of target components, combines each target atomic task to obtain a first target combined task, and then generates a first target task page corresponding to the first task event based on the first target combined task. In this disclosure, the corresponding task requirements are obtained by parsing the first task event on the user side, realizing the proactive acquisition of task requirements on the user side and improving the timeliness of task requirement acquisition. At least one set of target components for the task requirements is called from the candidate component library, and the target atomic tasks of each set of target components are combined to obtain the first target combination task. Then, the first target task page is generated by executing the first target combination task. The packaging and calling of components based on atomic tasks improves the efficiency of output content generation. In the microservice scenario, the generation and display of the target task page are realized. In the scenario of generating target task pages for different types of user sides, the target task page is generated by calling the functions of each component in the candidate component library, without the need for separate development work for different types of user sides, reducing the development cost of the user side and improving the practicality and applicability of the target task page generation method.

[0138] According to embodiments of the present disclosure, the present disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0139] Figure 7A schematic block diagram of an example electronic device 700 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0140] like Figure 7 As shown, device 700 includes a computing unit 701, which can perform various appropriate actions and processes based on a computer program stored in read-only memory (ROM) 702 or a computer program loaded from storage unit 709 into random access memory (RAM) 703. RAM 703 may also store various programs and data required for the operation of device 700. The computing unit 701, ROM 702, and RAM 703 are interconnected via bus 704. Input / output (I / O) interface 705 is also connected to bus 704.

[0141] Multiple components in device 700 are connected to I / O interface 705, including: input unit 706, such as keyboard, mouse, etc.; output unit 706, such as various types of monitors, speakers, etc.; storage unit 709, such as disk, optical disk, etc.; and communication unit 709, such as network card, modem, wireless transceiver, etc. Communication unit 709 allows device 700 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0142] The computing unit 701 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 701 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 701 performs the various methods and processes described above, such as page generation methods. For example, in some embodiments, the page generation method may be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 709. In some embodiments, part or all of the computer program may be loaded and / or installed on device 700 via ROM 702 and / or communication unit 709. When the computer program is loaded into RAM 703 and executed by the computing unit 701, one or more steps of the page generation method described above may be performed. Alternatively, in other embodiments, the computing unit 701 may be configured to perform page generation methods by any other suitable means (e.g., by means of firmware).

[0143] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0144] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0145] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0146] To initiate interaction with a user account, the systems and techniques described herein can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user account; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user account can submit input to the computer. Other types of devices can also be used to initiate interaction with the user account; for example, feedback submitted to the user account can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user account can be received in any form (including voice input, speech input, or tactile input).

[0147] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user account computer with a graphical user interface or web browser through which a user account can interact with the implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0148] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0149] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0150] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A page generation method, wherein, The method includes: Obtain the first task event from the user's end, and parse the first task event to obtain the task requirements of the first task event; Obtain a candidate component library, and obtain at least one set of target components corresponding to the task requirements from the candidate component library; Construct the target atomic tasks for each of the at least one set of target components, and combine the target atomic tasks to obtain the first target combined task corresponding to the task requirement; Based on the first target combined task, generate the first target task page of the first task event; The step of constructing the target atomic tasks for each of the at least one set of target components, and combining the target atomic tasks to obtain the first target combined task corresponding to the task requirement, includes: Obtain the candidate interface set of each target component in the at least one target component set, and the candidate interface call direction of each candidate interface; For any set of target components, according to the candidate interface call direction, the component functions of each target component in the set of target components are called to generate the target atomic task corresponding to the set of target components; Obtain the task execution order of each target atomic task, and combine the target atomic tasks according to the task execution order to obtain the first target combined task; The step of, for any set of target components, invoking the component functions of each target component in the set of target components according to the candidate interface invocation direction to generate the target atomic task corresponding to the set of target components, includes: Obtain the user terminal type to which the user terminal belongs, and determine the target calling interface for each target component from the candidate interface set based on the user terminal type and the candidate interface calling direction; For any set of target components, the component functions of each target component are invoked through the target invocation interface of each target component set to generate the target atomic task corresponding to the target component set.

2. The method according to claim 1, wherein, The step of obtaining the first task event from the user's end and parsing the first task event to obtain the task requirements of the first task event includes: The user terminal is monitored for task events to obtain the first task event of the user terminal. AIGC is used to parse the first task event to obtain the task requirement corresponding to the first task event.

3. The method according to claim 1, wherein, The step of obtaining a candidate component library and obtaining at least one set of target components corresponding to the task requirement from the candidate component library includes: The task requirements are broken down to obtain at least one atomic task requirement. For any atomic task requirement, at least one candidate component matching the atomic task requirement is obtained from the candidate component library to form the target component set for the atomic task requirement.

4. The method according to claim 1, wherein, The step of determining the target calling interface for each target component from the candidate interface set based on the user terminal type and the candidate interface calling direction includes: For any target component, obtain the target interface call direction that supports the client type from the candidate interface call directions of each candidate interface set of the target component; From the candidate interface set, obtain the candidate interface that indicates the target interface call direction, and use it as the target call interface of the target component.

5. The method according to claim 1, wherein, The first target task page, which generates the first task event based on the first target combined task, includes: The first target combination task is input into AIGC, and the first target task page of the first task event is generated based on the first target combination task using AIGC's model capabilities.

6. The method according to claim 5, wherein, After generating the first target task page based on the first target combined task, the method further includes: The first target task page is pushed to the user terminal, and the first target task page is displayed based on the user terminal's interactive interface; Monitor whether there are any changes in the first task event on the user's terminal; In response to the detection of a change in the first task event, the changed second task event is obtained, and the second target combined task corresponding to the second task event is obtained based on the candidate component library; The AIGC generates a second target task page for the second task event based on the second target combined task, and dynamically updates the first target task page based on the second target task page.

7. A page generation system, wherein, The system includes an access layer, an application layer, a component library, task components, a listening component, and a generation component, wherein... The access layer is used to receive user input information from the user terminal; The listening component is used to listen for task events on the user input information of the user terminal to obtain the first task event of the user terminal. The application layer is used to parse the first task event to obtain the task requirements of the first task event; The task component is used to obtain at least one set of target components corresponding to the task requirement from the component library, and to construct the target atomic task of each of the at least one set of target components; Furthermore, the target atomic tasks are combined to obtain the first target combined task corresponding to the task requirements; The generation component is used to generate a first target task page for the first task event based on the first target combined task; The task component is specifically used to obtain the candidate interface set of each target component in the at least one target component set, and the candidate interface call direction of each candidate interface; For any set of target components, according to the candidate interface call direction, the component functions of each target component in the set of target components are called to generate the target atomic task corresponding to the set of target components; Obtain the task execution order of each target atomic task, and combine the target atomic tasks according to the task execution order to obtain the first target combined task; The task component is specifically used to obtain the user terminal type to which the user terminal belongs, and to determine the target call interface of each target component from the candidate interface set according to the user terminal type and the candidate interface call direction. For any set of target components, the component functions of each target component are invoked through the target invocation interface of each target component set to generate the target atomic task corresponding to the target component set.

8. A page generation apparatus, wherein, The device includes: The first acquisition module is used to acquire the first task event from the user terminal and parse the first task event to obtain the task requirements of the first task event; The second acquisition module is used to acquire a candidate component library and acquire at least one set of target components corresponding to the task requirements from the candidate component library; A construction module is used to construct the target atomic tasks of each of the at least one set of target components, and to combine the target atomic tasks to obtain the first target combined task corresponding to the task requirement; The generation module is used to generate a first target task page for the first task event based on the first target combined task; The building module is also used for: Obtain the candidate interface set of each target component in the at least one target component set, and the candidate interface call direction of each candidate interface; For any set of target components, according to the candidate interface call direction, the component functions of each target component in the set of target components are called to generate the target atomic task corresponding to the set of target components; Obtain the task execution order of each target atomic task, and combine the target atomic tasks according to the task execution order to obtain the first target combined task; The building module is also used for: Obtain the user terminal type to which the user terminal belongs, and determine the target calling interface for each target component from the candidate interface set based on the user terminal type and the candidate interface calling direction; For any set of target components, the component functions of each target component are invoked through the target invocation interface of each target component set to generate the target atomic task corresponding to the target component set.

9. The apparatus according to claim 8, wherein, The first acquisition module is further configured to: The user terminal is monitored for task events to obtain the first task event of the user terminal. AIGC is used to parse the first task event to obtain the task requirement corresponding to the first task event.

10. The apparatus according to claim 8, wherein, The second acquisition module is further configured to: The task requirements are broken down to obtain at least one atomic task requirement. For any atomic task requirement, at least one candidate component matching the atomic task requirement is obtained from the candidate component library to form the target component set for the atomic task requirement.

11. The apparatus according to claim 8, wherein, The building module is also used for: For any target component, obtain the target interface call direction that supports the client type from the candidate interface call directions of each candidate interface set of the target component; From the candidate interface set, obtain the candidate interface that indicates the target interface call direction, and use it as the target call interface of the target component.

12. The apparatus according to claim 8, wherein, The generation module is further configured to: The first target combination task is input into AIGC, and the first target task page of the first task event is generated based on the first target combination task using AIGC's model capabilities.

13. The apparatus according to claim 12, wherein, The device further includes an adjustment module for: The first target task page is pushed to the user terminal, and the first target task page is displayed based on the user terminal's interactive interface; Monitor whether there are any changes in the first task event on the user's terminal; In response to the detection of a change in the first task event, the changed second task event is obtained, and the second target combined task corresponding to the second task event is obtained based on the candidate component library; The AIGC generates a second target task page for the second task event based on the second target combined task, and dynamically updates the first target task page based on the second target task page.

14. An electronic device comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-6.

15. A non-transitory computer-readable storage medium storing computer instructions, wherein, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-6.

16. A computer program product comprising a computer program that, when executed by a processor, implements the method according to any one of claims 1-6.

Images