Fault diagnosis method and system for coil cutting all-in-one machine based on large language model

Abstract

The invention discloses a fault diagnosis method and system for a coil cutting all-in-one machine based on a large language model, and relates to the technical field of equipment fault diagnosis, and the system comprises a table data intelligent processing module, a knowledge base construction module, a diagnosis reasoning module and a user interaction module. The table data intelligent processing module is used for carrying out automatic fault mode labeling and description standardization on a cutting and rolling all-in-one machine fault diagnosis case library provided by a user; the domain knowledge graph construction module is used for integrating the standardized table database and automatically constructing a domain knowledge graph; the diagnosis reasoning module is used for performing fault diagnosis reasoning based on a large language model and a knowledge graph; and the user interaction module provides a multi-modal user interaction interface and supports visual display of fault diagnosis. Therefore, by adopting the fault diagnosis method and system for the cutting and winding all-in-one machine based on the large language model, the intelligent level of fault diagnosis can be improved, the knowledge base construction and expansion cost can be reduced, and the usability and maintainability of the system can be enhanced.

Description

Technical Field

[0001] The present invention relates to the technical field of equipment fault diagnosis, and in particular to a method and system for diagnosing a fault of a cutting and rolling machine based on a large language model. Background Art

[0002] With the rapid development of the new energy industry and the continuous growth of energy storage demand, lithium batteries have been widely used due to their high energy density, long cycle life and environmental performance. In the production process of lithium batteries, the laser die-cutting and winding machine (hereinafter referred to as the "cutting and winding machine") is one of the key equipment, playing an important role in the tab forming and winding of the electrode roll into square battery cells. The stable operation of the cutting and winding machine is of great significance to the manufacturing efficiency and product quality of lithium batteries. However, the fault diagnosis and maintenance of the cutting and winding machine are currently facing multiple challenges, and its complex structure makes the fault diagnosis technology more difficult. The existing diagnostic methods still rely mainly on the experience of maintenance personnel, resulting in low diagnostic efficiency and difficulty in quickly locating the root cause of the fault. In addition, although a large amount of relevant data has been accumulated, due to the complex data structure, lack of a classification system, and inadequately standardized descriptions, these data have not been fully mined and effectively utilized, making it difficult to achieve systematic and structured preservation and inheritance, resulting in the continuous loss of corporate knowledge assets.

[0003] To address the issues of insufficient intelligence in fault diagnosis and low data knowledge, researchers have proposed a knowledge graph-based equipment fault diagnosis method. Leveraging the powerful data organization, representation, and management capabilities of knowledge graphs, this method transforms multi-source heterogeneous data into knowledge that serves intelligent industrial production and provides decision support for maintenance workers. For example, the invention patent "A Method for Constructing a Knowledge Graph for Turnout Machine Fault Diagnosis" uses a bidirectional long-short-term memory neural network model and a linear chain conditional random field model for named entity recognition, thereby constructing a knowledge graph to enable information query. The invention patent "A Method for Concurrent Transformer Fault Diagnosis Based on Graph Convolutional Neural Networks and Knowledge Graphs" fully models concurrent faults and identifies the equipment or component where the concurrent fault occurs.

[0004] However, existing technologies still have some shortcomings. First, existing equipment fault diagnosis models based on knowledge graphs rely heavily on domain experts manually managing datasets for each task and creating specific models for training. This approach is not only time-consuming and labor-intensive, but also difficult to maintain over the long term. Second, tabular data is widely used in fault diagnosis knowledge management, and existing research on methods for constructing knowledge graphs based on tabular processing is limited. Furthermore, there is currently a lack of a method and system for end-to-end fault diagnosis of slitting and winding machines. Summary of the Invention

[0005] The purpose of the present invention is to provide a fault diagnosis method and system for a cutting and winding machine based on a large language model, realizing an end-to-end process from table data processing to diagnostic suggestion generation, which can reduce manual dependence, significantly improve diagnostic efficiency and accuracy, and realize proactive fault diagnosis services.

[0006] To achieve the above object, the present invention provides a method for diagnosing a fault of a cutting and rolling machine based on a large language model, comprising the following steps:

[0007] S1. Collect various data from the slitter and roll-to-roll machine, unify the format and units, and integrate them into a table framework. Obtain a fault case library for the slitter and roll-to-roll machine, divide the equipment structure, define the fault modes, and build a domain dictionary.

[0008] S2. For the two subtasks of fault mode labeling and description standardization, we designed specialized prompt word templates. Combined with rule constraints, they guided the large language model to complete the tasks, enabling automated processing of tabular data and building a standardized fault diagnosis knowledge base.

[0009] In the fault mode labeling subtask, different labeling strategies were designed, and corresponding fault modes were obtained based on predefined rules. In the description normalization subtask, a two-layer large language model optimizer-evaluator was constructed. The optimizer uses fault modes as analysis units, performing data extraction and serialization, semantic grouping and standardization, and optimizing output and writing results. The evaluator receives the optimizer's input and output, performs binary scoring based on predefined evaluation dimensions, and feeds the evaluation results back to the optimizer.

