A personalized learning path recommendation method based on fractal recursive structure

Abstract

The embodiment of the present disclosure provides a personalized learning path recommendation method based on a fractal recursive structure, comprising: acquiring learning behavior data of a user and constructing a multi-level knowledge network graph; using a fractal recursive algorithm to assign weights to the knowledge network graph and expand the structure; generating an initial learning sequence according to the weight difference of the nesting relationship between knowledge nodes; and optimizing and adjusting the arrangement order of the knowledge points in the learning sequence based on a dynamic regulation strategy. Through the scheme of the embodiment of the present disclosure, the problem of how to regulate the learning sequence of the recommended path according to the weight difference of the multi-level nesting relationship between knowledge points to solve the problem of low knowledge transfer efficiency can be solved.

Description

Technical Field

[0001] This application relates to the field of educational informatization technology, specifically to a personalized learning path recommendation method based on fractal recursive structure. Background Technology

[0002] In the field of personalized learning path recommendation, existing technologies mostly rely on static recommendation based on knowledge graphs or similarity calculation based on collaborative filtering. Although these methods can construct knowledge point associations, they generally treat knowledge nodes as planar or simple hierarchical structures, failing to deeply quantify and utilize the multi-level nested dependencies with self-similar characteristics between knowledge points. Furthermore, they lack dynamic adjustment mechanisms for path sequences, resulting in often fixed and singular recommended paths that cannot adaptively adjust based on the deep weight differences of the knowledge structure and the user's real-time learning status. This leads to low path efficiency when learners transfer knowledge in complex knowledge systems. To address this, this invention proposes a personalized learning path recommendation method based on fractal recursive structure. By introducing a fractal recursive algorithm to assign weights and expand the structure of a multi-level knowledge network, and generating and dynamically optimizing learning sequences based on the weight differences of nested relationships between nodes, this invention aims to solve the technical problem of low knowledge transfer efficiency caused by rigid paths. Summary of the Invention

[0003] In view of this, the present disclosure provides a personalized learning path recommendation method based on fractal recursive structure, which at least partially solves the problems existing in the prior art.

[0004] A personalized learning path recommendation method based on fractal recursive structure includes: Acquire user learning behavior data and construct a multi-level knowledge network graph; A fractal recursive algorithm is used to assign weights and expand the structure of a knowledge network graph. An initial learning sequence is generated based on the weight differences in the nesting relationships between knowledge nodes; The order of knowledge points in the learning sequence is optimized and adjusted based on a dynamic control strategy.

[0005] In one specific implementation, acquiring user learning behavior data and constructing a multi-level knowledge network graph includes: Collect user interaction records, test scores, browsing time, and course completion status; For each knowledge point, a weight index is established as w_i = α·T_i + β·S_i, where T_i is the browsing time of knowledge node i, S_i is the completion rate of knowledge node i, and α and β are weighting coefficients; Generate an adjacency matrix M of the graph based on the user's historical behavior; The K-means clustering method is used to hierarchically divide knowledge nodes, forming a multi-level structure.

[0006] In one specific implementation, the step of using a fractal recursive algorithm to assign weights and expand the structure of the knowledge network graph includes: Define the recursion depth d, and set the initial depth to 0; For each knowledge node i, calculate the recursive weight W_i(d) = W_i(d1) × (1 δ)^{d}, where δ is the recursive decay factor; By recursively traversing all nodes and accumulating and propagating weights, a hierarchical weight distribution is formed. The network structure is dynamically adjusted based on the current recursion depth, adding or reducing redundant links.

[0007] In one specific implementation, generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Extract the nested weights between any two adjacent knowledge points u and v: W_uv = min(W_u, W_v) / max(W_u, W_v); Set thresholds θ_1 and θ_2. If W_uv > θ_1, it indicates a strong correlation. The initial order relationship is generated based on the W_uv value: if W_uv>θ_1, then the order is u → v, otherwise it is considered an independent node; A preliminary sequence S = [n_1, n_2, ..., n_k] is generated by sorting nodes according to their importance.

[0008] In one specific implementation, the optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: Calculate the association weight D_{ij} = 1 / |W_i-W_j| between any two nodes n_i and n_j in the current sequence, where W_i and W_j are the corresponding knowledge point weights; Define the priority factor P_i = ∑_{j≠i} D_{ij} × R_{ij}, where R_{ij} is the user's feedback rating; Reorder S_new based on priority factor: S_new = sorted(S, key=lambda x: P_x); A greedy algorithm is used to successively swap positions, so that the one with larger D_{ij} is placed in front.

[0009] In one specific implementation, generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Define the recursive dependency index η_i = ∑_{j∈child(i)} w_j × k_j, where w_j is the weight of child node j and k_j is the number of dependencies; All nodes are sorted using a linear weighted model: Score_i = η_i × log(1 + a_i), where a_i is the complexity coefficient of the knowledge point; Based on Score_i, the knowledge points are sorted in descending order to generate a temporary learning sequence L_temp; A time window mechanism is introduced, taking only the first N knowledge points as the initial sequence S.

[0010] In one specific implementation, the optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: In each step of the operation, the learning cost is evaluated as C_i = t_i × s_i, where t_i is the estimated time consumption of knowledge node i and s_i is the difficulty coefficient of the knowledge point. Construct the objective function F(S) = ∑ C_i * E_i, where E_i is the user's acceptance rating of the knowledge point; The simulated annealing algorithm is used to find the minimized F(S) state; Output the final learned sequence S_opt to improve overall efficiency.

