Multi-level intelligent mind map generation device based on large model

Abstract

The invention discloses a multilevel intelligent mind map generation device based on a large model, and the device comprises a multi-modal data conversion module which processes audio and video data through a multi-modal large model, and converts the input text data and the audio and video processing data into a unified structured text format; the data preprocessing module is used for performing deep semantic analysis on the structured text, extracting key information elements, and performing document slicing and entity structure processing to obtain structured data; the graph fusion module is used for constructing a knowledge graph based on the structured data and ensuring the data quality through an entropy increase resistant mechanism; the graph generation module is used for extracting a community structure from the knowledge graph and generating hierarchical node data of the mind map; the mapping module is used for rendering the node data into a multi-level mind map; and the output module provides interactive display and file export functions of the mind map. According to the device, automatic and multi-level generation of the mind map is realized, and the generation efficiency and accuracy are remarkably improved.

Description

Technical Field

[0001] This invention relates to the field of application software technology, and more specifically to a multi-level intelligent mind map generation device based on a large model, which is particularly suitable for achieving automated, efficient and intelligent mind map generation by integrating large models, knowledge graphs and rule engines. Background Technology

[0002] Mind mapping, as an important knowledge visualization tool, can present complex knowledge systems in a hierarchical and structured form, improving the efficiency and comprehensibility of knowledge expression. However, traditional mind map generation methods mainly rely on manual intervention, requiring users to manually construct nodes and relationships, leading to inefficiency, especially when processing large-scale or multimodal data (such as documents, audio, and video), which can easily result in excessive nodes and structural chaos. Furthermore, traditional tools struggle to adapt to dynamically changing thought processes, failing to guarantee the accuracy and consistency of information processing.

[0003] Despite the powerful capabilities of large models in semantic understanding and text generation, the excellent performance of knowledge graphs in knowledge organization and reasoning, and the advantages of rule engines in logical reasoning, existing technologies have failed to organically combine these technologies to address the multi-layered and multi-dimensional challenges in the automatic generation of mind maps.

[0004] Therefore, there is an urgent need for an innovative device that can comprehensively utilize these technologies to achieve efficient and intelligent mind map generation. Summary of the Invention

[0005] In view of the above problems, the present invention is proposed to provide a multi-level intelligent mind map generation device based on a large model to overcome or at least partially solve the above problems, so as to achieve more efficient and intelligent multi-level mind map generation, thereby promoting the further development of knowledge management and information organization technology.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: This invention provides a multi-level intelligent mind map generation device based on a large model, comprising: The multimodal data conversion module is used to receive multimodal input data, process audio and video data using a multimodal large model, and convert the input text data and audio and video processed data into a unified structured text format. The data preprocessing module is used to perform deep semantic parsing on the structured text, extract key information elements, perform document slicing and entity structure processing, and obtain structured data. The knowledge graph fusion module is used to construct knowledge graphs based on preprocessed structured data and ensure data quality through an anti-entropy mechanism. The graph generation module is used to extract community structure from knowledge graphs and generate hierarchical node data for mind maps; The graphing module is used to render node data into multi-level mind maps and supports multiple output formats; The output module provides interactive display and file export functionality for mind maps.

[0007] Furthermore, the multimodal data conversion module includes: The file type determination unit is used to identify whether the input data is a document, audio, or video type. The text extraction unit is used to extract text content through parsing, OCR recognition, speech recognition, and video processing technologies. Text standardization units are used to clean, correct, and standardize the format of extracted text content.

[0008] Furthermore, the text extraction unit includes: The document type processing unit extracts text content through format parsing, OCR recognition, structure parsing, and syntax parsing when the document is recognized as a document. The audio type processing unit performs format conversion, mute processing, and noise reduction when the data is identified as audio data. Then, it uses a multimodal large model for speech recognition and emotion analysis, followed by modal fusion processing, and outputs the audio file as intermediate text with document structure. The video type processing unit performs format conversion and decoding, keyframe extraction, and subtitle extraction when the data is identified as video data. Then, it performs visual feature extraction and analysis, content understanding and summary generation, sentiment analysis and fusion through multimodal large model video, and finally performs modal fusion processing to output the video data as intermediate text with document structure.

[0009] Furthermore, the data preprocessing module includes: The document topology deconstruction unit is used to intelligently slice structured text formats using a set of semantic breakpoint rules, generate a dimensional slice coordinate set, and generate atomic relation triples based on the OpenIE5 semantic probe to construct a graph topology structure. The data structure storage unit is used to convert the extracted entities and relationships into key-value pair format and serialize them into JSON format for import into the graph database; The intelligent slicing is configured to perform slicing operations through a semantic breakpoint rule set, which integrates regular slicing rules, spaCy NER, and dependency forest parsing.

[0010] Furthermore, the map fusion module includes three core components to resist entropy increase: The vector anchoring layer is used to generate semantic vectors for new or changed nodes in the graph database, and to form anchor points for the semantic vectors to build a nearest neighbor index. The temporal conflict resolution matrix is ​​used to resolve data conflicts between the current batch of data and existing data based on a four-dimensional decision model, update the graph database, and generate audit logs. The semantic fingerprint aggregation algorithm is used to calculate and fuse the repetition rate after generating unique node identifiers based on the dynamic topological fingerprint algorithm.

[0011] Furthermore, the four-dimensional decision model includes a weighted calculation of timestamps, credibility weights, semantic density, and version topology, and executes retention, overwrite, or branching strategies based on score differences.

