Intelligent product page automatic generation method and system for mass health industry

Abstract

The invention relates to the technical field of data processing, and discloses an intelligent product page automatic generation method and system for the massive health industry. The method comprises the following steps: performing multi-modal analysis and augmented reality processing on a large health industry prototype graph and multi-source medical data to obtain augmented design information; performing dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge associated data; performing adaptive micro-service deployment analysis on the semantic structure and knowledge associated data to obtain a containerized deployment strategy, and performing intention-driven API design and homomorphic encryption enhancement processing to obtain API interface specification data; performing component design and code generation processing on the API interface specification data to obtain a multi-modal interaction page code; and performing intelligent rendering and dynamic content filling on the multi-modal interaction page code to obtain a target product page. According to the method and the device, the efficiency and the accuracy of automatic generation of intelligent product pages in the large health industry are improved.

Description

Technical Field

[0001] The present application relates to the field of data processing technology, and in particular to an intelligent product page automatic generation method and system for the big health industry. Background Art

[0002] In the current big health industry, the development of product pages usually relies on traditional manual design and coding methods. This method usually includes UI / UX designers creating prototypes, front-end developers writing HTML, CSS and JavaScript code based on the design drafts, and back-end developers building APIs and database structures. This process also involves multiple communications and modifications to ensure that the final product meets the design requirements and functional requirements. At the same time, product pages in the big health industry also need to consider special requirements, such as the security of medical data, privacy protection, and complex medical terminology display.

[0003] However, this traditional approach has several shortcomings. First, the entire development process is time-consuming and requires the collaboration of multiple professional teams, which increases communication costs and error rates. Second, manual coding is prone to human errors, especially when dealing with complex medical data and logic. Third, traditional methods are difficult to quickly adapt to changing medical needs and technological updates. Finally, in terms of ensuring the security and privacy of medical data, traditional methods often require additional development work and expertise, which increases development difficulty and cost. Summary of the invention

[0004] The present application provides a method and system for automatically generating intelligent product pages for the big health industry, which are used to improve the efficiency and accuracy of automatically generating intelligent product pages for the big health industry.

[0005] In the first aspect, the present application provides a method for automatically generating intelligent product pages for the big health industry, and the method for automatically generating intelligent product pages for the big health industry includes: performing multimodal analysis and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information; performing dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data; performing adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy; performing intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data; performing component design and code generation processing on the API interface specification data to obtain multimodal interaction page code; performing intelligent rendering and dynamic content filling on the multimodal interaction page code to obtain a target product page.

[0006] In combination with the first aspect, in a first implementation method of the first aspect of the present application, the collected big health industry prototype images and multi-source medical data are subjected to multimodal analysis and augmented reality processing to obtain enhanced design information, including: performing image preprocessing on the big health industry prototype images to obtain standardized image data, and performing data cleaning and format unification processing on the multi-source medical data to obtain standardized medical data; performing feature extraction on the standardized image data through a convolutional neural network to obtain an image feature vector, and performing text feature extraction on the standardized medical data to obtain a text feature vector; performing feature fusion on the image feature vector and the text feature vector to obtain fused feature data; performing three-dimensional spatial mapping on the fused feature data to obtain a three-dimensional enhanced design model; performing semantic segmentation on the three-dimensional enhanced design model to obtain hierarchical design structure data; performing geometric transformation and lighting rendering on the hierarchical design structure data to obtain enhanced design information.

[0007] In combination with the first aspect, in a second implementation method of the first aspect of the present application, the enhanced design information is dynamically mapped to a knowledge graph and causal reasoning is performed to obtain a semantic structure and knowledge association data, including: performing named entity recognition on the enhanced design information to obtain a medical entity set, and performing entity relationship extraction on the medical entity set to obtain an entity relationship network; performing knowledge graph construction on the entity relationship network to obtain an initial knowledge graph, and performing knowledge reasoning and supplementation on the initial knowledge graph to obtain a complete knowledge graph; performing low-dimensional vector representation on the complete knowledge graph to obtain a graph embedding vector, and performing semantic similarity calculation on the graph embedding vector to obtain a semantic association matrix; performing causal relationship reasoning on the semantic association matrix to obtain a causal relationship graph, and performing critical path identification on the causal relationship graph to obtain a critical causal chain; performing semantic structure analysis on the critical causal chain to obtain a semantic structure tree, and performing domain ontology alignment on the semantic structure tree to obtain a semantic ontology network; performing multi-source knowledge integration on the semantic ontology network through a knowledge fusion algorithm to obtain a semantic structure and knowledge association data.

[0008] In combination with the first aspect, in a third implementation method of the first aspect of the present application, the adaptive microservice deployment analysis of the semantic structure and knowledge-related data to obtain a containerized deployment strategy includes: dividing the semantic structure and knowledge-related data into functional modules to obtain a microservice candidate set, and performing service dependency analysis on the microservice candidate set to obtain a service dependency graph; estimating the service load on the service dependency graph to obtain a service load distribution, and performing computing resource allocation on the service load distribution to obtain a preliminary resource allocation plan; designing service containerization for the preliminary resource allocation plan to obtain a container combination plan, and performing service network planning on the container combination plan to obtain a service network topology; designing a service registration and discovery mechanism for the service network topology to obtain a service registry, and formulating a traffic distribution strategy for the service registry to obtain load balancing rules; designing a dynamic expansion and contraction strategy for the load balancing rules to obtain an elastic scaling plan, and designing a high availability assurance mechanism for the elastic scaling plan to obtain a fault recovery strategy; automatically generating deployment scripts for the fault recovery strategy to obtain a containerized deployment strategy.

[0009] In combination with the first aspect, in a fourth implementation method of the first aspect of the present application, the containerized deployment strategy is subjected to intent-driven API design and homomorphic encryption enhancement processing to obtain API interface specification data, including: performing service function analysis on the containerized deployment strategy to obtain a service function list, and performing user intent identification on the service function list to obtain an intent-driven requirement list; performing API endpoint design on the intent-driven requirement list to obtain an API endpoint sketch, and performing request method definition on the API endpoint sketch to obtain an HTTP method mapping table; performing request parameter design on the HTTP method mapping table to obtain an input parameter pattern, and performing response structure design on the input parameter pattern to obtain an output data format; performing data flow analysis on the output data format to obtain sensitive data tags, and performing homomorphic encryption scheme design on the sensitive data tags to obtain an encrypted field mapping; performing key management mechanism design on the encrypted field mapping to obtain a key distribution strategy, and formulating a secure communication protocol for the key distribution strategy to obtain an encrypted transmission scheme; performing API document generation on the encrypted transmission scheme to obtain API interface specification data.

[0010] In combination with the first aspect, in a fifth implementation of the first aspect of the present application, the component design and code generation processing of the API interface specification data to obtain a multimodal interactive page code includes: performing interface layout analysis on the API interface specification data to obtain a page structure framework, and dividing the page structure framework into components to obtain a component hierarchy tree; defining component attributes on the component hierarchy tree to obtain a component configuration list, and performing state management design on the component configuration list to obtain a state flow diagram; performing event processing mechanism design on the state flow diagram to obtain an event listener list, and performing data processing on the event listener list; According to the binding rule formulation, a data synchronization solution is obtained; the API call logic design is performed on the data synchronization solution to obtain an interface call flow chart, and an error handling strategy is formulated for the interface call flow chart to obtain an exception handling mechanism; a multimodal interaction design is performed on the exception handling mechanism to obtain an interaction mode definition, and barrier-free functions are integrated into the interaction mode definition to obtain an accessibility solution; code template matching is performed on the accessibility solution to obtain a basic code structure, and component logic injection is performed on the basic code structure to obtain candidate component codes, and the candidate component codes are integrated to obtain the multimodal interaction page code.

[0011] In combination with the first aspect, in a sixth implementation method of the first aspect of the present application, the multimodal interactive page code is intelligently rendered and dynamically filled with content to obtain a target product page, including: constructing a DOM tree for the multimodal interactive page code to obtain a page structure tree, and performing style calculation on the page structure tree to obtain a style rule set; performing layout calculation on the style rule set to obtain layout information, and performing layer analysis on the layout information to obtain a rendering hierarchy table; performing drawing operations on the rendering hierarchy table to obtain graphics drawing instructions, and performing synthesis processing on the graphics drawing instructions to obtain a page view; performing data source binding on the page view to obtain a data binding mapping, and performing asynchronous loading strategy formulation on the data binding mapping to obtain a content loading scheme; performing interactive event registration on the content loading scheme to obtain an event listener set, and performing a state update mechanism design on the event listener set to obtain a state manager; performing performance monitoring point setting on the state manager to obtain a performance indicator set, and integrating the performance indicator set with the page view to obtain the target product page.

[0012] In a second aspect, the present application provides an intelligent product page automatic generation system for the big health industry, and the intelligent product page automatic generation system for the big health industry includes:

[0013] The parsing module is used to perform multimodal parsing and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information;

[0014] A mapping module, used to perform dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data;

[0015] A deployment module, used to perform adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy;

[0016] An encryption module is used to perform intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data;

[0017] A generation module is used to perform component design and code generation processing on the API interface specification data to obtain a multimodal interactive page code;

[0018] The filling module is used to intelligently render and dynamically fill the multimodal interactive page code to obtain a target product page.

