Intelligent receipt generation method and device based on multi-modal AI, computer equipment and storage medium

Abstract

The invention discloses a low-code platform receipt field real-time automatic generation method and system based on artificial intelligence, and realizes end-to-end conversion from user demands to structured fields and verification rules by fusing multi-modal input analysis, knowledge graph reasoning and distributed asynchronous computing technologies. The system adopts innovative designs such as semantic-driven dynamic completion, lightweight edge deployment, multi-modal interaction optimization and the like, the development efficiency is remarkably improved (the form generation time is shortened from 2 hours to 5 minutes), the technical threshold is reduced (the non-technical personnel configuration proportion is improved to 90%), and millisecond response (the end-to-end delay is less than 300 ms) in a high-concurrency scene is supported. The method is suitable for complex business scenes of multiple industries such as finance, manufacturing and retail.

Description

Technical Field

[0001] This invention lies at the intersection of artificial intelligence, natural language processing (NLP), knowledge graphs, and low-code development technologies. Specifically, it relates to a method and system for real-time, end-to-end generation of user requirements into document fields on a low-code platform through multimodal input parsing, knowledge reasoning, and distributed asynchronous computing. This method is suitable for rapid form configuration and dynamic rule generation in business scenarios such as enterprise procurement, finance, warehousing, and human resources, and is particularly well-suited for complex business environments requiring high-frequency iteration and cross-system integration. Background Art

[0002] Low manual configuration efficiency: Traditional low-code platforms (such as OutSystems and Mendix) rely on users to manually drag and drop components or write rules to generate fields, which takes an average of 2-3 hours per form and requires technical personnel to intervene, making it difficult to meet the needs of rapid business iteration (such as agile development cycle ≤ 1 week).

[0003] Insufficient response to dynamic needs: Existing solutions (such as SAP Fiori templates) cannot parse unstructured natural language input in real time, requiring repeated configuration adjustments, which extends the development cycle by 30%-50%.

[0004] Limited intelligence: Lacks the ability to automatically process complex logic (such as multi-table associations and dynamic formula generation), relies on manually written rules, has an error rate as high as 15%-20%, and increases maintenance costs.

[0005] Patent CN114328345A: Generates fields based on fixed templates, has poor flexibility (supports only 20 predefined templates), and cannot process user-defined natural language input.

[0006] The document "NLP-Driven Low-Code Platforms" uses NLP to parse requirements, but does not integrate knowledge graphs and real-time verification mechanisms. The accuracy of implicit field completion is less than 60%.

[0007] GPT-4 generation technology: The text generation effect is excellent, but the output lacks structured field definitions and verification rules (such as data type constraints and foreign key associations), requiring manual secondary processing. Although it supports field prediction, it does not integrate the industry knowledge base, and the implicit field omission rate exceeds 35%.

[0008] Existing technologies are unable to achieve an end-to-end automated process of "user requirements → structured fields → low-code components", and have significant defects in multimodal input support, dynamic rule reasoning, and real-time response in high-concurrency scenarios. Summary of the Invention

[0009] It provides an end-to-end automation solution that integrates multimodal input parsing, knowledge graph reasoning, and distributed asynchronous computing technologies to achieve real-time conversion of user requirements into editable document fields in a low-code platform, solving the problems of low manual configuration efficiency and slow response to dynamic demands, and lowering the technical threshold (non-technical personnel can independently complete 90% of form configuration).

[0010] Input format: Text: Supports natural language descriptions (such as "Create a purchase order, requiring supplier, product, quantity, and unit price").

[0011] Voice: Converted into text through ASR (automatic speech recognition) technology, supporting both Chinese and English, with a recognition accuracy rate of ≥95%.

[0012] Sketch: Use CV (computer vision) to parse the hand-drawn layout and extract the field location and type (for example, the table area is marked as "product list").

[0013] NLP Models: Architecture: Multi-task fine-tuning based on the BERT-base model, and the embedding layer introduces domain knowledge vectors (pre-trained through knowledge graph entity embedding).

[0014] Task design: Named Entity Recognition (NER): Extracts field names (such as "supplier") and data types (string, integer, date, etc.), with an F1-score ≥ 0.92.

[0015] Relationship extraction: Identify logical relationships between fields (such as "total amount = quantity × unit price"), and support arithmetic operations and conditional judgments (such as "unit price ≥ 0").