[0012] Furthermore, the graph generation module includes: The community detection unit is used to divide the knowledge graph into modules using the information flow community detection algorithm. The main screening unit adaptively selects either a concentration-first or coverage-first strategy based on the module dispersion. The tuple generation unit generates a mind map index tree and semantic tuples based on the selected backbone communities.

[0013] Furthermore, the community detection algorithm is based on the InfoMap method, which minimizes the Map equation to optimize the community structure.

[0014] Furthermore, the graphing module includes: Hierarchical building blocks are used to automatically trigger the TreeNode recursive mapping pipeline, extract standardized tree_ids from the Graph-Genesi backbone community module set, and dynamically construct multi-branch tree structures. The semantic processing and summarization unit is used to aggregate the semantic information of leaf nodes and realize intelligent summarization and semantic fusion of node content based on a large language model. Interaction enhancement unit, used to automatically generate semantic content that progresses step by step from details to abstraction through recursive mapping; The rendering output unit is used to invoke the formatted rendering pipeline to render a multi-level mind map and provides multiple rendering output formats, including any of the following: Markdown, JSON, PDF, and SVG.

[0015] Furthermore, the output module includes: Front-end interactive components are used to support dynamic interactive functions of mind maps, including dynamic node folding, keyword highlighting, and incremental rendering. The incremental update mechanism uses a differentiated algorithm to achieve incremental updates when the knowledge graph is updated.

[0016] As can be seen from the above technical solution, compared with the prior art, the present invention has the following technical advantages: This device achieves automated, multi-level generation of mind maps through the collaborative work of multimodal data parsing, large-scale model semantic understanding, knowledge graph construction, and rule engine reasoning, significantly improving generation efficiency and accuracy. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0018] Figure 1 This is a block diagram of a multi-level intelligent mind map generation device based on a large model provided in an embodiment of the present invention. Figure 2 This is a schematic diagram of the multi-level intelligent mind map generation device based on a large model provided in this embodiment of the invention. Figure 3 This is a flowchart illustrating the multimodal data conversion process provided in this embodiment of the invention. Detailed Implementation

[0019] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] This invention discloses a multi-level intelligent mind map generation device based on a large model, referring to... Figure 1 As shown, it includes: The multimodal data conversion module is used to receive multimodal input data, process audio and video data using a multimodal large model, and convert the input text data and audio and video processed data into a unified structured text format. The data preprocessing module is used to perform deep semantic parsing on the structured text, extract key information elements, perform document slicing and entity structure processing, and obtain structured data. The knowledge graph fusion module is used to construct knowledge graphs based on preprocessed structured data and ensure data quality through an anti-entropy mechanism. The graph generation module is used to extract community structure from knowledge graphs and generate hierarchical node data for mind maps; The graphing module is used to render node data into multi-level mind maps and supports multiple output formats; The output module provides interactive display and file export functionality for mind maps.

[0021] This invention overcomes the limitations of traditional mind mapping tools by integrating technologies such as rule engines, natural language processing, and knowledge graph construction systems to revolutionize mind map generation. The method first extracts the original text content, outline, and content summary from multimodal data such as documents, audio, and video through multimodal data parsing and transformation, thereby generating corresponding text based on the understanding of these data.

[0022] Then, based on the text parsing capabilities of the large language model, a deep semantic understanding of the input text is achieved, and key information elements are accurately extracted. Finally, knowledge graph construction technology is used to quickly generate mind maps in batches. Compared with traditional tools, this invention not only significantly improves the efficiency of mind map generation, but also greatly enhances the accuracy and reasonableness of the generated results in large datasets.

[0023] like Figure 2 As shown in the example, a user first uploads multimodal data. After uploading, the cross-modal data is uniformly text-encoded. After data encoding, the user selects the multimodal data for which a mind map needs to be generated and chooses the method for generating the mind map. The device supports the fusion generation of a large model and a knowledge graph. The input data is broken down according to a specified structure, extracting the original content of the leaf nodes. The outline and original text are input into the large model to summarize and generate leaf summary nodes, and a unified format of mind map node description data is generated. The device generates an XMind file based on the generated node data and the node structure. Then, it determines whether the user wants to generate a MindManager file. If so, it converts it to MindManager format using a converter; otherwise, it downloads the XMind format file.

[0024] The following is combined with Figure 1 , Figure 2 As shown, each of the above modules will be explained in detail: For example, after the user inputs data, a multimodal big data model is first used to process the data, converting audio or image data into text format to prepare for the next step. The entire "big data model + knowledge graph" mind map generation device, such as... Figure 2 As shown (the multimodal data conversion module is not illustrated), there are five main modules that operate linearly: Data preprocessing module, corresponding Figure 2 Central system data preprocessing system; The map fusion module, corresponding to Figure 2Nebula-Fusion Engine, a spectral fusion engine for China's geography. The graph module corresponds to Figure 2 Graph-Genesi (Chinese Library Classification) system; The graph module corresponds to Figure 2 MindMapRender (Map-Viz) is a Chinese mapping engine. Output module, corresponding Figure 2 Mind mapping output system.