[0019] In the technical solution provided by this application, through multimodal analysis and augmented reality processing technology, prototype images and multi-source medical data can be accurately understood and transformed, which greatly improves the integrity and accuracy of design information and lays a solid foundation for subsequent page generation. The dynamic knowledge graph mapping and causal reasoning technology are used to achieve a deep understanding of the complex semantic structure and knowledge association in the medical field, which not only ensures the professionalism and accuracy of the generated page, but also provides the possibility for intelligent content display and user interaction. Furthermore, the introduction of adaptive microservice deployment analysis makes the generated page more scalable and flexible, and can better adapt to the rapidly changing needs of the big health industry. At the same time, the intent-driven API design and homomorphic encryption enhanced processing greatly improve the security and privacy protection capabilities of the system, which is crucial for processing sensitive medical data. In the component design and code generation link, this method can automatically generate multimodal interactive page code that meets modern front-end development standards, which not only improves development efficiency, but also ensures the consistency of code quality. Through intelligent rendering and dynamic content filling, high-performance display and smooth interaction of the page are achieved, which greatly improves the user experience. Significantly shorten the development cycle, reduce human resource investment, and reduce development costs. It can quickly respond to changes in market demand, making product iteration more agile. At the same time, since the entire process is automated, human errors are greatly reduced, the stability of product quality is improved, and the efficiency and accuracy of automatic generation of intelligent product pages for the big health industry are improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other accompanying drawings can be obtained based on these accompanying drawings without paying creative work.

[0021] Figure 1 This is a schematic diagram of an embodiment of a method for automatically generating an intelligent product page for the health industry in an embodiment of the present application;

[0022] Figure 2 This is a schematic diagram of an embodiment of an intelligent product page automatic generation system for the big health industry in an embodiment of the present application. DETAILED DESCRIPTION

[0023] The present application embodiment provides a method and system for automatically generating intelligent product pages for the health industry. The terms "first", "second", "third", "fourth", etc. (if any) in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects, and do not have to be used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments described here can be implemented in an order other than that illustrated or described here. In addition, the terms "including" or "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0024] For ease of understanding, the specific process of the embodiment of the present application is described below. Figure 1 , an embodiment of the method for automatically generating intelligent product pages for the big health industry in the embodiments of the present application includes:

[0025] Step S101: performing multimodal analysis and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information;

[0026] It is understandable that the execution subject of this application can be an intelligent product page automatic generation system for the big health industry, or a terminal or a server, which is not limited here. The embodiment of this application is described by taking the server as the execution subject as an example.

[0027] Specifically, inputs are received from different sources, including prototype images of the big health industry (which may be in PNG, JPG or SVG format) and various forms of medical data (such as medical record text, medical images, laboratory test results, etc.). Next, the prototype images will be preprocessed using advanced image processing techniques, including denoising, contrast adjustment, and resolution standardization to ensure the accuracy of subsequent analysis. At the same time, for multi-source medical data, data cleaning and format unification will be performed to remove outliers and redundant information, and convert data in different formats into a standard format. Then, deep learning algorithms, such as convolutional neural networks (CNNs), will be used to extract features from the preprocessed prototype images to identify key information such as page layout, UI elements, and design style. For text-based medical data, natural language processing (NLP) technologies, such as BERT or GPT models, will be used to extract keywords, semantic structures, and contextual information. For medical image data, specialized medical image analysis algorithms may be used for feature extraction. After completing the feature extraction of each modality data, multimodal fusion algorithms, such as attention mechanisms or graph neural networks, will be used to integrate information from different sources into a unified feature representation. This fusion process not only considers the features of each modality, but also analyzes the interrelationships and dependencies between them. Next, the fused feature information is mapped into three-dimensional space to create a preliminary augmented reality (AR) model. This AR model can intuitively show the relationship between the prototype design and medical data. Subsequently, the AR model is further semantically segmented and structured to identify different functional areas and interactive elements. Finally, the structured AR model is rendered and optimized, adding appropriate lighting effects and interactive features to obtain the final augmented design information. For example, suppose there is a prototype of an electronic medical record and some real medical record data. First, the prototype is analyzed to identify key parts such as the medical record entry area, diagnosis suggestion area, and drug information area. Then, it analyzes the common fields and data structures in the real medical record data. In the multimodal fusion stage, the UI elements in the prototype are matched with the structure of the actual medical record data. It may be found that some necessary fields are missing in the prototype design, or the display of some fields is not intuitive enough. When creating the AR model, the page layout may be automatically adjusted, missing fields may be added, or the data display method may be optimized. For example, it may change the original flat display of drug information to a three-dimensional drug model, so that doctors and patients can understand the medication information more intuitively.

[0028] Step S102: Perform dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data;

[0029] Specifically, the augmented design information is deeply parsed, and named entity recognition (NER) technology is used to identify key medical concepts, terms, and entities in the text. These entities may include disease names, symptoms, drugs, treatment methods, etc. At the same time, the system uses relationship extraction algorithms to identify various relationships between these entities, such as "treatment", "cause", "prevention", etc. Next, the system uses these identified entities and relationships, combined with the pre-built medical field knowledge graph, to perform dynamic knowledge graph mapping. In this process, the system not only maps the identified entities and relationships to the existing knowledge graph, but also dynamically expands and updates the knowledge graph based on new information. For example, if the system identifies a new association between a symptom and a disease, and this association does not exist in the original knowledge graph, the system will automatically add this new association. After completing the knowledge graph mapping, the system uses graph embedding technology, such as TransE or ComplEx, to convert the entities and relationships in the knowledge graph into low-dimensional vector representations. This vector representation can capture the semantic similarity between entities and relationships, laying the foundation for subsequent causal reasoning. Next, the system will use causal discovery algorithms, such as the PC algorithm or the FCI algorithm, to analyze these vector representations and identify potential causal relationships. This process not only considers direct associations, but also analyzes indirect, multi-step causal chains. For example, the system may find that a certain lifestyle indirectly increases the risk of a certain disease by affecting a certain physiological indicator. After identifying these causal relationships, the system will conduct further semantic structure analysis to integrate these causal relationships into a larger semantic network. This network contains not only entities and relationships, but also the hierarchical structure, semantic categories, and contextual information between them. Finally, the system will align this semantic network with the domain ontology to ensure that the generated knowledge structure is consistent with the standard medical terminology and concept system. Through this series of complex processing, the system finally obtains a rich, structured semantic structure and knowledge association dataset. For example: suppose the enhanced design information contains a page design about diabetes management. The system will first identify key entities such as "diabetes", "blood sugar", "insulin", "exercise", "diet", and the relationships between them, such as "exercise helps control blood sugar". The system will then map this information to the existing medical knowledge graph, and may discover some new, not yet widely recognized associations, such as a certain type of exercise that is particularly effective in controlling blood sugar. When performing causal reasoning, the system may identify a causal chain: irregular work and rest habits → endocrine disorders → abnormal insulin secretion → poor blood sugar control → increased risk of diabetic complications. Based on these findings, the system will generate a semantic structure containing these entities, relationships, and causal chains. This structure not only reflects the information in the page design, but also includes broader medical knowledge and causal relationships.

[0030] Step S103: performing adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy;

[0031] Specifically, the semantic structure and knowledge-related data are deeply analyzed to identify different functional modules and data dependencies. In this process, the system considers factors such as data type, scale, access frequency, and processing complexity to preliminarily divide the potential microservice boundaries. Then, the system uses the principles of domain-driven design (DDD) to further refine and adjust these preliminarily divided modules to ensure that each microservice has a clear business boundary and an independent data model. On this basis, the system analyzes the call relationship and data flow between these microservices and builds a detailed service dependency graph. This dependency graph not only includes direct service calls, but also considers indirect data dependencies and potential performance bottlenecks. Subsequently, the system uses a load prediction algorithm to estimate the resource requirements of each microservice based on historical data and business growth expectations. This estimation process considers multiple dimensions such as CPU usage, memory consumption, and network bandwidth to provide a basis for subsequent resource allocation. Based on these analysis results, the system uses an intelligent resource allocation algorithm to formulate a preliminary resource allocation plan for each microservice. This plan considers factors such as the importance of the service, performance requirements, and available resources, and strives to maximize resource utilization while ensuring performance. Next, the system will enter the containerization design phase. It will select the appropriate base image for each microservice, configure the necessary environment variables and dependencies, and generate a Dockerfile. At the same time, the system will also consider the characteristics of the service, such as whether persistent storage is required, whether there are special network requirements, etc., to decide whether to use a specific container orchestration strategy. In this process, the system will also design a service discovery mechanism, and may choose to use tools such as Consul or etcd to achieve dynamic service registration and discovery. In addition, the system will also formulate a load balancing strategy, and may use reverse proxy tools such as Nginx or Traefik to achieve balanced distribution of traffic. Considering the special needs of the big health industry, the system will also pay special attention to data security and privacy protection. It may configure additional security measures for services that handle sensitive medical data, such as encrypted transmission and access control. At the same time, the system will also design fault recovery and data backup strategies to ensure that services can be quickly restored and important data can be protected in the event of an unexpected situation. Finally, the system will generate detailed deployment scripts and configuration files, including DockerCompose files or Kubernetes deployment manifests, to achieve automated deployment and management of the entire microservice architecture. For example: suppose there is a big health platform that includes functions such as user management, health data collection, data analysis, and diagnostic recommendations. The system first divides these functions into independent microservices, such as user services, data collection services, analysis services, and diagnostic services. Then, the system analyzes the dependencies between these services, such as the diagnostic service depends on the output of the data analysis service.In load forecasting, the system may find that data analysis services require higher computing resources, while user services require larger storage resources. Based on these analyses, the system configures high-performance containers for data analysis services, which may use GPU acceleration; and configures containers with persistent storage for user services. In containerized design, the system creates a dedicated Docker image for each service and sets appropriate resource limits and requests in the Kubernetes deployment manifest. For data security, the system may deploy an encryption agent between diagnostic services and data storage to ensure the secure transmission of sensitive medical data. Ultimately, the deployment strategy generated by the system includes not only the container configuration of each service, but also network policies, security policies, monitoring and log collection configuration, etc., forming a complete, secure, and efficient microservice deployment solution.

