Page generation method and device and electronic equipment

Abstract

The invention provides a page generation method, and relates to the technical field of computer software, in particular to the technical field of automatic page generation and artificial intelligence of a low-code platform. According to the specific implementation scheme, a page generation demand input by a user is analyzed, and page features are obtained; converting the page features into structured page data in an object representation format through a large model; and determining a corresponding target component based on the structured page data in the object representation format, and generating a target page according to the target component. The page generation efficiency and accuracy can be improved, and dependence on professional developers is reduced.

Description

Technical Field

[0001] The present disclosure relates to the field of computer software technology, and in particular to the field of automatic page generation and artificial intelligence on low-code platforms. Background Art

[0002] In the field of digital application development, traditional web page development relies on manual coding, resulting in low development efficiency, high costs, and a strong reliance on technical personnel. Low-code platforms lower the development barrier through prefabricated components and visual configuration. However, existing technologies still lack the level of automation from user requirements to page generation, especially when dealing with multimodal requirements, and lack efficient requirements analysis and structured data generation capabilities.

[0003] Therefore, how to use intelligent technology to automate the process from demand analysis to page generation has become a key technical issue in the current development of low-code platforms. Summary of the Invention

[0004] The present disclosure provides a page generation method, device, and electronic device for solving at least one of the above technical problems.

[0005] According to one aspect of the present disclosure, a page generation method is provided, wherein the method includes:

[0006] Parse the page generation requirements input by the user and obtain page features;

[0007] Converting the page features into structured page data in an object notation format using a large model;

[0008] Based on the structured page data in the object representation format, a corresponding target component is determined, and a target page is generated according to the target component.

[0009] According to another aspect of the present disclosure, a page generation device is provided, wherein the device includes:

[0010] Feature acquisition module, used to parse the page generation requirements input by the user and obtain page features;

[0011] a structured data module, configured to convert the page features into structured page data in an object notation format through a large model;

[0012] The page generation module is used to determine the corresponding target component based on the structured page data in the object representation format, and generate a target page according to the target component.

[0013] According to another aspect of the present disclosure, there is provided an electronic device, comprising:

[0014] at least one processor; and

[0015] a memory communicatively connected to the at least one processor; wherein,

[0016] The memory stores instructions that can be executed by the at least one processor. The instructions are executed by the at least one processor to enable the at least one processor to perform the above method.

[0017] According to another aspect of the present disclosure, a non-transitory computer-readable storage medium storing computer instructions is provided, wherein the computer instructions are used to cause the computer to execute the above method.

[0018] According to another aspect of the present disclosure, a computer program product is provided, comprising a computer program, wherein the computer program implements the above method when executed by a processor.

[0019] It should be understood that the contents described in this section are not intended to identify the key or important features of the embodiments of the present disclosure, nor are they intended to limit the scope of the present disclosure. Other features of the present disclosure will become readily understood through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] The accompanying drawings are provided to facilitate a better understanding of the present invention and do not constitute a limitation of the present disclosure.

[0021] Figure 1 This is a diagram of the layered structure of the low-code platform;

[0022] Figure 2 It is a comprehensive structural diagram of the low-code platform;

[0023] Figure 3 This is a flow chart of a page generation method provided by the first embodiment of the present disclosure;

[0024] Figure 4 is an exemplary flow chart of S102;

[0025] Figure 5 is an exemplary flow chart of S103;

[0026] Figure 6 is an exemplary flow chart of S103;

[0027] Figure 7 is a structural diagram of a page generating device according to a second embodiment of the present disclosure;

[0028] Figure 8 is a block diagram of an electronic device for implementing the method according to an embodiment of the present disclosure. DETAILED DESCRIPTION

[0029] The following description of exemplary embodiments of the present disclosure is made in conjunction with the accompanying drawings, including various details of the embodiments of the present disclosure to facilitate understanding. These details should be considered as merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications may be made to the embodiments described herein without departing from the scope and spirit of the present disclosure. Similarly, for the sake of clarity and conciseness, descriptions of well-known functions and structures are omitted in the following description.

[0030] In the absence of conflict, the various embodiments of the present disclosure and the various features therein may be combined with each other.

[0031] As used herein, the term "and / or" includes any and all combinations of one or more of the associated listed items.

[0032] The terminology used herein is for describing particular embodiments only and is not intended to limit the present disclosure.As used herein, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise.

