Operation system user intention processing method and device based on local large model and storage medium

Abstract

The invention discloses an operating system user intention processing method and device based on a local large model and a storage medium, and belongs to the field of artificial intelligence. Acquiring a natural language instruction input by a user side; calling a local large model to perform semantic simplification and intention analysis on the natural language instruction to obtain a user intention processing result; the user intention processing result is transmitted to an FAISS vector database for matching of a user-defined instruction set; in response to successful matching, the matched natural language instruction is sent to the actuator module to be executed, and a corresponding answer is obtained; and in response to matching failure, calling the local large model to generate a corresponding answer of the natural language instruction, thereby feeding back the corresponding answer to the user side in real time. According to the method, offline operation is supported, data privacy is guaranteed, semantic analysis is accurate and flexible, high-precision instruction matching is achieved, in addition, real-time feedback and authority control are achieved, multi-task parallel processing and performance optimization are obtained, it is ensured that efficient operation is still conducted in a low-resource offline environment, and the overall operation fluency is improved.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of artificial intelligence, and in particular to a method, device and storage medium for processing user intent in an operating system based on a local large model. Background Art

[0002] Currently, most natural language processing systems based on large models rely on large models deployed in the cloud, such as ChatGPT. These large models have a large number of parameters and require high-performance GPU servers to support their deployment and reasoning. Therefore, most existing natural language processing systems still need to be connected to the network to transmit and process data with remote servers where large models are deployed. Although such large cloud models have powerful semantic parsing capabilities, they cannot guarantee the privacy of user data and the normal operation of the system when the network is unstable or unavailable.

[0003] When processing complex instructions, natural language processing systems usually use keyword matching or simple rule-based parsing methods. These methods are difficult to handle instruction operations in multiple rounds of dialogue or complex scenarios, and may result in misunderstanding or inaccurate parsing results. Traditional matching technology has the problem of low computational efficiency in high-frequency interaction scenarios. When user instructions are too complex or ambiguous, the processing capacity of existing systems will be limited and cannot efficiently map the user's true intentions.

[0004] In addition, natural language processing systems generally rely on cloud-based feedback. The instructions entered by the user need to be transmitted through the network to the server for processing, and then the execution results are returned to the user. This interaction mode will affect the user experience, especially when there is no network or the network is in poor condition, the user will not be able to use the system or will have to wait too long. Summary of the invention

[0005] The embodiments of the present application provide a method, device and storage medium for processing user intent of an operating system based on a local large model.

[0006] On the one hand, a method for processing user intention of an operating system based on a local large model is provided, the method comprising:

[0007] Obtain natural language instructions input by the user;

[0008] Calling the local big model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result;

[0009] The user intention processing result is transmitted to the FAISS vector database for matching of the custom instruction set;

[0010] In response to a successful match, the matched natural language instruction is sent to the executor module for execution to obtain a corresponding answer;

[0011] In response to a match failure, calling the local big model to generate a corresponding answer to the natural language instruction;

[0012] The corresponding answer is fed back to the user terminal in real time.

[0013] Optionally, the local large model includes a prompt setting module and a semantics and intent parsing module;

[0014] The local large model is quantized and compressed and deployed on the end-side device running the openKylin operating system to achieve deep integration and support automatic loading and initialization in a network-free environment.

[0015] Optionally, calling the local large model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result includes:

[0016] Calling the Prompt setting module in the local large model to semantically simplify the natural language instruction to obtain a simplified instruction;

[0017] The semantics and intent analysis module in the local large model is called to perform intent analysis on the simplified instruction to obtain a user intent processing result.

[0018] Optionally, calling the Prompt setting module in the local large model to semantically simplify the natural language instruction to obtain a simplified instruction includes:

[0019] Adjust the response strategy of the model according to the natural language instruction through the Prompt setting module in the local large model, wherein the response strategy includes a response strategy corresponding to a direct and clear short instruction, a response strategy corresponding to a long description instruction, and a response strategy corresponding to a multi-task scenario instruction;

[0020] The natural language instruction is semantically simplified according to the adjusted response strategy to obtain a simplified instruction.

[0021] Optionally, semantic simplification of the natural language instruction is performed according to the adjusted response strategy to obtain a simplified instruction, including:

[0022] In response to the short instruction being a direct and clear instruction, the prompt setting module confirms the natural language instruction as the simplified instruction;

