PLKD: Personalized Learning Content Generation Algorithm Based on Knowledge Granularity Detector

1. Introduction

With the rapid advancement of artificial intelligence, personalized learning has become a research hotspot in the field of intelligent education. Unlike traditional unified teaching content generation, personalized learning content generation dynamically constructs knowledge point sequences suited to learners’ cognitive levels and generates corresponding learning materials according to their personal information, learning objectives and preferences [1]. This adaptive generation method helps mitigate drawbacks of one-size-fits-all teaching, such as low learning efficiency and mismatched content difficulty. With the powerful text generation capability of Large Language Models (LLMs), LLM-based personalized content generation boasts promising application prospects [2].

However, current LLM-based personalized learning content generation methods still face several critical challenges. Firstly, effective control over knowledge granularity remains unresolved. Original input knowledge points can be highly abstract, such as machine learning, or overly fragmented, like learning rate setting in gradient descent. Most existing approaches fail to judge and split knowledge points with reasonable granularity, producing excessively abstract or repetitive content [3]. Secondly, generated content usually has ambiguous knowledge boundaries. The absence of clear prerequisite relationships and logical progression among knowledge points tends to confuse learners [4]. Thirdly, documents covering multiple knowledge points often violate teaching logic, including rare content in the first knowledge point and repeated elaboration in subsequent knowledge points. Conventional prompt engineering and Chain-of-Thought (CoT) methods cannot systematically restrict such flaws [3].

To address the above problems, we propose PLKD, Personalized Learning content generation algorithm based on Knowledge Granularity Detector. The core idea of PLKD consists of two stages:

Stage 1: Knowledge Points Granularity Detection and Knowledge Points Split. First, we adaptively determine a reasonable granularity threshold based on user-provided personal information (such as knowledge background and learning preferences). Then, we use a self-constructed granularity dataset to train a Knowledge Granularity Detector, which maps any knowledge point to a granularity value within the $[0,1]$ interval. For knowledge points whose granularity value exceeds the user’s threshold and are not specific enough, we split them into more detailed knowledge points, supplemented by Peer Boundary Validation to ensure that the split knowledge points have clear boundaries and well-defined prerequisite relationships. Finally, we sort the split knowledge points in a reasonable order.

Stage 2: Knowledge Point Document Generation and Quality Constraints. When generating the document content for each knowledge point, we adopt the Prerequisite Knowledge Points Window mechanism, inputting the complete context of documents from nearby generated knowledge points and converting more distant knowledge points into summaries, thus balancing context length and coherence. Meanwhile, we design multiple quality constraint mechanisms: Rare Constraint for the first knowledge point, Redundancy Constraint for subsequent knowledge points, and Hard Prerequisite Constraint to ensure the generated content is non-redundant and consistent with instructional logic.

To demonstrate the effectiveness of PLKD, we designed comparative experiments with reference to existing studies [5,6,7]. We adopted an LLM-based automatic evaluation approach, conducting pairwise comparisons between texts generated by PLKD, its ablated version (PLKD w/o), the Chain-of-Thought method (CoT), and the Direct Prompting method (Dir). The evaluation is performed across five dimensions: fact accuracy relative, difficulty adaptation, personalization fit, knowledge transition reasonableness, and feedback timeliness.

The main contributions of this paper are summarized as follows:

(1)

We propose PLKD, Personalized Learning Content Generation Algorithm Based on Knowledge Granularity Detector, which, for the first time, introduces knowledge point granularity quantification and adaptive thresholding into the learning content generation task.

(2)

We design a multi-level content quality constraint mechanism, including Knowledge Points Split, Peer Boundary Validation, Prerequisite Knowledge Points Window, Rare Constraint, Redundancy Constraint, and Hard Prerequisite Constraint, which systematically enhances the logical coherence and pedagogical soundness of the generated content.

(3)

We construct a granularity detection dataset and design an LLM-based multi-dimensional evaluation scheme. Experimental results demonstrate the superiority of PLKD in difficulty adaptability, personalization fit, and rationality of knowledge transition.

2. Related Work

2.1. Personalized Learning Content Generation and Intelligent Education