[0033] Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art. It will also be understood that terms such as those defined in commonly used dictionaries should be interpreted as having a meaning consistent with their meaning in the context of the relevant art and the present disclosure, and will not be interpreted as having an idealized or overly formal meaning unless expressly defined as such herein.

[0034] The page generation method according to the present disclosure can be executed by an electronic device such as a terminal device or a server. The terminal device can be an in-vehicle device, a display device (User Equipment, UE), a mobile device, a user terminal, a terminal, a cellular phone, a cordless phone, a personal digital assistant (Personal Digital Assistant, PDA), a handheld device, a computing device, an in-vehicle device, a wearable device, etc. The method can be implemented by a processor calling computer-readable program instructions stored in a memory. Alternatively, the page generation method provided by the present disclosure can be executed by a server.

[0035] See also Figure 1 , Figure 1 This is a diagram of the layered structure of the low-code platform; see Figure 2 , Figure 2 A comprehensive structural diagram of the low-code platform.

[0036] Among them, the hierarchical structure of the low-code platform includes:

[0037] Front-end user interface layer: React is used as the front-end development framework. React is a JavaScript library for building user interfaces. It allows developers to create interactive user interface designs (UI) in a component-based manner. It is used with an editor and UI framework to build user interfaces and provide a visual interactive interface.

[0038] Presentation layer: Uses template engine rendering technology to generate the page content that is ultimately displayed to the user.

[0039] Data layer: involves various data forms. JavaScript Object Notation (JSON) is used as a common data exchange format. Static data (such as Sula static data) provides fixed configuration information, and interface dynamic data is used to obtain real-time changing data.

[0040] Business layer: covers form templates, which are used to create form-related functions; engine rendering, which is responsible for rendering page elements; data parsing, which processes and parses various types of data; event handling, which responds to and handles events such as user operations; preview, which provides page preview function; one-stop publishing, which publishes the prepared pages online.

[0041] It should be noted that this application can be applied on a low-code platform, and the output of the large model can be connected to the data layer, so the data layer can directly use the data of the large model to generate pages.

[0042] Among them, the comprehensive structure of the low-code platform includes:

[0043] Page: The operation platform's editing page can be embedded in the low-code platform's editor page via an inline frame (IFrame). The two communicate via postMessage, passing activity configuration JSON data and sula static data material configuration. The preview page renders the page, while the activity usage page first determines the publishing status before rendering the page.

[0044] Lowcode Engine part: includes the editor (Designer) for visual editing operations, including the skeleton (Skeleton) panel, configuration (Setter) component properties, plug-ins (Plugin) to expand platform functions, component library, including various components, and renderer (Render) responsible for page rendering.

[0045] Front-end technology stack: includes React, routing management (ReactRouter), network requests (Axios), strongly typed language (Typescript), build scripts (build-scripts) and other technologies.

[0046] Service part: includes service interface module (Server Api), which is used to provide server interface functions.

[0047] In the first embodiment disclosed, Figure 3 , Figure 3 A schematic diagram of a page generation method provided by the first embodiment of the present disclosure is shown. The method includes:

[0048] S101: Analyze the page generation requirements input by the user and obtain page features.

[0049] The page generation requirements input by the user are parsed. The page generation requirements can be multimodal, including but not limited to natural language, image, and existing web page formats. Page features are used to describe the function, layout, and appearance of the page to be generated by the user.

[0050] S102: Using the large model, convert the page features into structured page data in an object representation format.

[0051] Among them, structured page data (SCHEMA data) is a data structure specification used to standardize and organize the standard format of page component data, thereby ensuring that the structure of the generated page meets expectations and can be rendered correctly. It is usually saved in JSON format, so the structured page data in object notation format is referred to as "JSON_SCHEMA data".

[0052] In some examples, the structured page data in the object representation format includes at least one of the following: component metadata, component hierarchical relationships, and component constraint rules, etc. Of course, it may also include other information, which is not limited here.

[0053] Among them, component metadata may include component type, such as button, table, chart, etc.; component attributes, such as color, size, text content, etc.; event class, such as at least one of click event, load event, etc.

[0054] Component hierarchy: describes the nesting hierarchy, data flow, and dependencies between components.

[0055] Component constraint rules: specify the usage conditions of components, such as required fields, data type restrictions, etc.

[0056] S103: Based on the structured page data in the object notation format, determine the corresponding target component, and generate a target page according to the target component.