[0025] The previously generated text data, after being input into the mind map generation system, first undergoes specific formatting and transformation to become a data source suitable for the graph fusion engine. After the graph fusion module runs, a very complete knowledge graph is generated. This knowledge graph is essentially a graph database containing all the details. This graph database serves as the cornerstone of mind map generation, ensuring that our mind maps are not contaminated or deviate from their intended purpose due to excessive data volume. In the graph generation and graph transformation systems, the structure and content of the mind map are generated based on the data within the entire knowledge graph, ensuring that the content is generated from complete user input. In the final mind map output system, we use multiple processing steps, including content proofreading, structure proofreading, and format proofreading, to improve accuracy through a complete mind map backtracking process. Then, the mind map, after its self-backtracking and correction, is rewritten into three common output formats: Markdown, JSON, and PDF, providing file downloads and vector image downloads.

[0026] 1. Multimodal data conversion module: like Figure 1 As shown, it includes: a file type determination unit, used to identify whether the input data is a document, audio, or video type; The text extraction unit is used to extract text content through parsing, OCR recognition, speech recognition, and video processing technologies. Text standardization units are used to clean, correct, and standardize the format of extracted text content.

[0027] Furthermore, the text extraction unit includes: The document type processing unit extracts text content through format parsing, OCR recognition, structure parsing, and syntax parsing when the document is recognized as a document. The audio type processing unit performs format conversion, mute processing, and noise reduction when the data is identified as audio data. Then, it uses a multimodal large model for speech recognition and emotion analysis, followed by modal fusion processing, and outputs the audio file as intermediate text with document structure. The video type processing unit performs format conversion and decoding, keyframe extraction, and subtitle extraction when the data is identified as video data. Then, it performs visual feature extraction and analysis, content understanding and summary generation, sentiment analysis and fusion through multimodal large model video, and finally performs modal fusion processing to output the video data as intermediate text with document structure.

[0028] In the multimodal data conversion module, data processing is performed on the multimodal data, referring to... Figure 3 The following is the specific process: First, determine the file type. If it is file data, then determine the specific file type: whether it is doc, pdf, scanned document, html, or markdown. If none of these are true, then check the text encoding. Then perform the appropriate processing, such as parsing the XML or binary structure of doc, analyzing the layout and performing OCR recognition of pdf, parsing the structure of html, and parsing the syntax of markdown. If it is audio data, the audio data is first preprocessed by format conversion, mute processing, noise reduction processing, etc. Then, the multimodal large model audio analysis capability is used to perform speech recognition, sentiment analysis, etc. on the audio. Then, modal fusion processing is performed to output the audio file as intermediate text with document structure. If the data is video, it undergoes video data processing through operations such as format conversion and decoding, keyframe extraction, and subtitle extraction. Then, through multimodal large model video analysis capabilities, it performs operations such as visual feature extraction and analysis, content understanding and summarization generation, sentiment analysis, and fusion. Finally, it performs modal fusion processing and outputs the video data as intermediate text with document structure.

[0029] After completing their respective processes, the Markdown format data undergoes unified text cleaning and standardization operations, including control character processing, special symbol processing, and duplicate paragraph detection. Subsequently, existing intelligent error correction tools are used to perform spelling correction, grammar detection, and semantic enhancement on the text to ensure that the text is spelled and formatted correctly. Finally, the text is packaged in a unified manner.

[0030] 2. Data Preprocessing Module: like Figure 1 As shown, the data preprocessing module includes: The document topology deconstruction unit is used to intelligently slice structured text formats through a semantic breakpoint rule set, generate a dimensional slice coordinate set, and generate atomic relation triples based on the OpenIE5 semantic probe to construct a graph topology structure. The intelligent slicing is configured to implement the slicing operation through the semantic breakpoint rule set, which integrates regular slicing rules, spaCy NER, and dependency forest parsing. The data structure storage unit is used to convert the extracted entities and relationships into key-value pair format and serialize them into JSON format for import into the graph database.

[0031] 2.1 Document Topology Deconstruction: To address the diversity of data in user-input documents, a new multi-level text decomposition pipeline has been created. Its main function is to automatically decompose complex text containing multiple data types.

[0032] During the initialization phase, a multi-level text deconstruction pipeline is automatically triggered. The original document is intelligently sliced ​​using a set of semantic breakpoint rules: regular slicing rules, spaCy NER, and dependency forest parsing are integrated to output a dimensional slice coordinate set slices=[(para_id, sent_id, text)], which represents the paragraph ID, sentence ID, and text content, respectively.

[0033] Based on the deconstruction product, atomic relation triples are generated using OpenIE5 semantic probes, and term entity attributes {"type":"term"} are automatically labeled to represent type and type items, respectively. A three-dimensional relation matrix (subject, predicate, object) is dynamically constructed to represent subject, predicate, and object, respectively. Discrete semantic units are reconstructed into graph topology structures through knowledge graph conversion protocols to realize the {"src":id(u),"dst":id(v),"type":p} topology conversion model.

[0034] 2.2 Structured Data Storage: The extracted entities and relationships are converted into key-value pairs for easy database writing; each node stores attributes such as text, type, and source_id (recording the original paragraph); finally, the data structure is serialized into JSON format for import into the database.

[0035] 3. Nebula-Fusion Engine Before generating the knowledge graph, the diversity of input data can lead to entropy increase issues caused by heterogeneous document injection (synonymous duplication / version conflicts / retrieval delays). The emergence of the knowledge graph fusion engine addresses this problem by deploying three core anti-entropy components: 3.1 Triple anti-entropy core components: The Triple Entropy Resistance Core Component is a complete graph data governance system specifically designed to address the "entropy increase" problem in large-scale knowledge graphs, including data quality degradation, semantic inconsistencies, and version conflicts. The system uses three collaborative technical components to perform multi-level processing on the input data, ultimately outputting purified graph data.