[0011] In one specific implementation, acquiring user learning behavior data and constructing a multi-level knowledge network graph includes: By combining the hierarchical structure of knowledge with user interest tags, a heterogeneous knowledge graph G = (V, E) is constructed, where V represents knowledge points and E represents connecting edges; The TF-IDF algorithm is used to quantify user interest preferences, resulting in a vector f = [f_1, f_2, ..., f_m]. The association strength between nodes, A_ij = cos(f_i, f_j), is calculated using the similarity matrix. The weights w_ij are set based on the similarity A_ij, and the graph structure is constructed.

[0012] In one specific implementation, the step of using a fractal recursive algorithm to assign weights and expand the structure of the knowledge network graph includes: Let the total number of recursions be D, and the initial node weight be 1; In each iteration, update the weights of all nodes: w_i^{t} = w_i^{t1} × exp(β×d_i), where d_i is the current depth of knowledge node i and β is the decay rate; Based on the updated weights, the links are expanded and auxiliary knowledge links are added; Construct a hierarchical network G = {G_1, G_2, ..., G_n}, where G_k represents the knowledge graph of the k-th layer.

[0013] In one specific implementation, the optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: Calculate the knowledge coverage rate C(S) of the current sequence S = ∑_{i=1}^N γ_i, where γ_i is a binary variable indicating whether knowledge domain i is covered; Define the objective function M = C(S) × R_S, where R_S is the user's recommendation satisfaction; The particle swarm optimization algorithm is used to optimize S to maximize M; The optimized S_opt is retained as the final recommendation result.

[0014] In one specific implementation, generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Define the interconnection degree between knowledge nodes as μ_i,j = w_i + w_j ω_{ij}, where ω_{ij} represents the association weight between knowledge nodes i and j; The comprehensive connectivity of each node is evaluated using a non-linear weighted formula: P_i = (μ_i,1 + μ_i,2 + ... + μ_i,n) / n. Generate a preliminary knowledge sequence S = [n_1, n_2, ..., n_k] by sorting according to P_i; Add a random perturbation factor ε to avoid repetition and premature path termination.

[0015] This disclosure provides a personalized learning path recommendation method based on a fractal recursive structure, comprising: acquiring user learning behavior data and constructing a multi-level knowledge network graph; using a fractal recursive algorithm to assign weights and expand the structure of the knowledge network graph; generating an initial learning sequence based on the weight differences of the nesting relationships between knowledge nodes; and optimizing the arrangement order of knowledge points in the learning sequence based on a dynamic adjustment strategy. The solution provided by this disclosure addresses the problem of low knowledge transfer efficiency by adjusting the learning sequence of the recommended path according to the weight differences of the multi-level nesting relationships between knowledge points. Attached Figure Description

[0016] To more clearly illustrate the technical solutions of the exemplary embodiments of this disclosure, the accompanying drawings used in the embodiments will be briefly described below. It should be understood that the following drawings only show some embodiments of this disclosure and should not be regarded as a limitation of the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is a flowchart of a personalized learning path recommendation method based on fractal recursive structure; Figure 2 This is a further flowchart of acquiring users' learning behavior data and constructing a multi-level knowledge network graph; Figure 3 This is a flowchart of further processing of weight assignment and structural expansion of knowledge network graphs using fractal recursive algorithms; Figure 4 It is a further flowchart for generating an initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes; Figure 5 It is a flowchart for further optimizing and adjusting the order of knowledge points in the learning sequence based on dynamic control strategies; Figure 6 It is a further flowchart for generating an initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes; Figure 7 It is a flowchart for further optimizing and adjusting the order of knowledge points in the learning sequence based on dynamic control strategies; Figure 8 This is a further flowchart of acquiring users' learning behavior data and constructing a multi-level knowledge network graph; Figure 9 This is a flowchart of further processing of weight assignment and structural expansion of knowledge network graphs using fractal recursive algorithms; Figure 10 It is a flowchart for further optimizing and adjusting the order of knowledge points in the learning sequence based on dynamic control strategies; Figure 11 It is a further flowchart for generating an initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes. Detailed Implementation

[0018] The embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0019] The following specific examples illustrate the implementation of this disclosure. Those skilled in the art can easily understand other advantages and effects of this disclosure from the content disclosed in this specification. Obviously, the described embodiments are only a part of the embodiments of this disclosure, and not all of them. This disclosure can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this disclosure. It should be noted that, in the absence of conflict, the following embodiments and features in the embodiments can be combined with each other. Based on the embodiments in this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.

[0020] It should be noted that various aspects of embodiments within the scope of the appended claims are described below. It will be apparent that the aspects described herein can be embodied in a wide variety of forms, and any particular structure and / or function described herein is merely illustrative. Based on this disclosure, those skilled in the art will understand that one aspect described herein can be implemented independently of any other aspect, and two or more of these aspects can be combined in various ways. For example, any number of aspects set forth herein can be used to implement the device and / or practice the method. Additionally, this device and / or method can be implemented using structures and / or functionalities other than one or more of the aspects set forth herein.

[0021] It should also be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this disclosure. The drawings only show the components related to this disclosure and are not drawn according to the number, shape and size of the components in actual implementation. In actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0022] Furthermore, specific details are provided in the following description to facilitate a thorough understanding of the examples. However, those skilled in the art will understand that the described aspects can be practiced without these specific details.

[0023] Next, refer to Figure 1 This invention describes a personalized learning path recommendation method based on fractal recursive structures. For example... Figure 1 As shown, the method specifically includes: S101: Acquire user learning behavior data and construct a multi-level knowledge network graph. This step involves collecting user learning history, exam scores, and answer records, and using graph database technology to construct a multi-level knowledge network graph centered on knowledge points. In this graph, each knowledge point is defined as a node, and the relationships between knowledge points are modeled as edges. These nodes and edges not only represent the direct connections between knowledge points but also reflect their indirect influence relationships, thus forming a knowledge structure with deep nesting characteristics. For example, in mathematics, basic addition and subtraction knowledge points are nested with more complex algebraic knowledge; while in programming, the relationship between variables and functions further constitutes a deeper structure.