[0016] Output: Generates a structured semantic tree (JSON format), including field names, types, constraints, and relationships.

[0017] Domain knowledge graph: Data sources: industry-wide field libraries (such as required fields for purchase orders), enterprise-specific databases (such as supplier primary key tables), and third-party APIs (such as tax invoice rules).

[0018] Graph structure: It is stored in the Neo4j graph database. Nodes include field entities (such as "order number"), rule entities (such as "UUID generation rule"), and edges represent association relationships (such as "purchase order → includes → supplier").

[0019] Dynamic completion mechanism: Implicit field completion: Search the knowledge graph based on the root node of the semantic tree (such as "purchase order") and automatically add required fields (such as "order number" and "creation time"), with a completion accuracy rate of ≥85%.

[0020] Rule reasoning: Triggers the rule engine to generate foreign key binding suggestions (such as "the supplier ID must be associated with the primary key of the supplier table in the enterprise database") and generate verification rules (such as regular expressions matching the invoice number format).

[0021] Asynchronous pipeline design: Framework: Based on the Ray distributed computing framework, deployed in a Kubernetes cluster, and supports dynamic scaling.

[0022] Thread division: Parsing thread: processes NLP and knowledge graph queries, with the highest priority (response time ≤ 50ms).

[0023] Generate thread: Convert the semantic tree to JSON Schema and bind visual components (such as React form controls).

[0024] Verification thread: Checks field compatibility (such as database field length restrictions) and rule conflicts (such as circular dependencies).

[0025] Performance indicators: end-to-end latency <300ms (P99), throughput ≥5000 QPS (single cluster).

[0026] Caching strategy: Storage medium: Redis 6.0, using the LRU elimination strategy and TTL expiration mechanism.

[0027] Pre-storage of high-frequency templates: For example, the cache hit rate of templates such as "Purchase Order" and "Financial Reimbursement Form" is ≥85%, and the response time is <100ms.

[0028] Output Adapter: Format conversion: Map JSON Schema to a format supported by the low-code platform (such as XML, YAML).

[0029] Visual rendering: Generate Vue form controls and support dragging and dropping to adjust the layout.

[0030] Design for Interpretability: Field tracing: Click a field to view the generation basis (such as "Order number is triggered by knowledge graph rule ID: 2031").

[0031] Conflict prompts: Real-time mark rule conflicts (such as "Total amount formula does not reference the 'Tax rate' field") and provide repair suggestions.

[0032] Multimodal fusion input: Integrates text, voice, and sketch parsing technologies, covers all user interaction modes in all scenarios, and improves input adaptation rate by 40%.

[0033] Semantic-driven dynamic completion: solves the problem of incomplete user demand expression by inferring implicit fields and association rules through knowledge graph (completion accuracy ≥ 85%).

[0034] Lightweight edge deployment: Model distillation technology is used to compress the NLP model size (from 480MB to 190MB), reducing AI inference resource usage by 60%, and supporting operation on edge devices (such as industrial tablets).

[0035] Distributed asynchronous processing: Based on three-level priority message queues (high / medium / low) and dynamic resource allocation strategies, it supports task preemption and breakpoint resumption, ensuring service stability in high-concurrency scenarios (fault tolerance rate ≥ 99.9%).

[0036] Module division: User input layer: supports text, voice, sketch input, and Excel input, and is passed to the demand analysis module after ASR / CV pre-processing.

[0037] Demand parsing module: The BERT model generates a structured semantic tree, which includes field attributes and association relationships.

[0038] Knowledge enhancement module: Completes implicit fields through the knowledge graph and generates foreign key binding suggestions.

[0039] Real-time generation engine: Asynchronous pipeline processing of parsing, generation, and verification tasks, combined with Redis cache to accelerate response.

[0040] Low-code integration module: The output adapter generates JSON Schema and visual form controls, supporting user secondary editing.

[0041] Technology stack annotation: NLP model: fine-tuned BERT-base (HuggingFace Transformers library).

[0042] Distributed framework: Ray 2.0 (deployed in a Kubernetes cluster with ≥ 3 nodes).

[0043] Cache database: Redis 6.0 (cluster mode, number of shards = 6).

[0044] Core Process: Semantic tree construction: NLP extracts explicit fields and relationships (such as "quantity × unit price → total amount").

[0045] Knowledge graph completion: add implicit fields (such as "order number" and "supplier ID").