Personalized learning content generation is one of the core tasks of Intelligent Tutoring Systems (ITS). Early research mainly relied on rule-based expert systems and knowledge tracing techniques to numerically model learners’ cognitive states [8]. With the rapid development of LLMs, natural language generation technologies have been widely applied in educational scenarios. Recent studies have shown that LLMs exhibit remarkable abilities in text generation and logical reasoning, demonstrating potential in open-ended teaching tasks and companion-style interactive functions [9]. For example, educational large models such as EduChat have enhanced their performance in various scenarios, including heuristic teaching and knowledge question answering, through instruction tuning techniques [10]. However, most existing LLM-based systems still rely on direct prompt engineering, often assuming that the input knowledge points conform to a single standard of complexity and granularity. As a result, when faced with heterogeneous knowledge concepts and learners with diverse backgrounds, the generated content tends to suffer from mismatched difficulty levels and a lack of systematic decomposition and progression. In this paper, we adaptively determine a reasonable cognitive granularity threshold based on user information, breaking through the traditional “one-size-fits-all” barrier in content generation.

2.2. Knowledge Point Modeling and Granularity Control

In the field of educational knowledge modeling, accurately identifying and segmenting “knowledge points” has always been a major challenge. Early research focused on concept representation and prerequisite relationship modeling, aiming to address the issue of prerequisite dependencies among concepts in large-scale open online courses (MOOCs) [11]. With the advent of LLMs, researchers have attempted to leverage these models for knowledge graph extraction and concept reasoning [12]. However, these works rarely pay attention to “pedagogical granularity,” that is, whether a knowledge point is too general or too trivial for a specific audience. Existing generation strategies fail to strictly constrain concepts of different levels within their appropriate explanatory boundaries using quantifiable metrics. In this paper, we propose for the first time to train a Knowledge Granularity Detector by constructing a dedicated granularity dataset, mapping knowledge points to the $[0,1]$ interval, and performing adaptive split with Peer Boundary Validation. This approach fills the gap in natural language generation where there is a lack of quantitative granularity control criteria.

2.3. Controllable Text Generation and Content Quality Constraint Mechanisms

To ensure the reliability and factual accuracy of outputs from LLMs, Controllable Text Generation has attracted widespread attention in the academic community. Early approaches mainly relied on introducing constraints at the neural network decoding stage to control text output [13]. In recent years, with further research, self-reflection mechanisms have been shown to improve output quality and task performance in various generation and reasoning tasks. For example, the Self-Refine framework utilized multi-context feedback to iteratively verify and rewrite generated content [14], while Reflexion enhanced the decision-making and error-correction capabilities of agent language models in complex tasks through language feedback and reflective memory mechanisms [15].

Although such multi-round self-verification methods have shown potential for improving output quality and task performance in general text generation and reasoning tasks, new adaptation challenges may still arise in long-form, continuous personalized learning scenarios. On one hand, as the sequence of knowledge points progresses, the model may struggle to consistently maintain attention to prior instructional context and prerequisite relationships. On the other hand, content coherence and redundancy control across knowledge nodes become more complex. To address these issues, this paper, considering the strong knowledge progression and significant context dependence in educational scenarios, designs the Prerequisite Knowledge Points Window technique to enhance content continuity, and introduces “detection-rewriting” mechanisms such as Rare Constraint, Redundancy Constraint, and Hard Prerequisite Constraint into the generation process. Compared with general chain-of-thought strategies, this mechanism places greater emphasis on explicit constraints regarding instructional order, knowledge dependencies, and content coherence, thereby improving the pedagogical organization and consistency of the generated content.

3. Problem Definition

Following the formulation of Wang et al. [7], we provide the following formal definition of the entire process of intelligent instructional content generation:

Definition 1 (Learner Profile Generation): Given the learner’s input learning goal $goal$, learning preference $pref$, and initial knowledge state $state$, the learner profile agent ${\mathit{AGENT}}_{\mathit{LearnerProfile}}$ generates a learner profile U to describe the learner’s current state, as shown in Equation (1):