[0024] In one specific embodiment, the system first collects comprehensive learning behavior data from users in real time or in batches through an integrated learning management system (LMS), online education platform, or dedicated client. This data includes, but is not limited to: user interaction records (such as clicks, pauses, and markings) on each knowledge content node (e.g., videos, documents, exercise sets), test scores (accuracy rate, score), browsing time (time spent on the page accurate to the second), and course completion status (pass / fail status, number of completions). Subsequently, the system quantitatively evaluates each independent knowledge node i, constructing its initial weighting index. For example, a linear weighted model is used to calculate the initial weight of the node w_i = α·T_i + β·S_i, where T_i is the standardized browsing time of the node (e.g., the proportion of the total course time), S_i is the completion rate or test score (normalized to the 0-1 range), and α and β are weighting coefficients determined based on experience or machine learning optimization (e.g., α=0.4, β=0.6) to balance the impact of time investment and mastery. Next, based on a pre-defined subject knowledge system (such as curriculum standards and textbook catalogs) and the co-occurrence and sequential relationships between knowledge points in the user's historical behavior sequence, an adjacency matrix M representing the connection strength between knowledge nodes is generated. The value of the matrix element M_ij can be calculated based on statistics such as the frequency of a user continuously learning two knowledge points and the success rate of entering the next knowledge point after passing the previous knowledge point test. Finally, to construct a multi-level structure, the system uses the K-means clustering algorithm to perform unsupervised hierarchical partitioning of knowledge nodes. Specifically, each knowledge node is represented as its feature vector (which may contain weight w_i, the strength of association with other nodes, content labels, etc.), and multiple clusters are formed through iterative clustering. Each cluster represents a relatively macroscopic knowledge module; then, these knowledge modules are used as new nodes, and the above process is repeated to form a higher level of abstraction, thereby constructing a multi-level, tree-like or mesh-like knowledge network graph from microscopic knowledge points to macroscopic knowledge domains.

[0025] S102: Utilizing fractal recursion algorithms to assign weights and expand the structure of knowledge network graphs. Fractal recursion algorithms determine the importance of each node and the strength of its connections with other knowledge points by performing multi-level analysis of each knowledge point across different dimensions. This process simulates the fractal structure in complex systems in nature, capturing the mutual influence of knowledge nodes at different levels of abstraction. The algorithm assigns a dynamic weight to each node, reflecting not only the difficulty of the knowledge point but also the user's understanding and development of related skills. For example, in learning Python programming, the use of variables may be simple in the early stages, but as the learning progresses, nested variable calls and advanced applications become more important. Through fractal recursion, different weight parameters can be set for knowledge points at different stages, making subsequent learning sequences more accurately match the user's actual needs.

[0026] In a specific embodiment, the fractal recursive algorithm starts from the root node of the graph (or the top-level knowledge domain) and sets the initial recursion depth d=0. For each knowledge node i at the current depth, its recursion weight W_i(d) depends not only on its initial weight w_i, but also on its current recursion depth. A specific calculation method is: W_i(d) = W_i(base value) × (1 - δ)^{d}, where W_i(base value) can be the w_i calculated in step one or some transfer value of its parent node weight, and δ is a recursion decay factor (e.g., δ=0.1), which simulates the characteristic that the influence of knowledge decays as the level of abstraction increases or the distance of association increases. The algorithm recursively traverses all nodes and their child nodes (or associated nodes), with the depth d increasing layer by layer, propagating and accumulating weights from core nodes to their associated nodes, ultimately forming a hierarchical weight distribution, so that core and basic knowledge points receive higher global weights, while peripheral and advanced knowledge points have relatively lower weights. During the recursive process, the system dynamically adjusts the network structure based on the weight distribution. For example, redundant or weakly related links with extremely low recursive weights (below a set threshold) are pruned to reduce interference. At the same time, for knowledge point pairs that show strong correlation (high cumulative weight propagation value) on multiple recursive paths but are not directly connected in the original graph, an "auxiliary link" is dynamically added to strengthen the potential shortcut for knowledge transfer, thereby making the graph structure more adaptable and flexible.

[0027] S103: Generate an initial learning sequence based on the weight differences in the nested relationships between knowledge nodes. In this process, the system integrates the weight information of each node and its dependencies on surrounding nodes to calculate an initial learning order. This ordering is based not only on the priority of the knowledge itself but also on the user's current learning level and the speed of their skill development. For example, in a chemistry experiment teaching plan, if the user lacks a firm grasp of basic chemical reaction principles, the system will first push content related to basic reaction equations, and then gradually introduce more complex experimental designs and material applications.

[0028] In a specific embodiment, for any two knowledge points u and v that are directly dependent or closely related in the knowledge graph, their nesting weight W_uv is calculated. A feasible calculation formula is: W_uv = min(W_u, W_v) / max(W_u, W_v), where W_u and W_v are their recursive weights calculated in step two. This ratio reflects the proximity of the weights of the two nodes in the fractal structure. The higher the ratio, the more similar their hierarchy and importance in the knowledge system, and the stronger the nesting or dependency relationship may be. The system presets two thresholds θ_1 and θ_2 (e.g., θ_1=0.7, θ_2=0.3). If W_uv>θ_1, u and v are determined to have a strong nesting relationship and should be closely adjacent in the learning sequence. Their order is determined according to other rules (such as weight level, prerequisites) (e.g., u → v). If W_uv<θ_2, the two are considered relatively independent. Next, the system uses the recursive weight W_i of the knowledge nodes as the primary basis (those with higher weights are usually more fundamental or core), combined with the nested relationships mentioned above, and employs a topological sorting algorithm or priority queue to generate an initial learning sequence S = [n_1, n_2, ..., n_k]. This sequence ensures that basic knowledge is prioritized and arranges strongly related knowledge points together as much as possible.

