Page generation method and device based on natural language, equipment and medium

Abstract

The invention relates to the technical field of artificial intelligence, can be applied to business scenes such as financial science and technology and medical health, and discloses a page generation method and device based on a natural language, equipment and a medium, and the method comprises the steps: obtaining a demand description in a natural language form, analyzing the demand description based on a preset intention recognition material, and generating a user intention; retrieving in the page feature vector library according to user intention to obtain a page template, performing graphical user interface rendering on the page template to generate a visual component set, injecting associated data into a target component in the visual component set to generate a target page, publishing the target page or publishing and collecting use effect data after modification, and displaying the use effect data. And updating the page feature vector library by using the use effect data. By combining natural language analysis, intention recognition, vector retrieval, graphical rendering and effect data updating, automation from demand input to page generation is realized, manual intervention and development cycle are greatly reduced, and page generation efficiency and quality are improved.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to a method, apparatus, device, and storage medium for generating pages based on natural language. Background Technology

[0002] In the fintech sector, particularly in the digital marketing of the insurance industry, the construction of campaign landing pages generally relies heavily on human experience and traditional development processes. Current mainstream practices involve stages such as requirements review, requirements documentation writing, UI design, and front-end / back-end integration, resulting in a cumbersome and time-consuming process, typically taking 7 to 15 days to complete. This model fails to meet the "fast, efficient, and high-frequency" operational demands of fintech businesses. Furthermore, while existing low-code platforms have lowered the development threshold to some extent and provided visual building capabilities, their requirements input still primarily relies on structured or form-based methods. They cannot understand natural language requirements and lack the ability to integrate financial knowledge and insurance product data, leading to inefficient campaign content configuration and a high dependence on manual judgment for campaign effectiveness, resulting in insufficient standardization and automation. In practice, the low match between campaign content and user needs leads to poor overall conversion rates, with key metrics such as active users and conversion rates failing to meet expectations.

[0003] In the healthcare sector, building digital service pages presents similar challenges. Rapidly launching healthcare service activities typically involves complex process design and interface configuration, currently relying primarily on manual development by technical personnel and low-code visual platforms. While existing platforms can reduce some development costs, they still lack automated and intelligent understanding capabilities in the processes of requirements gathering, requirements understanding, page configuration, and component selection, failing to effectively interpret the scenario requirements expressed by healthcare professionals through natural language. In particular, the integration of medical knowledge graphs with page construction remains a gap. Page construction still depends on operations teams and product managers manually defining templates and data sources, resulting in an average construction time exceeding 5 hours, making it difficult to meet the healthcare business's goal of rapidly responding to patient needs and launching activities.

[0004] In other internet-based digital content operation scenarios, existing technologies generally suffer from low efficiency, heavy reliance on manual labor, and a lack of natural language understanding and dynamic optimization capabilities during page creation. These shortcomings make the generation process of digital marketing pages less agile, unable to quickly respond to operational needs, and the final page content has a low degree of matching with user preferences, resulting in limited room for improvement in operational performance indicators such as user activity and engagement conversion rates. In particular, during the acquisition and matching of page templates, existing technologies cannot accurately retrieve templates based on user intent and lack intelligent recommendation mechanisms tailored to user needs and context, making template selection dependent on human experience, further restricting the efficiency and effectiveness of digital operations. Summary of the Invention

[0005] The main objective of this invention is to provide a method, apparatus, device, and storage medium for generating pages based on natural language, aiming to solve the technical problem that existing technologies cannot directly parse natural language requirements into user intents and intelligently retrieve corresponding templates from a page feature vector library, thus failing to achieve rapid and automatic generation of pages from requirement descriptions.

[0006] To achieve the above objectives, the present invention provides a natural language-based page generation method, comprising:

[0007] Requirements description in natural language form;

[0008] The user intent is generated by parsing the requirement description based on preset intent recognition materials.

[0009] Based on the user's intent, a page template is obtained by searching the page feature vector library.

[0010] The page template is rendered using a graphical user interface to generate a set of visual components;

[0011] Inject relevant data into the target component in the set of visualization components to generate the target page;

[0012] The target page is published or modified and then published, and the usage effect data of the target page is collected. The page feature vector library is then updated using the usage effect data.

[0013] Furthermore, to achieve the above objectives, the present invention provides a page generation apparatus based on natural language, comprising:

[0014] The requirement receiving module is used to obtain requirement descriptions in natural language.

[0015] The intent parsing module is used to parse the requirement description based on preset intent recognition materials and generate user intent;

[0016] The template retrieval module is used to retrieve page templates from the page feature vector library based on the user's intent.

[0017] The interface rendering module is used to render the page template into a graphical user interface and generate a set of visual components.

[0018] The data injection module is used to inject related data into the target component in the visualization component set to generate the target page;

[0019] The effect feedback module is used to publish the target page or modify the target page and then publish it, collect the usage effect data of the target page, and update the page feature vector library using the usage effect data.

[0020] Furthermore, to achieve the above objectives, the present invention also provides a computer device, the computer device including a memory, a processor, and a natural language-based page generation program stored in the memory and executable on the processor, wherein the natural language-based page generation program, when executed by the processor, implements the steps of the natural language-based page generation method as described above.

[0021] Furthermore, to achieve the above objectives, the present invention also provides a computer-readable storage medium storing a natural language-based page generation program, which, when executed by a processor, implements the steps of the natural language-based page generation method as described above.

[0022] Beneficial Effects: This invention relates to the field of artificial intelligence technology and can be applied to business scenarios such as fintech and healthcare. It discloses a method, apparatus, device, and medium for page generation based on natural language, including: acquiring a requirement description in natural language form; parsing the requirement description based on preset intent recognition materials to generate user intent; retrieving a page template from a page feature vector library according to the user intent; rendering the page template using a graphical user interface to generate a set of visual components; injecting related data into target components in the set of visual components to generate a target page; publishing the target page or publishing it after modification and collecting usage effect data; and updating the page feature vector library using the usage effect data. This invention, by combining natural language parsing, intent recognition, vector retrieval, graphical rendering, and effect data updates, automates the process from requirement input to page generation, significantly reducing manual intervention and development cycle, and improving page generation efficiency and quality. Attached Figure Description

[0023] The present invention will be further described below with reference to the accompanying drawings and embodiments. In the accompanying drawings:

[0024] Figure 1This is a schematic diagram of an application environment for a page generation method based on natural language according to an embodiment of the present invention;

[0025] Figure 2 This is a flowchart illustrating an embodiment of the natural language-based page generation method of the present invention;

[0026] Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the natural language-based page generation device of the present invention;

[0027] Figure 4 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention;

[0028] Figure 5 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

[0029] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0030] The natural language-based page generation method provided in this invention can be applied to applications such as... Figure 1 In this application environment, the user terminal communicates with the server via a network. The server can obtain a natural language description of the requirements from the user terminal, parse the requirement description based on preset intent recognition materials to generate user intent, retrieve a page template from the page feature vector library according to the user intent, render the page template using a graphical user interface to generate a set of visual components, inject related data into the target components in the set of visual components to generate the target page, publish the target page or modify and publish it and collect usage effect data, and update the page feature vector library using the usage effect data. This invention, by combining natural language parsing, intent recognition, vector retrieval, graphical rendering and effect data updating, automates the process from requirement input to page generation, significantly reducing manual intervention and development cycle, and improving page generation efficiency and quality. The user terminal can be, but is not limited to, various personal computers, laptops, smartphones, tablets and portable wearable devices. The server can be implemented using a standalone server or a server cluster consisting of multiple servers. The following detailed description of specific embodiments further illustrates this invention.

[0031] Please see Figure 2 , Figure 2 This is a flowchart illustrating an embodiment of the natural language-based page generation method provided by the present invention. It should be noted that although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0032] like Figure 2As shown, the natural language-based page generation method proposed in this invention includes the following steps:

[0033] S10, Obtain the requirement description in natural language form;

[0034] In this embodiment, obtaining the requirement description in natural language requires first establishing an interface that can receive user input. This interface supports text input boxes, voice input transcription modules, or external data interfaces, thereby enabling the collection of user-expressed requirement text from multiple channels. The scope of natural language includes not only Chinese or English, but also industry-specific vocabulary, colloquial expressions, and domain-specific expressions that conform to semantic expression rules, such as diagnostic suggestions used in the healthcare industry or investment preference expressions used in the financial industry. The requirement description, as input content, typically includes sentence structure, contextual information, and potentially multimodal auxiliary information, such as user-uploaded annotations or tag descriptions. To ensure the integrity and consistency of the input text, a preliminary text parsing mechanism is needed, including symbol integrity detection, syntactic structure analysis, and length reasonableness assessment. This input detection mechanism is typically implemented using algorithms such as character length thresholds, punctuation distribution rules, and subject-verb-object structure verification. If an anomaly is detected, a prompt mechanism will request the user to complete the information. After a user submits their request, the natural language description will be converted into a standard character encoding format and enter the subsequent processing flow. This processing may also include removing invisible characters, unifying character encoding standards (such as UTF-8), and disambiguation analysis to ensure data consistency and standardization during subsequent semantic understanding module processing.