[0032] Step S104: perform intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data;

[0033] Specifically, the semantic structure and knowledge association data obtained in step S102 are first used to parse the core business concepts and their relationships, laying the foundation for the API resource model. Next, the system analyzes the user interface elements and interaction processes in the prototype diagram, and uses natural language processing technology to identify the user's operation intentions. It may use intent classification algorithms such as BERT or deep learning models such as XLNet. The system maps these intentions to specific API operations, such as GET, POST, PUT, etc. Then, the knowledge graph constructed in step S102 is used to enrich the semantic content of the API, and the API endpoints of the associated resources are automatically generated according to the relationship between entities. The system also uses causal reasoning results to design smarter APIs, such as designing predictive or suggestive API endpoints based on the identified key causal chains.

[0034] Based on the above analysis, the system automatically generates a preliminary API endpoint design, including resource path, HTTP method, request parameters, and response structure, to ensure compliance with RESTful principles. Next, the system performs data flow analysis and identifies sensitive data fields involved in the API by referring to the data attribute tags in the knowledge graph. For the identified sensitive data, the system designs a homomorphic encryption scheme, which may choose partial homomorphic encryption (PHE) or full homomorphic encryption (FHE), depending on the nature of the data and computing requirements. The system also designs a key management mechanism, including key generation, distribution, storage, and rotation strategies to ensure the security and availability of the encryption system. During the API design process, the system automatically generates security-related endpoints, such as user authentication, authorization, and audit logs, to ensure compliance with the latest security best practices. Finally, the system generates detailed API documentation, including descriptions of each endpoint, parameter descriptions, request examples, and response formats. These documents not only contain technical details, but also include usage guidelines and best practice recommendations, and come with semantic annotations to help developers understand the connection between APIs and business domain knowledge.

[0035] For example, suppose you are designing an API for a smart health management platform. The system first analyzes the semantic structure and identifies core concepts such as "user", "health data", "exercise plan", etc. By analyzing the prototype diagram, the system identifies the main operation intentions, such as "record health data", "generate personalized exercise suggestions", "check health trends", etc.

[0036] Based on these analyses, the system designs API endpoints such as:

[0037] 1.POST / health-data: records the user's health data;

[0038] 2.GET / exercise-recommendations: Get personalized exercise recommendations;

[0039] 3.GET / health-trends: View health trend analysis.

[0040] Using the knowledge graph, the system automatically adds relevant endpoints, such as GET / nutrition-info / {food-id}, to provide nutrition information related to exercise recommendations. Applying the results of causal reasoning, the system designed a predictive API endpoint: GET / health-risk-prediction, which predicts potential health risks based on the user's health data and lifestyle. In data stream analysis, the system identifies that health data contains sensitive information. Therefore, for the POST / health-data endpoint, the system uses a partially homomorphic encryption scheme to encrypt specific health indicators, and uses fully homomorphic encryption for numerical health data that may require statistical analysis. In the API documentation, the system not only provides technical details of these endpoints, but also includes semantic annotations. For example, for the / health-risk-prediction endpoint, the documentation explains the causal relationships on which this prediction is based and how to interpret the prediction results, helping developers better understand and use the API.

[0041] Step S105: Perform component design and code generation processing on the API interface specification data to obtain a multimodal interaction page code;

[0042] Specifically, the API interface specification data is deeply analyzed to extract key data structures, operation types, and business logic. Based on this information, the system will design a preliminary page layout and component structure, taking into account the user experience principles and the special needs of the big health industry. Next, the system will use a componentized design approach to split the page into multiple independent but interrelated components. Each component will be assigned specific functions and responsibilities, such as data display, user input, interaction control, etc. At this stage, the system will also consider the reusability and maintainability of the components, and may create some general component libraries to improve development efficiency. Subsequently, the system will define detailed properties and events for each component, which will be based on the specifications of the API interface to ensure that the components can correctly interact with the backend service for data. At the same time, the system will also design the communication mechanism between components, and may adopt state management patterns such as Flux or Redux to handle complex data flows and state changes. Next, the system will enter the code generation stage. It will select appropriate front-end frameworks and libraries, such as React, Vue, or Angular, and use the best practices of these tools to generate component code. During the generation process, the system automatically handles key logic such as API calls, data binding, and state management. For components that need to process encrypted data, the system will integrate the necessary decryption logic to ensure that the data can be securely displayed and processed on the client side. Considering the particularity of the big health industry, the system will also pay special attention to generating code that complies with accessibility standards (such as WCAG) to ensure that the generated pages are friendly to all user groups. In addition, the system will generate necessary error handling and exception capture code to improve the robustness of the application. In terms of multimodal interaction design, the system will automatically select the appropriate interaction mode based on the functions and data types of the API. For example, for numerical health data, the system may generate a chart or dashboard component; for image data, an image viewer that supports zooming and annotation may be generated; for time series data, an interactive timeline component may be generated. The system will also consider different input methods, such as touch, voice, or gesture input, and generate corresponding processing code. Finally, the system will generate the overall page framework code, assemble all components, and add the necessary routing logic and global state management. At the same time, the system will also generate unit test and integration test code to ensure the quality of the generated page code. Let's use a specific example to illustrate this process: suppose you are designing a page for a remote patient monitoring system. The API interface specification defines interfaces for obtaining basic patient information, real-time vital signs, and historical health records. The system first designs a page layout that includes a patient information card, a real-time monitoring panel, and a historical data chart. Then, it splits the page into multiple components. For the VitalSignsMonitor component, the system generates logic for real-time data updates and may use WebSocket technology to achieve real-time communication.For the HealthHistoryChart component, the system generates an interactive time series chart that allows medical staff to select different time ranges and health indicators. Taking into account the possible need to use it on mobile devices, the system also generates responsive layout code for these components. When processing sensitive data, such as patients' personal information, the system generates client-side decryption code to ensure that the data is always encrypted during transmission and storage. The system also generates code for the voice control interface, allowing medical staff to quickly view information about different patients or adjust monitoring parameters through voice commands. The final generated multimodal interactive page code is not only fully functional, but also has good performance, security and accessibility, and can meet the complex needs of remote patient monitoring systems.

[0043] Step S106: Intelligently render and dynamically fill the multimodal interactive page code to obtain a target product page.

[0044] Specifically, the multimodal interactive page code will be parsed to build a complete document object model (DOM) tree structure. During this process, the system will identify the various components and elements of the page and understand the hierarchical relationship and interaction logic between them. Next, the system will perform style calculations, apply CSS rules to each node of the DOM tree, and determine the specific style attributes of each element. This stage may involve complex CSS selector matching and style inheritance calculations, and the system will optimize this process to improve rendering efficiency. Then, the system will perform layout calculations to determine the exact position and size of each element in the page. During this process, the system will consider the requirements of responsive design and dynamically adjust the layout according to different device screen sizes and orientations. For complex layouts, such as Flexbox or Grid layouts, the system will use efficient algorithms to accurately calculate the position of each element. After completing the layout calculation, the system will perform layer analysis to divide the page elements into different rendering layers. This step is critical to optimizing rendering performance, especially for elements that contain animations or are frequently updated. The system will intelligently determine which elements require separate layers to minimize the overhead of redrawing and reflowing. Next, the system performs the actual drawing operation, converting each layer into a bitmap. During this process, the system considers various rendering optimization techniques, such as hardware acceleration, caching strategies, etc., to improve drawing efficiency and reduce resource consumption. For complex visual effects, such as gradients, shadows, or filters, the system uses GPU acceleration to speed up rendering. After the drawing is completed, the system performs layer synthesis, superimposing all layers in the correct order to form the final page view. At this stage, the system also handles advanced visual effects such as transparency and blending modes. After that, the system enters the dynamic content filling stage. It identifies the data parts of the page that need to be dynamically loaded, and obtains the corresponding data from the backend API according to the pre-defined data binding rules. During this process, the system intelligently manages data requests and may use strategies such as caching, preloading, or lazy loading to optimize data loading performance. For large amounts of data or complex data structures, the system may use virtual scrolling or paging loading techniques to ensure the responsiveness of the page. During the data filling process, the system also handles data formatting, localization, and internationalization requirements to ensure that the content is presented in the most suitable way for users. For data that needs to be updated in real time, the system will establish a WebSocket connection or use long polling technology to achieve real-time synchronization of data. The system will also register necessary event listeners to handle user interactions and dynamic updates. This includes handling form submissions, button clicks, scroll events, etc., as well as managing complex state changes and inter-component communications. Finally, the system will perform performance optimization and monitoring. It will set key performance indicator monitoring points, such as first content painting (FCP), maximum content painting (LCP), cumulative layout offset (CLS), etc., and collect these indicators in real time.The system dynamically adjusts the rendering strategy based on these indicators, such as adjusting the order of resource loading and optimizing the critical rendering path, to provide the best user experience. For example, suppose a complex medical dashboard page is being rendered. This page contains components such as a patient list, real-time vital signs monitoring, a medical image viewer, and a treatment plan timeline. The system first builds the DOM tree, calculates the style, and performs responsive layout calculations to ensure that the page can be displayed correctly on different devices. In the layer analysis phase, the system places the real-time updated vital signs monitoring component in a separate layer to optimize update performance. In the drawing phase, the system uses WebGL to render complex medical images, providing high-performance zooming and panning capabilities. In the data filling phase, the system first loads key patient information and then uses WebSocket to obtain real-time vital signs data. For large amounts of historical data, the system uses virtual scrolling technology to render only data in the visible area. The system also registers various interaction events, such as clicking on a patient list item to update the detail view, or dragging on the treatment plan timeline to adjust the plan. Finally, the system continuously monitors page performance and dynamically adjusts the update strategy to reduce CLS if it detects layout shifts caused by vital signs data updates. Through these complex steps, the system finally presents a medical dashboard page with rich functions, superior performance and smooth interaction, providing medical staff with an efficient working interface.