[0029] S104: The system optimizes the order of knowledge points in the learning sequence based on a dynamic adjustment strategy. Building upon the initial learning sequence, the system continuously monitors user feedback data and learning outcomes, adjusting the structure of the learning sequence in real time. This dynamic mechanism flexibly changes the playback order of knowledge points according to the user's progress, preventing user frustration due to overly rapid jumps or complex content. For example, in an English reading training task, if a user performs poorly in understanding highly difficult articles, the system may first reinforce relatively easier content closely related to the target knowledge points, gradually transitioning to more challenging articles. This optimization effectively improves the efficiency of knowledge transfer during the learning process.

[0030] In a specific embodiment, the system defines a dynamic association weight D_{ij} = 1 / |W_i - W_j|, which reflects the closeness of any two knowledge points i and j in the sequence based on their fractal recursive weight differences. The smaller the difference, the larger the D_{ij} value, meaning that being close in the sequence may better conform to cognitive continuity. Simultaneously, the system obtains real-time user feedback ratings R_{ij} for learned knowledge points (such as self-assessment of comprehension and practice accuracy). Next, it calculates the real-time priority factor P_i = ∑_{j≠i} D_{ij} × R_{ij} for each knowledge point i. This factor integrates the inherent connections of the knowledge structure (D_{ij}) and the user's individual learning effect (R_{ij}). Then, the system reorders the initial sequence S according to the P_i value to obtain S_new. To further optimize, a greedy algorithm can be used: starting from the beginning of the sequence, compare the optimization objective function values ​​(e.g., the weighted sum of D_{ij} and R_{ij}) of adjacent knowledge point pairs one by one. If swapping positions can improve the objective function value, then swap them, iterating multiple times until convergence. Alternatively, in a more complex implementation, the learning cost (e.g., the product C_i of estimated time t_i and difficulty s_i) and user acceptance E_i are taken into consideration, constructing a global objective function F(S) = ∑ C_i * (1 / E_i). Simulated annealing or particle swarm optimization is then used to search the entire sequence permutation space to find the sequence permutation S_opt that minimizes F(S). This S_opt is the final recommended personalized learning path that respects the fractal structure of knowledge while adapting to the user's individual learning state and efficiency.

[0031] The technical solution of this invention, through the above steps, can maintain the integrity of the knowledge system while adaptively adjusting according to the individual learning characteristics of users. It effectively overcomes the problem of poor learning effect caused by insufficient consideration of the nesting weight between knowledge points in traditional methods, and has good practical application value and broad prospects for promotion.

[0032] Next, the steps of acquiring user learning behavior data and constructing a multi-level knowledge network graph according to the present invention are described, specifically including: Collect user interaction records, test scores, browsing time, and course completion status; For each knowledge point, a weight index is established as w_i = α·T_i + β·S_i, where T_i is the browsing time of knowledge node i, S_i is the completion rate of knowledge node i, and α and β are weighting coefficients; Generate an adjacency matrix M of the graph based on the user's historical behavior; The K-means clustering method is used to hierarchically divide knowledge nodes, forming a multi-level structure.

[0033] Specifically, the system first collects user interaction records (such as video pause points, number of times exercises were redone), test scores (raw scores and percentiles relative to the group), browsing time (effective learning time, filtering out invalid pauses), and course completion status (such as whether a certificate of completion was obtained) from the log database and API interface. Then, for each knowledge node i at the smallest granularity (e.g., "Pythagorean theorem"), its initial weight is calculated according to the formula w_i = α·T_i + β·S_i. Here, T_i is the normalized average browsing time, S_i is the mastery rate calculated based on historical tests, and the coefficients α and β can be determined through regression analysis of historical data (e.g., α=0.3, β=0.7) to more accurately reflect the weighting orientation that "mastery level" is more important than "time spent." Next, based on a large number of user behavior sequences, the system statistically analyzes the transition probability and co-occurrence frequency between knowledge points, constructing an n×n adjacency matrix M, where the value of M_ij represents the intensity of the transition from knowledge point i to j. Finally, to form a multi-level structure, the K-means clustering method is adopted: using the feature vectors of knowledge nodes (including w_i, TF-IDF values ​​of content tags, and correlation spectrum features in matrix M) as input, the optimal number of clusters K is determined by the elbow rule, and iterative clustering is performed. The first round of clustering divides n knowledge points into K clusters, each cluster being a "knowledge unit"; the second round uses the features of these "knowledge units" (such as the mean and variance of the node weights within the cluster) as new nodes, and clusters them again to form higher-level "knowledge modules". This process is recursively repeated, ultimately constructing a graph with clear hierarchies (such as "knowledge point → knowledge unit → knowledge module → knowledge domain").

[0034] Next, the steps of the present invention for weight assignment and structural expansion of the knowledge network graph using a fractal recursive algorithm are described, specifically including: Define the recursion depth d, and set the initial depth to 0; For each knowledge node i, calculate the recursive weight W_i(d) = W_i(d1) × (1 δ)^{d}, where δ is the recursive decay factor; By recursively traversing all nodes and accumulating and propagating weights, a hierarchical weight distribution is formed. The network structure is dynamically adjusted based on the current recursion depth, adding or reducing redundant links.