[0035] Text input can be received via a web-based interactive interface and preprocessed and validated in real time using backend services, providing real-time feedback on input specifications. Alternatively, an intelligent speech recognition module can transcribe user speech input into text, adapting to different user needs acquisition methods across various input scenarios. In specific environments, structured input can be automatically received and converted into natural language through API integration with business databases, adapting to the collection of requirements descriptions for internal business support systems. For text integrity detection, a language integrity classifier trained using a deep learning model can determine whether the input text possesses syntactic and semantic integrity. If incomplete, it automatically prompts the user to complete the text and provides context-based prediction-based auto-completion suggestions, adapting to different business scenario requirements.

[0036] Example Explanation: In the healthcare business, patients or healthcare professionals can submit descriptions of their needs for health education pages for specific diseases through an input interface, such as "We need to generate a diet guide page for diabetic patients." This input is automatically checked for completeness, formatting issues are corrected, and it is standardized into structured text to ensure accurate processing in subsequent understanding stages.

[0037] In the fintech business, financial advisors can use voice input to request "a page for tax-advantaged insurance products for high-net-worth clients to be generated." The system will then transcribe the speech into text, perform format detection and disambiguation analysis, and store it as standardized input, laying the foundation for the subsequent intelligent generation of financial product display pages.

[0038] This embodiment establishes a unified and standardized entry point for receiving requirements descriptions, and combines multiple input data verification and processing mechanisms to achieve efficient conversion from user input to standardized text data. This reduces manual intervention, lowers the input error rate, and improves the availability and accuracy of requirements description data, thereby providing a reliable input source for subsequent processing.

[0039] S20, based on preset intent recognition materials, the demand description is parsed to generate user intent;

[0040] In this embodiment, the user intent is generated by parsing the demand description based on preset intent recognition materials. First, intent recognition materials need to be constructed, which include a set of text, phrases, and semantic tags used to understand and classify user input. Intent recognition materials can be derived from a set of common expressions extracted from historical business data, such as keywords like "appointment booking" and "health checkup" in the healthcare field, or "financial planning" and "risk preference assessment" in the fintech field. Alternatively, a high-quality semantic pattern template set can be constructed from a corpus annotated by industry experts. The demand description, as input text, needs to undergo word segmentation, part-of-speech tagging, syntactic analysis, and contextual understanding using a natural language processing model to ensure that the structural features of the input text match the preset intent recognition materials. During the parsing process, a semantic feature extraction algorithm is used to convert the demand description into a semantic feature vector, which includes lexical representation, contextual relevance embedding, and domain-specific weight information. By calculating the similarity between the semantic features and the intent recognition materials, a set of candidate intents with a high degree of matching can be obtained. Each intent in the candidate set needs to be ranked based on its confidence level using a contextual confidence assessment mechanism, such as historical user behavior preferences and business rule constraints, to select the optimal intent as the final user intent output. The entire process requires the semantic parsing and material matching algorithms to be open and scalable to adapt to the semantic diversity and scenario complexity across industries such as healthcare and finance.

[0041] Deep learning-driven text encoders (such as Transformer architectures) can be used to encode the requirement description, combined with semantic template embedding vectors from a pre-defined intent material library. The most relevant intent is selected by calculating the cosine similarity between vectors, and the confidence evaluation criteria are refined using contextual historical data to optimize the final user intent recognition performance. Alternatively, rule-based syntax tree matching algorithms can be used to directly match intent templates to short texts, suitable for high-precision requirement scenarios. Furthermore, knowledge graphs from industries such as healthcare and fintech can be integrated, aligning requirement description entities with knowledge graph nodes, and inferring implicit intents through upstream and downstream relationships to improve the understanding and parsing capabilities of complex semantics.

[0042] Example explanation: In the field of healthcare business, when a user enters "generate a health guidance page suitable for the elderly with hypertension", the system can identify the intent of "hypertension" and "health guidance" through preset medical semantic materials, and lock the user intent of "chronic disease management" through semantic feature similarity calculation.

[0043] In the fintech business, when a user enters "recommend a tax-advantaged insurance package introduction page for corporate clients", the system analyzes the keywords "corporate clients" and "tax-advantaged insurance", matches and selects the intent template "introduction of insurance for corporate clients" in the intent recognition material, and quickly generates a clear user intent as the input basis for subsequent page template retrieval.

[0044] This embodiment, by introducing preset intent recognition materials and semantic matching mechanisms, can quickly and accurately identify user intent from requirement descriptions, reduce the time cost of manual interpretation of requirements, improve the accuracy of intent understanding, provide clear and structured intent data for subsequent steps, and improve page generation efficiency and accuracy.

[0045] S30, based on the user intent, search the page feature vector library to obtain the page template;

[0046] In this embodiment, to retrieve page templates based on user intent from the page feature vector library, the user intent data must first be converted into a query vector suitable for the library's calculations. User intent is typically expressed in text form and needs to be converted into a multi-dimensional dense vector using a feature encoding algorithm to ensure its similarity can be calculated with the page template feature vectors already stored in the library. The page template feature vectors stored in the library originate from historical template data and are formed through semantic encoding of elements such as the template's layout structure, content theme, applicable scenarios, and user preferences. The retrieval process includes three key operations: first, the user intent is standardized, denoised, and encoded to generate a high-dimensional numerical vector; then, the page feature vector library is accessed, and a high-performance similarity retrieval algorithm (e.g., an approximate nearest neighbor algorithm based on vector space distance) is invoked to batch obtain several candidate page templates that are closest to the user intent query vector; finally, the candidate page templates are prioritized according to their similarity scores, and the page template with the highest similarity is selected as the output result. The retrieval process needs to ensure that the retrieval algorithm has the ability to quickly compute high-dimensional dense vectors, supports dynamic updates, incremental storage and high-concurrency access of the vector library, so as to adapt to the needs of actual business scenarios.

[0047] User intent can be encoded using embedding models, such as generating unified embedding vectors as retrieval input through Transformer models or pre-trained language models. The page feature vector library can utilize dedicated vector retrieval frameworks, such as those based on open-source engines like Milvus, to pre-store feature vectors of historical page templates. By accessing this vector library, vector retrieval based on Euclidean distance or cosine similarity can be performed to quickly locate the most matching page template entry. Furthermore, partitioned indexes can be built by combining page template features from different domains; for example, separate indexes can be created for healthcare and fintech scenarios to improve retrieval efficiency and accuracy. During the retrieval process, a dynamic ranking mechanism can be incorporated to further optimize the output results based on similarity score thresholds and business context requirements, ensuring retrieval accuracy and business adaptability.

[0048] Example explanation: In the field of healthcare business, if the user's intent is "elderly diabetes management page", the system converts the intent expression into a semantic embedding vector through feature encoding, and quickly retrieves historically stored "chronic disease management" and "elderly health" page templates from the page feature vector library, selecting the template with the highest similarity as the result.

[0049] In the fintech business, if the user's intent is "SME financing introduction page", the system maps the user's intent into a vector and performs similarity matching with templates related to "corporate financing" and "loan products" in the page feature vector library. It then obtains and returns the page template that best meets the user's needs, providing reliable input for subsequent page rendering and data filling.

[0050] This embodiment utilizes a vector retrieval mechanism to quickly and efficiently obtain the most relevant page templates based on user intent, reducing the need for manual template selection, improving the intelligence level of template retrieval and business response speed, making the overall page generation process more accurate, and meeting users' personalized needs.

[0051] S40, Render the page template using a graphical user interface to generate a set of visual components;

[0052] In this embodiment, rendering a page template into a graphical user interface and generating a set of visual components requires a detailed analysis of the page template's structure and content. This involves extracting and converting the layout definitions, component distribution, and style information into a format that the rendering engine can process. Page templates typically contain multi-level area divisions and placeholder descriptions for different types of components, such as text input boxes, image containers, buttons, and form groups. During the analysis, component description data is generated based on the hierarchical relationships, arrangement order, and style specifications defined in the template. Next, the graphical rendering engine is loaded. This engine converts the analyzed description data into renderable graphical interface elements, ensuring the conversion accurately reflects the spatial layout and appearance of the page template. During rendering, the size, margins, font, color, and other visual parameters of each component are processed individually to ensure good visualization across different devices and resolutions. Finally, the system aggregates these rendered interface elements to form a set of components that can participate in subsequent interactions, modifications, and data injection. The entire rendering process requires mapping each element in the page template to its corresponding component standard in the rendering engine, ensuring the integrity and accuracy of the rendered output.

[0053] The framework structure of the page template can be parsed to extract the attributes of each component. For example, templates defined based on HTML tags can extract the component type, layout parameters, and style sheet references as rendering description data. Then, a multi-platform-compatible graphical rendering engine, such as a WebGL or Canvas-based rendering framework, can be called to convert this description data into graphical user interface elements visible on the screen. A unified component type mapping rule can be defined in the rendering engine. For example, the "title area" defined in the template can be mapped to an h1 component, the "image display area" to an image component, and the "user input area" to an input component. The corresponding interface elements can be generated in batches through the rendering engine's API. Furthermore, the appearance style and interaction event listeners of each component can be initialized during the rendering process, forming a collection of visual components that supports dynamic interaction and expansion.