[0023] In response to a long description type instruction, simplifying the natural language instruction according to key operations through the Prompt setting module to obtain the simplified instruction;

[0024] In response to a multi-task scenario-type instruction, the natural language instruction is disassembled by the Prompt setting module to perform parallel processing instructions to obtain the simplified instruction.

[0025] Optionally, calling the semantics and intent parsing module in the local large model to perform intent parsing on the simplified instruction to obtain a user intent processing result includes:

[0026] Obtain the simplified instructions and perform data cleaning to obtain accurate language instructions;

[0027] The user intention processing result corresponding to the precise language instruction is obtained according to the context and historical record completion information.

[0028] Optionally, the transmitting the user intention processing result to the FAISS vector database for matching the custom instruction set includes:

[0029] Converting the user intention processing result into a vector form;

[0030] The FAISS vector database is used to perform fuzzy matching on the user intention processing results in vector form. The fuzzy matching is used to match incomplete or ambiguous expressions to the closest instructions in the custom instruction set, and the closest instructions are the matched natural language instructions.

[0031] Optionally, in response to a successful match, sending the matched natural language instruction to an executor module for execution to obtain a corresponding answer includes:

[0032] Obtaining parallel processing instructions for disassembling the Prompt setting module;

[0033] The parallel processing instructions are processed in parallel through resource scheduling and cache mechanism.

[0034] On the other hand, a device for processing user intention of an operating system based on a local large model is provided, the device comprising:

[0035] A first processing module, used to obtain a natural language instruction input by a user terminal;

[0036] The second processing module is used to call the local large model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result;

[0037] The third processing module is used to transmit the user intention processing result to the FAISS vector database for matching the custom instruction set;

[0038] A fourth processing module is used for sending the matched natural language instruction to the executor module for execution to obtain a corresponding answer in response to a successful match;

[0039] a fifth processing module, configured to, in response to a matching failure, call the local large model to generate a corresponding answer to the natural language instruction;

[0040] The sixth processing module is used to feed back the corresponding answer to the user terminal in real time.

[0041] On the other hand, a computer-readable storage medium is provided, wherein the storage medium stores at least one instruction, and the at least one instruction is used to be executed by a processor to implement the operating system user intention processing method based on the local large model as described in the above aspects.

[0042] On the other hand, a computer program product is also provided, which stores at least one instruction, and the at least one instruction is loaded and executed by the processor to implement the operating system user intention processing method based on the local large model described in the above aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] Figure 1 A flowchart of a method for processing user intention of an operating system based on a local large model provided by an exemplary embodiment of the present application is shown;

[0044] Figure 2 A flowchart of a real-time user semantic parsing and instruction execution system based on a locally deployed nine-grid large model is shown;

[0045] Figure 3 Shows a schematic diagram of the structure of each module of this application;

[0046] Figure 4 A flow chart of the method for processing operating system user intention based on a local large model executed in Example 1 is shown. DETAILED DESCRIPTION

[0047] In order to make the objectives, technical solutions and advantages of the present application clearer, the implementation methods of the present application will be further described in detail below with reference to the accompanying drawings.

[0048] The term "multiple" as used herein refers to two or more than two. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can mean: A exists alone, A and B exist at the same time, and B exists alone. The character " / " generally indicates that the related objects are in an "or" relationship.

[0049] It should be noted that the operating system user intent processing method based on the local large model, wherein the operating system is mainly aimed at domestic operating systems (such as openkylin, etc.), and the embodiment is described by taking the operation on the domestic operating system openKylin as an example.

[0050] Example 1

[0051] Please refer to Figure 1 , which shows a flowchart of a method for processing user intention of an operating system based on a local large model provided by an exemplary embodiment of the present application. The method includes:

[0052] Step 101, obtaining a natural language instruction input by a user terminal.

[0053] Step 102, call the local large model to perform semantic simplification and intent analysis on the natural language instructions to obtain the user intent processing result.

[0054] The local large model includes the prompt setting module and the semantics and intent parsing module;

[0055] The local large model is quantized, compressed and deployed on the end device running the openKylin operating system to achieve deep integration and support automatic loading and initialization in a network-free environment.

[0056] It should be noted that the local large model (such as the self-developed nine-grid large model) that has been quantized and compressed is deployed on the end-side device running the openKylin operating system to achieve deep integration and support automatic loading and initialization of the model. By running the large model locally, the system can handle semantic parsing tasks in a network-free environment, ensuring the privacy of user data and the stability of operations. The model supports cache optimization of inference results to avoid repeated calculations and improve response speed.