[0010] S3. Extract triples from the fault diagnosis knowledge base obtained in step S2 through a knowledge extraction method, design a top-down knowledge framework to construct a domain knowledge graph, store it in a Neo4j database, and connect it to the large language model;

[0011] S4. Use the large language model as a recommender for fault diagnosis suggestions, receive real-time fault alarm information from the roll-cutting machine, and support users to input fault phenomena in a multimodal form. By searching the domain knowledge graph and web page queries for reasoning, the system provides diagnostic conclusions and solutions.

[0012] In one possible implementation, in step S1, an abstraction process is performed based on the system structure or functional modules of the cutting and rolling machine, and the equipment structure is divided into three layers: modules, components, and parts; the failure mode F is expressed as: Mapping method f: M→F, C→F, P→F, where module M represents an independent and indivisible system function in the equipment, component C represents the structural unit of the module subclass, and part P represents the specific physical component or function of the component subclass.

[0013] In one possible implementation, in step S1, the constructed domain dictionary includes a dictionary of roll-to-roll machine components, an alarm dictionary, a stop word dictionary, and a dictionary of common words and their synonyms;

[0014] Among them, the component dictionary of the cutting and winding machine includes the equipment hierarchy structure and its mapping relationship with the fault mode, and the alarm dictionary includes the operation alarm description and its mapping relationship with the fault mode.

[0015] In one possible implementation, in step S2, the large language model serves as a pipeline supervisor for fault mode annotation, and performs fault mode annotation through three strategies: entity recognition based on domain dictionaries, fault mode recognition based on text similarity, and a proxy driven by the large language model.

[0016] Among them, entity recognition based on domain dictionaries includes text filtering, disambiguation, and word segmentation based on pre-built domain dictionaries, obtaining fault phrase sequences, matching fault patterns using a forward maximum matching algorithm, and establishing a correction rule library to correct common matching errors;

[0017] Fault pattern recognition based on text similarity involves using the TF-IDF algorithm to extract feature vectors of fault phenomena and operational fault alarm texts, calculating the similarity between the fault phenomena and the operational fault alarm texts in the cutter alarm dictionary using cosine similarity, setting a similarity threshold, and mapping the corresponding fault patterns based on the domain dictionary.

[0018] The agent driven by a large language model includes fault mode labeling rules based on user input. The large language model generates labeling code based on the React prompt word strategy, and is tested and debugged through external tools. Data is screened, judged, and automatically labeled in the provided table. Users review the results and provide feedback to guide the agent's continuous learning and optimization. At the same time, the labeling rules and code are stored in a correction rule library to support subsequent reuse.

[0019] In one possible implementation, in step S2, for the description normalization subtask, an optimizer-evaluator based on a two-layer large language model is constructed, including:

[0020] The optimizer uses the failure mode as the analysis unit, extracts all row data from the target column, divides it into several text blocks for batch processing, and serializes the data using a preset prompt word template.

[0021] The large language model uses contextual learning capabilities to semantically group the extracted text content and normalize and unify descriptions with similar semantics but different wording within each group.

[0022] The optimizer has long and short-term memory, which stores the original data, the reasoning steps, intermediate results, and normalized results during each processing. When receiving feedback from the evaluator, the optimizer adjusts its generation strategy through a reflection mechanism, reanalyzes, and optimizes. When all evaluation dimensions meet the standards, a new column is created to store the optimized content corresponding to the original content.

[0023] The optimizer also accumulates expertise from historical processing by integrating an iterative feedback mechanism and performs memory optimization based on the memory optimization mechanism of the Ebbinghaus forgetting curve;

[0024] The evaluator receives the input and output of the optimizer. In the preset iterative rounds, it evaluates the output quality of the optimizer through binary scoring based on predefined evaluation dimensions. If the score does not meet the standard, the unqualified content is fed back to the optimizer and specific modification suggestions are made. The above process is repeated until all dimensions meet the standard or the cycle round is reached.

[0025] In one possible implementation, the evaluation dimensions include completeness, semantic consistency, conciseness, comprehensibility, format standardization, and hallucination detection.

[0026] In one possible implementation, step S3 includes regularly updating the domain knowledge graph, extracting corresponding data from the fault diagnosis knowledge base for each newly labeled fault mode, converting it into a computable vector form through vectorization technology, calculating the correlation between the newly labeled fault mode and the corresponding data in the fault diagnosis knowledge base using cosine similarity, and judging whether there is updated content. If there is new content, the updated content is integrated into the existing fault diagnosis knowledge base.

[0027] In one possible implementation, in step S4, for the fault phenomenon input by the user, possible fault modes are identified based on entity recognition based on the domain dictionary, fault pattern recognition based on text similarity, and offline rules accumulated by the large language model-driven proxy strategy in step S1. At the same time, the m3e embedding model is used to align the input text with entities in the domain knowledge graph. By calculating cosine similarity, the top k nodes with the highest scores are selected as candidate nodes, and the corresponding fault modes are further queried as follows:

[0028]

[0029] Where, Sim(E q ,E t ) is the similarity, E q 、E t They are knowledge graph entity and user query entity respectively.