[0054] Example Description: In the healthcare business field, after parsing the template, a set of interface components including health record forms, user input boxes, and health indicator charts are rendered, enabling medical institutions to quickly launch health data collection pages.

[0055] In the fintech business, the template is parsed and rendered to generate a set of interface components, including a product introduction section, a fee calculator, and an application entry button, helping financial institutions quickly build interactive product promotion pages.

[0056] This embodiment automatically parses the page template and uses a graphical rendering engine to complete the interface rendering. It can efficiently and accurately transform the abstract template into a set of interface components that are visible to the user, reduce the workload of manually building the interface, improve the page generation speed and consistency, and ensure that the page has good display effects and operability on different terminal devices.

[0057] S50, inject associated data into the target component in the set of visualization components to generate the target page;

[0058] In this embodiment, the process of injecting associated data into target components in the visualization component set to generate the target page first requires identifying the target components selected in the visualization component set for displaying dynamic content. These target components are typically defined by page templates or determined based on user intent analysis, such as text display components, image display components, or list components. During the identification process, target components that need data filling are selected based on the unique identifier of each component, preset data interface specifications, or binding conditions. Then, associated data needs to be acquired and adapted. Associated data can come from external databases, knowledge graphs, user profile information, real-time calculation results, etc. The data acquisition process must ensure that its content format and data type are consistent with the target components, including requirements such as numerical format, text length limits, and image resolution. During the adaptation process, data can be directly bound to the corresponding components through data format conversion, content cropping, style mapping, etc. Finally, the adapted associated data is injected into each target component to complete the data filling of the page and generate a target page that is displayable and interactive. The entire injection process must ensure that the data corresponds one-to-one with the target components, and that the page structure remains intact after injection, with normal visual effects and interactive functions.

[0059] The process can begin by iterating through each component in the visualization component set, comparing its configured "data binding flag" field, and selecting the components that need data binding as the target component set. Then, based on the component's attribute definitions, a database query request is generated to access related data sources, including product information databases, user behavior databases, and medical data warehouses, to obtain relevant data related to the current business logic of the page. After acquisition, the data undergoes format checks and conversions, such as formatting the timestamps returned by the database into user-friendly time strings and converting image URLs into directly loadable image resource links after verification. Then, the converted data is written item by item into the data fields of the target components through the rendering engine or data binding interface. Event listeners can also be used to dynamically update the content of the target components with bound data, supporting content adjustments based on user actions or external events after page rendering. After injection is complete, all components are combined to output the complete page structure and content, forming the final displayable target page.

[0060] Example: In the healthcare business, users' health record data and examination report information can be automatically injected into form and chart components to generate personalized health report pages in real time, making it convenient for users to view and download.

[0061] In the fintech business, customer credit score data and product recommendation data can be injected into the credit assessment module and product recommendation list in real time, dynamically generating exclusive financial product pages for different users, thereby improving the accuracy and conversion rate of marketing.

[0062] This embodiment enables dynamic filling and automated construction of page content by accurately injecting associated data into the target components in the visualization component set. This significantly reduces manual input and configuration work, improves page generation efficiency, and ensures a high degree of consistency between page content and data source, giving the page real-time update capability and high personalization.

[0063] S60, publish the target page or modify the target page and then publish it, collect the usage effect data of the target page, and update the page feature vector library using the usage effect data.

[0064] In this embodiment, the process of publishing a target page or modifying and publishing a target page, and collecting usage effect data of the target page, followed by updating the page feature vector library using this usage effect data, first involves deploying the generated target page to a page distribution service environment. This environment may include content delivery network nodes or highly available load balancers to ensure that the page can be quickly accessed by end users. After deployment, user behavior is comprehensively collected through on-page monitoring mechanisms, including metrics such as page visit count, page dwell time, click area distribution, and user conversion behavior. Behavior collection can be achieved by embedding data tracking scripts in the page, recording and summarizing user interaction data in real time into a raw behavior dataset. Then, based on the raw behavior dataset, page performance is analyzed to extract usage effect data related to page performance, such as conversion rate, activity level, and bounce rate, and this data is associated with the page's basic metadata. Next, the historical feature vector entries for the corresponding target page need to be searched in the page feature vector library, and update parameters for adjusting these entries are calculated based on the usage effect data. These update parameters may include feature vector weights, content offsets, or relevance scores. During the update process, it is essential to ensure the integrity and consistency of the data structure. Adding timestamps or version information can also be beneficial for subsequent optimization and traceability. The updated page feature vector entries will be stored in the page feature vector library, enabling them to reflect the historical usage of pages in future page template retrieval or recommendation processes, thereby improving the accuracy and real-time performance of page retrieval and recommendation.

[0065] The target page can be deployed to a distribution server, and access performance can be accelerated through CDN node caching. JavaScript-written event tracking scripts can be embedded in the page to monitor user browsing paths, click events, scrolling behavior, etc., and data can be uploaded to the backend log processing system in real time via WebSocket or HTTP interfaces. The log processing system can perform batch cleaning and normalization of the collected data, extracting a set of key indicators reflecting page usage, forming structured usage performance data. When updating the page feature vector library, the template ID of the current page can be used as the index key to locate the page feature vector entries stored in the vector database. By comparing the page conversion rate in the usage performance data with the historical average, the dimension values ​​representing page relevance in the feature vectors are dynamically adjusted, so that well-performing page features receive higher priority in future searches. The update operation can employ methods such as batch vector replacement, weight decay, and gain adjustment. Finally, the updated page feature vectors are submitted to the database and an update timestamp is added for subsequent historical version queries and analysis.

[0066] Example explanation: In the healthcare business field, the target page can be the user's personalized health report page. By monitoring the user's click behavior on the health advice module and the time spent on the report, page usage data can be collected, and the page feature vector can be adjusted based on this data to make future recommendations more in line with the user's health management needs.

[0067] In the fintech business, the target page can be a financial product recommendation page. By collecting user clicks, application conversions, and other behaviors of different product modules, the page feature vector is dynamically updated so that in subsequent page template searches, the high-performing page templates are given priority for use in marketing activities for new users.

[0068] This embodiment uses real-time usage data of the target page as feedback to dynamically update the content of the page feature vector library. This allows subsequent page retrieval and template matching processes to reflect the latest user behavior and page performance, improving the targeting and accuracy of page recommendations, reducing the need for manual optimization, and further enhancing the automation level of page content production.

[0069] This invention relates to the field of artificial intelligence technology and can be applied to business scenarios such as fintech and healthcare. It discloses a method, apparatus, device, and medium for page generation based on natural language, comprising: acquiring a requirement description in natural language form; parsing the requirement description based on preset intent recognition materials to generate user intent; retrieving a page template from a page feature vector library according to the user intent; rendering the page template using a graphical user interface to generate a set of visual components; injecting related data into target components in the set of visual components to generate a target page; publishing the target page or publishing it after modification and collecting usage effect data; and updating the page feature vector library using the usage effect data. This invention, by combining natural language parsing, intent recognition, vector retrieval, graphical rendering, and effect data updates, automates the process from requirement input to page generation, significantly reducing manual intervention and development cycle, and improving page generation efficiency and quality.

[0070] In one embodiment, step S10 above includes:

[0071] S101 receives initial natural language input through an interactive interface and generates an initial requirement description;

[0072] S102, verify the textual integrity of the initial requirement description and generate a verification status marker;

[0073] S103, based on the verification status flag, trigger the information supplementation protocol to supplement the initial requirement description and generate a supplemented requirement description;

[0074] S104, Extract the domain entities from the supplemented requirement description and generate a domain entity set;

[0075] S105, Analyze the semantic relationships between domain entities in the domain entity set and generate a semantic relationship network;

[0076] S106, Integrate the semantic relationship network and the supplemented requirement description to generate a structured requirement description.

[0077] In this embodiment, during the process of obtaining the requirements description in natural language form, the initial natural language content input by the user is first received through an interactive interface. This interface can be a web-based input box or a voice input interface. The user input is captured by an input event listener, and the input is converted into a processable text format in real time to generate the initial requirements description. This process involves not only user input collection but also input data preprocessing, such as text encoding conversion, special character cleanup, and input content length standardization. Once the initial requirements description is generated, its textual integrity needs to be verified immediately. Verification can be performed using rule-matching algorithms or machine learning models to detect whether the input text has a complete syntactic structure and contains key elements, such as target objects, action verbs, or constraints. The verification result is output in the form of verification status markers, which can be Boolean values, scores, or multi-level states.

[0078] When the verification status flag indicates that the initial requirement description is incomplete, an information supplementation protocol is automatically triggered. The information supplementation protocol includes a query template library defining supplementary content and an interactive prompt module. Based on the missing content found during verification, the system selects the corresponding supplementary question template and initiates an interactive request to the user. Supplementary questions can be presented in text or voice format. The user's response is merged with the initial requirement description to form the supplemented requirement description. During the supplementation process, the source and timestamp of the user's supplementary content can also be recorded for subsequent source tracing analysis.