[0057] The method provided by the present invention automatically identifies page generation requirements, obtains page features, and then uses a pre-trained large model to directly output the page features as JSON_SCHEMA data. The target component is then determined through the JSON_SCHEMA data to generate the target page. Since the page features are converted into JSON_Schema data through the large model, and since JSON_Schema data is standardized structured data, it can be directly applied to the low-code platform. Therefore, the low-code platform can directly identify the structured page data and render and generate the target page based on it, thereby significantly improving the efficiency of page generation and rendering accuracy, and reducing dependence on professional developers.

[0058] In some examples, this method can be applied on a low-code platform. The output of the large model is connected to the data layer of the low-code platform. The low-code platform can directly identify structured page data and render and generate the target page based on it.

[0059] In actual application scenarios, users' demands for page generation are diverse and complex. Therefore, the present disclosure supports processing multimodal page generation demands, that is, users can input instructions for page generation demands in multiple forms, thereby breaking through the limitations of a single input method and improving operational flexibility and convenience.

[0060] In S101, the page generation requirement is a multimodal requirement. This requirement can take various forms, including natural language, where the user directly expresses the requirement in text, such as "Design an event registration page with a join button at the bottom." This type of requirement uses natural language, is close to everyday language, and requires no coding experience.

[0061] Another example is the need for generating a page in image form. For example, users can upload sketches such as those created using page vector drawing software, or drawn page images. Using page vector drawing software to draw a page sketch can intuitively present the page layout, component forms, and relative positional relationships. For example, they can draw a page framework containing a title bar, sidebar, main content area, and bottom operation area, and place charts and list components in the main content area. In addition to sketches created using page vector drawing software, hand-drawn scans and page images generated using other drawing tools also fall under the category of image-based page generation needs.

[0062] For example, the page generation requirement in the form of a webpage, the user can provide a webpage file as a reference or basis for page generation. The webpage is parsed and reused to extract the effective elements and layout structure. For example, a product display page is provided, and the system can analyze the page structure, component style, and interaction logic to provide a basis for the generation of a new page.

[0063] In addition, the page generation requirement can also include other types such as voice and video, which are not limited here.

[0064] As an example, when the multi-modal page generation requirement includes a page generation requirement in the form of natural language, S101 includes:

[0065] The page generation requirement in the form of natural language is input into a natural language processing engine for semantic recognition to obtain page features.

[0066] When the multi-modal page generation requirement includes a requirement in the form of natural language, the requirement can be parsed through natural language processing technology. Specifically, the page generation requirement in the form of natural language input by the user is transmitted to a natural language processing engine (NLP Engine). The NLP engine integrates basic processing modules such as word segmentation, part-of-speech tagging, and named entity recognition. First, the input text is disassembled into word units, and the part-of-speech of each word is tagged, such as nouns, verbs, adjectives, etc. The entities are identified, such as text, buttons, input boxes, etc. in the page. Then, a deep learning model such as a bidirectional transformer encoder representation (BERT) model, a generative pretrained transformer (GPT) pre-trained language model is used for semantic understanding to analyze sentence structure, semantic relationship and context information, and to mine the user's potential requirements. Finally, the processed semantic information is converted into page features. For example, the page features include functional features, layout features, style features, constraint features, and other dimensions to provide key basis for subsequent page generation.

[0067] As an example, when the multi-modal page generation requirement includes a page generation requirement in the form of natural language, S101 includes:

[0068] The page generation requirement in the form of natural language is input into a natural language processing engine for semantic recognition to obtain page features.

[0069] If the multimodal page generation requirement includes images, an image recognition engine (IRE) can be used to perform in-depth image analysis. Taking a user-uploaded drawn image as an example, the IRE first preprocesses the drawn image, including noise reduction, contrast enhancement, and edge detection, to improve image quality and feature clarity. It then uses computer vision algorithms, such as convolutional neural networks (CNNs), to identify user interface (UI) components in the drawn image, such as buttons, text boxes, tables, and images, accurately determining their type, shape, size, and position. It also analyzes the hierarchical relationships and layout between components. Furthermore, it extracts information such as annotation text and color fills from the image and converts them into corresponding style features and functional descriptions. Through this series of processes, comprehensive page features are extracted from the image requirements.

[0070] As an example, when the multimodal page generation requirement includes a page generation requirement in the form of a web page, S101 includes:

[0071] The page generation requirements in the form of a web page are input into the web page parser to perform page structure analysis to obtain page features.