[0030] Considering that the information obtained by the above retrieval methods may contain noise and irrelevant details, LLM is introduced as a retrieval evaluator. The evaluator judges the relevance between the candidate fault modes and their corresponding fault phenomenon lists and the user query description. The relevance is divided into two confidence levels: "correct" and "incorrect". Fault modes that are judged to be relevant are retained, and irrelevant ones are eliminated. Finally, a list of filtered fault modes is output. For the identified fault modes, their associated historical fault cases are further retrieved to achieve knowledge reuse. If no information that fully matches the user query is found in the domain knowledge graph, supplementary information is actively obtained from external web pages through prompt words to further recommend potential fault causes and solutions.

[0031] The present invention also provides a large language model-based fault diagnosis system for a slitting and rolling machine, which is used to implement the large language model-based fault diagnosis method for a slitting and rolling machine. The system includes a table data intelligent processing module, a domain knowledge graph construction module, a diagnostic reasoning module, and a user interaction module.

[0032] The intelligent table data processing module uses the large language model as a pipeline supervisor for fault mode annotation, automatically annotating the fault modes of the user-provided case library of integrated coil cutting machine fault diagnosis. Simultaneously, an optimizer-evaluator based on a two-layer large language model is constructed to process user-provided files, normalize the description of target columns, and construct a standardized fault diagnosis knowledge base.

[0033] The domain knowledge graph construction module is composed of equipment-related and fault-related pattern layers. The two pattern layers interact through fault patterns and are used to integrate the standardized table database of the slitting machine. The extraction function is constructed using Python to extract triples and store them in the Neo4j database. LangChain's vectorstores are then used to connect the Neo4j database with the large language model, and the domain knowledge graph is regularly updated incrementally.

[0034] The diagnostic reasoning module uses a large language model as a recommender for fault diagnosis suggestions. When corresponding cases exist in the constructed domain knowledge graph, recommendations are directly generated; otherwise, the device information currently related to the fault is identified and the cause and solution of the fault are inferred through online search.

[0035] The user interaction module is used to provide a multimodal user interaction interface and support visual presentation of fault diagnosis.

[0036] In one possible implementation, the optimizer-estimator based on the two-layer large language model includes:

[0037] The optimizer is used to generate initial output, and the evaluator provides feedback to the optimizer. Through a bidirectional loop, entity alignment and knowledge fusion are achieved, and the file processing results and process explanations are returned.

[0038] The optimizer uses the large language model as a professional assistant for database standardization management, performing data extraction and serialization, semantic grouping and standardization, optimized output and writing results, and self-evolution tasks;

[0039] The evaluator uses the large language model as the supervisor of database normalization management, receives the input and output of the optimizer, and in preset iteration rounds, evaluates the output quality of the professional assistant through binary scoring combined with predefined evaluation dimensions, and makes specific modification suggestions.

[0040] Therefore, the present invention adopts the above-mentioned large language model-based fault diagnosis method and system for the cutting and rolling machine, which has the following technical effects:

[0041] (1) The present invention designs a method for automatically constructing a knowledge graph from tabular data, including automated fault mode labeling, entity alignment, and knowledge fusion, which improves the efficiency, flexibility, and accuracy of knowledge base construction, reduces labor costs and human errors, and lowers the cost of knowledge base construction and expansion.

[0042] (2) The present invention forms a complete solution from data processing to diagnostic suggestions, while supporting the tracing of knowledge sources, assisting maintenance personnel in guided troubleshooting, shortening downtime, reducing dependence on manual experience, and improving the intelligent level of fault diagnosis.

[0043] (3) The system provided by the present invention supports users to interact with the system through natural language, which lowers the operation threshold and improves the user experience; at the same time, with the continuous interaction of users and the dynamic update of the knowledge graph, the model is iteratively updated, which improves the accuracy of understanding business needs and the quality of answers, and enhances the usability and maintainability of the system.

[0044] The technical solution of the present invention is further described in detail below through the accompanying drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Figure 1 1. A schematic diagram of the fault mode classification of a slitter-roller in an embodiment of a fault diagnosis method and system for a slitter-roller based on a large language model;

[0046] Figure 2 3. A schematic diagram of a model layer of a roll-slitting machine in an embodiment of a fault diagnosis method and system for a roll-slitting machine based on a large language model;

[0047] Figure 3This is a schematic diagram of the design and development process of a large language model for table data processing in an embodiment of a method and system for diagnosing a fault of a cutting and rolling machine based on a large language model;

[0048] Figure 4 This is a schematic diagram of a fault diagnosis reasoning process in an embodiment of a method and system for diagnosing a fault of a cutting and rolling machine based on a large language model;

[0049] Figure 5 Schematic diagram of a method for diagnosing a fault of a roll-cutting machine in an embodiment of a method and system for diagnosing a fault of a roll-cutting machine based on a large language model. DETAILED DESCRIPTION

[0050] The present invention can be explained in more detail by the following examples. The purpose of disclosing the present invention is to protect all changes and improvements within the scope of the present invention. The present invention is not limited to the following examples.

[0051] See Figures 1 to 3 The present invention provides a fault diagnosis method for a cutting and rolling machine based on a large language model, comprising the following steps:

[0052] S1. By collecting and integrating data related to the slitting and coiling machine, a fault case library is obtained, fault modes are defined, and a domain dictionary is constructed to initially form a data foundation for fault diagnosis. The details are as follows:

[0053] Data collection: Data on all aspects of the cutting and rolling machine are collected extensively. The data sources include (1) equipment manual: covering the main functions, relevant parameters and performance of the equipment and its submodules, main component models, common faults and treatment methods, equipment operating instructions and maintenance specifications; (2) operation data: a software system provided by the equipment manufacturer, whose interface includes functions such as operation fault alarm, working condition parameter setting, and alarm history record; (3) historical maintenance work order: recording the equipment repair process, including equipment information, fault phenomenon, fault cause, maintenance measures, maintenance time and maintenance personnel, etc.; (4) equipment fault maintenance analysis report: a detailed root cause analysis of high-frequency or high-hazard faults, including equipment information, maintenance time, fault phenomenon, fault cause, maintenance description, preventive measures, maintenance personnel and spare parts consumption, etc.

[0054] Data integration and preliminary preprocessing: Collected data is integrated into a unified table framework, including six basic elements: equipment information, fault symptoms, troubleshooting steps, fault causes, repair plans, and preventive measures. Standardized formats and units are used, and regular expressions are used to remove incorrect, missing, duplicate, and invalid table rows to obtain a database of slitter-roller fault cases. Invalid rows typically indicate short descriptions of the fault symptoms, or single sentences containing meaningless terms such as "not found," "unidentified," or "no abnormality" regarding the fault cause and repair plan.

[0055] Divide the equipment structure and define the failure mode: Abstract the system structure or functional modules of the cutting and rolling machine and divide it into three layers: modules, components, and parts. Failure mode F can be expressed as: Mapping method f: M→F, C→F, P→F. Module M represents an independent, indivisible system function within the device. Component C represents the structural unit of the module subclass. Part P represents the specific physical component or function of the component subclass. Modules include ten categories: positive and negative electrode feeding, positive and negative electrode unwinding, positive and negative electrode laser, positive electrode cutting and gluing, upper and lower separators, winding, gluing, unloading, blanking machine, and master control system. Components and parts vary according to the characteristics of each module.

[0056] Build a domain dictionary: This includes a dictionary of slitter components, an alarm dictionary, a stop word dictionary, and a dictionary of common words and their synonyms. The slitter component dictionary includes the device hierarchy and its mapping relationship to failure modes, while the alarm dictionary includes operating alarm descriptions and their mapping relationship to failure modes.

[0057] In one embodiment, a sensor network provides key data for detecting and diagnosing faults in a lithium battery production line. The fault text descriptions derived from the sensor data are used to understand the operational health of various industrial equipment. For example, fault downtime descriptions are filtered, and the device hierarchy structure is divided using the above method, and the fault mode is abstracted and classified. Figure 1 For the "AJGQAlm.W16.b01 Negative-pole laser cutting dot-shaped reinforcement cylinder, service life expired!" device hierarchy, the module is "negative-pole laser," the component is "cylinder," and the part is "dot-shaped reinforcement cylinder." For the "CJGQAlm.W10.b02 Positive-pole laser cutting strip-shaped reinforcement cylinder, failure or sensor failure," the device hierarchy is the module is "positive-pole laser," the component is "cylinder," and the part is "strip-shaped reinforcement cylinder." Their corresponding failure modes are both "positive-negative-pole laser-cylinder-rib-reinforcement cylinder." The device hierarchy, sensor text, and their corresponding failure modes are organized into a cutter-roller component dictionary and an alarm dictionary, respectively, and stored in table form, as shown in Tables 1 and 2.

[0058] Table 1 Alarm dictionary

[0059]

[0060] Table 2 Dictionary of components of slitting and rolling machine

[0061]

[0062] S2. Organize the failure case database of the cutting and rolling machine, including the failure phenomenon, failure cause, maintenance plan, etc. After data preprocessing, perform failure mode labeling and standardized description. Figure 3 ,This embodiment develops a large language model for tabular data processing, and designs ,special prompt word templates for the two sub-tasks of fault mode labeling and ,description standardization. Combined with rule constraints, the large language model ,is guided to complete the tasks, realizing the automated processing of tabular data, thereby ,

[0063] The prompt word template is designed with eight core elements to ensure that the LLM can accurately understand the task objectives and generate the required output:

[0064] Prompt={T, R, TS, I, TD, FA, Rea, IO};

[0065] Among them, time T records the current time; role R defines the LLM's role, capabilities, task background, code of conduct, and next instructions to help the LLM understand its own tasks and limitations; toolset TS describes the external tools that the LLM can use; I represents the received input; the final answer FA specifies the content and format of the output to accurately identify the user's intention; task decomposition TD prompts to summarize the user's task requirements and automatically decompose them; Rea is the reasoning strategy adopted by the LLM to complete the task; intermediate output IO is the intermediate result generated by the LLM during the iteration process, which is used by the LLM to learn from feedback.

[0066] For fault mode labeling, three strategy functions are used to implement fault mode labeling:

[0067] First, the entity recognition method based on the domain dictionary includes (1) word segmentation: combining the domain dictionary to segment the fault phenomenon and obtain the fault phrase sequence; (2) component matching: using the forward maximum matching algorithm to match the fault phrase with the cut-roll machine component dictionary; (3) mapping the fault mode: according to the mapping relationship between the equipment hierarchy and the fault mode, the corresponding fault mode is obtained; (4) error correction: establishing a correction rule library to correct common matching errors; (5) result storage: creating a new column in the table to store the annotation results. For example, extract "parts" and "part mode" from the cut-roll machine component dictionary, remove duplicates and store them in a txt file as a custom dictionary for Jieba word segmentation. Given the fault description "negative pole strip reinforcement rubber roller wear", use the forward maximum matching to obtain the word segmentation result "negative pole / strip reinforcement / rubber roller / wear". According to the cut-roll machine component dictionary, obtain "strip reinforcement" and its corresponding fault mode is "positive and negative pole laser-cylinder-reinforcement cylinder".

[0068] Secondly, a fault pattern recognition method based on text similarity includes: (1) extracting the feature vectors of the fault phenomenon and the operating fault alarm text using the TF-IDF algorithm; (2) similarity calculation: calculating the similarity between the fault phenomenon and the operating fault alarm text in the alarm dictionary of the winding machine by cosine similarity; (3) threshold judgment: if the similarity is greater than the preset threshold, then the corresponding fault mode is obtained according to the mapping relationship between the alarm description and the fault mode; (4) result storage: creating a new column in the table to store the annotation results. For example, given the fault description "normal winding report: positive pole four-level deviation correction motor exceeds the set deviation correction lower limit value", the TF-IDF vector and cosine value similarity between it and the "processed alarm description" in the alarm dictionary is calculated, and it is found that the description is similar to the "positive pole four-level deviation correction motor exceeds the set deviation correction upper limit value" in the alarm dictionary, and the corresponding fault mode "winding-motor-four-level deviation correction motor" is obtained, and the fault mode is annotated as "winding-motor-four-level deviation correction motor".

[0069] Third, a large language model-driven agent performs fault mode annotation. Users are required to provide files, annotation instructions, and rules. The large language model then uses a react strategy to generate code to operate the file for annotation. This method can handle commonly used colloquial expressions. Specifically, it includes: (1) Code generation and execution: Generate annotation code based on the react prompt word strategy, test and debug it through external tools (such as Python REPL Tool), create new columns in the table, and store the annotation results; (2) Continuous learning and optimization: Users review the results. If the review is unsatisfactory, feedback is provided to guide the agent to regenerate. If the review is satisfactory, the annotation rules and code are stored in the rule library to support subsequent reuse. For example, given the following annotation instructions and rules: "Apply the given rules to the [Fault phenomenon] column and perform corresponding annotation in the [Strategy three annotation result] column. The rules are independent of each other, and multiple annotations are allowed. Each value is separated by an English comma. It should be noted that: the [or] relationship indicates that it is triggered if any keyword is included; the [and] relationship indicates that the specified keywords must be included at the same time. The following are the annotation rules: If it contains ([positive pole] or [negative pole]) and [CCD], then label [positive / negative pole laser-CCD-laser cutting CCD]; if it contains [overhang], then label [winding-CCD-head and tail length]".

[0070] Based on the fault patterns annotated by the above strategy, the final fault pattern is determined by predefined rules and a new column is created for storage. The predefined rules include: (1) consistency principle: if the annotation results of multiple methods are consistent and unique, the result is directly adopted; (2) majority principle: for multiple results, weighted voting is used to determine the final fault pattern; (3) similarity inference: for unannotated fault phenomena, the semantic similarity between them and existing annotated samples is calculated and inferred annotation is performed.

[0071] For the description normalization subtask, an optimizer-evaluator based on a two-layer large language model is constructed. Its core task is that the user provides the file to be processed and specifies the target columns that need to be standardized. The optimizer generates the initial output; the evaluator provides feedback, realizes entity alignment and knowledge fusion through a bidirectional loop, and finally returns the file processing results and process explanation.

[0072] Among them, the optimizer defines the large language model as a "professional assistant for database standardization management". Its core tasks include: (1) Data extraction and serialization representation: Extract all row data from the target column and serialize the data using a preset prompt word template. Serialization methods include but are not limited to JSON, Markdown, CSV, DFLoader and other formats. (2) Semantic grouping and standardization: The large language model semantically groups the extracted text content based on context learning capabilities. Within each group, descriptions with similar semantics but different wording are further standardized and unified. (3) Optimization output and writing results: The optimizer has long and short-term memory and can store the original data and the reasoning steps, intermediate results and normalization results of each processing process. When the evaluator feeds back the evaluation results, the optimizer adjusts its generation strategy through the reflection mechanism, re-analyzes and optimizes. When all evaluation dimensions meet the standards, a new column will be created to write the optimized content corresponding to the original content. (4) Self-evolution: By integrating an iterative feedback mechanism, it can accumulate professional knowledge from historical processing and improve the processing capabilities in similar tasks. Memory optimization is performed based on the memory optimization mechanism of the Ebbinghaus forgetting curve to improve the processing ability of long-span information.