[0079] The supplemented requirement description undergoes structured content analysis, starting with the extraction of domain entities. The definitions of domain entities are derived from a pre-defined industry knowledge base. For example, in an insurance scenario, these include "insurance products," "claims period," and "insured's age," while in a healthcare scenario, they include "disease names," "examination items," and "treatment plans." The extraction process can be achieved using a named entity recognition model. The extraction results form a set of domain entities, which serves as the foundational data for the next step of semantic analysis.

[0080] Analyzing the semantic relationships between domain entities in a domain entity set requires using semantic graph algorithms, entity association rules, or knowledge graph reasoning tools to extract the association information of entity pairs from hierarchical relationships, causal relationships, temporal order, or spatial relationships between entities, generating a semantic relationship network. The semantic relationship network can be stored using a graph data structure, where each node represents a domain entity, each edge represents a specific semantic relationship between entities, and a weight value is attached to indicate the association strength.

[0081] By integrating the semantic relationship network with the supplemented requirement description, the original requirement text is used as annotation information for the semantic relationship network, and a structured requirement description is output with a unified structure. The structured requirement description contains both the original or supplemented requirement statements and records the entity elements in the requirement and the semantic connection between them, ultimately forming a standardized data object that can be parsed by subsequent machines.

[0082] This embodiment introduces multi-level text integrity verification, supplementary content interaction, domain entity extraction, and semantic relationship analysis during the requirements description collection stage. When user expressions are incomplete or semantically ambiguous, interactive information completion and knowledge graph-driven semantic parsing can effectively transform them into structured and standardized requirements data. This enables subsequent page generation tasks to accurately understand user intent without human intervention, improves data parsing efficiency, reduces the impact of differences in user expressions on the accuracy of the final page generation, and ensures that the final output has stronger applicability and contextual consistency.

[0083] In one embodiment, step S20 above includes:

[0084] S201, Load the preset intent recognition material library and generate a set of theme scenes and a set of user tags;

[0085] S202, parse the script flow and guide word structure of the requirement description, and generate semantic feature vectors;

[0086] S203, Match the semantic feature vector with the topic scene set to generate an initial intent with matching coefficients;

[0087] S204, combine the user tag set to correct the initial intent and generate a corrected intent;

[0088] S205, Generate a candidate set of intentions with confidence scores based on the modified intention;

[0089] S206, Select the candidate intent with the highest confidence score from the intent candidate set to generate the user intent.

[0090] In this embodiment, loading a preset intent recognition material library involves dynamically calling intent recognition resources stored in the system. The material library is a storage entity containing multi-dimensional intent mapping data, including historical interaction samples, industry-specific scene tags, commonly used user profile tags, and intent expression templates. The loading operation selectively reads the content of the material library through an indexing mechanism and maps it to a set of theme scenes and a set of user tags. The set of theme scenes represents the context related to the need, such as "health insurance consultation" and "car insurance application guidance" in the insurance industry, and "appointment registration" and "health assessment" in the healthcare field. The set of user tags stores user attribute characteristics, such as user preferences, user categories, and historical behavior patterns, facilitating subsequent intent correction.

[0091] Parsing the script flow and guide word structure of the requirement description involves decomposing and analyzing the requirement text according to a serialization processing logic. The script flow is the sequence of events contained in the user's expression, such as "I want to buy insurance for my child and understand the claims process," where "buy insurance" and "understand the claims process" are event nodes. The guide word structure is used to identify semantic connectors between events, such as "and," "then," and "afterwards," helping the system understand temporal and causal relationships. The parsing process employs natural language processing methods such as word segmentation, syntactic analysis, and dependency parsing tree modeling. Keywords and their contextual relationships are extracted from the parsing results to generate semantic feature vectors. These semantic feature vectors are vector representations that map the text to a high-dimensional semantic space through an encoder model, possessing the ability to capture contextual semantic information and forming a standard expression form for intent parsing.

[0092] Matching semantic feature vectors with a set of topic scenes involves calculating a similarity score between the two in the semantic space. Common methods include cosine similarity calculation and vector distance metrics. The system uses the semantic feature vector as the query vector, finds the most similar scene label in the set of topic scenes, and generates an initial intent with a matching coefficient based on the similarity result. The matching coefficient is a quantified score representing the degree of correlation between the current requirement description and the candidate topic scene.

[0093] Modifying the initial intent by incorporating user tag sets involves optimizing the initial intent by introducing personalized user factors. For example, if a user's past behavior indicates a preference for health insurance products, the system will increase the weight of health insurance-related topics in the initial intent. The modification algorithm can employ methods such as weighted averaging or Bayesian updates to comprehensively calculate the matching coefficients between user tags and the initial intent, forming the modified intent. The modified intent is the optimal expression of intent after integrating semantic analysis and personalized user background.

[0094] Generating a candidate intent set with confidence scores based on modified intents is a way to provide multiple alternatives during intent recognition to prevent the inaccuracy of a single candidate intent. Each intent item in the candidate set is accompanied by a confidence score, which is calculated using a statistical learning model or a probabilistic inference method based on historical data, representing the system's level of trust or confidence in the intent result.

[0095] The final intent determination step involves selecting the candidate intent with the highest confidence score from the intent candidate set to generate the user intent. The system sorts each intent in the candidate set according to its confidence score and selects the intent with the highest confidence score as the final output user intent. This user intent not only includes the topic scenario but also implicitly incorporates personalized user corrections, ensuring a high degree of consistency between the output content and the user's actual needs.

[0096] This embodiment combines requirement description text with multi-dimensional intent recognition materials and introduces processing flows such as script flow and guide word structure parsing, user tag correction, and confidence score sorting. This enables the system to efficiently and accurately extract users' true intent from their natural language expressions, reduce manual understanding and interaction time, improve intent parsing efficiency before automated page generation, and ensure the accuracy and personalized adaptability of subsequent page template intelligent recommendation and content rendering.

[0097] In one embodiment, step S30 above includes:

[0098] S301, Process the user intent to generate a query feature vector;

[0099] S302, Access the page feature vector library to obtain the set of feature entries;

[0100] S303, determine the similarity between the query feature vector and the feature item set, and generate a similarity score set;

[0101] S304, Filter the candidate template set based on the similarity score set;

[0102] S305, sort the candidate template set by priority to generate a sorted template queue;

[0103] S306, Select the highest priority entry from the sorting template queue to obtain the page template.

[0104] In this embodiment, processing user intent to generate query feature vectors is a numerical representation of the natural language parsing result of user intent. It employs text encoding methods, such as text vectorization techniques based on pre-trained language models, to map semantic information into a multi-dimensional vector space. This process involves segmenting the user intent text, denoising, and embedding vectors to form standardized query feature vectors suitable for vector retrieval, ensuring that subsequent similarity calculations can be performed in a unified numerical space.

[0105] Accessing the page feature vector library to retrieve a set of feature entries involves using query feature vectors as search criteria and connecting to a database that stores historical page template feature vectors. The page feature vector library is a persistent vector database that stores historical page templates and their corresponding semantic feature vectors. Access is performed via an API interface or by directly calling the vector database retrieval service. This returns a batch of page template feature entries related to the query criteria from the database. The set of feature entries includes unique identifiers, metadata, and pre-stored feature vector data related to the page template.

[0106] Determining the similarity between the query feature vector and the set of feature items involves calculating the semantic closeness between the query feature vector and the page template feature vector. Common calculation methods include cosine similarity or inverse normalization of Euclidean distance. The calculated similarity results are expressed as similarity scores, forming a similarity score set used to quantify the relevance between the user's current needs and historical page templates.

[0107] The candidate template set is filtered based on similarity scores. This involves selecting page templates that best match the user's needs according to a preset similarity threshold or ranking criteria. This filtering step, by setting dynamic thresholds or selecting the top N high-scoring templates, excludes irrelevant data or data with lower-than-expected similarity, narrowing the search results and ensuring the efficiency and accuracy of subsequent ranking processes.

[0108] Prioritizing the candidate template set to generate a ranked template queue involves comprehensively considering business metrics such as similarity score, template historical usage frequency, and conversion rate. Each template in the candidate template set is weighted, scored, and ranked. The ranked template queue is arranged in descending order to ensure that the business system can quickly locate the optimal page template and supports dynamic adjustment of weight factors to adapt to different business needs.

[0109] The final template output step involves selecting the highest priority entry from the sorted template queue to obtain the page template. The first page template in the sorted results is directly taken as the current search result and used as input for subsequent graphical user interface rendering. This template represents the system's optimal matching result based on its understanding of user intent and historical knowledge.

[0110] This embodiment accurately identifies the page template that best matches the current user's needs by vectorizing the user's intent and performing similarity calculation, filtering, and multi-dimensional sorting with the features of historical page templates in the page feature vector library. This reduces the workload of manual matching and design, improves the relevance and usability of search results, and makes the page template recommendation process efficient, automated, and business-adaptive.

[0111] In one embodiment, step S40 above includes:

[0112] S401, parse the frame structure of the page template and generate component frame data;

[0113] S402, Load the graphical rendering engine and generate a rendering engine instance;