[0036] The entire component data flow is as follows: Data input: A batch of vertex and edge data, which may come from multiple sources and has a temporal order. Vector anchoring layer: Processes newly added or changed vertices, generates or updates their embedding vectors, and writes them back to the graph database. Temporal conflict resolution matrix: Checks for conflicts between this batch of data and existing data, including vertex attribute conflicts and edge conflicts; resolves conflicts according to a four-dimensional decision model, updates the graph database, and generates an audit log.

[0037] Semantic fingerprint aggregation algorithm: After data update, the similarity of some entities may exceed the threshold, thus triggering entity fusion, merging multiple vertices into one, reconnecting edges, etc.

[0038] Component content description ① Vector anchoring layer The vector anchoring layer is mainly used to generate semantic vectors for newly added or changed nodes in the graph database and write these vectors back to the database to form anchor points. Then, fast retrieval is performed through an updatable nearest neighbor index. The specific implementation includes the following steps: 1). Text encoding: Use a pre-trained text encoding model, such as BGE-base-zh, to encode the text information of the nodes into high-dimensional vectors. The text information is concatenated as follows: the node name (name) and the node text (text) are connected with a newline character, i.e., "name+\n+text". If the text length exceeds the model limit, it is truncated, for example, truncated to 1024 tokens. The encoding process can be expressed as: Let the text information of node v be T_v = name_v + "\n" + text_v; The encoder is f: T_v → R D , where D is the output dimension of the encoder, such as 768 dimensions.

[0039] 2). Dimensionality reduction: To improve the subsequent retrieval speed, the high-dimensional vectors are reduced to d dimensions through random projection, where d < D. The random projection matrix R ∈ R (D×d) is sampled from the normal distribution N(0, 1 / d) for each element. The reduced-dimensional vector is calculated as: u_v = v * R where v is the original high-dimensional vector and u_v is the reduced-dimensional vector.

[0040] Note: Random projection is used in the code, and the reduced dimension is 384 dimensions.

[0041] 3). Vector normalization: The dimensionality-reduced vectors are then L2 normalized to ensure all vectors lie on a unit hypersphere, facilitating retrieval using cosine similarity. The normalization formula is: w_v = u_v / ||u_v||2 Where ||u_v||2 is the L2 norm of the vector.

[0042] 4) Vector write-back: The normalized vector w_v is written back to the node attributes of the graph database, while updating the dirty flag and update timestamp of the nodes. The specific fields for data persistence are { "embedding": v.tolist(), # Vector data "dirty_flag": 0, # Dirty flag "updated_at": int(time.time()) # Update timestamp } 5) Nearest Neighbor Index Construction: A nearest neighbor index is constructed using all nodes with generated embedding vectors. The index uses cosine similarity as the distance metric, with parameters: spatial type cosine similarity, M=32, ef=128. A brute-force search is performed in memory, returning the node ID and similarity score by performing full computation and sorting in descending order to select the top k nodes.

[0043] 6) Incremental Update: When new node embedding vectors are generated, the index can be updated incrementally.

[0044] ② Temporal conflict resolution matrix: (1). Specific implementation of the four-dimensional decision-making model Explicit weighting: Timestamp (ts): 25%, Credibility weight (conf): 35% (highest weight), Semantic density (density): 25%, Version topology (ver_topo): 15%. Default value handling: Set reasonable default values ​​for each dimension. Linear weighted model: standard weighted summation, w[0]*ts + w[1]*conf + w[2]*dens + w[3]*topo (2). Specific decision-making logic of the three-dimensional treatment strategy: Three handling strategies: keep, overwrite, and branch. Decision threshold: eps=1e-6: Used to determine if fractions are equal; delta=0.05: A critical value used to judge the merits of the new and old versions; Decision-making logic: If the difference between the old and new scores is less than eps, then the scores are equal → branching strategy (keeping both versions); If the new score is more than delta higher than the old score, the new version is significantly better than the old version → Coverage strategy; If the old score is more than delta higher than the new score, the old version is significantly better than the new version → retention strategy; If the score difference is within the critical interval (between ± delta), the scores are close but not equal → branching strategy.

[0045] (3). Conflict detection mechanism: Vertex conflict: Checks whether the old and new values ​​are consistent for specified attribute keys; Edge conflict: Check the edge attributes, such as confidence and negation, to see if they are consistent; Metadata extraction: Extract the metadata required for the four-dimensional decision model from the attributes of vertices or edges, such as timestamps, credibility, semantic density, and version topology.

[0046] (4). Solution Application and Audit: Based on the decision, perform the following actions: cover, retain, or branch. Implementation of the branching strategy: Store conflict values ​​in the history. Audit log: Records the entire conflict resolution process, including time, object, action, reason, score, etc.

[0047] For data imported into the database in a unified batch, the status of each vertex is queried. If some vertices are missing, they are marked as newly added. If they exist, a weighted calculation is performed using a four-dimensional decision model to generate relevant scores. It determines whether attribute or edge conflicts have occurred and intelligently executes a "retain-overwrite-branch" three-dimensional handling strategy, retaining both the branches before and after overwrite, while using a parallel saving strategy to ensure timely data updates. A fix patch and its cause are returned, and conflict source logs and conflict resolution logs are generated simultaneously.