$$U={\mathit{AGENT}}_{\mathit{LearnerProfile}}(goal,pref,state)$$

(1)

Definition 2 (Learning Path Planning): Based on the learner profile U, the path planning agent ${\mathit{AGENT}}_{\mathit{PathPlanning}}$ generates the optimal learning path $\mathit{p}$, as shown in Equation (2):

$$\mathit{p}={\mathit{AGENT}}_{\mathit{PathPlanning}}\left(U\right)$$

(2)

The learning path vector $\mathit{p}=[{\mathit{p}}_1,{\mathit{p}}_2,\dots ,{\mathit{p}}_m]$, where ${\mathit{p}}_i$ is the i-th chapter in the learning path, and m is the total length of the path.

Definition 3 (Knowledge Points Generation): By combining the learner profile U and the complete learning path $\mathit{p}$, the knowledge points generation agent ${\mathit{AGENT}}_{\mathit{KnowledgePoints}}$ generates the knowledge point vector ${\mathit{kp}}_i$ for the i-th chapter ${\mathit{p}}_i$, as shown in Equation (3):

$${\mathit{kp}}_i={\mathit{AGENT}}_{\mathit{KnowledgePoints}}(U,\mathit{p},{\mathit{p}}_i)$$

(3)

where the knowledge point vector ${\mathit{kp}}_i=[{\mathit{kp}}_{i,1},{\mathit{kp}}_{i,2},\dots ,{\mathit{kp}}_{i,n_i}]$, ${\mathit{kp}}_{i,j}$ is the j-th knowledge point in the i-th chapter ${\mathit{p}}_i$, and $n_i$ is the total number of knowledge points in that chapter.

Definition 4 (Document Generation): Given the learner profile U, the complete learning path $\mathit{p}$, the current chapter ${\mathit{p}}_i$, the knowledge point vector ${\mathit{kp}}_i$, the target knowledge point ${\mathit{kp}}_{i,j}$, and the retrieval-augmented generation documents ${\mathit{RAG}}_{\mathit{docs}}$, the document generation agent ${\mathit{AGENT}}_{\mathit{DocGen}}$ generates the instructional content document ${\mathit{d}}_{i,j}$ for the j-th knowledge point in the i-th chapter, as shown in Equation (4):

$${\mathit{d}}_{i,j}={\mathit{AGENT}}_{\mathit{DocGen}}(U,\mathit{p},{\mathit{p}}_i,{\mathit{kp}}_i,{\mathit{kp}}_{i,j},{\mathit{RAG}}_{\mathit{docs}})$$

(4)

4. PLKD

PLKD consists of two parts: “Granularity Detection” and “Content Generation,” as shown in Figure 1.

4.1. Granularity Detection

Inspired by Zadeh’s concept of fuzzy information granulation [16], we define “Knowledge Point Granularity” to quantify the specificity of a knowledge point. The broader the scope covered by a knowledge point, the closer its granularity value is to 1 (e.g., “Engineering,” “Computer Science,” “Artificial Intelligence”); conversely, the more specific the scope, the closer the granularity value is to 0 (e.g., “Inorder Traversal of Binary Trees,” “Definition of Supervised Learning,” “Bitwise AND Operation”).

The Granularity Detection module is used to reconstruct the original knowledge point vector into a fine-grained sequence of knowledge points suitable for the current learner. First, we train a granularity detector based on a self-constructed granularity dataset. Second, we adaptively output the learner’s granularity threshold according to the user’s input information. Then, we use the granularity detector to output the Knowledge Point Granularity value for each original knowledge point. Finally, we recursively perform Knowledge Points Split on those knowledge points in the original vector whose granularity values exceed the threshold. The details are as follows.

4.1.1. Granularity Detector Training

(1) Text Mapping and Feature Input. Given a knowledge point text $kp$, we first map it to a feature vector $\mathit{x}$ using a pre-trained embedding model $\mathit{Embed}(·)$. Let the feature dimension be 4096:

$$\mathit{x}=\mathit{Embed}\left(kp\right)\in {\mathbb{R}}^{4096}$$

(5)