[0114] S403, use the rendering engine instance to convert the component framework data into visual elements, and generate an initial set of visual elements;

[0115] S404, Optimize the rendering parameters of the initial visualization element set to generate an optimized visualization element set;

[0116] S405, aggregate the optimized set of visual elements to generate basic components, and obtain a set of basic components;

[0117] S406, Integrate the aforementioned basic component set to generate a visual component set.

[0118] In this embodiment, parsing the framework structure of the page template involves taking the obtained page template as input and performing a programmatic analysis on the logical blocks and interface element layout contained within it. This process identifies different interface areas and their interrelationships by parsing the hierarchical structure, block grouping, element hierarchy, and arrangement order defined in the template, thereby generating component framework data. Component framework data is a structured data model that describes the size, position, nesting relationship, and functional type of each area in the template, facilitating subsequent rendering operations. In specific implementation, Document Object Model (DOM) parsing technology can be used to transform the template description into a tree structure, marking the attributes and relationships of each node, such as specifying a node as a container and specifying the arrangement order and layout rules of its child nodes.

[0119] Loading the graphical rendering engine initializes the software components or framework environment used for UI rendering. The rendering engine instance provides the runtime foundation for subsequent visual element construction and presentation. Its loading process includes reading the engine configuration file, registering rendering plugins, preloading UI control libraries, and establishing a binding relationship with hardware graphics acceleration interfaces (such as GPU rendering contexts) to ensure subsequent rendering efficiency and performance. The specific implementation for generating the rendering engine instance can be achieved through software interface calls or container environment initialization, returning an instance object that can be used for rendering operations after resources are loaded.

[0120] Transforming component framework data into visual elements using a rendering engine instance involves converting the logical descriptions within the component framework data into visual objects that can be displayed on the interface. This transformation includes mapping the data model to actual graphical components; for example, converting title areas defined in the framework data into text controls and image placeholder areas into image components. During the transformation, the rendering engine instance parses data attributes such as style, size, and position, and generates an initial set of renderable visual elements. This set contains preliminary definitions of all visible interface elements to support subsequent visual optimizations.

[0121] Optimizing the rendering parameters of the initial visual element set involves fine-tuning the initially generated interface elements to ensure the final display meets business requirements and user experience needs. This optimization process includes adjusting element pixel precision, adapting to responsive layout requirements, resolving potential layout conflicts (such as component overlap), and supplementing default styles and interactive states. Optimization can be achieved through automated stylesheet application, adaptive adjustment algorithms, and alignment and distribution rules, ultimately generating an optimized visual element set as a collection of rendering objects that is correctly laid out, visually consistent, and styled.

[0122] Aggregating and optimizing visual element sets to generate basic components involves logically combining optimized individual interface elements, encapsulating multiple elements with inherent functional or visual relationships into basic components. These basic components embody complete interface unit functionality; for example, combining titles, descriptions, and buttons into a card component. The aggregation process considers the contextual relationships of elements, interaction requirements, and functional module divisions to form a set of components that can be reused on the page and are easy to maintain and extend. The aggregated result is a set of basic components containing all abstracted page module definitions.

[0123] Integrating the basic component set to generate a visual component set involves globally arranging and integrating the aggregated components to form the overall interface definition of the page structure. This step arranges the basic components according to a predetermined order and hierarchy based on page layout rules, generating a complete interface data model that can be directly rendered by the rendering engine. The integration process also includes detailed processing such as boundary alignment between components, spacing standardization, and cross-component style unification to ensure consistent and usable rendering output. The final visual component set prepares a deliverable interface structure for subsequent data injection and user interaction.

[0124] This embodiment transforms the abstract description in the page template into a complete set of visual components through a sequence of operations, including component framework parsing, rendering engine instantiation, element transformation, parameter optimization, component aggregation, and overall integration. This improves the consistency and accuracy of interface rendering, reduces manual development and adjustment costs, and enables the page interface rendering process to be highly automated and adaptable to different terminals and business scenarios.

[0125] In one embodiment, step S50 above includes:

[0126] S501, parse the structural attributes of the visualization component set and generate a component structural attribute table;

[0127] S502, Generate a data matching request set based on the component structure attribute table;

[0128] S503, based on the data matching request set, access the associated database to obtain associated data and generate the original associated dataset;

[0129] S504, Based on the component structure attribute table, parse the data compatibility strategy and generate a data compatibility strategy set;

[0130] S505, Filter the original associated dataset using the data compatibility strategy set to generate a compliant dataset;

[0131] S506, determine the quality score of the compliant dataset, and filter the compliant dataset to generate a high-quality candidate set based on the quality score and a dynamic quality threshold;

[0132] S507, The high-quality candidate set is trimmed and encapsulated to generate an adapted data block set;

[0133] S508, Inject the set of adaptive data blocks into the target component to generate a set of data-bound components;

[0134] S509, Integrate the data binding component set to generate the target page.

[0135] In this embodiment, parsing the structural attributes of the visualization component set is the process of extracting attributes from each integrated basic component within the set. This aims to determine the boundaries, functional types, data requirements, and layout relationships of all components on the page, thereby generating a component structure attribute table. This attribute table details the position coordinates, size parameters, display format, and the type and format requirements of the data to be bound to each component. In practice, the parsing logic needs to support traversing the component tree structure, identifying the attribute set of each component, and transforming it into a unified data model to ensure accurate component positioning and attribute adaptation capabilities in subsequent data injection processing.

[0136] Generating a data matching request set based on the component structure attribute table involves constructing a request data model capable of interacting with external databases based on the target component's data requirements specified in the attribute table. The data matching request set defines the fields, data types, format requirements, and contextual constraints of the data required by the target component. For example, it may specify that the component needs to display an insurance product list, user information summary, or specific statistical indicators. During the generation process, the component data interfaces, tag identifiers, and data adaptation rules recorded in the attribute table can be parsed and combined into standardized query conditions for accessing the backend relational database.

[0137] Accessing the associated database based on a data matching request set to retrieve associated data involves interacting with the database using the standardized requests generated in the previous step to retrieve the original associated dataset that the target component needs to populate. The associated database can be various types of data sources, including relational databases, graph databases, or column-oriented distributed data storage. In practice, query tasks are initiated through database connection pools, query engines, or graph query APIs. This operation ensures that the original associated dataset corresponds to the component's requirements and contains complete original data records for subsequent filtering and selection.

[0138] The data compatibility strategy based on component structure attribute table parsing utilizes the correspondence between component structure attributes and data content to generate a set of rules that can verify data format, content integrity, and business constraints—that is, a data compatibility strategy set. This strategy set can cover data format verification rules (such as numerical format, timestamp format, and currency unit standardization), data content constraints (such as data value range restrictions and legality checks), and business logic verification (such as consistency of data relationships). During strategy parsing, it relies on the field types recorded in the component attribute table, the business rule definitions, and the data content expression requirements, transforming them into a set of programmable verification and filtering rules.

[0139] Generating a compliant dataset by filtering the original related dataset using a set of data compatibility strategies involves applying the parsed data compatibility strategies one by one to the original related data. Each data entry is examined according to the logical conditions of the rule set, eliminating records that do not meet the requirements, and retaining only those records that conform to all data specifications and business requirements as the compliant dataset. In practice, a streaming data processing framework or parallel data validation algorithm is used to improve the processing efficiency of large-scale datasets, ensuring that the compliant dataset accurately matches the needs of page components while maintaining data quality.

[0140] Determining the quality score of the compliant dataset and generating a high-quality candidate set based on that score and a dynamic quality threshold involves a more detailed evaluation of the dataset's quality. The optimal data records are selected to form the candidate set by combining the scoring results with dynamically adjusted threshold standards. The quality score comprehensively calculates multiple dimensions such as data freshness, contextual relevance, and content completeness, while the dynamic quality threshold is adjusted based on the current page context, user profile, and real-time operational goals. This step, through a combination of data quality scoring functions and threshold judgment logic, selects the high-value candidate set with the best display effect.

[0141] The process of trimming and encapsulating the high-quality candidate data set to generate an adapted data block set involves segmenting the selected high-quality candidate data according to the target component's capacity requirements and data display format, organizing the data into standardized data blocks that can be directly injected into the component. During the trimming process, component space constraints, readability, and user experience are considered to avoid data overflow or content redundancy. The encapsulation process ensures that the data blocks are self-descriptive, including data source identifiers, field mapping rules, and style definitions, so that subsequent injection operations can be completed efficiently.

[0142] Injecting a set of adapted data blocks into a target component to generate a data-bound component set involves associating encapsulated data blocks with the target component through binding operations, enabling the component to display the required dynamic data content. Data binding operations include mapping data fields to the component's display area, data format rendering, and binding interactive states (such as populating clickable element data), ensuring that the data content is presented completely and accurately in the page's visual components. The data-bound component set is simply a collection of all components that have completed data binding and possess dynamic data display capabilities.

[0143] Integrating data-bound components to generate a target page involves arranging and combining all data-bound components according to predetermined page layout rules to form a complete target page output with business logic and data interaction capabilities. The integration process supports boundary alignment between components, interaction configuration, and style consistency checks, ultimately resulting in a complete page that can be displayed and interacted with by users.