[0057] Optionally, step 102 includes the following contents.

[0058] Step S11, calling the Prompt setting module in the local large model to semantically simplify the natural language instructions to obtain simplified instructions.

[0059] The Prompt setting module in the local large model is used to adjust the response strategy of the model according to natural language instructions, wherein the response strategies include response strategies corresponding to direct and clear short instructions, response strategies corresponding to long description instructions, and response strategies corresponding to multi-task scenario instructions. The natural language instructions are semantically simplified according to the adjusted response strategies to obtain simplified instructions.

[0060] For discussion of each case, in response to a direct and clear short instruction, the Prompt setting module confirms the natural language instruction as a simplified instruction; in response to a long description instruction, the Prompt setting module simplifies the natural language instruction according to the key operation to obtain the simplified instruction; in response to a multi-task scenario instruction, the Prompt setting module disassembles the natural language instruction for parallel processing to obtain the simplified instruction.

[0061] In one example, the Prompt setting module flexibly adjusts the model's response strategy based on the user's input. For direct and clear short instructions, such as "screenshot" or "shutdown", the Prompt setting module will directly pass the instructions to the execution layer to avoid redundant processing. For longer descriptive inputs, such as "I have some information, please print it for me", the Prompt setting module will simplify it into key operations such as "turn on the printer" to ensure that the instructions are concise and accurate. For multi-tasking scenarios, such as "The screen is a little dark, turn on the light mode, help me set the input method and find the word files modified in the past week", the Prompt setting module will break down a sentence into multiple independent tasks and pass them to different modules in parallel for processing. "

[0062] Step S12, calling the semantics and intent analysis module in the local large model to perform intent analysis on the simplified instruction to obtain the user intent processing result.

[0063] Obtain simplified instructions and perform data cleaning to obtain precise language instructions; complete information based on context and historical records to obtain user intent processing results corresponding to precise language instructions.

[0064] In one example, based on the preliminary processing of the Prompt setting module, the user input is further refined (such as processing the content of the user input, such as the processing of punctuation marks such as "ne ah oh", and the user subsequently simplifies and performs a data cleansing) to accurately determine the purpose of the input. The system can understand synonymous expressions, multiple rounds of dialogue, and fuzzy instructions, complete information based on context and historical records, and perform appropriate operations. For example, when a user says "print this", the system will infer the specific file based on the current scenario and complete the task.

[0065] Step 103, the user intention processing result is transmitted to the FAISS vector database for matching of the custom instruction set.

[0066] Step S31, converting the user intention processing result into a vector form;

[0067] Step S32, using the FAISS vector database to perform fuzzy matching on the user intention processing results in vector form. The fuzzy matching is used to match the incomplete or ambiguous expression to the closest instruction in the custom instruction set, and the closest instruction is the matched natural language instruction.

[0068] Among them, a custom instruction set is built in advance. Common operations (such as turning on Bluetooth, searching for word files created in the last seven days, opening a browser, playing music, adjusting screen resolution, adjusting screen brightness, turning on wifi and searching, etc., which can be executed with just one sentence) are mapped to the underlying execution commands to generate a custom instruction set. For example, "open terminal" is mapped to the execution command xdotool ctrl+alt+T, so that the system can directly call the corresponding execution instruction according to the user's natural language input.

[0069] In one possible implementation, the parsed user input is converted into a vector form, and the FAISS vector database is used for efficient fuzzy matching (the efficiency is reflected in the significant improvement in speed compared with conventional SQL databases or search methods, and the search can be completed within 0.2 seconds, matching the instructions with the highest similarity. For example, the simplified input is "Please help me adjust the screen brightness of my computer", which is accurately matched to "Adjust the screen brightness"). Even in the face of incomplete or ambiguous expressions, the system can match the closest instruction, such as matching "turn on the computer printer" to "turn on the printer."

[0070] In addition, there is a fault-tolerant mechanism. When the confidence of the matching result is lower than the set threshold, the system will not execute the instruction directly, but pass the problem to the big model for further processing (further processing refers to the fault-tolerant mechanism. If the instruction is not matched correctly, it will not be executed or return an incorrect result, but will be handed over to the big model for a second time, and a big model dialogue will be conducted to return the correct result. For example, if the screen brightness is adjusted, if there is no successful match, it will not return a failed result, but ask the big model a question, and then return the text content to you (how to adjust the screen brightness)), and feedback to the user in the form of dialogue to ensure the safety and accuracy of the operation.