[0073] The evaluator defines the large language model as the "supervisor" and receives the input and output of the optimizer. Its task is to evaluate the output quality of the "professional assistant" through binary scoring combined with predefined evaluation dimensions in preset iterative rounds. If the score does not meet the standard, the "supervisor" will feedback the unqualified content to the "professional assistant" and make specific modification suggestions. The above process is repeated until all dimensions meet the standards or the cycle round is reached.

[0074] The evaluation dimensions include: (1) Completeness: All original data are correctly retained or classified, and no valid information or cases are omitted; (2) Semantic consistency: All identical or similar descriptions use unified terminology; (3) Conciseness: The description is concise, redundant information is removed, and no important content is lost; (4) Understandability: There are no ambiguous or obscure expressions; (5) Format standardization: Data is output according to the specified structure, with clear levels and complete information; (6) Hallucination detection: All information can be found in the original data, and no new information that cannot be derived from the original data is generated.

[0075] S3. Extract triples from the fault diagnosis knowledge base obtained in step S2 through the knowledge extraction method, design a top-down knowledge framework to construct a domain knowledge graph, store it in the Neo4j database, and connect it with the large language model.

[0076] The pattern layer designed in this embodiment consists of two interacting sublayers: a device-related pattern layer and a fault-related pattern layer. These interact through fault patterns, constructing a domain knowledge graph using a top-down approach. The device-related pattern layer describes the actual device structure and includes three entity categories: module, component, and part. The fault-related pattern layer consists of fault entities extracted from the knowledge base and includes six categories: fault mode, phenomenon, cause, troubleshooting steps, repair plan, and preventive measures. The attributes of each entity category are defined as the name of the corresponding instance. Since the fault mode occurs on the corresponding faulty component, the attributes also include the names of the module, component, and part. The relationships between the entity categories are defined as: "module-contains-component", "module-contains-part", "component-contains-part", "module-contains-failure mode", "component-contains-failure mode", "part-contains-failure mode", "failure mode-exists-failure phenomenon", "failure cause-leads to-failure phenomenon", "failure cause-leads to-failure mode", "failure phenomenon-exists-failure troubleshooting steps", "failure cause-suggested-repair plan", and "failure cause-suggested-preventive measures".

[0077] Under the guidance of the knowledge organization architecture of the pattern layer, an extraction function is constructed using Python to extract triples from the fault diagnosis knowledge base obtained in step S2, construct a domain knowledge graph, and store it in the Neo4j database. Then, the Neo4j graph database and the large language model are connected using LangChain's vectorstores to integrate them into a system. In one embodiment, updating the domain knowledge graph includes (1) for new table data, using the fault mode annotation method to obtain the fault mode corresponding to each record; (2) for each fault mode, extracting the same column content of the knowledge base and the new table, converting it into a vector form that can be calculated using vectorization technology, and calculating the correlation between the new table data and the fault diagnosis knowledge base content using cosine similarity to determine whether there is new content; (3) if there is updated content, integrating the new data with the knowledge base content, and updating the integrated new content to the existing fault diagnosis knowledge base, thereby achieving regular incremental updates of the knowledge graph.

[0078] S4, see Figure 4 and Figure 5, using a large language model as a recommender for fault diagnosis suggestions, receiving real-time fault alarm information from the coil-cutting machine, and supporting users to input fault symptoms in a multimodal form. By searching the domain knowledge graph and web queries for reasoning, the system provides diagnostic conclusions and solutions, as follows:

[0079] User interaction and intent understanding: When a slitter fails, the large language model can receive and generate an analysis report in real time. It also supports users in troubleshooting questions and answers using natural language text and voice descriptions, maintains a continuous dialogue with users, and records historical user interactions for accurate fault reasoning based on the context.

[0080] Knowledge graph query and reasoning: The large language model is defined as a "roller-cutting machine fault diagnosis expert." Given a given input, it first uses a self-questioning strategy combined with m3e vector embedding to understand the user's intent. It then automatically generates a structured query Cypher statement targeting the knowledge graph. The resulting triples are then further filtered and summarized to generate a comprehensive diagnostic conclusion. If no complete match is found in the knowledge graph, the system proactively retrieves supplementary information from external websites for any faulty components exhibiting anomalies in the input fault symptoms, recommending potential causes and solutions.

[0081] Diagnostic Result Visualization and Interpretation: Based on the query and reasoning results from the domain knowledge graph or external web pages, fault diagnosis conclusions are generated. This includes multimodal visualization and natural language interpretation. Multimodal visualization presents diagnostic results in the form of charts, flow charts, or tree diagrams, highlighting key fault nodes and impact relationships, and providing detailed information on key nodes. Natural language interpretation involves the system converting diagnostic results and reasoning processes into natural language descriptions for easier user understanding.

[0082] The present invention also provides a large language model-based fault diagnosis system for a roll-cutting machine, which is used to implement the above-mentioned large language model-based fault diagnosis method for a roll-cutting machine. The system includes a table data intelligent processing module, a domain knowledge graph construction module, a diagnostic reasoning module, and a user interaction module, as follows:

[0083] Intelligent tabular data processing module: This module uses the large language model as a pipeline supervisor for fault mode labeling, automatically labeling the fault modes of the user-provided case library of coil-cutting machine fault diagnosis. Furthermore, it constructs an optimizer-evaluator based on a two-layer large language model to process user-provided files, normalize the description of target columns, and construct a standardized fault diagnosis knowledge base.

[0084] Domain knowledge graph construction module: It consists of equipment-related and fault-related pattern layers. The two pattern layers interact through fault patterns and are used to integrate the standardized table database of the roll-cutting machine. The extraction function is constructed through Python to extract triples and store them in the Neo4j database. LangChain's vectorstores are then used to connect the Neo4j database with the large language model, and the domain knowledge graph is regularly updated incrementally.

[0085] Diagnostic reasoning module: This module uses a large language model as a recommender for fault diagnosis suggestions. When corresponding cases exist in the constructed domain knowledge graph, recommendations are directly generated. Otherwise, the module identifies the current device information related to the fault and infers the cause and solution of the fault through online search.

[0086] User interaction module: provides a multimodal user interaction interface and supports visual display of fault diagnosis.

[0087] Therefore, the present invention adopts the above-mentioned large language model-based slitter-roller fault diagnosis method and system, which can improve the intelligence level of fault diagnosis, reduce the cost of knowledge base construction and expansion, and enhance the usability and maintainability of the system.

[0088] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention rather than to limit the same. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that they can still modify or replace the technical solutions of the present invention with equivalents, and these modifications or equivalent replacements cannot cause the modified technical solutions to deviate from the spirit and scope of the technical solutions of the present invention.

Claims

1. A fault diagnosis method for a cutting and rolling machine based on a large language model, characterized in that: The following steps are involved: S1. Collect various data from the slitter and roll-to-roll machine, unify the format and units, and integrate them into a table framework. Obtain a fault case library for the slitter and roll-to-roll machine, divide the equipment structure, define the fault modes, and build a domain dictionary. S2. For the two subtasks of fault mode labeling and description standardization, we designed specialized prompt word templates. Combined with rule constraints, they guided the large language model to complete the tasks, enabling automated processing of tabular data and building a standardized fault diagnosis knowledge base. In the fault mode labeling subtask, different labeling strategies were designed, and corresponding fault modes were obtained based on predefined rules. In the description normalization subtask, a two-layer large language model optimizer-evaluator was constructed. The optimizer uses fault modes as analysis units, performing data extraction and serialization, semantic grouping and standardization, and optimizing output and writing results. The evaluator receives the optimizer's input and output, performs binary scoring based on predefined evaluation dimensions, and feeds the evaluation results back to the optimizer. S3. Extract triples from the fault diagnosis knowledge base obtained in step S2 through a knowledge extraction method, design a top-down knowledge framework to construct a domain knowledge graph, store it in a Neo4j database, and connect it to the large language model; S4. Use the language model as a recommender for fault diagnosis suggestions, receive real-time fault alarm information from the roll-cutting machine, and support users to input fault phenomena in a multimodal form. By searching the domain knowledge graph and external web page queries for reasoning, the system provides diagnostic conclusions and solutions.

2. The method for diagnosing a fault of a cutting and rolling machine based on a large language model according to claim 1, characterized in that: In step S1, the system structure or functional modules of the cutting and rolling machine are abstracted and the equipment structure is divided into three layers: modules, components, and parts. The failure mode F is expressed as: Mapping method f: M→F, C→F, P→F, where module M represents an independent and indivisible system function in the equipment, component C represents the structural unit of the module subclass, and part P represents the specific physical component or function of the component subclass.

3. The fault diagnosis method for a cutting and rolling machine based on a large language model according to claim 1, characterized in that: In step S1, the constructed domain dictionary includes a dictionary of roll-to-roll machine components, an alarm dictionary, a stop word dictionary, and a dictionary of common words and their synonyms; Among them, the component dictionary of the cutting and winding machine includes the equipment hierarchy structure and its mapping relationship with the fault mode, and the alarm dictionary includes the operation alarm description and its mapping relationship with the fault mode.

4. The method for fault diagnosis of a cutting and rolling machine based on a large language model according to claim 1, characterized in that: In step S2, the large language model acts as a pipeline supervisor for fault mode annotation, and performs fault mode annotation through three strategies: entity recognition based on domain dictionaries, fault mode recognition based on text similarity, and a proxy driven by the large language model. Among them, entity recognition based on domain dictionaries includes text filtering, disambiguation, and word segmentation based on pre-built domain dictionaries, obtaining fault phrase sequences, matching fault patterns using a forward maximum matching algorithm, and establishing a correction rule library to correct common matching errors; Fault pattern recognition based on text similarity involves using the TF-IDF algorithm to extract feature vectors of fault phenomena and operational fault alarm texts, calculating the similarity between the fault phenomena and the operational fault alarm texts in the cutter alarm dictionary using cosine similarity, setting a similarity threshold, and mapping the corresponding fault patterns based on the domain dictionary. The agent driven by a large language model includes fault mode labeling rules based on user input. The large language model generates labeling code based on the React prompt word strategy, and is tested and debugged through external tools. Data is screened, judged, and automatically labeled in the provided table. Users review the results and provide feedback to guide the agent's continuous learning and optimization. At the same time, the labeling rules and code are stored in a correction rule library to support subsequent reuse.