[0144] This embodiment analyzes the structural attributes of a collection of visualized components and generates a standardized component structure attribute table. Combined with automated data request generation, data compatibility verification, two-stage data quality screening, trimming and encapsulation, and data binding, it ensures that each target component obtains high-quality associated data that closely matches its needs. At the same time, it reduces manual intervention, making page generation more efficient, data filling more accurate, and display effects more complete, thereby improving the content quality and user experience of digital marketing or service pages.

[0145] In one embodiment, step S60 above includes:

[0146] S601, Deploy the target page to the distribution server to generate the deployed page;

[0147] S602, Monitor user interaction behavior on the deployed page and generate a raw behavior log set;

[0148] S603, Analyze the original behavior log set to determine key indicators and generate a set of page performance indicators;

[0149] S604, Generate usage effect data based on the page performance indicator set;

[0150] S605, the set of entries to be updated in the location page feature vector library that are associated with the target page;

[0151] S606, Generate a feature update strategy based on the usage effect data;

[0152] S607, Modify the set of entries to be updated using the feature update strategy to generate optimized feature entries;

[0153] S608, Write back the optimized feature entries to the page feature vector library.

[0154] In this embodiment, deploying the target page to the distribution server involves pushing the fully functional page content, which has already been built, to the distribution node network through a standardized publishing process. This ensures that the page can be accessed and rendered on different user devices. Specific operations may include transmitting the page's static resources and dynamic interface configurations to the content distribution network nodes. Simultaneously, a load balancing strategy is used to rationally distribute traffic based on factors such as geographical location and network status, thereby achieving fast loading and stable access, ensuring the deployed page is available to the public.

[0155] Monitoring user interaction behavior on deployed pages involves recording various user actions on the page using event tracking technology and a user behavior analysis module. The raw behavior log set is the raw data collection generated during this monitoring process, specifically including user behavior information such as page access time, dwell time, clicked areas, form filling, scroll depth, and page exits. This information is recorded in the form of time series and event attributes, and is collected and stored in real time.

[0156] Analyzing the raw behavior log set to determine key metrics involves using a data analysis engine to clean, format, and calculate metrics from the collected behavior logs, extracting a set of important metrics for measuring page performance. The page performance metric set includes key data such as conversion rate, average visit duration, user interaction frequency, and bounce rate. These metrics can comprehensively reflect the page's attractiveness, content value, and interaction effectiveness.

[0157] Generating usage effectiveness data based on a set of page performance metrics involves structurally integrating multiple metrics into a quantitative information set that expresses the overall usage of the page. Usage effectiveness data can include a comprehensive page usage score, user segmentation usage, behavioral pattern clustering results, etc., and is stored in a traceable data structure for subsequent use in page optimization and feature library updates.

[0158] The set of entries to be updated in the page feature vector library associated with the target page is located by searching for entries associated with the current target page in the page feature vector library. By associating the usage effect data with the page history through page ID, template reference, version identifier or metadata index, the set of feature vector entries that need to be updated is found. This ensures that subsequent update operations only affect the vector data corresponding to the target page, maintaining the manageability and consistency of the vector library.

[0159] Feature update strategies based on usage performance data analyze the differences between current usage performance data and historical data to calculate adjustment rules for relevant feature vectors of the target page. These strategies may include feature vector weight adjustment factors, dimensional weighting parameters, time decay coefficients, and confidence adjustment coefficients. By comprehensively analyzing the deviation between the current page performance and preset standards, a standardized strategy that can be directly used for updating vector values ​​is formed.

[0160] Modifying the set of items to be updated using feature update strategies involves applying the generated update strategy to the items in the page feature vector library. This involves weighting or shifting each dimension of the feature vectors to better represent the page's performance based on the latest usage data. The modification process should support batch calculations and atomic updates across multiple dimensions to avoid concurrency conflicts or data inconsistencies, ultimately resulting in optimized feature items.

[0161] Writing back optimized feature entries to the page feature vector library involves persistently storing the modified vector data in the feature vector library, ensuring that the next feature retrieval, page template matching, or personalized recommendation can utilize the latest page feature vectors. The write-back process can include version control, data consistency verification, and vector compression storage, improving storage efficiency and preserving update history.

[0162] Example Description: In a healthcare business scenario, a hospital's digital services department wants to quickly build an activity page dedicated to appointment booking, health consultation, and personalized health management for users. Traditional methods would require over a week for business requirements gathering, documentation, UI design, front-end and back-end development, and integration testing, which is not conducive to the rapid promotion of short-term health education activities.

[0163] First, the system receives natural language input from medical operations staff through the hospital's official website's interactive interface. For example, a message might be, "I need a page for promoting health checkups, allowing users to book appointments online, view health information, and link their electronic health records." The system automatically generates an initial requirement description and verifies its completeness, checking for essential fields such as service type, target audience, and required content. If anything is missing, the system automatically triggers an information supplementation protocol, guiding operations staff to add key information like "target department" and "appointment entry style," generating a revised requirement description.

[0164] Subsequently, the system extracts domain entities from the supplemented requirements description, such as medical-related elements like "health checkup," "electronic health record," "appointment portal," and "target department," forming a domain entity set. By analyzing the semantic relationships between these entities, such as the service process relationship between "health checkup" and "appointment portal," a semantic relationship network is constructed. Finally, the system integrates this network with the supplemented requirements description to generate a structured requirements description, supporting more precise page generation in the future.

[0165] Next, the system loads a pre-defined intent recognition material library, which contains diverse medical scenario tags (such as "outpatient appointment," "health checkup package promotion," and "health consultation") and medical user tags (such as "chronic disease patients" and "elderly users"). The system parses the script flow and guiding word structure of the demand description, such as "allowing users to easily complete appointment registration," and generates a semantic feature vector. By matching it with the theme scenario set in the material library, an initial intent with a matching coefficient is obtained, and then the initial intent is corrected by combining the medical user tags (such as recognizing that the demand is aimed at "elderly users"). Based on the corrected intent, a candidate intent set is generated, and each candidate intent has a confidence score. Finally, the system selects the candidate intent with the highest confidence score, such as "generation of health checkup appointment page for elderly users," as the final user intent.

[0166] Subsequently, the system processes the user intent and generates a query feature vector for retrieval in the page feature vector library. It accesses the page feature vector library to obtain a set of related feature entries, calculates the similarity between the query feature vector and each set of entries, and generates a similarity score set. A candidate template set is filtered by setting a dynamic similarity threshold, for example, selecting templates such as "health checkup promotion page" and "appointment registration page". The system prioritizes the candidate template set, for example, by weighting it based on "senior user friendliness", and finally selects the highest-priority entry in the ranked template queue, such as "age-friendly health checkup appointment page template" as the page template.

[0167] After obtaining the page template, the system parses its framework structure, extracting sections for displaying health package lists, appointment entry points, and doctor introductions, generating component framework data. A graphical rendering engine is loaded and instantiated to support multi-resolution medical information display. This engine instance is used to convert the component framework data into visual elements, such as illustrated package cards and large-font buttons with supplementary text, generating an initial set of visual elements. The rendering parameters of the initial element set are optimized, such as adjusting color contrast, font size, and component spacing to suit the visual needs of elderly users, generating an optimized set of visual elements. These optimized elements are aggregated to generate basic components, such as a "health package module" and a "doctor introduction module," forming a basic component set. Finally, all basic component sets are integrated to form an age-friendly and easy-to-use set of visual components.