[0035] Specifically, first, the recursion depth d is defined, starting from the root node of the graph (e.g., "junior high school mathematics"), and d=0 is set. For the current node i, its recursive weight is calculated as W_i(d) = W_i(d-1) × (1 - δ)^{d}. Where W_i(d-1) is the weight of its parent node or itself in the previous round of recursion (initially W_i(0) can be w_i calculated in claim 2), and δ is a preset recursion decay factor (e.g., δ=0.15). The algorithm recursively traverses all nodes and their connections in a depth-first or breadth-first manner. During the traversal, child nodes inherit and decay the weight of their parent nodes, while accumulating the weight propagation values ​​from different parent nodes. Finally, each node obtains a W_i that reflects its global importance in the multi-level nested structure. Meanwhile, the system dynamically adjusts the network structure based on the current recursion depth: when the depth d is large, if the cumulative weight values ​​of the nodes at both ends of an edge are both lower than the threshold τ, the link is considered redundant in the current learning stage and is "pruned"; conversely, if two nodes are found to have high weight correlation in multiple recursions (for example, they frequently co-occur in subgraphs at different depths), but there is no edge directly connecting them in the original graph, a weighted link is dynamically "added" as a potential bridge for knowledge transfer.

[0036] Furthermore, in one embodiment of this application, generating an initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Extract the nested weights between any two adjacent knowledge points u and v: W_uv = min(W_u, W_v) / max(W_u, W_v); Set thresholds θ_1 and θ_2. If W_uv > θ_1, it indicates a strong correlation. The initial order relationship is generated based on the W_uv value: if W_uv>θ_1, then the order is u → v, otherwise it is considered an independent node; A preliminary sequence S = [n_1, n_2, ..., n_k] is generated by sorting nodes according to their importance.

[0037] Specifically, for directly connected knowledge point pairs (u, v) in the graph, the recursive weights W_u and W_v calculated in claim 3 are extracted, and their nesting weights W_uv are calculated using the formula: W_uv = min(W_u, W_v) / max(W_u, W_v). This value ranges from [0, 1]. A larger value indicates that the importance levels of the two nodes in the fractal structure are closer, and the nesting or dependency relationship is stronger. The system presets two empirical thresholds θ_1 = 0.75 and θ_2 = 0.25. The judgment and sorting rules are as follows: If W_uv > θ_1, then u and v are determined to have a strong nesting relationship and should be adjacent in the initial sequence, and the node with the higher weight is given priority for learning (assuming u → v). If W_uv < θ_2, then it is considered a weakly related or independent node. Afterwards, the system uses the recursive weight W_i of each knowledge node as the node importance and sorts them in descending order to form a basic sequence. Finally, combining the aforementioned strong nesting relationship rules, the basic sequence is locally adjusted: nodes with strong nesting relationships are moved to adjacent positions, and the node with higher weight is placed first, thus generating the initial sequence S = [n_1, n_2, ..., n_k].

[0038] Next, we describe a step of generating an initial learning sequence based on the weight difference of the nesting relationship between knowledge nodes according to an embodiment of the present invention, which includes: Calculate the association weight D_{ij} = 1 / |W_iW_j| between any two nodes n_i and n_j in the current sequence, where W_i and W_j are the corresponding knowledge point weights; Define the priority factor P_i = ∑_{j≠i} D_{ij} × R_{ij}, where R_{ij} is the user's feedback rating; Reorder S_new based on priority factor: S_new = sorted(S, key=lambda x: P_x); A greedy algorithm is used to successively swap positions, so that the one with larger D_{ij} is placed in front.

[0039] Specifically, for any two knowledge point nodes n_i and n_j in the current learning sequence S, the structural association weight D_{ij} = 1 / |W_i - W_j| is calculated based on their final weights W_i and W_j obtained in the fractal recursive structure. This formula quantifies the "distance" between the two at the level of global knowledge importance; the smaller the difference, the larger D_{ij}, meaning that the cognitive load of continuous learning may be lower. Simultaneously, the system obtains the user's subjective feedback rating R_{ij} on the association between learned knowledge points. For example, after learning n_i, the system asks the user, "Does understanding n_i help with learning n_j?", and collects their ratings from 1 to 5. Then, a real-time priority factor P_i is calculated for each node n_i: P_i = ∑_{j≠i} D_{ij} × R_{ij}. This factor integrates the inherent similarity of the knowledge structure (D_{ij}) and the user's individual learning experience verification (R_{ij}). Based on P_i, the system performs the first rearrangement of the original sequence, generating S_new = sorted(S, key=lambda x: P_x), which moves the knowledge points with higher comprehensive priority to the front. For further optimization, the system uses a greedy algorithm for local fine-tuning: starting from the beginning of the sequence, it sequentially compares the D_{t,t+1} values ​​of two adjacent nodes n_t and n_{t+1}; if swapping their positions results in a larger sum of D values ​​between the new adjacent node pairs, then the swap is performed. This process iterates multiple times until there are no more swaps that can be improved.

[0040] Next, we describe a step of generating an initial learning sequence based on the weight difference of the nesting relationship between knowledge nodes according to an embodiment of the present invention, which includes: Define the recursive dependency index η_i = ∑_{j∈child(i)} w_j × k_j, where w_j is the weight of child node j and k_j is the number of dependencies; All nodes are sorted using a linear weighted model: Score_i = η_i × log(1 + a_i), where a_i is the complexity coefficient of the knowledge point; Based on Score_i, the knowledge points are sorted in descending order to generate a temporary learning sequence L_temp; A time window mechanism is introduced, taking only the first N knowledge points as the initial sequence S.