[0045] In the embodiment of the present application, through multimodal analysis and augmented reality processing technology, the prototype diagram and multi-source medical data can be accurately understood and transformed, which greatly improves the integrity and accuracy of the design information and lays a solid foundation for subsequent page generation. The dynamic knowledge graph mapping and causal reasoning technology are used to achieve a deep understanding of the complex semantic structure and knowledge association in the medical field, which not only ensures the professionalism and accuracy of the generated page, but also provides the possibility for intelligent content display and user interaction. The introduction of adaptive microservice deployment analysis makes the generated page more scalable and flexible, and can better adapt to the rapidly changing needs of the big health industry. Specifically, the adaptive microservice deployment allows the page function to be modularized, and each microservice can be independently developed, deployed and expanded. This architecture allows the page to dynamically load different functional modules according to demand without reconstructing the entire page. For example, when a new health data visualization function needs to be added, only the corresponding microservice needs to be developed and deployed, and then integrated into the existing page without affecting other functions. This modular and loosely coupled feature greatly improves the scalability of the page. The microservice architecture also provides better fault isolation capabilities. Even if a functional module has a problem, it will not affect the operation of the entire page, thereby enhancing the stability and reliability of the system. At the same time, intent-driven API design and homomorphic encryption enhancement processing greatly improve the security and privacy protection capabilities of the system, which is crucial for processing sensitive medical data. In the component design and code generation stages, this method can automatically generate multimodal interactive page code that meets modern front-end development standards, which not only improves development efficiency but also ensures the consistency of code quality. Through intelligent rendering and dynamic content filling, high-performance display and smooth interaction of the page are achieved, greatly improving the user experience. The development cycle is significantly shortened, human resource investment is reduced, and development costs are reduced. It can quickly respond to changes in market demand, making product iteration more agile. At the same time, since the entire process is automated, human errors are greatly reduced, the stability of product quality is improved, and the efficiency and accuracy of automatic generation of intelligent product pages for the big health industry are improved.

[0046] In a specific embodiment, the process of executing step S101 may specifically include the following steps:

[0047] (1) Perform image preprocessing on prototype images of the big health industry to obtain standardized image data, and perform data cleaning and format unification on multi-source medical data to obtain standardized medical data;

[0048] (2) extracting features from the standardized image data using a convolutional neural network to obtain an image feature vector, and extracting text features from the standardized medical data to obtain a text feature vector;

[0049] (3) Perform feature fusion on the image feature vector and the text feature vector to obtain fused feature data;

[0050] (4) Performing three-dimensional spatial mapping on the fused feature data to obtain a three-dimensional enhanced design model;

[0051] (5) Perform semantic segmentation on the 3D enhanced design model to obtain hierarchical design structure data;

[0052] (6) Perform geometric transformation and lighting rendering on the hierarchical design structure data to obtain enhanced design information.

[0053] Specifically, image preprocessing for prototype images in the big health industry involves multiple steps, including denoising, contrast adjustment, color correction, and resolution standardization. This process may use a Gaussian filter to remove noise, then apply histogram equalization to enhance contrast, then perform color space conversion to ensure color consistency, and finally adjust the image to a uniform resolution. At the same time, the cleaning and format unification of multi-source medical data may involve steps such as missing value processing, outlier detection, data type conversion, and format standardization. For example, it may be necessary to convert medical record data from different sources into a unified JSON format, or convert various medical images into a standard DICOM format.

[0054] Feature extraction of standardized image data usually uses pre-trained convolutional neural networks, such as ResNet or VGG networks. These networks can effectively capture high-level features in images, such as shape, texture, and layout. At the same time, text feature extraction of standardized medical data may use natural language processing techniques, such as word embedding or the more advanced BERT model, to capture semantic information in text data.

[0055] The extracted image feature vector and text feature vector are fused. This process may use an attention mechanism or a multimodal fusion network to make full use of the complementary information between different modal data. The fused feature data contains comprehensive information of the prototype image and medical data, providing a rich basis for subsequent processing. Next, the fused feature data is mapped into a three-dimensional space. This step may use dimensionality reduction techniques such as t-SNE or UMAP, combined with a three-dimensional modeling algorithm to convert abstract feature information into a specific three-dimensional structure. This three-dimensional enhanced design model can intuitively display the relationship and structure between the prototype design and medical data. Among them, the three-dimensional space mapping of the fused feature data is performed to obtain the implementation process of the three-dimensional enhanced design model:

[0056] First, the fused feature data is standardized. This step ensures that features of different dimensions have the same scale to prevent some features from dominating the final mapping result due to their large numerical range. Standardization can be done using the Z-score method, which is to subtract the mean from each feature and divide it by the standard deviation. The t-SNE (t-distributed stochastic neighbor embedding) algorithm is used to reduce the high-dimensional fused features to three-dimensional space. The principle of t-SNE is to maintain the local relationship between data points while revealing the global structure of the data. It achieves dimensionality reduction by minimizing the KL divergence between the probability distribution of data points in high-dimensional space and the probability distribution of corresponding points in low-dimensional space.

[0057] The specific steps include:

[0058] a) Calculate the conditional probability between data points in high-dimensional space to represent the similarity between points.

[0059] b) The locations of randomly initialized points in low-dimensional space.

[0060] c) Use the gradient descent method to iteratively optimize the position of the midpoint in the low-dimensional space so that the distribution of the midpoint in the low-dimensional space is as close as possible to the distribution in the high-dimensional space.

[0061] Post-process the output of t-SNE to enhance the structure in the 3D space. This may include using a force-directed algorithm to adjust the position of points so that related elements are closer and unrelated elements are farther apart. Map the original design elements and medical data concepts to points in the 3D space. This step requires the establishment of a mapping relationship that converts the semantic information in the high-dimensional feature space into properties such as position, size, shape, etc. in the 3D space. Build the actual 3D model based on the optimized 3D point distribution. This includes assigning geometric shapes, colors, and textures to each point. Important design elements may be represented as larger objects, while minor elements are represented as smaller objects. Add visual elements that represent the relationships between elements in the 3D model, such as connecting lines, color coding, etc. These relationships are based on the semantic information contained in the original fused features.

[0062] For example, suppose there is a product page design for a smart health monitoring system. The prototype includes the main page layout, user information panel, health data dashboard, and activity suggestion module. The relevant medical data includes user health indicators, historical data, and doctor recommendations. After feature fusion, a high-dimensional vector is obtained, which contains visual design features (such as layout, color scheme) and medical data features (such as data type, importance).

[0063] 1. In the data preprocessing stage, this high-dimensional vector is standardized to ensure that features of different natures, such as "blood pressure value" and "page color saturation", have the same weight in subsequent processing.

[0064] 2. During the dimensionality reduction process, the t-SNE algorithm tries to find an arrangement in three-dimensional space so that similar elements (for example, all design elements and data related to heart rate) are close to each other in three-dimensional space.

[0065] 3. During the spatial structure optimization phase, you may find that the user information panel and the health data dashboard are too close in three-dimensional space. Through the force-directed algorithm, you can slightly separate these two elements while maintaining their connection with their respective related elements.

[0066] 4. During the semantic mapping phase, you may decide to use spheres to represent data points, where the size of the sphere represents the importance of the data and the color represents the data type (such as red for warning information).

[0067] 5. During the 3D model building phase, corresponding 3D objects are created for each design element. For example, the main page may be represented as a large plane, while the health data dashboard may be a series of small chart objects suspended on this plane.

[0068] 6. Finally, in the relationship visualization stage, a glowing line may be added between the user information panel and the health data dashboard to indicate that there is data flow between them. At the same time, the activity suggestion module may be connected to the relevant health indicators with a dotted line to indicate that the suggestions are generated based on these indicators.

[0069] Transforming the original flat design prototype into a layered and meaningful three-dimensional model not only intuitively displays the page structure, but also expresses the connection and importance between data through spatial relationships and visual elements. This three-dimensional representation provides a basis for subsequent augmented reality applications, and also provides designers with a new perspective to optimize the structure and function of product pages.

[0070] Semantic segmentation of the 3D enhanced design model is a key step, which divides the model into regions or components with specific meanings. This process may use 3D convolutional neural networks or point cloud segmentation algorithms to accurately segment the model based on the geometric features and semantic information of the model. The segmentation results in hierarchical design structure data, which clearly shows the hierarchy and organization of the design. Finally, the system performs geometric transformation and lighting rendering on the hierarchical design structure data. Geometric transformation may include operations such as rotation, scaling, or deformation to optimize the visual effects and functionality of the design. Lighting rendering uses advanced rendering algorithms, such as ray tracing or global illumination, to create realistic visual effects and enhance the three-dimensionality and realism of the design.