[0071] In one example, "turn on the computer's printer" is matched to "turn on the printer". The sample code is as follows:

[0072] #1. Read data (vector database)

[0073] df=pd.read_excel('database.xlsx', header=0)

[0074] texts = df.iloc[:,0].values

[0075] #2. Text vectorization

[0076] model=SentenceTransformer('. / paraphrase-multilingual-MiniLM-L12-v2')

[0077] text_vectors=model.encode(texts,convert_to_numpy=True)

[0078] #3. Create an index

[0079] d = text_vectors.shape[1] #vector dimension

[0080] index = faiss.IndexFlatL2(d)

[0081] #4. Add data to the index

[0082] index.add(text_vectors)

[0083] #5. Query data

[0084] query_vector=model.encode([job],convert_to_numpy=True)

[0085] distances,indices=index.search(query_vector,1)

[0086] stresct=2

[0087] #Judge the matching results

[0088] if distances[0][0]>stresct:

[0089] print("The vector is not matched in the database!")

[0090] return ""

[0091] text = texts[indices[0][0]]

[0092] Step 104, in response to a successful match, the matched natural language instruction is sent to the executor module for execution to obtain a corresponding answer.

[0093] For common task scenarios, after receiving the instruction, the executor module immediately calls the underlying command to perform the operation. For common instructions, such as "open terminal", the system will directly call the xdotool ctrl+alt+T shortcut key combination to open the terminal window immediately. For operations involving system permissions, such as "shutdown" or "restart", the system will first trigger the verification process and require the user to enter the root password. Only after the authentication is passed will the execution continue to ensure the security of key operations.

[0094] Considering the multi-tasking scenario, the executor module obtains the parallel processing instructions disassembled by the prompt setting module; and processes the parallel processing instructions in parallel through resource scheduling and caching mechanism.

[0095] Step 105, in response to a matching failure, calling the local large model to generate a corresponding answer to the natural language instruction.

[0096] Step 106: Feedback the corresponding answer to the user in real time.

[0097] After the operation is completed, the system will immediately feedback the execution results to the user interface. The execution status of each task, whether successful or failed, will be clearly presented on the interface. For example, when the printer is successfully turned on, the prompt "Printer is turned on" is displayed; if the operation fails to complete, it will display "Printer not found, please check the device". When the operation instruction cannot be completed smoothly, the system will also give clear guidance or prompts to help users make adjustments.

[0098] This application has at least the following technical effects.

[0099] 1) Support offline operation and ensure data privacy: Large models deployed locally do not need to rely on cloud services and can parse user input stably and efficiently in a network-free environment. Through data isolation, user privacy protection is improved to meet the needs of various special scenarios.

[0100] 2) Accurate and flexible semantic analysis: The system has high-precision semantic analysis capabilities. It can not only handle ambiguous expressions and multi-round interactions, but also accurately distinguish system commands from ordinary questions and answers, ensuring the reliability of command execution, reducing misoperations, and improving user experience.

[0101] 3) High-precision instruction matching: Using the FAISS vector database, efficient mapping between user natural language and custom instruction sets is achieved. Even if the input is incomplete or inaccurate, the system can match the appropriate instructions and cooperate with the fault-tolerant mechanism to avoid erroneous execution.

[0102] 4) Real-time feedback and permission control: The system has real-time feedback and permission control mechanisms, which improves the security of the system. For high-risk commands such as shutdown, the verification process will be triggered, and the results will be quickly fed back after the operation is completed, so that users can obtain clear and timely status confirmation.

[0103] 5) Multi-task parallel processing and performance optimization: The system supports the independent execution of multiple instructions without blocking each other. Through resource scheduling and caching mechanisms, it ensures efficient operation in low-resource environments and improves the smoothness of overall operations.

[0104] Example 2

[0105] Figure 2 A flow chart of a real-time user semantic parsing and instruction execution system based on a locally deployed nine-grid large model is shown.

[0106] like Figure 2 As shown in the figure, the user inputs natural language instructions through the front-end page. The system first uses the locally deployed nine-grid model to semantically simplify and parse the input language to ensure privacy protection and efficient processing in an offline state. The parsed results are passed to the FAISS vector database for high-precision matching with the custom instruction set. If the instruction matches successfully, the system sends the instruction to the executor module to complete the operation and feeds back the execution result to the user; if the match fails, the system calls the local large model to enter the dialogue mode, generates a reasonable answer and returns it to the user. This dual feedback mechanism ensures the efficiency and stability of the system, and can provide users with instant response and friendly operation experience in any situation.