[0072] When the multimodal page generation requirement is in the form of a web page, it can be processed by a web page parser (WPP). The web page parser first obtains the Hypertext Markup Language (HTML) code, Cascading Style Sheets (CSS) style sheet and JavaScript script file of the web page, performs Document Object Model (DOM) parsing on the HTML code, builds a structure tree of the page, and clearly presents the nested relationship and hierarchical structure of each element in the page. At the same time, the CSS style sheet is parsed to extract style information such as color, font, margin, layout mode, etc. of the page elements. For example, the interactive logic defined in the JavaScript script, such as button click events, data loading logic, etc., will also be analyzed and extracted. Through comprehensive parsing and structural analysis of the web page form requirements, complete page features are extracted.

[0073] In some examples, in S101 , the page feature includes at least one of the following: a functional feature, a layout feature, a style feature, and a constraint feature.

[0074] Among them, functional features: represent the core functions that the page needs to implement, such as data display components, such as table components, chart display data components; data entry components, such as form filling components; interactive operations, such as button click triggering events, etc.

[0075] Layout characteristics: Describe the overall layout structure and arrangement of page components, including component hierarchical relationships and relative positions.

[0076] Style features: define the visual presentation style of the page, including theme color, font type and size, component border style, shadow effect, etc.

[0077] Constraint features: These define the business logic and data rules for a page, including data validation rules, such as format verification and mandatory field settings; component linkage rules, such as dynamically loading a city list after selecting a province; and permission control rules, such as making a button visible only to logged-in users. Page features are then used to generate structured page data through the large model.

[0078] For some examples, see Figure 4 , Figure 4 An exemplary flow chart of S102 is shown, where S102 includes:

[0079] S1021. Convert the page features into initial page data in object representation format through the large model.

[0080] The large model performs semantic analysis and conversion of page features based on a pre-trained language model architecture, such as Transformer. Specifically, feature vectorization is first performed to map unstructured information such as page features (such as functional features, layout features, etc.) into semantic representations in a high-dimensional vector space to obtain a page feature vector. Then, based on the page feature vector, an initial data structure in JSON format is generated. Exemplarily, the initial data structure in JSON format contains component metadata, specifically including at least one of the component type and its component attributes.

[0081] S1022: Match the initial page data with predefined structured data to obtain structured page data in an object representation format.

[0082] The structured page data includes at least one of the following: component metadata, component hierarchical relationships, and component constraint rules.

[0083] Among them, component metadata may include component type, such as button, table, chart, etc.; component attributes, such as color, size, text content, etc.; event class, such as at least one of click event, load event, etc.

[0084] Component hierarchy: describes the nesting hierarchy, data flow, and dependencies between components.

[0085] Component constraint rules: specify the usage conditions of components, such as required fields, data type restrictions, etc.

[0086] The predefined structured data may include at least one of the following:

[0087] Predefined component structured data (SCHEMA data), including at least one of the following: form component, layout component, and interaction component;

[0088] Predefined domain scenario structured data: For different application fields, such as education, e-commerce, and medical care, pre-define component combination patterns and / or component constraint rules that are adapted to the field.

[0089] In S1022, the similarity between the component metadata in the initial page data and the predefined SCHEMA data can be calculated, and the SCHEMA data with the highest matching degree can be selected. Subsequently, based on the selected SCHEMA data, missing component hierarchical relationships, component constraint rules, and other information in the initial page data can be supplemented. For example, the hierarchical relationship of the component linkage logic of "select province - pop up city list" can be automatically added, such as the component constraint rule of "must contain 16 digits", etc., which are not limited here.

[0090] The SCHEMA data in JSON format can ensure that the generated page components comply with the design specifications and avoid incompatible or incorrect structures. The availability of components is guaranteed by constraint rules (such as required commands). In this application, the SCHEMA data in JSON format produced by the large model can be connected to the data layer of the low-code platform for direct use by the page generator, thereby ensuring that the system can efficiently and accurately generate expected pages.

[0091] In an example, JSON-formatted SCHEMA data can be returned in a format that is constrained by JSON_Schema. The required field can also be used to ensure that necessary information is present. For example, the messages field can be used to set system prompts and user questions, and the response_forma function can be used to cause the large model to return formatted data (i.e., JSON_Schema data) for automated processing by the program.

[0092] In some examples, the version of the large model is the GPT-4o model.

[0093] In some examples, in S102 , the large model converts page features into structured page data in an object representation format through three network layers;