[0071] For example, suppose you are working on the user interface design of a telemedicine platform. The prototype may be a complex layout that includes patient information display, video call interface, and electronic medical record system. The system will first preprocess the prototype to standardize its resolution and color scheme. At the same time, it will clean and unify the format of patient data from different hospitals. Then, through convolutional neural networks, the system will extract key visual elements in the prototype, such as button positions, information block divisions, etc. For text data, such as medical terms and diagnosis descriptions, the system will use NLP models to extract key concepts and semantic relationships. Next, the system will fuse these features to create a comprehensive representation, which is then mapped to three-dimensional space to form an interactive 3D interface model. Through semantic segmentation, the system is able to identify different functional areas, such as patient information area, video call area, and medical record area. Finally, the system will optimize and render this 3D model, and may add soft lighting effects to emphasize important information, or use specific color schemes to distinguish different functional areas. The resulting enhanced design information not only retains the core elements of the original design, but also incorporates the characteristics of medical data, forming a telemedicine platform interface design that is both beautiful and practical.

[0072] In a specific embodiment, the process of executing step S102 may specifically include the following steps:

[0073] (1) Perform named entity recognition on the enhanced design information to obtain a medical entity set, and then perform entity relationship extraction on the medical entity set to obtain an entity relationship network;

[0074] (2) Construct a knowledge graph for the entity relationship network to obtain an initial knowledge graph, and perform knowledge reasoning and supplementation on the initial knowledge graph to obtain a complete knowledge graph;

[0075] (3) Represent the complete knowledge graph as a low-dimensional vector to obtain a graph embedding vector, and calculate the semantic similarity of the graph embedding vector to obtain a semantic association matrix;

[0076] (4) Perform causal reasoning on the semantic association matrix to obtain a causal relationship graph, and identify the key path of the causal relationship graph to obtain the key causal chain;

[0077] (5) Perform semantic structural analysis on the key causal chain to obtain a semantic structure tree, and align the semantic structure tree with domain ontology to obtain a semantic ontology network;

[0078] (6) The semantic ontology network is integrated with multi-source knowledge through the knowledge fusion algorithm to obtain semantic structure and knowledge association data.

[0079] Specifically, named entity recognition of augmented design information is the basis of the entire process. This step usually uses pre-trained deep learning models, such as BERT or BiLSTM-CRF, which can accurately identify medical-related entities in the text, such as disease names, symptoms, drugs, treatment methods, etc. After the recognition is completed, the system will classify and standardize these medical entities to form a structured set of medical entities. Next, neural network models with remote supervised learning or attention mechanisms are used. These models can automatically identify semantic relationships between entities, such as "treatment", "cause", "prevention", etc., to form a preliminary entity relationship network. With the entity relationship network, the system can start to build a knowledge graph. This process first maps entities and relationships into a graph structure, with each entity as a node and relationships as edges. At this stage, the system may use graph database technology, such as Neo4j, to efficiently store and query these complex relationship data. After building the initial knowledge graph, the system will perform knowledge reasoning and supplementation, which may involve using rule reasoning engines or probabilistic graph models, such as Markov logic networks, to infer potential implicit relationships and knowledge. For example, if there are two relationships in the graph, "Drug A treats disease B" and "Disease B is caused by virus C", the system may infer a new relationship, "Drug A may be effective against virus C". Through such reasoning and supplementation, the initial knowledge graph gradually evolves into a more complete and rich knowledge system.

[0080] In order to better utilize and analyze this complex knowledge graph, the system needs to convert it into a low-dimensional vector representation. This process usually uses graph embedding techniques such as TransE, ComplEx or more advanced graph neural network models. These methods can map each entity and relationship in the graph into a low-dimensional continuous vector space, retaining the semantic information between entities and relationships. After obtaining these graph embedding vectors, the system can perform efficient semantic similarity calculations. This usually involves using metrics such as cosine similarity or Euclidean distance to calculate the similarity between different entity or relationship vectors to form a semantic association matrix. This matrix reveals the potential connections between medical concepts and provides an important basis for subsequent analysis. The system will perform causal reasoning on the semantic association matrix. This step may combine statistical methods (such as structural equation models) and machine learning techniques (such as causal discovery algorithms) to identify possible causal relationships. This process not only considers direct associations, but also analyzes indirect, multi-step causal chains. Through such analysis, the system can construct a causal relationship graph that shows the complex causal network between medical concepts. After obtaining the causal relationship graph, the system will identify key paths, which may involve using graph algorithms such as shortest path or PageRank variants to find the most important or influential causal chains. These key causal chains represent the most core medical knowledge and reasoning paths. The concepts and relationships in the causal chain are organized into a hierarchical structure to form a semantic structure tree. This tree structure can clearly show the hierarchical relationship and semantic organization between medical concepts. Next, this semantic structure tree will be aligned with the pre-defined medical domain ontology. This step usually involves ontology matching techniques, such as semantic similarity calculation and structure matching algorithms, in order to align the automatically generated knowledge structure with the standardized medical terminology and concept system. Through this alignment process, the system obtains a standardized semantic ontology network, which not only retains the new knowledge discovered from the data, but also maintains good compatibility with the existing medical knowledge system. Use knowledge fusion algorithms to integrate multi-source knowledge in the semantic ontology network. This process may involve knowledge graph fusion techniques, such as entity alignment, relationship mapping, and conflict resolution. Integrate knowledge from different sources (such as literature data, clinical records, expert knowledge, etc.) with the automatically generated semantic ontology network to resolve possible contradictions and duplications and form a unified and comprehensive knowledge system. The resulting semantic structure and knowledge association data not only contain rich medical knowledge, but also retain complex semantic relationships and reasoning paths.

[0081] For example, suppose you are processing a medical knowledge base about pneumonia. The system first identifies relevant entities such as "a virus", "ACE2 receptor", "lung inflammation", etc. from various medical literature and clinical reports. Then, it extracts the relationships between these entities, such as "a virus enters human cells through the ACE2 receptor". In the process of building the knowledge graph, the system may infer new relationships, such as "a virus causes lung inflammation" and "lung inflammation may cause breathing difficulties", and infer that "a virus infection may cause breathing difficulties". When embedding the graph, "a virus" and "influenza virus" may be close in the vector space because they are both respiratory viruses. In causal reasoning, the system may identify a key causal chain from "viral infection" to "cytokine storm" to "multiple organ failure". In semantic structure analysis, "virus", "symptoms", and "complications" may form a hierarchical structure. Finally, in the knowledge fusion stage, the system may integrate this automatically generated knowledge with the official guidelines issued by WHO or CDC to form a comprehensive and authoritative pneumonia knowledge base. This knowledge base not only includes the symptoms, transmission routes, diagnostic methods and treatment strategies of the disease, but also covers the complex pathological mechanisms and potential research directions, providing valuable knowledge resources for medical workers and researchers.

[0082] In a specific embodiment, the process of executing step S103 may specifically include the following steps:

[0083] (1) Semantic structures and knowledge-related data are divided into functional modules to obtain a microservice candidate set, and inter-service dependency analysis is performed on the microservice candidate set to obtain a service dependency graph;

[0084] (2) Estimate the service load on the service dependency graph to obtain the service load distribution, and perform computational resource allocation on the service load distribution to obtain a preliminary resource allocation plan;

[0085] (3) Perform service containerization design on the preliminary resource allocation plan to obtain a container combination plan, and perform service network planning on the container combination plan to obtain a service network topology structure;

[0086] (4) Design a service registration and discovery mechanism for the service network topology to obtain a service registry, and formulate a traffic distribution strategy for the service registry to obtain load balancing rules;

[0087] (5) Design a dynamic expansion and contraction strategy for the load balancing rules to obtain an elastic scaling solution, and design a high availability guarantee mechanism for the elastic scaling solution to obtain a fault recovery strategy;

[0088] (6) Generate an automated deployment script for the fault recovery strategy to obtain a containerized deployment strategy.

[0089] Specifically, the functional module division of semantic structure and knowledge-related data is the basis of the whole process. This step usually adopts the domain-driven design (DDD) method, combined with business requirements and data flow analysis, to divide the entire system into multiple independent but interrelated functional modules. In this process, clustering algorithms or graph segmentation techniques may be used to assist in identifying potential service boundaries, while taking into account the cohesion and coupling of each module. Such a division will form a preliminary set of microservice candidates, each of which represents a relatively independent functional unit in the system. Using static code analysis tools and dynamic call chain tracking technology, the call relationship, data flow and shared resources between each service are deeply analyzed. Through such analysis, a detailed service dependency graph can be constructed, which clearly shows the interaction mode and degree of dependency between each microservice. This dependency graph not only includes direct service calls, but also takes into account indirect data dependencies and potential performance bottlenecks.

