Product innovation design scheme generation method based on large language model and knowledge graph
By constructing CKG and PKG combined with LLM for multi-round information retrieval and reasoning, the problems of high labor costs, long cycles and inaccurate design in the existing design framework are solved, and efficient and accurate product innovation design is achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- SUZHOU UNIV
- Filing Date
- 2026-03-23
- Publication Date
- 2026-06-19
AI Technical Summary
The existing product innovation design framework suffers from high labor costs, long design cycles, incomplete design solutions when user needs cross domains, and inaccurate designs due to superficial knowledge graph information retrieval.
Construct a user needs context knowledge graph (CKG) and a product design knowledge graph (PKG), combine them with a large language model (LLM) to perform multi-round information retrieval and reasoning, generate a list of user needs and product design schemes, and select the optimal scheme through preset evaluation criteria.
It reduces labor costs, improves the efficiency of user demand discovery and product design, enhances the depth and accuracy of knowledge and information retrieval, and ensures the comprehensiveness and effectiveness of design solutions.
Smart Images
Figure CN122240814A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of knowledge graph technology, specifically to a method for generating product innovation design schemes based on large language models and knowledge graphs. Background Technology
[0002] With the increasing market demand for personalized product innovation design, enterprises are placing higher demands on the ability to generate efficient and accurate innovative design solutions. Traditional, end-to-end manual investigation and research are no longer sufficient to meet current task requirements. To improve the intelligence level of the design process, the industry is committed to building a closed-loop design paradigm of "requirements mining—knowledge retrieval—solution generation," thereby enhancing the accuracy of output and promoting the automation of customized product design. However, existing product innovation design frameworks suffer from high labor costs and long design cycles.
[0003] However, existing design frameworks suffer from several drawbacks. First, the entire process from user needs to solution generation relies heavily on manual intervention, making it difficult to meet the growing demand for personalization. Second, user needs may involve knowledge from multiple domains; if designers are unfamiliar with a particular domain, the resulting design may fail to meet user requirements, potentially even halting the product design process. While some design frameworks now utilize knowledge graphs (KG) in product innovation design, current retrieval methods often have limited hop counts, leading to insufficient information and ultimately incomplete or functionally inadequate design solutions. Summary of the Invention
[0004] Purpose of the invention: The purpose of this invention is to provide a method for generating product innovation design schemes based on large language models and knowledge graphs, which solves problems such as cross-domain user needs, superficial knowledge graph information retrieval, and automated generation of product design schemes in existing product innovation design methods.
[0005] Technical Solution: The present invention provides a method for generating product innovation design schemes based on large language models and knowledge graphs, comprising the following steps:
[0006] S1. Construct knowledge graphs, including user requirement context knowledge graph CKG and product design knowledge graph PKG;
[0007] S2. Input the user's input requirements into the large language model for decomposition, extract topic entities, and combine the user requirement context knowledge graph CKG for multi-round information retrieval and reasoning to generate a list of user requirements.
[0008] S3. Input the user requirement list into the large language model, and combine it with the product design knowledge graph PKG to perform multiple rounds of information retrieval and reasoning to generate at least one product design solution.
[0009] S4. Input the product design scheme into the large language model, score and compare it according to the preset evaluation criteria, and select the optimal design scheme.
[0010] Furthermore, step S1 includes the following steps:
[0011] S11. Collect text data on user needs and product-related patent text data respectively;
[0012] S12. Use a text parser to parse the text data;
[0013] S13. Divide the parsed text data into text blocks;
[0014] S14. Define the ontology model of the knowledge graph, including entity types and relation types;
[0015] S15. Input the ontology model and text blocks into the large language model and extract knowledge triples;
[0016] S16. Write the knowledge triples into the graph database to construct a knowledge graph.
[0017] Furthermore, step S2 includes the following steps:
[0018] S21. Input the user's needs into the large language model for decomposition and extract the topic entities;
[0019] S22. Perform similarity retrieval in the user demand context knowledge graph CKG to obtain similar entities related to the topic entity;
[0020] S23. Starting with similar entities, retrieve the set of relationships connected to them;
[0021] S24. Input the current sub-problem, similar entities and their relationship set into the large language model, and filter out the relationship most relevant to the user's needs;
[0022] S25. Based on the filtered relationships, retrieve the set of entities corresponding to their ends;
[0023] S26. Input the current sub-problem, similar entities, filtering relations and corresponding entities into the large language model, and filter out the most relevant entities as the starting point for the next round of retrieval;
[0024] S27. Combine the selected entities and relations into knowledge triples;
[0025] S28. Input the current sub-problem and the retrieved information into the large language model, and infer to generate a list of user requirements;
[0026] S29. Determine whether the current information is sufficient to generate a complete list of requirements. If not, backtrack to the unselected entities for supplementary retrieval.
[0027] S210. Repeat steps S23 to S29 until the retrieval depth or information content meets the preset conditions, and output the final user demand list.
[0028] Furthermore, step S3 includes the following steps:
[0029] S31. Based on the user requirement list, perform a similarity search in the Product Design Knowledge Graph (PKG) to obtain relevant functional entities;
[0030] S32. Starting with a functional entity, retrieve the set of relationships connected to it;
[0031] S33. Input the user requirement list, functional entities and their relationship set into the large language model, and filter out the relationships most relevant to the design goals;
[0032] S34. Based on the filtered relationships, retrieve the set of entities corresponding to their ends;
[0033] S35. Input the user demand list, functional entities, filtering relationships and corresponding entities into the large language model, and filter out the most relevant entities as the starting point for the next round of retrieval.
[0034] S36. Combine functional entities with the selected relationships and entities into knowledge triples;
[0035] S37. Input the user requirement list and the current search information into the large language model, and infer to generate a preliminary design scheme;
[0036] S38. Determine whether the current information is sufficient to generate a complete design scheme. If not, backtrack to the unselected entities for supplementary retrieval.
[0037] S39. Repeat steps S32 to S38 until the retrieval depth or information content meets the preset conditions, and output at least one product design scheme.
[0038] Furthermore, step S4 includes the following steps:
[0039] S41. Input the generated multiple product design schemes and preset evaluation criteria into the large language model, and let the model score each scheme;
[0040] S42. Repeat the scoring process multiple times to calculate the average score for each solution;
[0041] S43. Select the scheme with the highest average score as the final product innovation design scheme.
[0042] The product innovation design scheme generation system based on large language models and knowledge graphs described in this invention includes:
[0043] Knowledge Graph Module: Used to build knowledge graphs, including the User Requirement Context Knowledge Graph (CKG) and the Product Design Knowledge Graph (PKG);
[0044] User Requirements Module: This module is used to input user-inputted requirements into a large language model for decomposition, extract topic entities, and combine the user requirement context knowledge graph (CKG) for multi-round information retrieval and reasoning to generate a list of user requirements.
[0045] Retrieval and Reasoning Module: This module is used to input the user requirement list into the large language model and combine it with the Product Design Knowledge Graph (PKG) to perform multiple rounds of information retrieval and reasoning to generate at least one product design solution.
[0046] Optimal Module: This module is used to input product design schemes into a large language model, score and compare them using preset evaluation criteria, and select the optimal design scheme.
[0047] An electronic device according to the present invention includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program, when loaded onto the processor, implements any of the methods described herein.
[0048] The present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements any of the methods described herein.
[0049] Beneficial Effects: Compared with existing technologies, this invention has the following significant advantages: User-friendly for designers: In this invention, designers do not need in-depth knowledge of the domain; they only need to collect relevant data, and the design framework handles the rest. Improved efficiency in user demand mining: After constructing a CKG (Customer Needs Group) based on user demand background information, potential product needs can be fully mined without questionnaires or face-to-face interviews. This also significantly reduces labor costs. Improved efficiency in product design: After constructing a PKG (Primary Needs Group) based on relevant product information, a user demand list is obtained from the user mining process. The product design process utilizes this demand list in conjunction with LLM (Local Management Model) + PKG to efficiently generate product design solutions. Enhanced depth of knowledge information retrieval: This invention incorporates LLM reasoning into the knowledge graph retrieval process for information filtering, which improves information accuracy and ensures the global relevance of retrieved knowledge as the retrieval depth increases. Attached Figure Description
[0050] Figure 1 This is a flowchart of the present invention. Detailed Implementation
[0051] The technical solution of the present invention will be further described below with reference to the accompanying drawings.
[0052] like Figure 1 As shown, this embodiment of the invention provides a method for generating product innovation design schemes based on large language models and knowledge graphs, including the following steps:
[0053] S1. It is necessary to collect text data related to user needs scenarios to construct a CKG knowledge graph, which will be used in conjunction with LLM for user needs mining; and collect text data related to product patents to construct a PKG knowledge graph, which will be used in conjunction with LLM for product design scheme generation. The specific process is as follows:
[0054] S11. Taking a wheelchair as an example, in constructing the CKG knowledge graph, since users of this product may have certain physical illnesses leading to personalized needs for the wheelchair, we collect textual data related to these illnesses as source data to construct the CKG; simultaneously, we collect patent data related to wheelchair products as primary source data to construct the PKG. The data collected in this step is mainly text data in PDF file format.
[0055] S12. Initialize a large language model object ex_llm = OpenAILLM(
[0056] model_name="deepseek-chat",
[0057] api_key=DEEPSEEK_API_KEY,
[0058] base_url="https: / / api.deepseek.com",
[0059] model_params={
[0060] "response_format": {"type": "json_object"},
[0061] "temperature": 0,
[0062] In this example, LLM inference is performed by calling the DeepSeek API.
[0063] S13. Initialize the knowledge graph object
[0064] neo4j_driver = neo4j.GraphDatabase.driver(NEO4J_URI,
[0065] auth=(NEO4J_USERNAME, NEO4J_PASSWORD)),
[0066] This example uses the Neo4j database to store the knowledge graph;
[0067] S14. Define the ontology modeling of the knowledge graph. In this example, the entity types and relation types of the knowledge graph are defined in advance. Taking the construction of CKG as an example, the following is the defined ontology modeling:
[0068] node_labels = ['Disease', 'Symptom', 'UserNeed', 'Environment', 'AssistiveDevice', 'PsychologicalFactor']
[0069] rel_types = ['has_symptom', 'triggers', 'aggravated_by', 'alleviated_by', 'requires_feature']
[0070] S15. Import the Python packages for processing text data and constructing knowledge graphs: FixedSizeSplitter and SimpleKGPipeline; use the objects initialized above as parameters of SimpleKGPipeline() to construct an automated knowledge graph builder to batch process PDF text data and construct knowledge graphs.
[0071] kg_builder_pdf = SimpleKGPipeline(
[0072] llm=ex_llm,
[0073] driver=neo4j_driver,
[0074] text_splitter=FixedSizeSplitter(chunk_size=1000, chunk_overlap=100),
[0075] embedder=embedder,
[0076] entities=node_labels,
[0077] relations=rel_types,
[0078] prompt_template=prompt_template,
[0079] from_pdf=True)
[0080] S16. Put the PDF file addresses collected in step S11 into an address list path_list so that the raw data can be processed in batches to construct a knowledge graph;
[0081] S17. Call the kg_builder_pdf object to process text data and construct a knowledge graph: kg_builder_pdf.run_async(file_path=path).
[0082] S2, such as Figure 1 As shown, the user demand mining process utilizes user demand scenario data stored in CKG combined with the inference capabilities of LLM. The specific implementation process is as follows:
[0083] S21. User Input Requirement Problem: Design an outdoor wheelchair for Parkinson's patients.
[0084] Call LLM to extract possible subject entities from the problem: ["Parkinson's disease", 'Outdoor'].
[0085] S22. Based on the extracted topic entities, perform fuzzy-wuzzy matching in CKG to retrieve relevant entities from CKG as the starting entities for information retrieval, and then perform a deeper search layer by layer. The retrieved similar entities are as follows:
[0086] sim_eneity=["rheumatologist's interpretation", "customizable toindividual user's preferences", "disease self-management education for people with Parkinson's and their care partners", 'outdoor mobility', 'betteroutdoor propulsion']
[0087] S23. Iterate through each entity in sim_entity, retrieve all the relationships corresponding to each entity, and then, based on the relevant hints, pass the entity and the retrieved relationships to the LLM to filter the retrieved relationships, leaving only the relevant ones. Taking 'better outdoor propulsion' as an example, the filtered relationships are as follows: [{"entity": 'betteroutdoor propulsion', "relation": 'supportsFunction', "head": True}, ] Only one relevant relationship 'supportsFunction' is filtered out;
[0088] S24. Based on the relationships filtered in step S23, perform entity retrieval on the other end of the relationship. In the example above...
[0089] The entity retrieved corresponding to {"entity": 'better outdoor propulsion', "relation": 'supportsFunction', "head": True} is as follows: {'better outdoor propulsion': {'tail': {'supportsFunction': ['storage module']}},……}; The current information is given to the LLM to infer and filter relevant entities, and the result is as follows: the total entity relation triples after entity pruning.
[0090] {'better outdoor propulsion': {'tail': {'supportsFunction': ['storagemodule']}},…}
[0091] S25. After filtering by relationships and entities, we now have the first layer of information about sim_entity. We hand this information over to the LLM to try to reason and obtain the requirement list. If the LLM determines that the current information is insufficient to reason and the previously filtered entities need to be backtracked, it will hand over the current information and the filtered entities to the LLM, allowing the LLM to reselect some relevant entities from the filtered entities to supplement the current information.
[0092] S26. After backtracking, the entities obtained from steps S24 and S25 are used as sim_entity in the next round of step S23 to start the information retrieval of the next layer of the knowledge graph.
[0093] S27. After multiple rounds of information retrieval from steps S23-S25, sufficient information has been retrieved, or the LLM has inferred sufficient information to derive a list of user requirements during these rounds of retrieval. Since the required list is an open-ended result, we simply continue with the multiple rounds of information retrieval without ignoring the LLM's judgment that sufficient information is needed for inference. We only need to pass the currently retrieved information to the LLM for further inference after each round of retrieval to obtain the final list of user requirements. In this example, the required list is as follows: ["stability", "convenience", "portability",……];
[0094] S3, such as Figure 1 As shown, after the user requirement mining process in step S2, a user requirement list is obtained. This user requirement list is then passed to the next step, product design scheme generation. This process utilizes product patent and other knowledge data stored in the PKG (Primary Module Tree) combined with the reasoning capabilities of the LLM (Limited Learning Model). The specific implementation process is as follows:
[0095] S31. Based on the input requirement list requirement_list = ["stability", "convenience", "portability", ...], using fuzzywuzzy matching, relevant entities in the PKG are retrieved as the starting entities for information retrieval, and a deeper search is performed layer by layer. The retrieved similar entities are as follows:
[0096] topic_eneity=['incorporation of adjustability', 'standing stability','improved stability', 'portability', 'higher seating interface pressures', 'safety', 'user needs',……]
[0097] S32. Iterate through each entity in topic_entity, retrieve all relationships corresponding to each entity, and then, based on relevant hints, pass the entity and retrieved relationships to the LLM (Local Management System) for filtering, retaining only relevant relationships. For example, the filtered relationships for 'user needs' are as follows:
[0098] [{"entity": 'user needs', "relation": hasRequirementsFrom, "head":True}, {"entity": 'user needs', "relation": subjectToConstraints, "head":True}, {"entity": 'user needs', "relation": supportsFunction, "head": False}] Filter out 3 related relationships 'hasRequirementsFrom', 'subjectToConstraints', 'supportsFunction';
[0099] S33. Based on the relationships filtered in step S23, perform entity retrieval on the other end of the relationship. In the example above...
[0100] [{"entity": 'user needs', "relation": hasRequirementsFrom, "head":True}, {"entity": 'user needs', "relation": subjectToConstraints, "head":True}, {"entity": 'user needs', "relation": supportsFunction, "head": False}] The corresponding retrieved entities are as follows: 'user needs': {'head': {'hasRequirementsFrom': ['rehabilitation industry',
[0101] 'user needs',
[0102] 'social service workers'
[0103] 'storage module'],
[0104] 'subjectToConstraints': ['user needs']},
[0105] 'tail': {'supportsFunction': ['standing stability']}}}; The current information is given to the LLM to infer and filter relevant entities. The result is as follows: the total entity relation triples after entity pruning.
[0106] 'user needs': {'head': {'hasRequirementsFrom': ['storage module'],
[0107] 'subjectToConstraints': ['user needs']},
[0108] 'tail': {'supportsFunction': ['standingstability']}}}
[0109] S34. After filtering by relationships and entities, we now have the first layer of information about topic_entity. We hand this information over to the LLM to try to reason and obtain the list of requirements. If the LLM determines that the current information is insufficient to reason and the previously filtered entities need to be backtracked, it will hand over the current information and the filtered entities to the LLM, allowing the LLM to reselect some relevant entities from the filtered entities to supplement the current information.
[0110] S35. After backtracking, the entities obtained from steps S34 and S35 are used as the topic_entity in the next step S32 to start the information retrieval of the next layer of the knowledge graph.
[0111] S36. After multiple rounds of information retrieval from steps S32 to S35, sufficient information has been retrieved, or the LLM has determined through reasoning that sufficient information has been retrieved to deduce the product design solution during these multiple rounds of retrieval. Since the design solution obtained in this example is an open-ended result, this framework directly performs multiple rounds of information retrieval and ignores the result obtained by the LLM in determining that the information is sufficient during this process. This framework only needs to hand over the currently retrieved information to the LLM for another round of reasoning after multiple rounds of retrieval to obtain the final product design solution.
[0112] S4. Evaluate the multiple product design schemes obtained in step S3 and select the design scheme with the highest evaluation result.
[0113] S41. By reading relevant design scheme evaluation articles, the design scheme evaluation criteria are divided into two parts: product standards and user standards. The relevant standards for these two aspects are defined as follows: Product standards: safety, stability, reliability, maintainability, manufacturing technology, and price. User standards: 1. Does it conform to and meet the user's physical structure and functions? 2. Are users restricted when performing related activities, such as going out or personal care? 3. Are users restricted in their daily lives, such as going on vacation or engaging in rehabilitation exercises?
[0114] S42. Based on step S3, this example generates three candidate design schemes. These three candidate design schemes and the evaluation criteria in step S41 are given to LLM to score the candidate schemes.
[0115] S43. Repeat step S42 three times to obtain three scores for the candidate solutions: Solution 1: 9, 9.1, 8.8 (26.9) Solution 2: 8, 9.3, 8.5 (25.8) Solution 3: 7, 8.5, 9.3 (24.8).
[0116] S44. As learned from step S43, Scheme 1 has the highest score, so Scheme 1 is selected as the best product design scheme.
[0117] Through the above implementation methods, the product innovation design method based on LLM+KG proposed in this invention effectively solves the problems of high degree of human involvement, long design cycle, and lack of designer friendliness in the current process of user needs mining and product design. By combining LLM with knowledge graph, the density of knowledge graph information retrieval is greatly improved, ensuring the effectiveness of the design solution.
Claims
1. A method for generating product innovation design schemes based on large language models and knowledge graphs, characterized in that, Includes the following steps: S1. Construct knowledge graphs, including user requirement context knowledge graph CKG and product design knowledge graph PKG; S2. Input the user's input requirements into the large language model for decomposition, extract topic entities, and combine the user requirement context knowledge graph CKG for multi-round information retrieval and reasoning to generate a list of user requirements. S3. Input the user requirement list into the large language model, and combine it with the product design knowledge graph PKG to perform multiple rounds of information retrieval and reasoning to generate at least one product design solution. S4. Input the product design scheme into the large language model, score and compare it according to the preset evaluation criteria, and select the optimal design scheme.
2. The product innovation design scheme generation method based on large language model and knowledge graph according to claim 1, characterized in that, Step S1 includes the following steps: S11. Collect text data on user needs and product-related patent text data respectively; S12. Use a text parser to parse the text data; S13. Divide the parsed text data into text blocks; S14. Define the ontology model of the knowledge graph, including entity types and relation types; S15. Input the ontology model and text blocks into the large language model and extract knowledge triples; S16. Write the knowledge triples into the graph database to construct a knowledge graph.
3. The product innovation design scheme generation method based on large language model and knowledge graph according to claim 1, characterized in that, Step S2 includes the following steps: S21. Input the user's needs into the large language model for decomposition and extract the topic entities; S22. Perform similarity retrieval in the user demand context knowledge graph CKG to obtain similar entities related to the topic entity; S23. Starting with similar entities, retrieve the set of relationships connected to them; S24. Input the current sub-problem, similar entities and their relationship set into the large language model, and filter out the relationship most relevant to the user's needs; S25. Based on the filtered relationships, retrieve the set of entities corresponding to their ends; S26. Input the current sub-problem, similar entities, filtering relations and corresponding entities into the large language model, and filter out the most relevant entities as the starting point for the next round of retrieval; S27. Combine the selected entities and relations into knowledge triples; S28. Input the current sub-problem and the retrieved information into the large language model, and infer to generate a list of user requirements; S29. Determine whether the current information is sufficient to generate a complete list of requirements. If not, backtrack to the unselected entities for supplementary retrieval. S210. Repeat steps S23 to S29 until the retrieval depth or information content meets the preset conditions, and output the final user demand list.
4. The product innovation design scheme generation method based on large language model and knowledge graph according to claim 1, characterized in that, Step S3 includes the following steps: S31. Based on the user requirement list, perform a similarity search in the Product Design Knowledge Graph (PKG) to obtain relevant functional entities; S32. Starting with a functional entity, retrieve the set of relationships connected to it; S33. Input the user requirement list, functional entities and their relationship set into the large language model, and filter out the relationships most relevant to the design goals; S34. Based on the filtered relationships, retrieve the set of entities corresponding to their ends; S35. Input the user demand list, functional entities, filtering relationships and corresponding entities into the large language model, and filter out the most relevant entities as the starting point for the next round of retrieval. S36. Combine functional entities with the selected relationships and entities into knowledge triples; S37. Input the user requirement list and the current search information into the large language model, and infer to generate a preliminary design scheme; S38. Determine whether the current information is sufficient to generate a complete design scheme. If not, backtrack to the unselected entities for supplementary retrieval. S39. Repeat steps S32 to S38 until the retrieval depth or information content meets the preset conditions, and output at least one product design scheme.
5. The product innovation design scheme generation method based on large language model and knowledge graph according to claim 1, characterized in that, Step S4 includes the following steps: S41. Input the generated multiple product design schemes and preset evaluation criteria into the large language model, and let the model score each scheme; S42. Repeat the scoring process multiple times to calculate the average score for each solution; S43. Select the scheme with the highest average score as the final product innovation design scheme.
6. A product innovation design scheme generation system based on large language models and knowledge graphs, characterized in that, include: Knowledge Graph Module: Used to build knowledge graphs, including the User Requirement Context Knowledge Graph (CKG) and the Product Design Knowledge Graph (PKG); User Requirements Module: This module is used to input user-inputted requirements into a large language model for decomposition, extract topic entities, and combine the user requirement context knowledge graph (CKG) for multi-round information retrieval and reasoning to generate a list of user requirements. Retrieval and Reasoning Module: This module is used to input the user requirement list into the large language model and combine it with the Product Design Knowledge Graph (PKG) to perform multiple rounds of information retrieval and reasoning to generate at least one product design solution. Optimal Module: This module is used to input product design schemes into a large language model, score and compare them using preset evaluation criteria, and select the optimal design scheme.
7. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the computer program is loaded into the processor, it implements the method described in any one of claims 1-5.
8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method described in any one of claims 1-5.