[0094] The three-layer network includes: basic entity recognition layer, domain intent recognition layer and context completion layer.

[0095] The basic entity recognition layer is responsible for extracting component types and domain keywords from page features to achieve mapping from natural language to basic entities.

[0096] The domain intent recognition layer combines industry domain knowledge bases, such as e-commerce domain knowledge bases and academic domain knowledge bases, to parse users' implicit needs and generate component configurations that comply with domain specifications. It can also infer users' implicit needs through a semantic reasoning engine.

[0097] The context completion layer completes the context between components based on historical data, such as the interaction properties between components.

[0098] For some examples, see Figure 5 , Figure 5 An exemplary flow diagram of S103 is shown. In S103, based on the structured page data in the object notation format, determining the corresponding target component includes:

[0099] S1031. Determine component metadata included in the structured page data in the object notation format.

[0100] Specifically, the component type in the component metadata can be extracted, and the type field of each component node can be extracted from the structured page data to identify the basic component type.

[0101] Exemplarily, component properties (props) and component constraint rules (constraints) information of the component may also be extracted; component hierarchical relationships may be extracted, and the like.

[0102] S1032: Select a target component that matches the component metadata from a preset component library.

[0103] The components in the component library and the component metadata can be matched and calculated in multiple ways, for example, their semantic similarity can be calculated.

[0104] In some examples, S1032 includes:

[0105] Step 1: Use a bidirectional feature matrix to perform matching calculations on multiple components and component metadata contained in the component library, and identify the target component from the multiple components based on the calculation results.

[0106] The bidirectional feature matrix refers to an intelligent matching mechanism used in the component mapping layer of the low-code platform. It establishes a bidirectional relationship between the component metadata extracted from the user's requirements and the components in the component library. A bidirectional feature matrix can be used, in other words, a bidirectional attention mechanism is used to calculate the matching degree between the components in the component library and their own metadata. Specifically, step one includes:

[0107] Sub-step 1: convert component metadata into component metadata feature vectors, and convert predefined features of each component in the component library into component vectors, where the predefined features include at least one of the following: supported properties, events, applicable scenarios, etc.

[0108] Sub-step 2: Calculate the matching degree between the component metadata feature vector and the component vector through cosine similarity, and select the component with the highest similarity as the target component based on the matching calculation result.

[0109] In some examples, the component library includes at least one of the following types: basic component type, domain-customized component type, extended component type, etc.

[0110] Exemplarily, the basic components include at least one of the following: form components, such as input boxes and drop-down selectors; layout components, such as cards and grids; and interactive components, such as buttons and modal boxes.

[0111] Domain-customized components: including specialized components for education, finance, government affairs, and other fields;

[0112] Extension components: Users can customize components and automatically update them to the system.

[0113] For some examples, see Figure 6 , Figure 6 An exemplary flow diagram of S103 is shown. In S103, generating a target page according to a target component includes:

[0114] S1033. Construct the target component into a component tree structure according to the component hierarchical relationship contained in the structured page data in the object notation format.

[0115] This step constructs a tree-like component instance based on the component hierarchy contained in the JSON_Schema data. Specifically, the parent-child relationships between target components are extracted based on the component hierarchy. Based on the parsed parent-child relationships between target components, the target components are instantiated and a tree structure is constructed to obtain a component tree structure. Each component node in the component tree structure contains: a component instance, inherited component properties and events, and a list of child components.

[0116] S1034. Convert the component tree into a renderable document object model structure.

[0117] This step converts the abstract component tree into a DOM structure recognizable by the page editor. Specifically, first, a virtual DOM (VDOM) representation is generated based on the component nodes in the component tree structure. Then, the generated VDOM is optimized, such as flattening, merging redundant components, reducing the DOM hierarchy, lazy loading tags, and adding lazy loading indicators to non-first-screen components. Finally, the component constraint rules are converted into DOM attributes or styles to complete the conversion of the component tree to the DOM structure.

[0118] S1035: Render based on the document object model structure to generate a target page.

[0119] Specifically, a rendering engine is selected and dynamic rendering is performed based on the DOM structure to obtain the target page.

[0120] In some examples, before S1033, S103 may further include the following steps:

[0121] The component attributes in the component metadata included in the structured page data in the object notation format are determined, and the component attributes are mapped to the target component.