[0048] ③ Semantic fingerprint aggregation algorithm: Based on the dynamic topological fingerprint algorithm, a hybrid calculation of SimHash and cosine similarity is used to generate unique node identifiers before repeatability calculation and fusion. I. Dynamic Topology Fingerprint Algorithm Step 1: Normalize the text, including lowercase, removing special characters, and normalizing whitespace; Step 2: Convert the text and the list of neighbor VIDs into a sequence of token integers; Text token: Each word is hashed using MD5 and modulo the result to obtain an integer ranging from 0 to 10_000_018; Neighbor VID list: Each neighbor VID is treated as a string, and then MD5 hashed and moduloed to obtain an integer; Step 3: Merge the two integer sequences above, f"{e.name} {e.text}" + " ".join(e.neighbors), and then perform SimHash calculation (64-bit); For each integer, calculate its MD5 hash, and then for each bit, increment by 1 if the bit is 1, and decrement by 1 otherwise; Finally, based on the accumulated value of each bit, if it is greater than or equal to 0, it is set to 1; otherwise, it is set to 0, thus forming a 64-bit signature.

[0049] II. Calculation of Mixed Similarity: Step 1: Calculate the Hamming similarity of the dynamic topological fingerprints of the two entities, Hamming similarity = 1 - HammingDistance / 64; Step 2: Calculate the cosine similarity of the embedding vectors of the two entities and normalize it using the standard vector dot product; Step 3: Mixed similarity = α * Hamming similarity + (1-α) * Cosine similarity (α=0.7).

[0050] III. Merged Entities: Step 1: Prefetch views of all entities to be compared, including name, text, neighbors, and embedding vectors; Step 2: Compare the mixed similarity pairwise. If the similarity is greater than or equal to the threshold θ (0.82), then the second entity is used as an alias for the first entity. Note: Here, the order is listed, and the first one is the canonical entity. Step 3: For each alias entity, perform the following operations: Reconnect edges: Redirect edges that point to alias entities to canonical entities; Merge Attributes: Merge the attributes of the alias entity into the canonical entity; Record alias mappings; The entire process involves generating unique node identifiers based on a dynamic topological fingerprint algorithm, and using entity text tokens and neighbor VID_Hash to participate in SimHash voting to generate Hamming similarity. A weighted fusion of Hamming similarity and cosine similarity of semantic vectors is then performed to generate the final mixed similarity. Once the similarity reaches a threshold, a graph database rewrite is performed, reconnecting edges and merging attributes.

[0051] Overall engine system architecture: Nebula Graph is used as the graph storage backend, supporting high-concurrency read and write operations and attribute graph semantics. Entity nodes are classified by creating tags and deduplicated and synonymous entities are merged. Relationship edges are structurally bound by defining edge types.

[0052] The system utilizes a triple anti-entropy core component to deduplicate documents and generate conflict reports. It also constructs a full-text index, performs cross-document version conflict detection and repair, and conducts consistency checks.

[0053] To improve engine reusability: the interface module uses perm_nebula_conn.connect() to encapsulate nebula-driver connection, session reuse and load balancing strategies in one go, and the graph database interaction logic is uniformly encapsulated. It supports operations such as querying node attributes, edge relationships, and path exploration, and the output structure is standardized as JSON format for easy downstream processing.

[0054] 4. Image generation module: like Figure 1 As shown, it includes: a community detection unit, used to divide the knowledge graph into modules using an information flow community detection algorithm; The main screening unit adaptively selects either a concentration-first or coverage-first strategy based on the module dispersion. The tuple generation unit generates a mind map index tree and semantic tuples based on the selected backbone communities.

[0055] 4.1 System Initialization and Data Processing Phase The system automatically triggers the fusion community screening pipeline during the initialization phase, first calling the anchoring filtering algorithm to perform multi-dimensional community detection. The specific implementation steps are as follows: 4.1.1 Edge Data Extraction and Normalization The system receives the fused graph output by Nebula-Fusion Engine, calls the edge data extraction function to extract all edges within the knowledge graph space, and then uniformly converts them into the standard edge dictionary format {"src": u, "dst": v,"type": e}. To ensure data reliability, the system performs the following preprocessing algorithm: Validity check: Filter out null values, self-loops (src = dst), and duplicate relationships; Uniqueness verification: A hash table is built using the triple (src, dst, type) as the key, and duplicate edges are removed; Standardized output: Generates a structured collection that conforms to a specific format.

[0056] 4.1.2 Semantic Weighted Graph Construction: The GraphPainter module (a function used for structure transformation) then automatically converts the edge data into a networkx.Graph structure, forming a standardized graph structure. The system then constructs an undirected weighted graph G based on the aforementioned edge set. The weight It consists of two parts: Semantic similarity weight For nodes If both contain embedding vectors Calculate the cosine similarity:

[0057] Relationship type weight The system maintains a relation type weight table (e.g., IS_A = 1.5, USES = 1.2). If the type is not defined, the default weight of 1.0 is used.

[0058] The final formula for calculating the total weight of the edge is:

[0059] 4.2 Logical Processing and Community Detection Phase: 4.2.1 Information Flow Community Detection Algorithm: The system automatically invokes the InfoMap community detection pipeline, using InfoMapHelper.create_infomap_tree() to perform community detection and module hierarchy partitioning on the standard graph structure.