[0090] With the service dependency graph, service load estimation can be performed. This step usually combines historical data analysis and predictive models, such as time series analysis or machine learning algorithms, to estimate the resource requirements of each service in different scenarios. This estimation process takes into account multiple dimensions such as CPU usage, memory consumption, and network bandwidth to form a comprehensive service load distribution diagram. Based on this load distribution, intelligent computing resource allocation will be performed, and heuristic algorithms or linear programming methods may be used to optimize resource utilization while ensuring performance, so as to obtain a preliminary resource configuration plan. The preliminary resource configuration plan will be designed for service containerization. This process involves selecting appropriate container technologies (such as Docker), designing container image building strategies, configuring container networks and storage, etc. A dedicated container definition will be created for each microservice, including base image selection, environment variable configuration, dependency management, etc. Through such a design, a detailed container combination plan is obtained, which provides an independent and portable operating environment for each microservice. Next, the service network planning will be performed for this container combination plan, which may involve the use of service mesh technologies (such as Istio or Linkerd) to manage communication between services. A complete service network topology will be designed, defining the communication path, security policy and traffic control rules between services. After obtaining the service network topology, the service registration and discovery mechanism design will be carried out. This usually involves selecting a suitable service registry (such as Consul or ZooKeeper) and designing service registration, deregistration and health check policies. Through this step, a dynamically maintained service registry is established, which provides a basis for efficient communication between services. Based on this service registry, a detailed traffic distribution strategy will be formulated, including load balancing algorithm selection (such as polling, least connection or weighted response time), traffic diversion rules and service degradation strategies, etc., to form a complete set of load balancing rules. Dynamic expansion and contraction strategies will be designed for load balancing rules. This process may use an automated capacity planning algorithm, combined with real-time monitoring data and predefined performance indicators, to dynamically adjust the number of service instances. Through such a design, an elastic scaling solution is obtained, which can automatically adjust resource configuration according to actual load conditions. Based on this elastic scaling solution, a high availability guarantee mechanism design will also be carried out, including multi-availability zone deployment strategy, data backup and recovery mechanism, service fuse and degradation strategy, etc. These designs together form a comprehensive fault recovery strategy that ensures rapid recovery and service continuity in the face of various potential failures.

[0091] Convert all these designs and strategies into automated deployment scripts. This process may use Infrastructure as Code (IaC) tools, such as Terraform or Ansible, to generate detailed deployment configurations and scripts. These scripts include not only container build and deployment instructions, but also network configuration, storage mounting, security policy settings, etc. Through such automated scripts, a complete containerized deployment strategy is finally obtained, which can realize the automated deployment and management of the entire microservice architecture.

[0092] For example, suppose you are designing a large telemedicine platform. In the functional module division phase, you may identify microservices such as user management, appointment booking, video diagnosis and treatment, electronic medical records, and prescription management. When analyzing service dependencies, you may find that the video diagnosis and treatment service depends on user management and appointment booking, while the prescription management service depends on the electronic medical record service. When performing load estimation, you may predict that the video diagnosis and treatment service has a higher load in the morning and evening on weekdays, while the electronic medical record service may have a peak after the diagnosis and treatment. Based on these analyses, more computing resources will be allocated to the video diagnosis and treatment service, and automatic scaling strategies will be designed to cope with peak periods. In containerization design, you may choose a container image that supports GPU acceleration for the video diagnosis and treatment service to improve video processing performance. In network planning, you will configure a dedicated high-bandwidth network channel for the video diagnosis and treatment service, and set a traffic control strategy to ensure service quality. When designing a service registration and discovery mechanism, you may choose to use Consul as the service registration center and configure an automatic service discovery mechanism based on health checks. For load balancing, you may adopt a geo-location-based intelligent routing strategy for the video diagnosis and treatment service to direct user requests to the nearest service node. In the elastic scaling solution, automatic scaling rules based on CPU usage and concurrent connections will be set. In order to ensure high availability, a multi-region deployment strategy may be designed, and real-time data synchronization and fast failover mechanisms may be implemented for key services such as electronic medical records. Finally, a complete set of Terraform scripts will be generated, which can deploy the entire telemedicine platform to the cloud environment with one click, including container deployment of all microservices, network configuration, security group settings, etc. Such design and implementation ensure that the telemedicine platform can operate efficiently, safely, and reliably, providing stable services for patients and doctors.

[0093] In a specific embodiment, the process of executing step S104 may specifically include the following steps:

[0094] (1) Perform service function analysis on the containerized deployment strategy to obtain a service function list, and then identify user intent on the service function list to obtain a list of intent-driven requirements;

[0095] (2) Design the API endpoint for the intent-driven requirement list to obtain an API endpoint sketch, and define the request method for the API endpoint sketch to obtain an HTTP method mapping table;

[0096] (3) Design request parameters for the HTTP method mapping table to obtain an input parameter pattern, and design a response structure for the input parameter pattern to obtain an output data format;

[0097] (4) Perform data flow analysis on the output data format to obtain sensitive data tags, and design a homomorphic encryption scheme for the sensitive data tags to obtain encrypted field mapping;

[0098] (5) Design a key management mechanism for the encrypted field mapping to obtain a key distribution strategy, and formulate a secure communication protocol for the key distribution strategy to obtain an encrypted transmission solution;

[0099] (6) Generate API documentation for the encrypted transmission solution to obtain API interface specification data.

[0100] Specifically, the function definition and data model of each microservice are parsed to form a detailed service function list. The list contains key information such as the core functions, data processing logic, input and output types of each service. For example, in a telemedicine platform, the service function list includes functional modules such as patient information management, appointment scheduling, video diagnosis and treatment, electronic medical records, and drug prescriptions. User intent is identified for the service function list, and natural language processing technology, especially intent classification algorithms, are used to analyze the user's possible operation intentions and usage scenarios. The intent classification algorithm maps user queries or operation instructions to predefined intent categories through semantic analysis of the user's query or operation instruction. In the example of the telemedicine platform, the user query "How to make an appointment for the cardiology clinic next Wednesday" is identified as the "appointment scheduling" intent. This process generates an intent-driven requirement list that associates user high-level requirements with specific service functions.

[0101] Based on the intent-driven requirement list, API endpoint design is performed. This step creates corresponding API endpoints for each identified user intent, following the RESTful design principle. In the telemedicine platform, the " / appointments" endpoint is designed for the "appointment scheduling" intent. This process forms an API endpoint sketch, which contains the basic structure and functional description of each endpoint. Subsequently, the request method is defined for the API endpoint sketch to determine the HTTP method used by each endpoint. For example, the POST method is defined for the " / appointments" endpoint to create a new appointment, and the GET method is used to query appointment information. This step generates an HTTP method mapping table to clarify the correspondence between API endpoints and HTTP methods. The HTTP method mapping table is designed for request parameters to define the input parameters required for each API endpoint in detail. In the appointment scheduling API, the input parameters include patient ID, doctor ID, appointment date and time, and consultation department. This process generates a complete input parameter model to provide clear guidance for API use. At the same time, the response structure of the input parameter model is designed to define the data format and structure returned by the API. For example, after a successful appointment, the appointment confirmation number, consultation time, doctor information, etc. are returned. This step forms a detailed output data format specification.

[0102] Subsequently, the output data format is analyzed for data flow, the data flow path in the system is tracked, and the processing and transmission process of sensitive information is identified. In the telemedicine platform, patient personal information and medical record data are marked as sensitive data. This analysis process obtains sensitive data tags and clarifies the data fields that require special security processing. A homomorphic encryption scheme is designed for these sensitive data tags to allow necessary data processing in an encrypted state. For example, partial homomorphic encryption is used for the patient's age data, allowing the system to perform age statistical analysis without decryption. This design process produces an encrypted field mapping, indicating which fields use which homomorphic encryption algorithm. A key management mechanism is designed for the encrypted field mapping, including key generation, distribution, storage and update strategies. In the telemedicine platform, a hierarchical key management strategy is adopted to set different keys for different levels of data access rights. This design produces a detailed key distribution strategy that specifies how to securely distribute encryption keys to authorized system components and users. Based on the key distribution strategy, a secure communication protocol is formulated to ensure that all data transmission processes are properly protected. This protocol defines key elements such as encryption algorithms, key exchange mechanisms, and session management, forming a complete encryption transmission solution.

[0103] Finally, the API documentation is generated for the entire encrypted transmission solution. This document not only contains the technical details of each API endpoint, but also includes important information such as safe usage guidelines and encrypted data processing recommendations. In the example of the telemedicine platform, the API documentation details how to safely call the appointment API, including how to properly handle encrypted patient information, how to verify the server identity to prevent man-in-the-middle attacks, etc. This process ultimately produces comprehensive API interface specification data, providing developers with detailed implementation guidance.

[0104] In a specific embodiment, the process of executing step S105 may specifically include the following steps:

[0105] (1) Performing interface layout analysis on the API interface specification data to obtain a page structure framework, and dividing the page structure framework into components to obtain a component hierarchy tree;

[0106] (2) Define component attributes for the component hierarchy tree to obtain a component configuration list, and perform state management design on the component configuration list to obtain a state flow diagram;

[0107] (3) Design an event processing mechanism for the state flow diagram, obtain an event listener list, and formulate data binding rules for the event listener list to obtain a data synchronization solution;

[0108] (4) Design the API call logic for the data synchronization solution to obtain an interface call flow chart, and formulate an error handling strategy for the interface call flow chart to obtain an exception handling mechanism;

[0109] (5) Perform multimodal interaction design on the exception handling mechanism to obtain the interaction mode definition, and integrate the barrier-free function into the interaction mode definition to obtain the accessibility solution;

[0110] (6) Code template matching is performed on the accessibility solution to obtain the basic code structure, and component logic is injected into the basic code structure to obtain candidate component codes. The candidate component codes are integrated to obtain multimodal interactive page codes.