[0046] Rule generation and mapping: Generate validation rules (such as "unit price ≥ 0") and map them to JSON Schema.

[0047] Notes: The dashed boxes represent user input, and the solid boxes represent system-generated content.

[0048] Processing flow: Request reception and diversion: Choose to return directly or enter the asynchronous queue based on the cache hit situation.

[0049] Distributed processing: Parsing, generation, and verification threads are executed in parallel, supporting dynamic scaling and breakpoint resumption.

[0050] Result aggregation and push: Improve user experience by progressively rendering fields via WebSocket (first screen loading time < 200ms).

[0051] Performance parameters: Throughput: ≥5000 QPS (single cluster, CPU utilization ≤70%).

[0052] Fault tolerance: supports simultaneous failure of 3 nodes, and task recovery time is less than 10s. DETAILED DESCRIPTION

[0053] User input: Voice command "Create a purchase order. Requires supplier, product, quantity, and price." Requirements analysis: ASR converts to text: "Create a purchase order. Requires supplier, product, quantity, and unit price." The NLP model extracts entities: supplier (string), product (string), quantity (integer), unit price (floating point number).

[0054] Generate a semantic tree: the root node is "Purchase Order", and the child nodes contain explicit fields and the relationship "Total Amount = Quantity × Unit Price".

[0055] Knowledge completion: Search the knowledge graph and complete private data and industry data, and complete implicit fields: order number (UUIDv4), creation time (ISO 8601 timestamp), total amount (formula field).

[0056] Foreign key binding suggestion: Supplier → Primary key "supplier_id" of the supplier table in the enterprise database.

[0057] Real-time generation: The asynchronous pipeline generates JSON Schema, and the validation module checks field compatibility (e.g., the length of "Supplier" is ≤ 50 characters).

[0058] Low-code rendering: Output a visual form, mark "Total Amount" as a formula field (Total Amount = Quantity × Unit Price Total Amount = Quantity × Unit Price), and support users to adjust the field order.

[0059] User input: Sketch the expense report layout and label "department, project, amount, invoice number".

[0060] Requirements analysis: CV parses the sketch structure and identifies the table areas and field positions.

[0061] NLP extracts fields and infers data types: department (string), item (string), amount (float), invoice number (string).

[0062] Knowledge completion: Complete the following fields: Reimbursement form number (rule "FIN-{YYYYMMDD}-{SEQ}"), submission time (automatically filled in by the system), and approver (synchronized from the OA system).

[0063] Generate verification rules: The invoice number must conform to the regular expression ^[0-9]{8}-[0-9]{4}$.

[0064] Real-time generation: The cache hits the historical template "Financial Reimbursement Form" and directly returns the JSON Schema, with an end-to-end latency of less than 150ms. BRIEF DESCRIPTION OF THE DRAWINGS Figure 1 :Processor execution layer diagram Figure 2 : Schematic diagram of the memory device interaction layer.

Claims

1. A method for automatically generating document fields on a low-code platform based on artificial intelligence, characterized in that The following steps are involved: Receive user needs through multimodal input (text, voice, sketch) and preprocess them into standard text format; Use a multi-task NLP model to parse text and generate a structured semantic tree containing field names, data types, and relationships; Complete implicit fields and foreign key binding rules based on the preset domain knowledge graph, and generate verification logic through the rule engine; Through distributed asynchronous pipelines, the parsing, generation, and verification tasks are executed in parallel to generate JSON Schema and visualization components that can be edited by the low-code platform; The generated results are returned to the user end, supporting real-time modification and feedback to the knowledge graph and NLP model optimization.

2. The method according to claim 1, wherein: The NLP model uses the BERT-base architecture. The training dataset contains 100,000 industry document description texts and annotated entities. Domain-Adaptive Pretraining technology is applied to optimize the model's generalization ability. The training hyperparameters are: batch_size=32, learning_rate=2e-5, epochs=10.

3. The method according to claim 1, wherein: The asynchronous pipeline adopts a three-level priority message queue (high / medium / low) and a dynamic resource allocation strategy. High-priority tasks (such as real-time user requests) preempt low-priority tasks (such as batch data processing) and support breakpoint resuming (Checkpoint Interval = 5s).

4. The method according to claim 1, wherein: The user's modification behavior of the generated fields is fed back to the reinforcement learning model (PPO algorithm) through log collection, continuously optimizing the knowledge graph node weights and NLP model parameters. The optimization cycle is daily offline training.

Images