[0060] Input preparation: Renumber each node And based on edge weights Construct a weighted adjacency list; The algorithm configuration parameters are as follows: Number of trials: num_trials = 20; The probability of a random walk transition is teleportation_probability = 0.15; Maximum number of iterations max_iterations = 200; Seed = 42; Two-level partitioning model; The core computation is based on minimizing the "Map equation":

[0061] in: : Probability of jumping between modules; H(Q): Entropy of the module index; : Probability of staying within module i; Entropy of node access probability within module i; By minimizing L(M), the system obtains the optimal community partition M and calculates the encoding length of each module. The output structure is a community tree file in JSON format, with each node corresponding to a path and codelength, forming a collection of module records.

[0062] Indicates the module path; Type: List of integers, such as [1, 3, 2] Meaning: The hierarchical location path of this module in the community tree output by InfoMap. For example: [1] represents the first large community on the first floor; [1, 3] represents "the third sub-community under the first community"; [1, 3, 2] is the next level of sub-nodes, and so on.

[0063] When building the mind map tree later, use path i This is used to construct a multi-level directory structure, determining the level of each node in the mind map and under which parent node it resides.

[0064] Indicates the module code length; Type: Floating-point number, for example, 0.1234.

[0065] Meaning: In Map Equation / InfoMap, the information encoding length corresponding to this module is used to measure the "information content" or "importance" of the compressed information.

[0066] The longer the code length, the longer the random walk stays in that module / the greater the amount of information accessed → the more important this module is to the overall structure.

[0067] Its function is to calculate the total amount of information in all modules; It is used to calculate CV (coefficient of variation) and determine whether the module distribution is balanced. It is used to filter modules based on "≥5% information content" or "cumulative 80% information content" to determine which modules enter the main body of the mind map.

[0068] Represents the set of entity IDs within the module; Type: List of strings, such as ["paper_1:para_3", "paper_2:para_7", ...] Meaning: The IDs of all original graph nodes contained in this module, which are the unique identifiers of each node when falling back into the Nebula Graph / Knowledge Graph.

[0069] Typical form: VIDs of points in a graph database. Subsequently, in S4 / S5, this content is retrieved from the map or the original text and filled into the corresponding mind map node; It is used to calculate coverage (how many original nodes the trunk covers).

[0070] The M triple = "the position of this module in the tree + the amount of information + the specific nodes in it", is a descriptive unit at the community / module level.

[0071] 4.2.2 Module Discreteness Evaluation and Adaptive Threshold Selection: By calculating the code length of each module, a tree-like hierarchical mapping is established between modules. The module tree structure is further parsed to extract the module path and code length. The system uses the coefficient of variation calculation function (calculate_cv) to evaluate the dispersion of the module structure.

[0072] System set baseline threshold = 2, and adaptively adjusts according to graph size and density:

[0073] Where |V| is the total number of nodes, and d is the graph density.

[0074] 4.2.3 Adaptive backbone filtering strategy: When the coefficient of variation (CV) of the module structure dispersion exceeds the threshold of 2, the concentration threshold strategy is automatically triggered; if the CV does not reach the threshold, the cumulative information coverage strategy is adopted to realize the automatic stratification of "trunk-branch".

[0075] Strategy A (Concentration First): When CV > At that time, backbone communities with a coding length exceeding 5% of the total length will be selected and retained.

[0076] m i Let m represent the i-th module; Strategy B (Coverage Priority): When CV ≤ At that time, a cumulative information coverage strategy was adopted, retaining community modules with a cumulative information volume of 80% or higher.

[0077] The system outputs the main module set and its retention rate:

[0078] 4.3 Tuple generation and output stage: 4.3.1 Mind Map Index Tree Generation and Semantic Tuple Construction: The system automatically calls tuples to generate the pipeline. After the main module is determined, the system constructs a mind map tree structure T using the module path as the hierarchical index. Starting from the root node (ROOT), hierarchical nodes are generated sequentially according to the path; The entity set vids in the leaf layer node attachment module; Recursively generate a complete hierarchical tree structure T.

[0079] A unique identifier is dynamically generated for each selected community path. Combining the vertices on the path with the set of relation types, output a standardized set of tuples. Based on this, the system generates a set of triples for constructing the mind map:

[0080] 4.3.2 Dynamic Consistency Maintenance Mechanism: To ensure real-time consistency between the graph rendering and the knowledge graph, the system integrates an incremental monitoring mechanism: when a new or updated operation occurs in the graph, the recalculation program is triggered in real time to re-run the community screening pipeline and synchronize the latest status of the map and the knowledge graph.

[0081] 4.4 Quality Assessment and Technical Effectiveness: 4.4.1 Quality assessment indicators: The graph generation system generates a list of tuples (gen_tuples.json) and calculates the percentage of backbone information (maintain_rate), which is then used by the MindMapRender engine to build TreeNodes and perform semantic fill. The system comprehensively evaluates the quality of the mind map using the following metrics: Maintain Rate: The proportion of the main module to the total code length; Modularity: The ratio of improved internal connectivity to improved external connectivity within a module; Coverage (node ​​coverage rate): The proportion of nodes included in the main module out of all nodes; CV (Structural Dispersion): Reflects the stability and balance of module partitioning.