5. The method for fault diagnosis of a cutting and rolling machine based on a large language model according to claim 1, characterized in that: In step S2, for the description normalization subtask, an optimizer-evaluator based on a two-layer large language model is constructed, including: The optimizer uses the failure mode as the analysis unit, extracts all row data from the target column, divides it into several text blocks for batch processing, and serializes the data using a preset prompt word template. The large language model uses contextual learning capabilities to semantically group the extracted text content and normalize and unify descriptions with similar semantics but different wording within each group. The optimizer has long and short-term memory, which stores the original data, the reasoning steps, intermediate results, and normalized results during each processing. When receiving feedback from the evaluator, the optimizer adjusts its generation strategy through a reflection mechanism, reanalyzes, and optimizes. When all evaluation dimensions meet the standards, a new column is created to store the optimized content corresponding to the original content. The optimizer also accumulates expertise from historical processing by integrating an iterative feedback mechanism and performs memory optimization based on the memory optimization mechanism of the Ebbinghaus forgetting curve; The evaluator receives the input and output of the optimizer. In the preset iterative rounds, it evaluates the output quality of the optimizer through binary scoring based on predefined evaluation dimensions. If the score does not meet the standard, the unqualified content is fed back to the optimizer and specific modification suggestions are made. The above process is repeated until all dimensions meet the standard or the cycle round is reached.

6. The method for fault diagnosis of a cutting and rolling machine based on a large language model according to claim 5, characterized in that: Evaluation dimensions include completeness, semantic consistency, conciseness, comprehensibility, format standardization, and hallucination detection.

7. The method for fault diagnosis of a cutting and rolling machine based on a large language model according to claim 1, characterized in that: Step S3 includes regularly updating the domain knowledge graph. For each newly labeled fault mode, the corresponding data of the fault diagnosis knowledge base is extracted and converted into a vector form that can be calculated through vectorization technology. The cosine similarity is used to calculate the correlation between the newly labeled fault mode and the corresponding data of the fault diagnosis knowledge base to determine whether there is updated content. If there is new content, the updated content is integrated into the existing fault diagnosis knowledge base.

8. The method for fault diagnosis of a cutting and rolling machine based on a large language model according to claim 1, characterized in that: In step S4, for the fault phenomenon input by the user, candidate fault modes are identified based on entity recognition based on the domain dictionary, fault mode recognition based on text similarity, and offline rules accumulated by the proxy strategy driven by the large language model in step S1. The evaluator is used to retain relevant fault modes based on the correlation between the candidate fault modes and the user query description, and a filtered fault mode list is output. The corresponding fault causes and solutions are then generated through a domain knowledge graph search or an external web page query.

9. A large language model-based fault diagnosis system for a slitter and roll machine, used to implement the large language model-based fault diagnosis method for a slitter and roll machine according to any one of claims 1 to 8, characterized in that: It includes a table data intelligent processing module, a domain knowledge graph construction module, a diagnostic reasoning module, and a user interaction module: The table data intelligent processing module uses the large language model as a pipeline supervisor for fault mode annotation, automatically annotating the fault modes of the user-provided case library of integrated coil cutting machine fault diagnosis. Simultaneously, an optimizer-evaluator based on the two-layer large language model is constructed to process user-provided files, normalize the description of target columns, and construct a standardized fault diagnosis knowledge base. The domain knowledge graph construction module consists of equipment-related and fault-related pattern layers. The two pattern layers interact through fault patterns and are used to integrate the standardized table database of the slitting and coiling machine. A Python extraction function is constructed to extract triples and store them in a Neo4j database. LangChain's vectorstores are then used to connect the Neo4j database to the large language model. The domain knowledge graph is then incrementally updated regularly. The diagnostic reasoning module uses the large language model as a recommender for fault diagnosis suggestions. When the constructed domain knowledge graph contains corresponding cases, it directly generates recommendations. Otherwise, identify the equipment information currently related to the fault and infer the cause and solution of the fault through online search; The user interaction module is used to provide a multimodal user interaction interface and support visual presentation of fault diagnosis.

10. The large language model-based fault diagnosis system for a cutting and rolling machine according to claim 9, characterized in that: The built optimizer-estimator includes: The optimizer is used to generate initial output, and the evaluator provides feedback to the optimizer. Through a bidirectional loop, entity alignment and knowledge fusion are achieved, and the file processing results and process explanations are returned. The optimizer uses the large language model as a professional assistant for database standardization management, performing data extraction and serialization, semantic grouping and standardization, optimized output and writing results, and self-evolution tasks; The evaluator uses the large language model as the supervisor of database normalization management, receives the input and output of the optimizer, and in preset iteration rounds, evaluates the output quality of the professional assistant through binary scoring combined with predefined evaluation dimensions, and makes specific modification suggestions.

Images