[0168] The system further injects associated data into target components (such as "Package List" and "Appointment Entry") within the visualization component set. Specifically, this involves parsing the structural attributes of the component set to generate a component structural attribute table (e.g., defining that the "Package List" must include "Name," "Price," and "Service Description" fields). Based on this structural attribute table, a data matching request set is generated, accessing associated databases (e.g., the hospital's health package database and doctor information database) to obtain the original associated dataset. The component structural attribute table is parsed to determine data compatibility strategies, such as performing adaptation checks on field formats ("Price" numeric format), content length, and image size, filtering out data that does not conform to the rules, and generating a compliant dataset. A quality score is calculated for the compliant dataset, for example, combining the sales history of packages with user reviews, and using dynamic quality thresholds to generate a high-quality candidate set. The high-quality candidate set is then trimmed and encapsulated, for example, displaying only the top 3 highly-rated packages, generating an adapted data block set. These adapted data block sets are injected into the target components, such as filling the "Package Module" with specific health checkup packages according to priority, ultimately forming a complete page bound to medical business data, which serves as the target page.

[0169] After the target page is generated, the system deploys it to the hospital's website distribution server and supports fast access for users in different regions through CDN nodes. The system continuously monitors user interaction behavior on the deployed pages, such as the frequency of users clicking the "Book Now" button and the duration of time spent in the "Doctor Introduction Module," forming a raw behavior log set. This log data is cleaned and analyzed to calculate key indicators, such as page conversion rate, appointment completion rate, and average browsing depth, forming a page performance indicator set. Based on this performance indicator set, usage effectiveness data is generated, such as a comprehensive score to evaluate the page's usability and attractiveness to elderly users. The system locates the set of items in the page feature vector library that are related to the target page and needs updating. By analyzing the current usage effectiveness data, a feature update strategy is generated, such as reducing the weight of feature vectors for poorly performing page templates and increasing the weight of templates with high appointment conversion rates. The update strategy is used to modify the set of items to be updated, forming optimized feature items, which are then written back to the page feature vector library to ensure that in the future, when there are similar needs such as "health checkups for elderly users," the system can prioritize recommending optimized, high-quality page templates.

[0170] In a fintech insurance business scenario, an insurance company's marketing department wanted to quickly build a one-page promotional page for insurance products aimed at young users, specifically for a newly launched short-term accident insurance product, to drive traffic via WeChat mini-program. The traditional process involved business requirements analysis, PRD writing, UI design, front-end and back-end development, and data testing, taking more than a week, significantly lagging behind the rapid iteration and operational pace of insurance products.

[0171] First, the system receives natural language input from operations personnel through the interactive interface of the insurance company's digital marketing backend. For example, a user might say, "I need a mobile page to promote short-term accident insurance, highlighting price advantages, showcasing the application process, and suitable for WeChat users." The system automatically generates an initial requirement description and verifies the completeness of the input, checking for fields such as promotional goals, page functionality, and target user attributes. If missing information is detected, the system automatically triggers an information supplementation protocol, guiding marketing personnel to supplement information such as "target age group" and "application entry point layout," generating a supplemented requirement description.

[0172] The system further analyzes the supplemented requirement description, extracting domain entities such as "short-term accident insurance," "insurance process," "WeChat users," and "price advantage," forming a domain entity set. By analyzing the semantic relationships between these entities—for example, using "short-term accident insurance" as the core product, "WeChat users" as the target audience, and "insurance process" as the main display content—a semantic relationship network is constructed. Finally, the semantic relationship network and the supplemented requirement description are integrated to generate a structured requirement description, providing clear and usable input for subsequent automated page construction.

[0173] Then, the system loads a pre-set intent recognition material library, which contains rich insurance promotion theme tags (such as "low-priced short-term protection", "health insurance promotion", "car insurance renewal") and user behavior tags (such as "first-time insured users", "frequent WeChat users"). The system parses the script flow and guiding word structure reflected in the requirement description, such as "highlighting convenient online insurance", and generates a semantic feature vector. By matching with the theme scenario set, an initial intent with a matching coefficient is obtained, and the intent is corrected by combining user behavior tags (such as identifying the target group as "mobile WeChat users"). Based on the corrected intent, an intent candidate set is generated, and combined with the confidence score, the candidate intent with the highest confidence is finally selected, such as "mobile low-priced short-term accident insurance promotion page" as the user intent.

[0174] Next, the system processes the user intent to generate a query feature vector and retrieves a set of relevant feature entries from the page feature vector library. It calculates the similarity between the query feature vector and each feature entry, generates a similarity score set, and filters out a candidate template set, such as "low-price insurance product promotion template" and "fast insurance conversion template." The candidate templates are then prioritized, for example, templates well-adapted to mobile devices are given priority. Finally, the highest priority entry is selected from the ranked template queue to obtain the page template.

[0175] After obtaining the page template, the system parses the template's framework structure, extracting page blocks such as the "Product Highlights Display Area," "Immediate Insurance Button Area," and "User Reviews Area," generating component framework data. A graphical rendering engine is loaded and instantiated to support multi-device adaptive rendering. This rendering engine instance is used to convert the component framework data into visual elements, generating an initial set of visual elements. The rendering parameters of the initial elements are further optimized, such as increasing font contrast on mobile pages and adjusting the spacing between images and text, generating an optimized set of visual elements. These optimized elements are aggregated to generate basic components, such as the "Insurance Plan Card Component," "Discount Price Display Component," and "Mobile Order Entry Component," forming a basic component set, which is then integrated to generate the final set of visual components.

[0176] Subsequently, for target components in the visualization component set, such as the "Insurance Plan Card Component" and the "Mobile Order Entry Component," related data is injected. Specifically, this includes: parsing the structural attributes of the visualization component set to generate a component structural attribute table (e.g., defining that the "Insurance Plan Card" must include "Product Name," "Coverage Scope," and "Price" fields). Based on the component structural attribute table, a data matching request set is generated, and related databases (e.g., insurance company product databases, rate databases) are accessed to obtain the original related dataset. The component structural attribute table is parsed to determine data compatibility strategies, such as checking price format, amount precision, and text length, filtering non-compliant data, and generating a compliant dataset. The compliant dataset is quality-scored, for example, by combining historical conversion rates and complaint rates, and using dynamic quality thresholds to select high-quality candidate sets. The high-quality candidate sets are then trimmed and encapsulated, for example, displaying a maximum of three insurance products, generating an adaptive data block set, injecting these data blocks into the target components, generating a data-bound component set, and finally integrating them to generate the target page for WeChat users.

[0177] The generated target page is deployed to the insurance company's distribution server and configured with a WeChat mini-program entry point to ensure quick access for users from WeChat. The system monitors user interaction behavior on the deployed page, such as recording the frequency of users clicking the "Insure Now" button and the duration of their stay in the "User Reviews" section, generating a raw behavior log set. This behavior log set is analyzed to determine key metrics, such as click-through rate, insurance conversion rate, and bounce rate, forming a page performance metric set. Based on this performance metric set, usage effect data is generated to evaluate the page's promotional effectiveness and user acceptance on mobile devices. The system locates the set of items in the page feature vector library associated with the target page that need updating. By analyzing the usage effect data, a feature update strategy is generated, such as reducing the weight of low-conversion-rate templates and increasing the weight of high-conversion-rate templates. This strategy modifies the set of items to be updated, generating optimized feature items, which are then written back to the page feature vector library. This ensures that high-conversion-rate page templates are prioritized when generating pages with similar needs in the future.

[0178] This embodiment deploys the target page to the distribution server and monitors user interaction behavior to generate detailed raw behavior logs. These logs are then subjected to in-depth analysis to extract key metrics. This metric data is combined to generate usage effect data, which is used for feature updates, continuously optimizing the content and structure of the page feature vector library. Utilizing a dynamic update mechanism driven by usage effect data, the page feature vectors better reflect actual user interaction behavior and preferences, providing a more accurate and efficient foundation for subsequent page template retrieval and matching. This improves the accuracy of page retrieval, the personalization of content presentation, and the overall user experience.

[0179] In one embodiment, a natural language-based page generation apparatus is provided, which corresponds one-to-one with the natural language-based page generation method described in the above embodiments. (Refer to...) Figure 3 , Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the natural language-based page generation device of the present invention. The modules include a request receiving module 10, an intent parsing module 20, a template retrieval module 30, an interface rendering module 40, a data injection module 50, and an effect feedback module 60. Detailed descriptions of each functional module are as follows:

[0180] Requirement receiving module 10 is used to obtain requirement descriptions in natural language form;

[0181] The intent parsing module 20 is used to parse the requirement description based on preset intent recognition materials and generate user intent;

[0182] Template retrieval module 30 is used to retrieve page templates from the page feature vector library based on the user intent;

[0183] The interface rendering module 40 is used to render the page template into a graphical user interface and generate a set of visual components.

[0184] Data injection module 50 is used to inject related data into the target component in the visualization component set to generate the target page;

[0185] The effect feedback module 60 is used to publish the target page or modify the target page and then publish it, collect the usage effect data of the target page, and update the page feature vector library using the usage effect data.

[0186] In one embodiment, the demand receiving module 10 is specifically used for:

[0187] The system receives initial natural language input through an interactive interface and generates an initial requirement description.

[0188] Verify the textual integrity of the initial requirements description and generate a verification status marker;

[0189] Based on the verification status flag triggering information supplementation protocol, the initial requirement description is supplemented to generate a supplemented requirement description;

[0190] Extract the domain entities from the supplemented requirement description to generate a domain entity set;

[0191] Analyze the semantic relationships between domain entities in the domain entity set to generate a semantic relationship network;

[0192] By integrating the semantic relationship network and the supplemented requirement description, a structured requirement description is generated.

[0193] In one embodiment, the intent parsing module 20 is specifically used for:

[0194] Load the preset intent recognition material library to generate a set of theme scenes and a set of user tags;

[0195] Analyze the script flow and guide word structure of the requirements description to generate semantic feature vectors;

[0196] The semantic feature vector is matched with the set of topic scenes to generate an initial intent with matching coefficients;

[0197] The initial intent is modified by combining the user tag set to generate a modified intent;

[0198] Based on the revised intent, generate a candidate set of intents with confidence scores;

[0199] The candidate intent with the highest confidence score is selected from the intent candidate set to generate the user intent.

[0200] In one embodiment, the template retrieval module 30 is specifically used for:

[0201] Process the user intent to generate a query feature vector;

[0202] Access the feature vector library on the page to obtain a set of feature entries;

[0203] Determine the similarity between the query feature vector and the set of feature entries, and generate a set of similarity scores;

[0204] The candidate template set is filtered based on the similarity score set;

[0205] The candidate template set is sorted by priority to generate a sorted template queue;

[0206] The highest priority entry is selected from the sorting template queue to obtain the page template.

[0207] In one embodiment, the interface rendering module 40 is specifically used for:

[0208] The frame structure of the page template is parsed to generate component frame data;

[0209] Load the graphical rendering engine and generate a rendering engine instance;

[0210] The rendering engine instance is used to transform the component framework data into visual elements, generating an initial set of visual elements;

[0211] Optimize the rendering parameters of the initial visualization element set to generate an optimized visualization element set;

[0212] The optimized set of visual elements is aggregated to generate basic components, resulting in a set of basic components.

[0213] Integrate the aforementioned basic component set to generate a visual component set.

[0214] In one embodiment, the data injection module 50 is specifically used for:

[0215] Parse the structural attributes of the visualization component collection to generate a component structural attribute table;

[0216] Generate a data matching request set based on the component structure attribute table;

[0217] Based on the data matching request set, access the associated database to obtain associated data and generate the original associated dataset;

[0218] Based on the component structure attribute table, the data compatibility strategy is parsed and a data compatibility strategy set is generated.

[0219] The original associated dataset is filtered using the data compatibility strategy set to generate a compliant dataset.

[0220] Determine the quality score of the compliant dataset, and filter the compliant dataset based on the quality score and a dynamic quality threshold to generate a high-quality candidate set;

[0221] The high-quality candidate set is trimmed and encapsulated to generate an adapted data block set;

[0222] Inject the set of adapted data blocks into the target component to generate a set of data-bound components;

[0223] Integrate the data binding component set to generate the target page.

[0224] In one embodiment, the effect feedback module 60 is specifically used for:

[0225] Deploy the target page to the distribution server to generate a deployed page;

[0226] Monitor user interaction behavior on the deployed pages and generate a raw behavior log set;

[0227] Analyze the original behavior log set to determine key metrics and generate a set of page performance metrics.

[0228] Generate usage effect data based on the aforementioned page performance indicator set;

[0229] The set of entries to be updated in the feature vector library of the location page that are associated with the target page;

[0230] A feature update strategy is generated based on the aforementioned usage effect data;

[0231] The feature update strategy is used to modify the set of entries to be updated, thereby generating optimized feature entries;

[0232] Write back the optimized feature entries to the page feature vector library.

[0233] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 4 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with external user terminals via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a natural language-based page generation method on the server side.

[0234] In one embodiment, a computer device is provided, which may be a user terminal, and its internal structure diagram may be as follows: Figure 5 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with an external server via a network connection. When executed by the processor, the computer program implements the user-side functions or steps of a natural language-based page generation method.

[0235] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps:

[0236] Requirements description in natural language form;

[0237] The user intent is generated by parsing the requirement description based on preset intent recognition materials.

[0238] Based on the user's intent, a page template is obtained by searching the page feature vector library.

[0239] The page template is rendered using a graphical user interface to generate a set of visual components;

[0240] Inject relevant data into the target component in the set of visualization components to generate the target page;

[0241] The target page is published or modified and then published, and the usage effect data of the target page is collected. The page feature vector library is then updated using the usage effect data.

[0242] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor:

[0243] Requirements description in natural language form;

[0244] The user intent is generated by parsing the requirement description based on preset intent recognition materials.

[0245] Based on the user's intent, a page template is obtained by searching the page feature vector library.

[0246] The page template is rendered using a graphical user interface to generate a set of visual components;

[0247] Inject relevant data into the target component in the set of visualization components to generate the target page;

[0248] The target page is published or modified and then published, and the usage effect data of the target page is collected. The page feature vector library is then updated using the usage effect data.

[0249] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and user side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0250] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0251] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0252] It should be noted that if any software tools or components not belonging to this company appear in the embodiments of this application, they are merely illustrative examples and do not represent actual use. The embodiments described above are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A page generation method based on natural language, characterized in that, Includes the following steps: The requirement is to obtain a description of the natural language form; The user intent is generated by parsing the requirement description based on preset intent recognition materials. Based on the user's intent, a page template is obtained by searching the page feature vector library. The page template is rendered using a graphical user interface to generate a set of visual components; Inject relevant data into the target component in the set of visualization components to generate the target page; The target page is published or modified and then published, and the usage effect data of the target page is collected. The page feature vector library is then updated using the usage effect data.