[0107] like Figure 3 As shown, Figure 3 The schematic diagram of the module structure of this solution is shown. The system mainly includes the following modules:

[0108] 1. System core module

[0109] 1) FAISS vector database

[0110] Match custom instruction sets, match user intent with high precision, and generate system instructions;

[0111] 2) Nine local large model modules

[0112] Semantic analysis, user intent analysis, offline natural language processing, and data privacy protection;

[0113] 3) Instruction execution and feedback module

[0114] Pass the matching instructions to the executor module and provide real-time feedback to the front-end page;

[0115] 2. Front-end page module

[0116] 1) Natural language input

[0117] executing system instructions generated from the matching results;

[0118] 2) Task completion feedback

[0119] Return the execution result to the front-end page;

[0120] 3. System support module

[0121] 1) Resource and data management (such as video memory allocation, CPU, memory allocation, boost speed-up);

[0122] 2) System hardware support (e.g. I / O devices, Linux kernel, real-time feedback);

[0123] like Figure 4 As shown, it corresponds to the operating system user intention processing method based on the local large model executed in Example 1.

[0124] An exemplary embodiment of the present application further provides an operating system user intention processing device based on a local large model, the device comprising:

[0125] A first processing module, used to obtain a natural language instruction input by a user terminal;

[0126] The second processing module is used to call the local large model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result;

[0127] The third processing module is used to transmit the user intention processing result to the FAISS vector database for matching the custom instruction set;

[0128] A fourth processing module is used for sending the matched natural language instruction to the executor module for execution to obtain a corresponding answer in response to a successful match;

[0129] a fifth processing module, configured to, in response to a matching failure, call the local large model to generate a corresponding answer to the natural language instruction;

[0130] The sixth processing module is used to feed back the corresponding answer to the user terminal in real time.

[0131] Optionally, the local large model includes a prompt setting module and a semantics and intent parsing module;

[0132] The local large model is quantized and compressed and deployed on the end-side device running the openKylin operating system to achieve deep integration and support automatic loading and initialization in a network-free environment.

[0133] Optionally, the second processing module includes:

[0134] A first processing unit is used to call the Prompt setting module in the local large model to semantically simplify the natural language instruction to obtain a simplified instruction;

[0135] The second processing unit is used to call the semantics and intention analysis module in the local large model to perform intention analysis on the simplified instruction to obtain a user intention processing result.

[0136] Optionally, the first processing unit is also used to adjust the response strategy of the model according to the natural language instructions through the Prompt setting module in the local large model, wherein the response strategy includes a response strategy corresponding to direct and clear short instructions, a response strategy corresponding to long description instructions, and a response strategy corresponding to multi-task scenario instructions; the natural language instructions are semantically simplified according to the adjusted response strategy to obtain simplified instructions.

[0137] Optionally, the first processing unit is also used to, in response to a direct and clear short instruction, confirm the natural language instruction as the simplified instruction through the Prompt setting module; in response to a long description instruction, simplify the natural language instruction according to key operations through the Prompt setting module to obtain the simplified instruction; in response to a multi-task scenario instruction, disassemble the natural language instruction through the Prompt setting module to perform parallel processing instructions to obtain the simplified instruction.

[0138] Optionally, the second processing unit is further used to obtain the simplified instruction, perform data cleaning, and obtain a precise language instruction; complete the information according to the context and historical records to obtain a user intention processing result corresponding to the precise language instruction.

[0139] Optionally, the third processing module includes:

[0140] A third processing unit, used for converting the user intention processing result into a vector form;

[0141] The fourth processing unit is used to use the FAISS vector database to perform fuzzy matching on the user intention processing results in vector form, wherein the fuzzy matching is used to match the incomplete or ambiguous expression to the closest instruction in the custom instruction set, and the closest instruction is the matched natural language instruction.

[0142] Optionally, the fourth processing module includes:

[0143] A fifth processing unit, used for obtaining parallel processing instructions disassembled by the Prompt setting module;

[0144] The sixth processing unit is used to process the parallel processing instructions in parallel through resource scheduling and cache mechanism.

[0145] The serial numbers of the above-mentioned embodiments of the present application are for description only and do not represent the advantages or disadvantages of the embodiments.