(2) Two-layer MLP Forward Propagation Mechanism. The prediction network gradually compresses the high-dimensional features and maps them to the granularity probability space through a multi-layer structure. The layer-wise transformation is as follows:

$${\mathit{h}}^{\left(1\right)}={\mathit{Dropout}}_{0.4}\left(\mathit{ReLU}({\mathit{W}}^{\left(1\right)}\mathit{x}+{\mathit{b}}^{\left(1\right)})\right)$$

(6)

where the weight matrix is ${\mathit{W}}^{\left(1\right)}\in {\mathbb{R}}^{512\times 4096}$, the bias term is ${\mathit{b}}^{\left(1\right)}\in {\mathbb{R}}^{512}$. ${\mathit{Dropout}}_{0.4}$ is a Dropout layer with a dropout rate of 0.4, and ${\mathit{h}}^{\left(1\right)}\in {\mathbb{R}}^{512}$ is the output feature of the first layer.

$${\mathit{h}}^{\left(2\right)}={\mathit{Dropout}}_{0.2}\left(\mathit{ReLU}({\mathit{W}}^{\left(2\right)}{\mathit{h}}^{\left(1\right)}+{\mathit{b}}^{\left(2\right)})\right)$$

(7)

where ${\mathit{W}}^{\left(2\right)}\in {\mathbb{R}}^{128\times 512}$, ${\mathit{b}}^{\left(2\right)}\in {\mathbb{R}}^{128}$.

At the output layer, a linear transformation followed by the Sigmoid activation function $\sigma (·)$ maps ${\mathit{h}}^{\left(2\right)}$ to a real value in the interval $[0,1]$:

$$\widehat{y}=\sigma ({\mathit{W}}^{\left(3\right)}{\mathit{h}}^{\left(2\right)}+{\mathit{b}}^{\left(3\right)})$$

(8)

where ${\mathit{W}}^{\left(3\right)}\in {\mathbb{R}}^{1\times 128}$, ${\mathit{b}}^{\left(3\right)}\in \mathbb{R}$, ${\mathit{h}}^{\left(2\right)}\in {\mathbb{R}}^{128}$.

(3) Loss Function and Objective Optimization. We use mean squared error (MSE) as the loss function and sample on the self-constructed granularity dataset. For a given batch of samples $\mathcal{BS}={\left\{(k{p}_i,y_i)\right\}}_{i=1}^B$ (with a default batch size $B=16$), the MSE is calculated according to Equation (9):

$${\mathcal{L}}_{\mathit{MSE}}={\displaystyle \frac{1}{B}}{\displaystyle \sum _{i=1}^B}{(y_i-{\widehat{y}}_i)}^2$$

(9)

To improve generalization ability, we introduce $L_2$ regularization. The final loss function $\mathcal{L}\left(\theta \right)$ is as follows:

$$\mathcal{L}\left(\theta \right)={\mathcal{L}}_{\mathit{MSE}}+{\displaystyle \frac{\lambda }{2}}{\displaystyle \sum _{l=1}^3}{\parallel {\mathit{W}}^{\left(l\right)}\parallel }_F^2$$

(10)

where the parameter set $\theta$ includes all weight matrices and biases in the network, $\lambda ={10}^{-4}$ controls the strength of weight decay, and ${\parallel ·\parallel }_F$ denotes the Frobenius norm.

4.1.2. Granularity Detection and Split

(1) Adaptive Granularity Threshold Prediction. Based on the learner’s input learning preference $pref$ and initial knowledge state $state$, we use the adaptive granularity threshold prediction agent ${\mathit{AGENT}}_{\mathit{GranThresh}}$ to generate the initial granularity threshold $T_{\mathit{raw}}$, as shown in Equation (11):

$$T_{\mathit{raw}}={\mathit{AGENT}}_{\mathit{GranThresh}}(pref,state)$$

(11)

To prevent threshold divergence, we use a truncation function to constrain the final threshold T within the range $[T_{\mathit{min}},T_{\mathit{max}}]$:

$$T=max\left(T_{\mathit{min}},min(T_{\mathit{raw}},T_{\mathit{max}})\right)$$

(12)