[0122] Among them, after determining the target component and before generating the component tree structure, you can obtain the component attributes in the component metadata and map the component attributes to the target component, that is, configure the attribute values ​​of the component attributes to the corresponding target component as rendering parameters, and then render according to the rendering parameters in the rendering step.

[0123] In some examples, before S1033, S103 may further include the following steps:

[0124] According to the component constraint rules contained in the structured page data in the object notation format, it is determined that the target component satisfies the component constraint rules.

[0125] Among them, after determining the target component and before generating the component tree structure, verify whether the instantiation process of the target component meets the requirements of the component constraint rules, such as whether it has necessary fields, etc. If not, automatic adjustment or user prompts are triggered; if satisfied, no operation is performed.

[0126] The method provided by the present disclosure converts page features into JSON_Schema data through a large model, so the JSON_Schema data can be directly applied to the low-code platform, and the low-code platform can directly generate a structured description that conforms to its data layer specifications, thereby significantly improving the component matching efficiency and rendering accuracy. In some examples, through bidirectional feature matrix calculation, the target components in the preset component library can be accurately mapped, reducing the manual configuration process. At the same time, the component hierarchical relationship and component constraint rules contained in JSON_Schema provide clear rendering guidelines for front-end frameworks such as React, thereby achieving efficient page construction. In addition, the present disclosure increases the processing capabilities for multi-modal page generation requirements input by users, supports the unified conversion of features extracted from natural language, images, web pages and other inputs into executable page configurations, and ultimately realizes the automated generation process from requirements to pages, shortens the development cycle, and lowers the technical threshold, so that non-professional developers can also quickly build complex pages.

[0127] In disclosing the second embodiment, see Figure 7 , Figure 7 A schematic diagram of the structure of a page generation device according to the second embodiment of the present disclosure is shown. The device includes:

[0128] Feature acquisition module 701, used to parse the page generation requirements input by the user and obtain page features;

[0129] The structured data module 702 is used to convert the page features into structured page data in an object notation format through the large model;

[0130] The page generation module 703 is used to determine the corresponding target component based on the structured page data in the object notation format, and generate a target page according to the target component.

[0131] In some examples, the structured data module 702 is specifically configured to:

[0132] Using the large model, convert the page features into the initial page data in the object representation format;

[0133] The initial page data is matched with predefined structured data to obtain structured page data in an object notation format.

[0134] In some examples, the structured page data includes at least one of the following: component metadata, component hierarchical relationships, and component constraint rules.

[0135] In some examples, the page generation module 703 is specifically configured to:

[0136] Determine component metadata included in structured page data in object notation format;

[0137] Select a target component that matches the component metadata from the preset component library.

[0138] In some examples, when the page generation module 703 selects a target component that matches the component metadata from a preset component library, it is specifically configured to:

[0139] Through the bidirectional feature matrix, matching calculations are performed on multiple components and component metadata contained in the component library, and the target component is determined from the multiple components based on the calculation results.

[0140] In some examples, the component library includes at least one of the following types: a basic component type, a domain-customized component type, and an extended component type.

[0141] In some examples, the page generation module 703 is specifically configured to:

[0142] According to the component hierarchical relationship contained in the structured page data in the object notation format, the target component is constructed into a component tree structure;

[0143] Convert the component tree into a renderable Document Object Model structure;

[0144] Rendering is performed based on the document object model structure to generate the target page.

[0145] In some examples, the apparatus further includes:

[0146] The property module is used to determine component properties in component metadata contained in structured page data in an object notation format, and map the component properties to target components.

[0147] In some examples, the apparatus further includes:

[0148] The constraint module is used to determine whether the target component satisfies the component constraint rules according to the component constraint rules contained in the structured page data in the object representation format.

[0149] In some examples, the page generation requirement is a multimodal page generation requirement; when the multimodal page generation requirement includes a page generation requirement in a natural language form, the feature acquisition module 701 is used to:

[0150] The page generation requirements in natural language form are input into the natural language processing engine for semantic recognition to obtain page features.

[0151] In some examples, the page generation requirement is a multimodal page generation requirement;

[0152] When the multimodal page generation requirement includes a page generation requirement in an image format, the feature acquisition module 701 is used to:

[0153] The page generation requirements in image form are input into the image recognition engine to perform page structure analysis and obtain page features.

[0154] In some examples, the page generation requirement is a multimodal page generation requirement;

[0155] When the multimodal page generation requirement includes a page generation requirement in the form of a web page, the feature acquisition module 701 is used to:

[0156] The page generation requirements in the form of a web page are input into the web page parser to perform page structure analysis to obtain page features.

[0157] In some examples, the large model of the structured data module 702 converts page features into structured page data in an object notation format through three network layers;

[0158] The three-layer network includes: basic entity recognition layer, domain intent recognition layer and context completion layer.

[0159] In some examples, the page feature includes at least one of the following: a functional feature, a layout feature, a style feature, and a constraint feature.

[0160] In some examples, the method is applied on a low-code platform, and the output of the large model is connected to the data layer of the low-code platform.

[0161] In the technical solution disclosed herein, the collection, storage, use, processing, transmission, provision, disclosure and application of user personal information involved comply with the provisions of relevant laws and regulations, take necessary confidentiality measures, and do not violate public order and good morals.

[0162] In the technical solution disclosed herein, the user's authorization or consent is obtained before obtaining or collecting the user's personal information.

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

[0164] like Figure 8 As shown, the device 800 includes a computing unit 801, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 802 or a computer program loaded from the storage unit 802 into a random access memory (RAM) 803. Various programs and data required for the operation of the device 800 can also be stored in the RAM 803. The computing unit 801, the ROM 802, and the RAM 803 are connected to each other via a bus 804. An input / output (I / O) interface 805 is also connected to the bus 804.

[0165] Various components in device 800 are connected to I / O interface 805, including an input unit 806, such as a keyboard, mouse, etc.; an output unit 807, such as various types of displays, speakers, etc.; a storage unit 808, such as a magnetic disk, optical disk, etc.; and a communication unit 809, such as a network card, modem, wireless communication transceiver, etc. The communication unit 809 allows device 800 to exchange information / data with other devices via a computer network such as the Internet and / or various telecommunication networks.

[0166] The computing unit 801 can be a variety of general and / or special processing components with processing and computing capabilities. Some examples of the computing unit 801 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various dedicated artificial intelligence (AI) computing chips, various computing units that run machine learning model algorithms, digital signal processors (DSPs), and any appropriate processors, controllers, microcontrollers, etc. The computing unit 801 performs the various methods and processes described above, such as the page generation method. For example, in some embodiments, the page generation method can be implemented as a computer software program that is tangibly contained in a machine-readable medium, such as the storage unit 808. In some embodiments, part or all of the computer program can be loaded and / or installed on the device 800 via the ROM 802 and / or the communication unit 809. When the computer program is loaded into the RAM 803 and executed by the computing unit 801, one or more steps of the page generation method described above can be performed. Alternatively, in other embodiments, the computing unit 801 can be configured with the page generation method in any other appropriate manner (e.g., by means of firmware).

[0167] Various embodiments of the systems and techniques described 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), system-on-chip systems (SOCs), programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments can include being implemented in one or more computer programs that are executable and / or interpreted on a programmable system comprising at least one programmable processor, which can be a special purpose or general purpose programmable processor that can receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit data and instructions to the storage system, the at least one input device, and the at least one output device.

[0168] The program code for implementing the method of the present disclosure can be written in any combination of one or more programming languages. These program codes can be provided to a processor or controller of a general-purpose computer, a special-purpose computer, or other programmable data processing device so that when the program code is executed by the processor or controller, the functions / operations specified in the flow chart and / or block diagram are implemented. The program code can be executed entirely on the machine, partially on the machine, as a stand-alone software package, partially on the machine and partially on a remote machine, or entirely on a remote machine or server.

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

[0170] To provide interaction with a user, 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; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user can provide input to the computer. Other types of devices can also be used to provide interaction with the user; for example, the feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including acoustic input, voice input, or tactile input).

[0171] The systems and techniques described herein can be implemented in a computing system that includes back-end components (e.g., as a data server), or a computing system that includes middleware components (e.g., an application server), or a computing system that includes front-end components (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with implementations of the systems and techniques described herein), or a computing system that includes any combination of such back-end components, middleware components, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network (LAN), a wide area network (WAN), and the Internet.

[0172] A computer system may include a client and a server. The client and server are generally remote from each other and typically interact through a communication network. The client-server relationship arises through computer programs running on the respective computers and having a client-server relationship with each other. The server may be a cloud server, a server in a distributed system, or a server integrated with a blockchain.

[0173] It should be understood that the various forms of processes shown above can be used to reorder, add, or delete steps. For example, the steps described in this disclosure can be performed in parallel, sequentially, or in a different order, as long as the desired results of the technical solutions of this disclosure can be achieved, and this document is not limited here.