[0082] 4.4.2 Technical Effects and Advantages: Through the above mechanism, the graph generation system efficiently solves the problems caused by heterogeneous graph scale noise, real-time dynamic consistency maintenance, and weak semantic associations: Large-scale noise elimination: Effectively filters out interference from weakly correlated nodes through adaptive coefficient of variation threshold and dual-strategy screening; Dynamic consistency guarantee: The incremental monitoring mechanism ensures that the master map is synchronized in real time when the map is updated; Semantic association enhancement: Combining heterogeneous weighted graphs with semantic similarity and relation type weights to improve semantic accuracy; Computational efficiency optimization: Community partitioning based on minimizing information entropy maintains computational feasibility on graphs of millions of nodes; Compared to traditional graph structure extraction methods based on fixed thresholds or single clustering algorithms, this system significantly improves interpretability, scalability, and computational robustness, providing a stable and flexible infrastructure for ultra-large-scale knowledge graph rendering.

[0083] 5. Graph module: Reference Figure 1 As shown, the graphing module includes: Hierarchical building blocks are used to automatically trigger the TreeNode recursive mapping pipeline, extract standardized tree_ids from the Graph-Genesi backbone community module set, and dynamically construct multi-branch tree structures. The semantic processing and summarization unit is used to aggregate the semantic information of leaf nodes and realize intelligent summarization and semantic fusion of node content based on a large language model. Interaction enhancement unit, used to automatically generate semantic content that progresses step by step from details to abstraction through recursive mapping; The rendering output unit is used to invoke the formatted rendering pipeline to render a multi-level mind map and provides multiple rendering output formats, including any of the following: Markdown, JSON, PDF, and SVG.

[0084] To address issues such as hierarchical redundancy, information overload, and lack of content consistency in ultra-large-scale graph rendering, the MindMapRender engine has designed an efficient multi-level graph visualization pipeline that is tightly coupled with the Graph-Genesi system to achieve unlimited expansion of node structures, automated semantic generation, and multi-format rendering output.

[0085] During the hierarchical construction phase, the system automatically triggers the TreeNode recursive mapping pipeline, extracting standardized tree_ids from the Graph-Genesi backbone community module set to dynamically construct a multi-branch tree structure. By calling the _traverse_tree() function, the system traverses the community tree structure, batch-injecting the corresponding semantic information into the content field of the leaf nodes. Subsequently, the system performs dynamic node mounting, integrating the constructed child nodes into the children array of the parent node in real time, achieving fully automatic bottom-up mounting from the leaf node to the root node, generating a highly scalable and naturally mapped multi-dimensional mind graph hierarchy.

[0086] In the semantic processing and summarization stage, the system automatically calls the `create_content_with_llm()` pipeline (a function used to generate content using a Large Language Model (LLM)) to aggregate the semantic information of leaf nodes, achieving intelligent summarization and semantic fusion of node content based on the Large Language Model (qwen3). Through a recursive strategy using `get_conclusion_for_leaf_nodes()` (a function to extract conclusions from the leaf nodes of the decision tree) and `get_conclusion_for_mind_map()` (a function to extract conclusions from the mind map), the system automatically generates semantic content that progresses from details to abstraction, ensuring the semantic consistency and integrity of the mind map structure.

[0087] During the rendering output stage, the MindMapRender engine invokes the formatted rendering pipeline, providing rendering outputs for multiple formats such as Markdown, JSON, PDF, and SVG. Specifically: Markdown: Outputs structured headings and key points, supporting secondary editing and fast reading; JSON: A standardized interface protocol that facilitates rapid data integration by front-end components; PDF / SVG: Integrates WeasyPrint and Graphviz engines, providing vector graphics and printing formats to meet the needs of various application scenarios.

[0088] 6. Output module: like Figure 1 As shown, it includes: a front-end interactive component to support the dynamic interactive functions of mind maps, including dynamic node folding, keyword highlighting, and incremental rendering; The incremental update mechanism uses a differentiated algorithm to achieve incremental updates when the knowledge graph is updated.

[0089] This module is designed with a high-performance front-end interaction mechanism and an incremental content rendering pipeline to solve the problems of interaction latency, low content search efficiency, and high rendering cost during incremental updates when browsing large-scale mind maps.

[0090] In terms of interactive enhancement mechanisms, an efficient recursive component is implemented for dynamic node collapsing / expanding. Vue.js's v-if conditional rendering mechanism is used to precisely control the display hierarchy of nodes, achieving millisecond-level response times even with thousands of nodes. The keyword highlighting mechanism employs regular expression matching and a custom weighted sorting strategy, highlighting keywords in node text in real-time through front-end tags, significantly improving users' information retrieval efficiency.

[0091] Regarding incremental content updates, the system integrates the Graph-Genesi real-time incremental monitoring mechanism. When the graph is updated and recalculated, the graph engine (Map-Viz) uses a diff algorithm to re-render only the changed branch nodes, making the most of the existing DOM structure, greatly reducing rendering costs, and ensuring an efficient and real-time user experience.

[0092] This device achieves efficient, multi-layered intelligent mind map generation by integrating a large-scale model, knowledge graph, and rule engine. Specifically, the large-scale model can deeply understand complex input information and extract key content, while the knowledge graph provides structured and semantic knowledge support for mind map generation. This multi-technology integration not only improves generation efficiency but also significantly enhances the accuracy and intelligence of the generated results. It also demonstrates excellent self-generation accuracy even with large amounts of data and offers diverse output options to better meet different user needs.