[0111] Specifically, layout analysis algorithms, such as constraint-based layout analysis or heuristic layout reasoning, are used to parse the structure and data flow of the API to obtain the basic structural framework of the page. For example, in a telemedicine consultation system, the API interface specification data contains key data points such as patient information, doctor list, and appointment time period. The layout analysis algorithm will map these data points to the corresponding page blocks to form a preliminary page structural framework.

[0112] Divide the page structure framework into components. This step uses component recognition algorithms, such as pattern matching-based component recognition or deep learning-based UI component classification, to decompose the page structure into independent functional components. In the example of a telemedicine consultation system, the page may be divided into components such as header navigation, patient information form, doctor selection list, and appointment calendar. This process generates a component hierarchy tree that clearly shows the hierarchical relationship and nested structure between components.

[0113] Defining component attributes for the component hierarchy tree is the next important step. Here, an attribute inference algorithm is used to define the attributes and behaviors of each component based on the data types and business rules in the API specification. For example, a doctor selection list component may be defined as containing attributes such as doctor name, specialty, and score, as well as click-to-select behavior. This process produces a detailed component configuration list containing all the attributes and methods of each component. Subsequently, the state management design of the component configuration list is performed, and the state transfer and data flow between components are defined using state machine modeling technology, thereby obtaining a complete state flow diagram.

[0114] The state flow diagram provides a basis for the design of event handling mechanisms. This step uses the event-driven programming model to define the corresponding processing logic for each possible user interaction and system event, and generate a comprehensive list of event listeners. In the telemedicine system, this includes processing events such as user selection of doctors and submission of appointment requests. Next, data binding rules are formulated for the event listener list, and data flow analysis algorithms are used to determine how each event triggers data updates and propagation, thereby obtaining a complete data synchronization solution.

[0115] The data synchronization solution lays the foundation for the API call logic design. This step uses workflow modeling technology to design the API call sequence required for each user operation to form a detailed interface call flow chart. For example, when a user submits an appointment request, the system needs to call APIs such as verifying user identity, checking doctor availability, and creating appointment records in sequence. Subsequently, the error handling strategy is formulated for the interface call flow chart, and the exception handling design pattern is used to define the processing logic for each possible error situation to obtain a comprehensive exception handling mechanism. Multimodal interaction design for the exception handling mechanism is a key step to improve user experience. Here, the multimodal interaction theory is used to design corresponding interface response methods for different types of interactions (such as touch, voice, and gestures) to form a complete interaction mode definition. In a telemedicine system, this may include supporting voice command appointments or gesture operations to browse doctor information. Next, the interaction mode definition is integrated with barrier-free functions, and the accessibility design principles are used to ensure that the interface is friendly to special groups such as the visually impaired and the hearing impaired, thereby obtaining a comprehensive accessibility solution.

[0116] Finally, code template matching is performed on the accessibility solution. The template matching algorithm is used to select the most suitable template from the predefined code template library to generate the basic code structure. Then, component logic is injected into the basic code structure. The code generation technology is used to convert the previously designed component logic, event processing, data binding and other functions into actual code implementation to obtain candidate component codes. The last step is to integrate the candidate component codes and use the code assembly algorithm to combine all component codes into a complete and fully functional multimodal interactive page code.

[0117] For example, in the process of automatic page generation for a remote heart disease monitoring system, the API interface specification data includes endpoints such as basic patient information, real-time heart rate data, and historical ECG records. Interface layout analysis maps these data points to a structural framework that includes a top patient information bar, a central real-time heart rate display area, and a bottom history list. Component division identifies patient information components, real-time heart rate chart components, and history table components. In the component property definition phase, the real-time heart rate chart component is assigned properties such as data source, update frequency, and alarm threshold. The state management design defines how to trigger the alarm state and affect the display of other components when the heart rate exceeds the alarm threshold. The event handling mechanism designs how to expand detailed information when the user clicks on the history record, and how to handle real-time data update events. The data binding rules ensure that real-time heart rate data can be reflected on the chart in a timely manner without affecting system performance. The API call logic designs how to regularly obtain the latest heart rate data from the backend, and how to obtain detailed history records when the user requests it. The error handling strategy considers how to handle situations such as network interruptions and data anomalies. The multimodal interaction design allows doctors to switch the data display of different patients through voice commands, or use gestures to zoom in on ECG details. The barrier-free function ensures that color-blind users can also clearly distinguish the changes in the heart rate chart. The resulting page code is not only fully functional, but also highly usable and accessible, providing strong technical support for remote monitoring of heart disease.

[0118] In a specific embodiment, the process of executing step S106 may specifically include the following steps:

[0119] (1) Construct a DOM tree for the multimodal interactive page code to obtain a page structure tree, and perform style calculation on the page structure tree to obtain a style rule set;

[0120] (2) Perform layout calculation on the style rule set to obtain layout information, and perform layer analysis on the layout information to obtain a rendering level table;

[0121] (3) performing a drawing operation on the rendering level table to obtain a graphics drawing instruction, and synthesizing the graphics drawing instruction to obtain a page view;

[0122] (4) Bind the data source to the page view to obtain a data binding map, and formulate an asynchronous loading strategy for the data binding map to obtain a content loading solution;

[0123] (5) Registering interactive events for the content loading scheme to obtain an event listener set, and designing a state update mechanism for the event listener set to obtain a state manager;

[0124] (6) Setting performance monitoring points for the state manager to obtain a performance indicator set, and integrating the performance indicator set with the page view to obtain a target product page.

[0125] Specifically, a recursive descent parsing algorithm is used to convert HTML code into a tree structure. The time complexity of DOM tree construction can be expressed by the following formula:

[0126]

[0127] Where n is the total number of HTML elements, α i and β i are the analytical and interpolation coefficients of the ith element, respectively, and d i is the depth of the ith element.

[0128] Perform style calculation on the page structure tree, use the selector matching algorithm and cascading rules to apply the CSS style to the corresponding DOM node. The complexity of style calculation can be expressed as:

[0129]

[0130] Where p is the number of DOM nodes, m is the number of CSS rules, k is the maximum complexity of the selector, and γ ij and δ ij are the matching and application coefficients of the i-th node to the j-th rule, λ ij is the selector complexity index.

[0131] Perform layout calculations on the style rule set, using the box model algorithm and flow layout algorithm to calculate the exact position and size of each element. The time complexity of layout calculation can be expressed as:

[0132]

[0133] Where e is the number of elements in the page, r i is the relative position complexity of the i-th element, ∈ i and i They are the layout calculation and position adjustment coefficients of the elements respectively.

[0134] The layout information is analyzed by layers, and the rendering hierarchy table is obtained using the z-index sorting and compositing layer identification algorithm. Subsequently, the rendering hierarchy table is drawn, and the layout and style information is converted into a series of drawing instructions using the vector drawing algorithm. The graphics drawing instructions are synthesized, and the layer synthesis algorithm is used to overlay all layers in the correct order to obtain the final page view.

[0135] Bind the data source to the page view, and use data binding algorithms such as dirty checking or virtual DOM comparison to associate dynamic data with page elements. Then, formulate asynchronous loading strategies for data binding mappings, and use lazy loading and preloading algorithms to optimize data loading performance. Register interactive events for content loading solutions, and use event delegation and event bubbling mechanisms to add necessary event listeners to page elements. Design a state update mechanism for the event listener collection, and use the state management mode to design a unified state manager. Set performance monitoring points for the state manager, and use performance indicator collection algorithms to obtain a set of key performance indicator sets. Integrate these performance indicators with the page view, and use real-time performance optimization algorithms to dynamically adjust page rendering and interaction strategies to ultimately obtain the optimized target product page.

[0136] For example, in the automatic page generation process of an intelligent chronic disease management system, a DOM tree containing key nodes such as patient health data dashboard, medication reminders, and lifestyle recommendations is first built. Assuming that the page contains 500 HTML elements with an average depth of 5, the DOM tree construction time is approximately:

[0137]

[0138] During the style calculation phase, specific medical interface design rules are applied, such as using high-contrast color schemes to accommodate visually impaired patients. Assuming there are 300 CSS rules and a maximum selector complexity of 4, the style calculation time is approximately:

[0139]

[0140] During the layout calculation phase, each element is precisely positioned, such as placing important health indicators at the top of the page. Assuming that there are 200 elements on the page that need to be calculated for layout, and the average relative position complexity is 2, the layout calculation time is approximately:

[0141]

[0142] In the data binding phase, real-time blood sugar levels, blood pressure data, etc. are associated with display components. The asynchronous loading strategy ensures real-time updates of key health data, while lazy loading is used to load non-urgent historical data. Event registration adds event listeners for key operations (such as the emergency help button), and the state manager design ensures that all relevant components can respond to state changes in a timely manner when abnormal health indicators are detected.

[0143] Finally, performance monitoring sets monitoring points for key indicators such as first contentful painting (FCP), maximum contentful painting (LCP), and cumulative layout shift (CLS). By adjusting the rendering strategy in real time, such as prioritizing the loading of key health data when the network condition is poor, the efficient operation of the page under various conditions is guaranteed. This intelligent page generation method not only improves the development efficiency of the chronic disease management system, but also ensures the high performance and reliability of the system in complex medical scenarios, providing patients with better self-management tools.

[0144] The above describes the intelligent product page automatic generation method for the big health industry in the embodiment of the present application. The following describes the intelligent product page automatic generation system for the big health industry in the embodiment of the present application. Figure 2 In the embodiment of the present application, an embodiment of the intelligent product page automatic generation system for the big health industry includes:

[0145] The parsing module 201 is used to perform multimodal parsing and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information;