[0041] Specifically, the recursive dependency index η_i is calculated for each knowledge node i. Specifically, it iterates through the set of all direct child nodes (or strongly dependent nodes) child(i) in the multi-level graph, using the formula: η_i = ∑_{j∈child(i)} w_j × k_j. Here, w_j is the weight of child node j (from claim 2 or 3), and k_j is the frequency (number of times) a node has been learned from i and then accessed from j in the user's historical data. This index reflects the foundational nature and supporting strength of the current node for its subsequent knowledge. Then, the system uses a linear weighted model to calculate a ranking score for each node: Score_i = η_i × log(1 + a_i). Here, a_i is the preset complexity coefficient for that knowledge point (e.g., obtained based on expert annotation or text analysis). Taking the logarithm prevents excessively large differences in complexity from completely dominating the ranking. Subsequently, the system sorts all nodes in descending order according to Score_i, generating a temporary learning sequence L_temp. Finally, to avoid overwhelming users' cognitive load by recommending too much content at once, the system introduces a time window mechanism: for example, based on the user's average daily available learning time (e.g., 30 minutes) and the average time spent on each knowledge point, the number of knowledge points N that can be completed within the window period is estimated, and only the first N nodes in L_temp are extracted to form a preliminary sequence S.

[0042] Furthermore, in another embodiment of the present invention, the step of optimizing and adjusting the order of knowledge points in the learning sequence based on a dynamic adjustment strategy specifically includes: In each step of the operation, the learning cost is evaluated as C_i = t_i × s_i, where t_i is the estimated time consumption of knowledge node i and s_i is the difficulty coefficient of the knowledge point. Construct the objective function F(S) = ∑ C_i * E_i, where E_i is the user's acceptance rating of the knowledge point; The simulated annealing algorithm is used to find the minimized F(S) state; Output the final learned sequence S_opt to improve overall efficiency.