[0093] The mind maps generated by this device have a multi-level structure, clearly demonstrating the hierarchical relationships and logical connections between information. Through the deep learning capabilities of large-scale models, the system can automatically identify and summarize key nodes and their relationships in complex information, and combined with the semantic understanding capabilities of knowledge graphs, ensure that the generated mind maps have both depth and breadth in content.

[0094] In summary, this invention achieves efficient, accurate, and intelligent multi-level mind map generation through the integration of multiple technologies. It not only significantly improves the efficiency of information processing and knowledge management, but also provides users with a flexible and customizable thinking tool, which has important practical application value.

[0095] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to the method section.

[0096] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A large model-based multi-level intelligent mind map generation device, characterized by, The method comprises the following steps: A multi-modal data conversion module is used to receive multi-modal input data, process audio and video data using a multi-modal large model, and convert input text data and audio and video processing data into a unified structured text format; A data preprocessing module is used to perform deep semantic analysis on the structured text, extract key information elements, perform document slicing and entity structure processing, and obtain structured data; A graph fusion module is used to construct a knowledge graph based on the structured data obtained after preprocessing, and ensure data quality through an anti-entropy increase mechanism; A graph generation module is used to extract community structure from the knowledge graph and generate hierarchical node data for a mind map; A graph rendering module is used to render node data into a multi-level mind map and support multiple output formats; An output module is used to provide interactive display and file export functions for the mind map.

2. The apparatus of claim 1, wherein, The multi-modal data conversion module comprises: A file type judgment unit is used to identify whether the input data is a document, audio or video type; A text extraction unit is used to extract text content through analysis, OCR recognition, speech recognition and video processing technology; A text standardization unit is used to clean, correct and format the extracted text content.

3. The apparatus of claim 2, wherein, The text extraction unit comprises: A document type processing unit is used to extract text content through analysis, OCR recognition, structure analysis and syntax analysis when the input data is identified as a document; An audio type processing unit is used to perform format conversion, silence processing and noise reduction processing on the audio data, and then use a multi-modal large model to perform speech recognition, sentiment analysis and modal fusion processing to output the audio file as intermediate text with a document structure; A video type processing unit is used to perform format conversion and decoding, key frame extraction and subtitle extraction on the video data, and then use a multi-modal large model to perform visual feature extraction and analysis, content understanding and summary generation, sentiment analysis and fusion, and then perform modal fusion processing to output the video data as intermediate text with a document structure.

4. The apparatus of claim 1, wherein, The data preprocessing module comprises: A document topology deconstruction unit is used to intelligently slice the structured text format through a semantic breakpoint rule set, generate a dimensional slicing coordinate set, and generate atomized relationship triples based on an OpenIE5 semantic probe to construct a graph topology structure; A data structured storage unit is used to convert the extracted entities and relationships into a key-value pair format and serialize them into a JSON format for import into a graph database; The intelligent slicing is configured to implement slicing operations through a semantic breakpoint rule set, and the semantic breakpoint rule set integrates regular slicing rules, spaCy NER and dependency forest analysis.

5. The apparatus of claim 1, wherein, The graph fusion module comprises a triple anti-entropy increase core component: A vector anchoring layer is used to generate semantic vectors for new or changed nodes in the graph database, and form anchors from the semantic vectors to construct a near neighbor index; A temporal conflict resolution matrix is used to solve data conflicts between the current batch data and the existing data based on a four-dimensional decision model, update the graph database and generate an audit log; The semantic fingerprint aggregation algorithm is used for repetition calculation and fusion after generating node uniqueness identification based on a dynamic topology fingerprint algorithm.

6. The apparatus of claim 5, wherein, The four-dimensional decision model includes weighted calculation of timestamp, credibility weight, semantic density and version topology, and performs reservation, coverage or branching strategy according to score difference.

7. The apparatus of claim 1, wherein, The graph generation module comprises: A community detection unit is configured to divide the knowledge graph into modules using an information flow community detection algorithm; A main trunk screening unit is configured to adaptively select a concentration priority or coverage priority strategy according to module dispersion; A tuple generation unit is configured to generate a guide index tree and semantic tuples based on the screened main trunk community.

8. The apparatus of claim 7, wherein, The community detection algorithm is based on the InfoMap method, which minimizes the Map equation to optimize the community structure.

9. The apparatus of claim 1, wherein, The graphing module comprises: A hierarchical construction unit is configured to automatically trigger a TreeNode recursive mapping pipeline, extract standardized tree_id from the main trunk community module set of Graph-Genesi, and dynamically construct a multi-way tree structure; A semantic processing and summarization unit is configured to aggregate semantic information of leaf nodes, and realize intelligent summarization and semantic fusion of node content based on a large language model; An interaction enhancement unit is configured to automatically generate semantic content from details to abstraction and progressive levels through recursive mapping; A rendering output unit is configured to call a formatting rendering pipeline, render a multi-level mind map, and provide a multi-format rendering output, including any one of the following: Markdown, JSON, PDF and SVG.

10. The apparatus of claim 1, wherein, The output module comprises: A front-end interaction component is configured to support dynamic interaction functions of the mind map, including node dynamic folding, keyword highlighting and incremental rendering; An incremental update mechanism is configured to realize incremental update through a differential algorithm when the knowledge graph is updated.

Images