[0174] The above specific embodiments do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions may be made based on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure shall be included within the scope of protection of this disclosure.

Claims

1. A page generation method, wherein: The method comprises: Parse the page generation requirements input by the user and obtain page features; Converting the page features into structured page data in an object notation format using a large model; Based on the structured page data in the object representation format, a corresponding target component is determined, and a target page is generated according to the target component.

2. The method according to claim 1, wherein The step of converting the page features into structured page data in an object representation format using a large model includes: Converting the page features into initial page data in object representation format using the large model; The initial page data is matched with predefined structured data to obtain structured page data in the object representation format.

3. The method according to claim 1 or 2, wherein: The structured page data includes at least one of the following: component metadata, component hierarchical relationships, and component constraint rules.

4. The method according to any one of claims 1 to 3, wherein: The determining of the corresponding target component based on the structured page data in the object notation format includes: determining component metadata included in the structured page data in the object notation format; The target component that matches the component metadata is selected from a preset component library.

5. The method according to claim 4, wherein The selecting the target component that matches the component metadata from a preset component library includes: A matching calculation is performed on the multiple components contained in the component library and the component metadata through a bidirectional feature matrix, and the target component is determined from the multiple components according to the calculation result.

6. The method according to claim 4 or 5, wherein: The component library includes at least one of the following types: basic component type, domain customized component type, and extended component type.

7. The method according to any one of claims 1 to 6, wherein: Generating a target page according to the target component includes: constructing the target component into a component tree structure according to the component hierarchical relationship contained in the structured page data in the object notation format; Converting the component tree into a renderable document object model structure; Rendering is performed based on the document object model structure to generate the target page.

8. The method according to claim 7, wherein: Before constructing a component tree structure based on the target component according to the component hierarchical relationship contained in the structured page data in the object notation format, generating a target page according to the target component further includes: Component attributes in component metadata included in the structured page data in the object representation format are determined, and the component attributes are mapped to the target component.

9. The method according to claim 7 or 8, wherein Before constructing a component tree structure based on the target component according to the component hierarchical relationship contained in the structured page data in the object notation format, generating a target page according to the target component further includes: According to the component constraint rules contained in the structured page data in the object representation format, it is determined that the target component satisfies the component constraint rules.

10. The method according to any one of claims 1 to 9, wherein: The page generation requirement is a multimodal page generation requirement; In a case where the multimodal page generation requirement includes a page generation requirement in a natural language form, parsing the page generation requirement input by the user and obtaining page features includes: The page generation requirements in natural language form are input into a natural language processing engine for semantic recognition to obtain the page features.

11. The method according to any one of claims 1 to 10, wherein: The page generation requirement is a multimodal page generation requirement; In a case where the multimodal page generation requirement includes a page generation requirement in an image format, parsing the page generation requirement input by the user and obtaining page features includes: The page generation requirement in the form of an image is input into an image recognition engine to perform page structure analysis to obtain the page features.

12. The method according to any one of claims 1 to 11, wherein: The page generation requirement is a multimodal page generation requirement; In a case where the multimodal page generation requirement includes a page generation requirement in the form of a web page, parsing the page generation requirement input by the user and obtaining page features includes: The page generation requirements in the form of a web page are input into a web page parser to perform page structure analysis to obtain the page features.

13. The method according to any one of claims 1 to 12, wherein: The large model converts the page features into structured page data in object representation format through three network layers; The three network layers include: basic entity recognition layer, domain intent recognition layer and context completion layer.

14. The method according to any one of claims 1 to 13, wherein: The page features include at least one of the following: functional features, layout features, style features, and constraint features.

15. The method according to any one of claims 1 to 14, wherein: The method is applied on a low-code platform, and the output of the large model is connected to the data layer of the low-code platform.

16. A page generating device, wherein: The device comprises: Feature acquisition module, used to parse the page generation requirements input by the user and obtain page features; a structured data module, configured to convert the page features into structured page data in an object notation format through a large model; The page generation module is used to determine the corresponding target component based on the structured page data in the object representation format, and generate a target page according to the target component.

17. 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, and the instructions are executed by the at least one processor to enable the at least one processor to perform the method according to any one of claims 1 to 15.

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

19. A computer program product comprising a computer program, which, when executed by a processor, implements the method according to any one of claims 1 to 15.

Images