[0146] A person skilled in the art will understand that all or part of the steps to implement the above embodiments may be accomplished by hardware or by instructing related hardware through a program, and the program may be stored in a computer-readable storage medium, and the above-mentioned storage medium may be a read-only memory, a disk or an optical disk, etc.

[0147] The above description is only an optional embodiment of the present application and is not intended to limit the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application shall be included in the protection scope of the present application.

Claims

1. A method for processing user intention in an operating system based on a local large model, characterized in that: The method comprises: Obtain natural language instructions input by the user; Calling the local big model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result; The user intention processing result is transmitted to the FAISS vector database for matching of the custom instruction set; In response to a successful match, the matched natural language instruction is sent to the executor module for execution to obtain a corresponding answer; In response to a match failure, calling the local big model to generate a corresponding answer to the natural language instruction; The corresponding answer is fed back to the user terminal in real time.

2. The method according to claim 1, characterized in that: The local large model includes a prompt setting module and a semantics and intention analysis module; The local large model is quantized and compressed and deployed on the end-side device running the openKylin operating system to achieve deep integration and support automatic loading and initialization in a network-free environment.

3. The method according to claim 2, characterized in that The calling of the local large model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result includes: Calling the Prompt setting module in the local large model to semantically simplify the natural language instruction to obtain a simplified instruction; The semantics and intent analysis module in the local large model is called to perform intent analysis on the simplified instruction to obtain a user intent processing result.

4. The method according to claim 3, characterized in that The calling of the Prompt setting module in the local large model to semantically simplify the natural language instruction to obtain a simplified instruction includes: Adjust the response strategy of the model according to the natural language instruction through the Prompt setting module in the local large model, wherein the response strategy includes a response strategy corresponding to a direct and clear short instruction, a response strategy corresponding to a long description instruction, and a response strategy corresponding to a multi-task scenario instruction; The natural language instruction is semantically simplified according to the adjusted response strategy to obtain a simplified instruction.

5. The method according to claim 4, characterized in that The natural language instruction is semantically simplified according to the adjusted response strategy to obtain a simplified instruction, including: In response to the short instruction being a direct and clear instruction, the prompt setting module confirms the natural language instruction as the simplified instruction; In response to a long description type instruction, simplifying the natural language instruction according to key operations through the Prompt setting module to obtain the simplified instruction; In response to a multi-task scenario-type instruction, the natural language instruction is disassembled by the Prompt setting module to perform parallel processing instructions to obtain the simplified instruction.

6. The method according to claim 4, characterized in that The calling of the semantics and intention parsing module in the local large model to perform intention parsing on the simplified instruction to obtain a user intention processing result includes: Obtain the simplified instructions and perform data cleaning to obtain accurate language instructions; The user intention processing result corresponding to the precise language instruction is obtained according to the context and historical record completion information.

7. The method according to claim 1, characterized in that The step of transmitting the user intention processing result to the FAISS vector database for matching the custom instruction set includes: Converting the user intention processing result into a vector form; Process the user intention in vector form The FAISS vector database is used to perform fuzzy matching on the user intention processing results in vector form. The fuzzy matching is used to match incomplete or ambiguous expressions to the closest instructions in the custom instruction set, and the closest instructions are the matched natural language instructions.

8. The method according to claim 5, characterized in that In response to a successful match, the matched natural language instruction is sent to the executor module for execution to obtain a corresponding answer, including: Obtaining parallel processing instructions for disassembling the Prompt setting module; The parallel processing instructions are processed in parallel through resource scheduling and cache mechanism.

9. An operating system user intention processing device based on a local large model, characterized in that: The device comprises: A first processing module, used to obtain a natural language instruction input by a user terminal; The second processing module is used to call the local large model to perform semantic simplification and intent analysis on the natural language instruction to obtain a user intent processing result; The third processing module is used to transmit the user intention processing result to the FAISS vector database for matching the custom instruction set; A fourth processing module is used for sending the matched natural language instruction to the executor module for execution to obtain a corresponding answer in response to a successful match; a fifth processing module, configured to, in response to a matching failure, call the local large model to generate a corresponding answer to the natural language instruction; The sixth processing module is used to feed back the corresponding answer to the user terminal in real time.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, which is loaded and executed by a processor to implement the method for processing user intentions of an operating system based on a local large model as described in any one of claims 1 to 8 above.

Images