2. The natural language-based page generation method as described in claim 1, characterized in that, The requirements for obtaining natural language form include: The system receives initial natural language input through an interactive interface and generates an initial requirement description. Verify the textual integrity of the initial requirements description and generate a verification status marker; Based on the verification status flag triggering information supplementation protocol, the initial requirement description is supplemented to generate a supplemented requirement description; Extract the domain entities from the supplemented requirement description to generate a domain entity set; Analyze the semantic relationships between domain entities in the domain entity set to generate a semantic relationship network; By integrating the semantic relationship network and the supplemented requirement description, a structured requirement description is generated.

3. The natural language-based page generation method as described in claim 1, characterized in that, Based on preset intent recognition materials, the user intent is generated by parsing the demand description, including: Load the preset intent recognition material library to generate a set of theme scenes and a set of user tags; Analyze the script flow and guide word structure of the requirements description to generate semantic feature vectors; The semantic feature vector is matched with the set of topic scenes to generate an initial intent with matching coefficients; The initial intent is modified by combining the user tag set to generate a modified intent; Based on the revised intent, generate a candidate set of intents with confidence scores; The candidate intent with the highest confidence score is selected from the intent candidate set to generate the user intent.

4. The natural language-based page generation method as described in claim 1, characterized in that, Based on the user intent, a search is performed in the page feature vector library to obtain a page template, including: Process the user intent to generate a query feature vector; Access the feature vector library on the page to obtain a set of feature entries; Determine the similarity between the query feature vector and the set of feature entries, and generate a set of similarity scores; The candidate template set is filtered based on the similarity score set; The candidate template set is sorted by priority to generate a sorted template queue; The highest priority entry is selected from the sorting template queue to obtain the page template.

5. The natural language-based page generation method as described in claim 1, characterized in that, The page template is rendered using a graphical user interface to generate a set of visual components, including: The frame structure of the page template is parsed to generate component frame data; Load the graphical rendering engine and generate a rendering engine instance; The rendering engine instance is used to transform the component framework data into visual elements, generating an initial set of visual elements; Optimize the rendering parameters of the initial visualization element set to generate an optimized visualization element set; The optimized set of visual elements is aggregated to generate basic components, resulting in a set of basic components. Integrate the aforementioned basic component set to generate a visual component set.

6. The natural language-based page generation method as described in claim 1, characterized in that, Injecting associated data into the target component in the set of visualization components to generate the target page includes: Parse the structural attributes of the visualization component collection to generate a component structural attribute table; Generate a data matching request set based on the component structure attribute table; Based on the data matching request set, access the associated database to obtain associated data and generate the original associated dataset; Based on the component structure attribute table, the data compatibility strategy is parsed and a data compatibility strategy set is generated. The original associated dataset is filtered using the data compatibility strategy set to generate a compliant dataset. Determine the quality score of the compliant dataset, and filter the compliant dataset based on the quality score and a dynamic quality threshold to generate a high-quality candidate set; The high-quality candidate set is trimmed and encapsulated to generate an adapted data block set; Inject the set of adapted data blocks into the target component to generate a set of data-bound components; Integrate the data binding component set to generate the target page.

7. The natural language-based page generation method as described in claim 1, characterized in that, Publishing the target page or modifying and then publishing the target page, collecting usage effect data of the target page, and updating the page feature vector library using the usage effect data, including: Deploy the target page to the distribution server to generate a deployed page; Monitor user interaction behavior on the deployed pages and generate a raw behavior log set; Analyze the original behavior log set to determine key metrics and generate a set of page performance metrics. Generate usage effect data based on the aforementioned page performance indicator set; The set of entries to be updated in the feature vector library of the location page that are associated with the target page; A feature update strategy is generated based on the aforementioned usage effect data; The feature update strategy is used to modify the set of entries to be updated, thereby generating optimized feature entries; Write back the optimized feature entries to the page feature vector library.

8. A page generation device based on natural language, characterized in that, The natural language-based page generation device includes: The requirement receiving module is used to obtain requirement descriptions in natural language. The intent parsing module is used to parse the requirement description based on preset intent recognition materials and generate user intent; The template retrieval module is used to retrieve page templates from the page feature vector library based on the user intent. The interface rendering module is used to render the page template into a graphical user interface and generate a set of visual components. The data injection module is used to inject relevant data into the target component in the visualization component set to generate the target page; The effect feedback module is used to publish the target page or modify the target page and then publish it, collect the usage effect data of the target page, and update the page feature vector library using the usage effect data.

9. A computer device, characterized in that, The computer device includes a memory, a processor, and a natural language-based page generation program stored in the memory and executable on the processor, wherein the natural language-based page generation program, when executed by the processor, implements the steps of the natural language-based page generation method as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The storage medium stores a natural language-based page generation program, which, when executed by a processor, implements the steps of the natural language-based page generation method as described in any one of claims 1-7.

Images