[0146] A mapping module 202, used to perform dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data;

[0147] A deployment module 203 is used to perform adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy;

[0148] An encryption module 204 is used to perform intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data;

[0149] A generation module 205 is used to perform component design and code generation processing on the API interface specification data to obtain a multimodal interaction page code;

[0150] The filling module 206 is used to perform intelligent rendering and dynamic content filling on the multimodal interactive page code to obtain a target product page.

[0151] Through the collaboration of the above components, multimodal analysis and augmented reality processing technology can accurately understand and transform prototype images and multi-source medical data, greatly improve the integrity and accuracy of design information, and lay a solid foundation for subsequent page generation. The dynamic knowledge graph mapping and causal reasoning technology are used to achieve a deep understanding of the complex semantic structure and knowledge association in the medical field, which not only ensures the professionalism and accuracy of the generated pages, but also provides the possibility for intelligent content display and user interaction. Furthermore, the introduction of adaptive microservice deployment analysis makes the generated pages more scalable and flexible, and can better adapt to the rapidly changing needs of the big health industry. At the same time, intent-driven API design and homomorphic encryption enhanced processing greatly improve the security and privacy protection capabilities of the system, which is crucial for processing sensitive medical data. In the component design and code generation link, this method can automatically generate multimodal interactive page code that meets modern front-end development standards, which not only improves development efficiency, but also ensures the consistency of code quality. Through intelligent rendering and dynamic content filling, high-performance display and smooth interaction of the page are achieved, greatly improving the user experience. Significantly shorten the development cycle, reduce human resource investment, and reduce development costs. It can quickly respond to changes in market demand, making product iteration more agile. At the same time, since the entire process is automated, it greatly reduces human errors, improves the stability of product quality, and improves the efficiency and accuracy of automatic generation of intelligent product pages for the big health industry.

[0152] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described systems, systems and units can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0153] As described above, the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A method for automatically generating intelligent product pages for the health industry, characterized in that: The intelligent product page automatic generation method for the big health industry includes: Perform multimodal analysis and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information; Performing dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data; Performing adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy; Perform intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data; Performing component design and code generation processing on the API interface specification data to obtain multimodal interactive page code; The multimodal interactive page code is intelligently rendered and dynamically filled with content to obtain a target product page.

2. The intelligent product page automatic generation method for the health industry according to claim 1 is characterized in that: The multimodal analysis and augmented reality processing of the collected big health industry prototype images and multi-source medical data are performed to obtain enhanced design information, including: Performing image preprocessing on the prototype image of the big health industry to obtain standardized image data, and performing data cleaning and format unification processing on the multi-source medical data to obtain standardized medical data; Performing feature extraction on the standardized image data through a convolutional neural network to obtain an image feature vector, and performing text feature extraction on the standardized medical data to obtain a text feature vector; Performing feature fusion on the image feature vector and the text feature vector to obtain fused feature data; Performing three-dimensional spatial mapping on the fused feature data to obtain a three-dimensional enhanced design model; Performing semantic segmentation on the three-dimensional enhanced design model to obtain hierarchical design structure data; The hierarchical design structure data is subjected to geometric transformation and lighting rendering to obtain enhanced design information.

3. The intelligent product page automatic generation method for the big health industry according to claim 1 is characterized in that: The dynamic knowledge graph mapping and causal reasoning are performed on the enhanced design information to obtain semantic structure and knowledge association data, including: Performing named entity recognition on the enhanced design information to obtain a medical entity set, and performing entity relationship extraction on the medical entity set to obtain an entity relationship network; Constructing a knowledge graph for the entity relationship network to obtain an initial knowledge graph, and performing knowledge reasoning and supplementation on the initial knowledge graph to obtain a complete knowledge graph; Performing a low-dimensional vector representation on the complete knowledge graph to obtain a graph embedding vector, and performing semantic similarity calculation on the graph embedding vector to obtain a semantic association matrix; Performing causal relationship reasoning on the semantic association matrix to obtain a causal relationship graph, and performing key path identification on the causal relationship graph to obtain a key causal chain; Performing semantic structural analysis on the key causal chain to obtain a semantic structure tree, and performing domain ontology alignment on the semantic structure tree to obtain a semantic ontology network; The semantic ontology network is subjected to multi-source knowledge integration through a knowledge fusion algorithm to obtain semantic structure and knowledge association data.

4. The intelligent product page automatic generation method for the big health industry according to claim 1 is characterized in that: The adaptive microservice deployment analysis of the semantic structure and knowledge association data to obtain a containerized deployment strategy includes: Dividing the semantic structure and knowledge association data into functional modules to obtain a microservice candidate set, and analyzing the inter-service dependency relationship of the microservice candidate set to obtain a service dependency graph; Estimating the service load on the service dependency graph to obtain service load distribution, and performing computing resource allocation on the service load distribution to obtain a preliminary resource allocation plan; Performing service containerization design on the preliminary resource configuration scheme to obtain a container combination scheme, and performing service network planning on the container combination scheme to obtain a service network topology structure; Designing a service registration and discovery mechanism for the service network topology structure to obtain a service registration table, and formulating a traffic distribution strategy for the service registration table to obtain a load balancing rule; Design a dynamic expansion and contraction strategy for the load balancing rule to obtain an elastic scaling solution, and design a high availability guarantee mechanism for the elastic scaling solution to obtain a fault recovery strategy; An automated deployment script is generated for the fault recovery strategy to obtain a containerized deployment strategy.

5. The intelligent product page automatic generation method for the big health industry according to claim 1 is characterized in that: The containerized deployment strategy is subjected to intent-driven API design and homomorphic encryption enhancement processing to obtain API interface specification data, including: Performing service function analysis on the containerized deployment strategy to obtain a service function list, and performing user intent recognition on the service function list to obtain an intent-driven demand list; Designing an API endpoint for the intent-driven requirement list to obtain an API endpoint sketch, and defining a request method for the API endpoint sketch to obtain an HTTP method mapping table; Designing request parameters for the HTTP method mapping table to obtain an input parameter pattern, and designing a response structure for the input parameter pattern to obtain an output data format; Performing data flow analysis on the output data format to obtain sensitive data tags, and designing a homomorphic encryption scheme for the sensitive data tags to obtain an encrypted field mapping; Designing a key management mechanism for the encryption field mapping to obtain a key distribution strategy, and formulating a secure communication protocol for the key distribution strategy to obtain an encryption transmission scheme; Generate API documentation for the encrypted transmission solution to obtain API interface specification data.

6. The intelligent product page automatic generation method for the big health industry according to claim 1 is characterized in that: The component design and code generation processing of the API interface specification data to obtain the multimodal interaction page code includes: Performing interface layout analysis on the API interface specification data to obtain a page structure framework, and dividing the page structure framework into components to obtain a component hierarchy tree; Defining component attributes of the component hierarchy tree to obtain a component configuration list, and performing state management design on the component configuration list to obtain a state flow diagram; Designing an event processing mechanism for the state flow diagram to obtain an event listener list, and formulating data binding rules for the event listener list to obtain a data synchronization solution; Performing API call logic design on the data synchronization solution to obtain an interface call flow chart, and formulating an error handling strategy for the interface call flow chart to obtain an exception handling mechanism; Performing multimodal interaction design on the exception handling mechanism to obtain an interaction mode definition, and integrating barrier-free functions on the interaction mode definition to obtain an accessibility solution; Code template matching is performed on the accessibility scheme to obtain a basic code structure, component logic is injected into the basic code structure to obtain candidate component codes, and the candidate component codes are integrated to obtain the multimodal interaction page code.

7. The intelligent product page automatic generation method for the big health industry according to claim 6 is characterized in that: The intelligent rendering and dynamic content filling of the multimodal interactive page code to obtain the target product page includes: Performing DOM tree construction on the multimodal interactive page code to obtain a page structure tree, and performing style calculation on the page structure tree to obtain a style rule set; Performing layout calculation on the style rule set to obtain layout information, and performing layer analysis on the layout information to obtain a rendering level table; Performing a drawing operation on the rendering level table to obtain a graphics drawing instruction, and synthesizing the graphics drawing instruction to obtain a page view; Binding the page view to a data source to obtain a data binding map, and formulating an asynchronous loading strategy for the data binding map to obtain a content loading solution; Registering interactive events for the content loading solution to obtain an event listener set, and designing a state update mechanism for the event listener set to obtain a state manager; The state manager is set with performance monitoring points to obtain a performance indicator set, and the performance indicator set is integrated with the page view to obtain a target product page.

8. An intelligent product page automatic generation system for the health industry, characterized in that: Used to execute the method for automatically generating intelligent product pages for the big health industry according to any one of claims 1 to 7, the intelligent product page automatic generation system for the big health industry comprises: The parsing module is used to perform multimodal parsing and augmented reality processing on the collected big health industry prototype images and multi-source medical data to obtain enhanced design information; A mapping module, used to perform dynamic knowledge graph mapping and causal reasoning on the enhanced design information to obtain semantic structure and knowledge association data; A deployment module, used to perform adaptive microservice deployment analysis on the semantic structure and knowledge association data to obtain a containerized deployment strategy; An encryption module is used to perform intent-driven API design and homomorphic encryption enhancement processing on the containerized deployment strategy to obtain API interface specification data; A generation module is used to perform component design and code generation processing on the API interface specification data to obtain a multimodal interactive page code; A filling module is used to intelligently render and dynamically fill the multimodal interactive page code to obtain a target product page.

Images