(2) Recursive Knowledge Points Split. For any knowledge point $kp$, we use the trained granularity detector (comprising the embedding model $\mathit{Embed}(·)$ and the regression network $\mathit{MLP}(·)$) to determine its granularity score S:

$$S=\mathit{MLP}\left(\mathit{Embed}\right(kp\left)\right)\in [0,1]$$

(13)

Let the current depth be d, and the maximum allowed split depth be $d_{\mathit{max}}$. If the current granularity is greater than the granularity threshold T and the maximum depth $d_{\mathit{max}}$ has not been reached, the Knowledge Points Split agent ${\mathit{AGENT}}_{\mathit{KnowledgeSplit}}$ is used to split the high-granularity knowledge point into a set of more detailed knowledge points, denoted as $k{p}_{\mathit{sub}}$:

$$k{p}_{\mathit{sub}}=\left\{\begin{array}{cc}{\mathit{AGENT}}_{\mathit{KnowledgeSplit}}\left(kp\right),\hfill & \mathrm{if}S>T\wedge d<d_{\mathit{max}}\hfill \\ \left\{kp\right\},\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(14)

(3) Peer Boundary Overlap Detection. For the set of child knowledge points $k{p}_{\mathit{sub}}=\{k{p}_1,k{p}_2,\dots ,k{p}_q\}$ obtained from splitting the same parent node, we take any two child knowledge points $k{p}_i$ and $k{p}_j$ and their respective boundary description keyword sets $V_i$ and $V_j$. We adopt a heuristic overlap coefficient measurement mechanism:

$$O(k{p}_i,k{p}_j)={\displaystyle \frac{|V_i\cap V_j|}{min\left(\right|V_i|,|V_j\left|\right)}}$$

(15)

When the overlap coefficient exceeds the preset safe overlap threshold ${\tau }_{\mathit{overlap}}$ (default ${\tau }_{\mathit{overlap}}=0.75$), it is determined as a significant content overlap conflict, indicating that the two knowledge points $k{p}_i$ and $k{p}_j$ have a large amount of overlapping content. If any pair of content-overlapping nodes exists among the child nodes split from a parent node, the parent node’s split process will be re-executed until the maximum allowed number of splits is reached.

(4) Peer Knowledge Point Sorting. After the split and Peer Boundary Validation, we use the sorting agent ${\mathit{AGENT}}_{\mathit{Sort}}$ to sort all knowledge points in the child knowledge point set $k{p}_{\mathit{sub}}$:

$$k{p}_{\mathit{sub}}^{*}={\mathit{AGENT}}_{\mathit{Sort}}(k{p}_{\mathit{sub}},kp)$$

(16)

where $kp$ is the parent knowledge point before the split.

4.2. Content Generation

The Content Generation module is designed to transform the reconstructed fine-grained knowledge point sequence into a coherent and non-redundant personalized learning document along with corresponding quizzes. First, during the content generation for the first knowledge point, we apply the Rare Constraint to ensure that beginners can smoothly transition and master fundamental concepts. Next, when generating the document content for the current knowledge point, we integrate the information from preceding knowledge points to maintain the coherence of the subsequent content. Finally, in the content generation for subsequent knowledge points, we introduce Redundancy Constraint and Hard Prerequisite Constraint, precisely eliminating overlapping content by leveraging the preceding context. The details are as follows.

4.2.1. Rare Constraint for the First Knowledge Point

Since ${kp}_1$ is the entry point for beginners into this domain, if the document $d_1$ contains prerequisite concepts that the user has not yet learned, it may lead to learning interruption. Therefore, we specifically introduce the Rare Constraint detection and rewriting mechanism for $d_1$.

Let ${\mathit{AGENT}}_{\mathit{RcDet}}$ be the rare knowledge detection agent, which compares the content of the first knowledge point document $d_1$ with the learner profile U and outputs the set of rare content $Rc$:

$$Rc={\mathit{AGENT}}_{\mathit{RcDet}}(d_1,U)$$

(17)

If a rare constraint violation is detected (i.e., $Rc\ne ⌀$), the rare content is rewritten by the rare knowledge rewriting agent ${\mathit{AGENT}}_{\mathit{RcRewrite}}$:

$$d_1=\left\{\begin{array}{cc}{d}_1,\hfill & Rc=⌀\hfill \\ {\mathit{AGENT}}_{\mathit{RcRewrite}}(d_1,Rc,U),\hfill & Rc\ne ⌀\hfill \end{array}\right.$$

(18)

The process described in Equation (17) and (18) is executed iteratively until $Rc=⌀$ or the maximum number of iterations is reached.

4.2.2. Prerequisite Knowledge Points Window Mechanism

To ensure that the generation model fully “builds upon” the prerequisite knowledge points when generating the content for the n-th knowledge points, we construct a dynamic Prerequisite Knowledge Points Window $W_n$. Considering the model’s context length limitation and attention dispersion issues, we adopt a heuristic truncation strategy: only the full text of the most recent preceding nodes (for local deduplication and smooth transition) is retained, while more distant nodes are kept as summaries.

Let the sequence of previously generated document contents be $d_{<n}=\{d_1,d_2,\dots ,d_{n-1}\}$. The size of the neighboring window that retains the full text is w (default $w=6$), and the summarization function is $\mathit{Summarize}(·)$. Then, the Prerequisite Knowledge Points Window $W_n$ at the n-th step can be expressed as:

$$W_n=\left\{\begin{array}{cc}\mathit{concat}(d_1,\dots ,d_{n-1}),\hfill & n\le w\hfill \\ \mathit{concat}\left(\mathit{Summarize}\left(d_1\right),\dots ,\mathit{Summarize}\left(d_{n-w-1}\right),d_{n-w},\dots ,d_{n-1}\right),\hfill & n>w\hfill \end{array}\right.$$

(19)

where $\mathit{concat}(·)$ is the concatenation function. The document generation agent ${\mathit{AGENT}}_{\mathit{DocGen}}$, based on the original input information in Equation (4), further incorporates the Prerequisite Knowledge Points Window $W_n$ for content retrieval and generation:

$${\mathit{d}}_n={\mathit{AGENT}}_{\mathit{DocGen}}(U,\mathit{p},{\mathit{p}}_i,{\mathit{kp}}_i,{\mathit{kp}}_{i,n},{\mathit{RAG}}_{\mathit{docs}},W_n)$$

(20)

4.2.3. Redundancy Constraint for Subsequent Knowledge Points

For subsequent knowledge points with $n>1$, redundancy with previous content is likely to occur, such as repeatedly explaining the same concept. In addition to enabling the model to perceive the Prerequisite Knowledge Points Window $W_n$, an additional constraint mechanism is introduced for subsequent knowledge points.

Let the redundancy detection agent be ${\mathit{AGENT}}_{\mathit{RedunDet}}$, which compares the current draft $d_n$ with the Prerequisite Knowledge Points Window $W_n$ and outputs the set of redundancy issues ${Re}_n$:

$${Re}_n={\mathit{AGENT}}_{\mathit{RedunDet}}(d_n,W_n,U)$$

(21)

If redundancy issues are detected (i.e., ${Re}_n\ne ⌀$), the redundant content is rewritten by the redundancy rewriting agent ${\mathit{AGENT}}_{\mathit{RedunRewrite}}$:

$$d_n=\left\{\begin{array}{cc}{d}_n,\hfill & {Re}_n=⌀\hfill \\ {\mathit{AGENT}}_{\mathit{RedunRewrite}}(d_n,W_n,U,{Re}_n),\hfill & {Re}_n\ne ⌀\hfill \end{array}\right.$$

(22)

The process described in Equation (21) and (22) is executed iteratively until ${Re}_n=⌀$ or the maximum number of iterations is reached.

4.2.4. Hard Prerequisite Constraint

In addition to redundancy content detection, we also introduce the Hard Prerequisite Constraint for subsequent knowledge points, which ensures the smooth transition of knowledge points in the document content. If the document for a subsequent knowledge point contains content not covered by the preceding documents and not yet mastered by the learner, the Hard Prerequisite Constraint rewriter is invoked to rewrite that part of the content.

Let the hard prerequisite constraint agent be ${\mathit{AGENT}}_{\mathit{HPCDet}}$, which compares the current draft $d_n$ with the Prerequisite Knowledge Points Window $W_n$ and outputs the set of prerequisite issues ${HPC}_n$:

$${HPC}_n={\mathit{AGENT}}_{\mathit{HPCDet}}(d_n,W_n,U)$$

(23)

If prerequisite issues are detected (i.e., ${HPC}_n\ne ⌀$), the prerequisite issue content is rewritten by the hard prerequisite constraint rewriting agent ${\mathit{AGENT}}_{\mathit{HPCRewrite}}$:

$$d_n=\left\{\begin{array}{cc}{d}_n,\hfill & {HPC}_n=⌀\hfill \\ {\mathit{AGENT}}_{\mathit{HPCRewrite}}(d_n,W_n,U,{HPC}_n),\hfill & {HPC}_n\ne ⌀\hfill \end{array}\right.$$

(24)

The process described in Equation (23) and (24) is executed iteratively until ${HPC}_n=⌀$ or the maximum number of iterations is reached.

4.3. Algorithm Description

The complete process of PLKD is shown in Algorithm 1.

Algorithm 1 PLKD

Require:  Learning goal $goal$, learning preference $pref$, initial knowledge state $state$ Ensure:  Personalized learning document sequence $\mathcal{D}$ 1: Generate the learner profile U according to Equation (1). 2: Generate the learning path $\mathit{p}$ according to Equation (2). 3: for each chapter ${\mathit{p}}_i$ in the learning path do 4:     Generate the chapter knowledge point vector ${\mathit{kp}}_i$ according to Equation (3). 5: end for 6: Obtain the learner’s initial granularity threshold $T_{\mathit{raw}}$ according to Equation (11), and truncate it to the preset range according to Equation (12) to get the final granularity threshold T. 7: for each original knowledge point $kp$ do 8:     Calculate its granularity score S according to Equation (13). 9:     if $S>T$ and the current recursion depth $<d_{\mathit{max}}$ then 10:         Perform Knowledge Points Split according to Equation (14). 11:     else 12:         Keep the original knowledge point unchanged. 13:     end if 14: end for 15: for the set of peer knowledge points obtained from the split do 16:     Calculate the boundary overlap between any two knowledge points according to Equation (15). 17:     if there exist knowledge points with significant overlap then 18:         Perform Knowledge Points Split again until the overlap constraint is satisfied or the maximum number of splits is reached. 19:     end if 20: end for 21: After passing Peer Boundary Validation, sort the peer knowledge points according to Equation (16) to obtain the final fine-grained knowledge point sequence. 22: for the first knowledge point do 23:     Perform Rare Constraint detection: identify $Rc$ according to Equation (17). 24:     if $Rc\ne ⌀$ then 25:         Rewrite the document according to Equation (18), repeat until $Rc=⌀$ or the maximum number of rewrites is reached. 26:     end if 27: end for 28: for$n=1$ to N do 29:     Construct the Prerequisite Knowledge Points Window $W_n$ according to Equation (19). 30:     Generate the draft document $d_n$ according to Equation (20). 31:     if $n>1$ then 32:         Obtain ${Re}_n$ according to Equation (21). 33:         if ${Re}_n\ne ⌀$ then 34:            Rewrite redundant content according to Equation (22), repeat until ${Re}_n=⌀$ or max rewrites reached. 35:         end if 36:         if redundancy constraint satisfied but prerequisite issues remain then 37:            Obtain ${HPC}_n$ according to Equation (23). 38:            if ${HPC}_n\ne ⌀$ then 39:                Rewrite prerequisite content according to Equation (24), repeat until ${HPC}_n=⌀$ or max rewrites reached. 40:            end if 41:         end if 42:     end if 43:     Add $d_n$ to output document sequence $\mathcal{D}$. 44: end for 45: return$\mathcal{D}$

5. Experiments

Specific content awaiting subsequent refinement.

6. Conclusions

Specific content awaiting subsequent refinement.