[0043] Specifically, firstly, the learning cost C_i is estimated for each knowledge node i in sequence S: C_i = t_i × s_i. Here, t_i is the average learning time calculated based on historical user data, and s_i is the standardized difficulty coefficient of that knowledge point. Simultaneously, the system obtains the user's acceptance rating E_i for the knowledge points they have encountered (such as learning enjoyment and self-efficacy ratings). Next, a global optimization objective function F(S) is constructed: F(S) = ∑ C_i * (1 / E_i). This function aims to minimize the overall "negative experience cost," that is, to favor recommending combinations of knowledge points with short total learning time, low difficulty, and high user acceptance. To solve this complex combinatorial optimization problem, the system uses simulated annealing. The algorithm takes the current sequence S as the initial state and generates a new state S' by randomly swapping the positions of two knowledge points in the sequence. The change in the objective function value ΔF = F(S') - F(S) is calculated. According to the Metropolis criterion, if ΔF < 0, the new state is accepted; if ΔF > 0, it is accepted with probability P = exp(-ΔF / T) (where T is the current temperature). The algorithm starts from a relatively high initial temperature, slowly lowers the temperature T at a predetermined cooling rate, and repeats the above state generation and acceptance process until the temperature drops to the termination temperature. The sequence state S_opt corresponding to the final convergence is the optimized recommendation result.

[0044] In another embodiment of acquiring user learning behavior data and constructing a multi-level knowledge network graph, firstly, a heterogeneous knowledge graph G = (V, E) is constructed by combining the hierarchical structure of knowledge with user interest tags, where V represents knowledge points and E represents connecting edges; then, the TFIDF algorithm is used to quantify user interest preferences to obtain vectors f = [f_1, f_2, ..., f_m]; then, the association strength A_ij = cos(f_i, f_j) between each node is calculated through the similarity matrix; Finally, the weights w_ij are set based on the similarity A_ij, and the graph structure is constructed.

[0045] Specifically, the graph pattern is first defined: entity nodes (V) not only include the knowledge points themselves, but also incorporate user interest tags (such as "prefers geometric proofs" or "interested in historical figures") as another type of node. Relationship edges (E) include various semantic types such as "belongs to" (knowledge point and subject area), "precedence" (dependence between knowledge points), and "association" (knowledge point and interest tag). In its construction, the system uses the TF-IDF algorithm to quantify user interest preferences: all user interaction records (such as document titles viewed, search keywords, and discussion topics participated in) are aggregated into a text corpus, and the TF-IDF value of each interest tag term t in the user's corpus is calculated to form a vector f = [f_1, f_2, ..., f_m] representing the user's personalized interests. Next, the association strength between knowledge points and interest tags is calculated: for a knowledge point node i (whose content can be represented by a text vector) and an interest tag j, their similarity A_ij = cos(f_i, f_j). Finally, the system sets the weights w_ij of the connecting edges based on the inherent hierarchical relationships between knowledge (such as parent-child relationships) and the calculated semantic similarity A_ij, thereby constructing a heterogeneous graph G = (V, E) that integrates knowledge structure, user interests and complex relationships.

[0046] In another embodiment, the step of using a fractal recursive algorithm to assign weights and expand the structure of the knowledge network graph includes: Let the total number of recursions be D, and the initial node weight be 1; In each iteration, update the weights of all nodes: w_i^{t} = w_i^{t1} × exp(β×d_i), where d_i is the current depth of knowledge node i and β is the decay rate; Based on the updated weights, the links are expanded and auxiliary knowledge links are added; Construct a hierarchical network G = {G_1, G_2, ..., G_n}, where G_k represents the knowledge graph of the k-th layer.

[0047] Specifically, the algorithm first presets the total number of recursions D (e.g., D=5) and assigns an initial weight w_i^0 of 1 to all nodes in the graph. In each iteration t (from 1 to D), the algorithm traverses the nodes hierarchically and updates their weights using the formula: w_i^{t} = w_i^{t-1} × exp(-β×d_i). Here, d_i is the depth of node i in the original knowledge level (e.g., the root node has a depth of 0), and β is the decay rate parameter (e.g., β=0.2). This formula simulates the fractal characteristic of knowledge influence decaying exponentially with depth. After the weight update, the algorithm performs link expansion: it scans all node pairs (i, j). If they are not directly connected in the current graph, but |w_i^{t} - w_j^{t}| < ε (ε is a small threshold), they are considered to have convergent weight evolution and potential strong correlation. Therefore, an auxiliary knowledge link is added between them, with the weight set to the average of the two weights. After the recursive iteration is completed, the system divides the graph into a series of subgraphs according to the final weights and connections of the nodes, based on the final weights and connections of the nodes, thereby constructing a hierarchical network G = {G_1, G_2, ..., G_n}, where G_k represents the k-th layer substructure with similar weights and connections in the knowledge system.

[0048] In another embodiment, the optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic adjustment strategy includes: Calculate the knowledge coverage rate C(S) of the current sequence S = ∑_{i=1}^N γ_i, where γ_i is a binary variable indicating whether knowledge domain i is covered; Define the objective function M = C(S) × R_S, where R_S is the user's recommendation satisfaction; The particle swarm optimization algorithm is used to optimize S to maximize M; The optimized S_opt is retained as the final recommendation result.

[0049] Specifically, an optimization objective function is defined, which includes two key metrics: knowledge coverage C(S) and user recommendation satisfaction R_S. Coverage is calculated as: C(S) = ∑_{i=1}^{N_d} γ_i, where N_d is the total number of pre-defined knowledge domains, and γ_i is a binary variable, set to 1 if the sequence S contains at least one knowledge point from that domain, and 0 otherwise. User satisfaction R_S can be quantified by short-term click-through rate, completion rate, or average score from real-time user feedback. Finally, the objective function M = C(S) × R_S is constructed, aiming to maximize the product of coverage breadth and user satisfaction. To efficiently solve this optimization problem, the system employs a particle swarm optimization algorithm. Each particle represents a candidate learning sequence S, its position represented by the permutation encoding of knowledge points in the sequence. The fitness value of the particle is the objective function value M. The algorithm initializes a swarm of particles (random sequence), and each particle adjusts its sequence (i.e., "position") based on its own historical best position and the swarm's historical best position using a specific operator (such as exchange-based updates). After multiple iterations, the particle swarm will converge to the sequence arrangement S_opt that maximizes M, which will be the final recommendation result.

[0050] In another embodiment, generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Define the interconnection degree between knowledge nodes as μ_i,j = w_i + w_j ω_{ij}, where ω_{ij} represents the association weight between knowledge nodes i and j; The comprehensive connectivity of each node is evaluated using a non-linear weighted formula: P_i = (μ_i,1 + μ_i,2 + ... + μ_i,n) / n. Generate a preliminary knowledge sequence S = [n_1, n_2, ..., n_k] by sorting according to P_i; Add a random perturbation factor ε to avoid repetition and premature path termination.

[0051] Specifically, a more refined interconnectivity metric, μ_{i,j}, is first defined: μ_{i,j} = w_i + w_j - ω_{ij}. Here, w_i and w_j are node weights, and ω_{ij} is the association weight of the edge (i, j) in the knowledge graph. This metric aims to combine the importance of nodes themselves with the strength of connections between them; a larger value indicates that the node pair is more "important" and the connection is more "tight" in the overall network. Subsequently, for each node i, its comprehensive connectivity score P_i is calculated: P_i = (μ_{i,1} + μ_{i,2} + ... + μ_{i,n}) / n, where the summation is over all n directly connected neighbor nodes. This score reflects the node's local hub status in the network. The system sorts the knowledge points in descending order of P_i, generating a preliminary knowledge sequence S. To prevent the algorithm from getting stuck in a fixed pattern or the path from terminating prematurely (e.g., always starting from the node with the highest connectivity), the system introduces a random perturbation factor ε after sorting: in the final sequence, it allows the random swapping of the positions of two adjacent nodes with a small probability ε (e.g., 5%), or the random addition of a node with a medium P_i value that was not included at the end of the sequence.

[0052] This invention discloses a personalized learning path recommendation method based on fractal recursive structure, comprising: First, collecting user learning behavior data, such as answer records, browsing time, and knowledge mastery level, to construct a multi-level knowledge network graph. This graph, centered on knowledge points, connects their hierarchical relationships and associations with other knowledge points, forming a structured data model with rich semantic information. Then, a fractal recursive algorithm is used to assign weights and expand the structure of the knowledge network. This algorithm simulates the self-similarity of fractal structures in nature through recursion, introducing an adaptive weight mechanism at each node, so that knowledge nodes at different levels receive relative weights consistent with actual logic, thus more accurately reflecting the nesting relationships between knowledge points. Based on this, an initial learning sequence is generated according to the weight differences, ensuring the logical and coherent transfer between knowledge nodes. Next, a method based on a dynamic adjustment strategy is used to further optimize and adjust the generated learning sequence. This strategy adjusts the order of knowledge points in real time according to the user's learning ability and current progress, reducing repetitive learning and knowledge gaps, improving knowledge transfer efficiency, and thus achieving personalized and efficient learning path recommendation.

[0053] This invention proposes an innovative solution to address the problem of low knowledge transfer efficiency by regulating the learning sequence of recommended paths based on the weight differences in multi-level nested relationships between knowledge points. By applying the concept of fractal recursion to knowledge structure modeling and introducing a weight assignment mechanism, the inherent connections and hierarchical structure between knowledge points are effectively revealed. Simultaneously, a dynamic regulation strategy is used to intelligently optimize the learning sequence, achieving dynamic adaptation and accurate recommendation of learning paths. This significantly improves the coherence and efficiency of knowledge transfer, overcoming the shortcomings of traditional methods in knowledge organization and learning recommendation, and enhancing the quality and effectiveness of personalized learning experiences.

[0054] The above description is the preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this invention, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A personalized learning path recommendation method based on fractal recursive structure, characterized in that, include: Acquire user learning behavior data and construct a multi-level knowledge network graph; A fractal recursive algorithm is used to assign weights and expand the structure of a knowledge network graph. An initial learning sequence is generated based on the weight differences in the nesting relationships between knowledge nodes; The order of knowledge points in the learning sequence is optimized and adjusted based on a dynamic control strategy.

2. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The process of acquiring user learning behavior data and constructing a multi-level knowledge network graph includes: Collect user interaction records, test scores, browsing time, and course completion status; For each knowledge point, a weight index is established as w_i = α·T_i + β·S_i, where T_i is the browsing time of knowledge node i, S_i is the completion rate of knowledge node i, and α and β are weighting coefficients; Generate an adjacency matrix M of the graph based on the user's historical behavior; The K-means clustering method is used to hierarchically divide knowledge nodes, forming a multi-level structure.

3. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The method of using fractal recursive algorithm to assign weights and expand the structure of knowledge network graphs includes: Define the recursion depth d, and set the initial depth to 0; For each knowledge node i, calculate the recursive weight W_i(d) = W_i(d1) × (1 δ)^{d}, where δ is the recursive decay factor; By recursively traversing all nodes and accumulating and propagating weights, a hierarchical weight distribution is formed. The network structure is dynamically adjusted based on the current recursion depth, adding or reducing redundant links.

4. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The step of generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Extract the nested weights between any two adjacent knowledge points u and v: W_uv = min(W_u, W_v) / max(W_u, W_v); Set thresholds θ_1 and θ_2. If W_uv > θ_1, it indicates a strong correlation. The initial order relationship is generated based on the W_uv value: if W_uv > θ_1, then the order is u → v; otherwise, they are treated as independent nodes. A preliminary sequence S = [n_1, n_2, ..., n_k] is generated by sorting nodes according to their importance.

5. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: Calculate the association weight D_{ij} = 1 / |W_i-W_j| between any two nodes n_i and n_j in the current sequence, where W_i and W_j are the corresponding knowledge point weights; Define the priority factor P_i = ∑_{j≠i} D_{ij} × R_{ij}, where R_{ij} is the user's feedback rating; Reorder S_new based on priority factor: S_new = sorted(S, key=lambda x: P_x); A greedy algorithm is used to successively swap positions, so that the one with larger D_{ij} is placed in front.

6. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The step of generating the initial learning sequence based on the weight differences in the nesting relationships between knowledge nodes includes: Define the recursive dependency index η_i = ∑_{j∈child(i)} w_j × k_j, where w_j is the weight of child node j and k_j is the number of dependencies; All nodes are sorted using a linear weighted model: Score_i = η_i × log(1 + a_i), where a_i is the complexity coefficient of the knowledge point; Based on Score_i, the knowledge points are sorted in descending order to generate a temporary learning sequence L_temp; A time window mechanism is introduced, taking only the first N knowledge points as the initial sequence S.

7. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: In each step of the operation, the learning cost is evaluated as C_i = t_i × s_i, where t_i is the estimated time consumption of knowledge node i and s_i is the difficulty coefficient of the knowledge point. Construct the objective function F(S) = ∑ C_i * E_i, where E_i is the user's acceptance rating of the knowledge point; The simulated annealing algorithm is used to find the minimized F(S) state; Output the final learned sequence S_opt to improve overall efficiency.

8. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The process of acquiring user learning behavior data and constructing a multi-level knowledge network graph includes: By combining the hierarchical structure of knowledge with user interest tags, a heterogeneous knowledge graph G = (V, E) is constructed, where V represents knowledge points and E represents connecting edges; The TF-IDF algorithm is used to quantify user interest preferences, resulting in a vector f = [f_1, f_2, ..., f_m]. The association strength between nodes, A_ij = cos(f_i, f_j), is calculated using the similarity matrix. The weights w_ij are set based on the similarity A_ij, and the graph structure is constructed.

9. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The method of using fractal recursive algorithm to assign weights and expand the structure of knowledge network graphs includes: Let the total number of recursions be D, and the initial node weight be 1; In each iteration, update the weights of all nodes: w_i^{t} = w_i^{t1} × exp(β×d_i), where d_i is the current depth of knowledge node i and β is the decay rate; Based on the updated weights, the links are expanded and auxiliary knowledge links are added; Construct a hierarchical network G = {G_1, G_2, ..., G_n}, where G_k represents the knowledge graph of the k-th layer.

10. The personalized learning path recommendation method based on fractal recursive structure according to claim 1, characterized in that, The optimization and adjustment of the order of knowledge points in the learning sequence based on the dynamic control strategy includes: Calculate the knowledge coverage rate C(S) of the current sequence S = ∑_{i=1}^N γ_i, where γ_i is a binary variable indicating whether knowledge domain i is covered; Define the objective function M = C(S) × R_S, where R_S is the user's recommendation satisfaction; The particle swarm optimization algorithm is used to optimize S to maximize M; The optimized S_opt is retained as the final recommendation result.

Images