Intelligent programming auxiliary method and system combining large model and knowledge graph

Abstract

The invention discloses an intelligent programming assistance method and system combining a large model and a knowledge graph. The method comprises the steps that the system is initialized, and a programming domain knowledge graph body and an education programming large language model are loaded; constructing a learner initial portrait and associating the learner initial portrait with a knowledge graph; personalized programming learning experience is provided, including real-time programming tutoring, and thinking chain-based heuristic guidance is generated through combination of a large language model and knowledge graph information; and interactive feedback and system iteration are carried out, and a reinforcement learning mechanism based on human feedback is utilized to continuously optimize the large language model. Through deep fusion of structured knowledge of a knowledge graph and understanding generation ability of a large language model, the method aims at solving the problems that an existing programming auxiliary tool is insufficient in individuation and heuristic, heterogeneous knowledge is difficult to fuse, teaching resource modes are single, and an effective evolution mechanism is lacked. More accurate, personalized, heuristic and sustainable-evolution intelligent programming assistance can be provided, and the programming thinking and autonomous learning ability of learners can be effectively improved.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to a method and system for assisting programming learning using large language models and knowledge graph technology. Background Technology

[0002] With the rapid development of information technology, programming skills have become an indispensable core skill in all walks of life, and the importance of programming education is becoming increasingly prominent. However, traditional programming teaching models and existing programming aids still face many challenges in meeting the needs of large-scale, personalized, and in-depth learning.

[0003] Existing programming aids, such as code completion, syntax highlighting, and static error suggestions commonly found in integrated development environments (IDEs), primarily rely on preset rules, lexical analysis, or local contextual understanding. While these tools improve coding efficiency to some extent, they struggle to understand learners' true intentions, deep logical errors, or knowledge gaps. Consequently, their guidance often simply provides corrective solutions or API hints, rather than inspiring learners to think critically and solve problems independently. This superficial interaction fails to effectively cultivate learners' programming thinking and independent problem-solving abilities.

[0004] On the other hand, the internet contains a vast amount of programming learning resources, such as tutorials, code examples, and technical documentation. However, these resources are often fragmented and unstructured. Learners struggle to efficiently retrieve, filter, integrate, and internalize this information, easily leading to information overload and reduced learning efficiency. Knowledge graph (KG) technology can organize discrete knowledge points into a graph structure, revealing their inherent connections and providing an effective approach for structured knowledge representation and accurate knowledge reasoning. However, traditional knowledge graphs have limited capabilities in processing large-scale unstructured text, performing complex natural language understanding, and generating flexible content.

[0005] In recent years, artificial intelligence technologies, represented by Large Language Models (LLMs), have made groundbreaking progress. With their powerful capabilities in natural language understanding, text generation, code generation and interpretation, and even multimodal content transformation, LLMs have brought new possibilities to the field of programming assistance. LLMs can understand complex natural language queries and generate high-quality code snippets, explanations, and documentation. However, LLMs still suffer from an "illusion" phenomenon in terms of accuracy in handling factual and structured knowledge. The coherence and logic of their generation often heavily rely on contextual prompts from the input, lacking a systematic grasp and precise reasoning ability regarding domain-specific knowledge (such as the complete grammatical system and conceptual dependencies of programming languages).

[0006] Therefore, how to deeply integrate the precise and structured domain knowledge and individual learner knowledge states carried by knowledge graphs with the powerful contextual understanding, generalization, and generation capabilities of large language models to overcome the limitations of single technologies, break down information barriers between them, and achieve truly intelligent, personalized, and heuristic programming guidance is a key technical problem that urgently needs to be solved. Especially in scenarios requiring dynamic adjustment of knowledge paths based on user needs, provision of personalized explanations, and transformation of abstract code logic into intuitive multimodal expressions such as flowcharts, existing technical solutions often fall short. Furthermore, how to build an intelligent assistance system that can continuously learn from real-world teaching interactions, constantly optimize its performance, and adapt to new knowledge and needs is also a significant technical challenge for achieving long-term effective intelligent programming assistance. Summary of the Invention

[0007] The main objective of this invention is to provide a programming intelligent assistance method and system that combines large models and knowledge graphs, aiming to solve the problems of shallow interaction with insufficient personalization and inspiration in existing programming assistance technologies, information silos caused by difficulties in integrating heterogeneous knowledge, the inability of static single-modal teaching resources to meet complex cognitive needs, and the lack of effective evolutionary mechanisms.

[0008] To achieve the above objectives, this invention provides a programming intelligent assistance method that combines a large language model and a knowledge graph, comprising the following steps: S1: Initialize the system, loading the pre-built programming domain knowledge graph ontology and the pre-trained educational programming language model. The programming domain knowledge graph ontology defines the core concepts, attributes, relationships, and constraints of the programming domain. The educational programming language model is a large-scale language model fine-tuned from programming education-related corpora.

[0009] S2: Learner Registration and Profile Building. When learners use the system for the first time, they are guided to complete basic information entry (such as learning background and programming experience) and initial ability assessment (such as assessing their mastery of basic concepts through test questions). The system collects preliminary learner data and uses user programming knowledge graph building units to create an initial learner profile for each learner, recording their current knowledge status and establishing connections between it and relevant knowledge points in the programming domain knowledge graph.

[0010] S3: Provide a personalized programming learning experience. This step is the core of the invention, aiming to provide learners with comprehensive, adaptive intelligent assistance, and may specifically include one or more of the following sub-steps: S3.1: Learning Path Recommendation. The personalized learning path planning module of the Personalized Learning Content Generation and Intelligent Guidance Unit dynamically generates and recommends one or more personalized learning paths for learners based on their profiles (such as current knowledge level, learning goals, and cognitive preferences) and dynamic knowledge tracking results (such as the degree of mastery of learned knowledge points), combined with the dependencies between knowledge points in the programming domain knowledge graph, and using path planning algorithms (such as improved ant colony optimization algorithms or reinforcement learning-based path optimization algorithms).

[0011] S3.2: Adaptive Content Learning. Learners can follow the system-recommended learning path or choose knowledge nodes that interest them. The system invokes the adaptive programming problem generation module, which, based on the current knowledge node on the learning path and the learner's ability level, drives the educational programming language model to generate programming practice problems of appropriate difficulty and relevant content. Problems can include descriptions, input / output examples, and constraints.

[0012] S3.3: Real-time Programming Tutoring. During learners' solutions to programming problems or free programming practice, the real-time heuristic programming guidance module analyzes the code snippets submitted by learners in real time. When potential syntax errors, logical flaws, or inefficient implementations are detected, this module combines the contextual information of the code with the learner's weaknesses in that knowledge point obtained from the user's programming knowledge graph, and uses the educational programming language model to generate heuristic guidance suggestions based on the Chain of Thought (CoT). This guidance does not directly provide answers or corrected code, but rather inspires learners to think independently, discover the root causes of problems, and proactively improve their code through a series of guiding questions or analytical steps.

[0013] S3.4: Multimodal Aid to Comprehension. When learners encounter complex code logic that is difficult to understand during the learning process (such as recursion, complex algorithm flow), they can actively request or the system can intelligently trigger the cross-modal teaching content generation module based on the context. This module can transform abstract code logic into other more intuitive modal representations, such as automatically generating corresponding program flowcharts, data structure visualizations, or code execution animations for code segments, thereby reducing the learner's cognitive load and improving comprehension efficiency.

[0014] S4: Interactive Feedback and System Iteration. The User Interaction and Feedback Management Unit is responsible for collecting learners' behavioral data throughout the learning process (such as answer records, code submission history, learning duration, and interaction logs with the system), explicit evaluations of system-generated content (such as questions, guidance suggestions, and flowcharts) (such as ratings and comments), and feedback from teachers or administrators on teaching content and system behavior. This multi-dimensional feedback data, especially high-quality human feedback, will serve as the core input for a Human Feedback-Based Reinforcement Learning (RLHF) mechanism, continuously iterating and optimizing the educational programming language model to ensure that the generated teaching content and guidance strategies better align with teaching objectives and human preferences. Simultaneously, the User Programming Knowledge Graph Construction Unit dynamically updates learners' knowledge status and learner profiles based on their learning progress and knowledge tracking results, ensuring the continuous accuracy of personalized services.

[0015] Preferably, the specific process in S3.3 for generating heuristic guidance suggestions based on thought chains using the educational programming language model is as follows: Input Acquisition: Retrieve the learner's currently submitted code snippet C_current, and the error message E detected by the system (such as a static analysis tool or unit testing framework) (e.g., TypeError: filter object is not subscriptable). Simultaneously, retrieve the current user's programming knowledge graph KG_user and domain knowledge graph KG_domain.

[0016] Error entity identification: Parse the error message E to locate the key code entity Entity_error that caused the error. For example, for the TypeError mentioned above, the key entity is the filter function call.

[0017] Knowledge Graph Query and Information Augmentation: Query the domain knowledge graph KG_domain to retrieve attributes related to Entity_error. For example, query the return type of the filter function to find that it is an iterator.

[0018] Query the domain knowledge graph KG_domain to obtain common operations or transformation methods related to iterator, such as the list() and tuple() constructors, or traverse them using a for loop.

[0019] Query the user knowledge graph KG_user to obtain learner A's level of mastery of the iterator concept and related concepts of type conversion (such as type_conversion) (e.g., displayed as weak).

[0020] Prompt Engineering: The collected structured information (code snippet C_current, error E, filter returning an iterator, common iterator operations, learners' weak grasp of iterators and type conversion) is integrated into a rich context and injected into the prompt given to the large language model. This prompt instructs the large language model to act as a "Socratic tutor," generating step-by-step thought chain (CoT)-style heuristic guidance based on the provided context.

[0021] For example, a hint could guide an LLM student to think: "(1) The student used filter and lambda, which is the right direction. (2) filter returns an iterator, not a list, which is the direct cause of the error. (3) Iterators need to be converted or traversed to get the elements. (4) What built-in functions or methods in Python can convert an iterator to a list? Or how do you traverse an iterator?" LLM generation guidance: The large language model generates heuristic guidance based on a carefully designed prompt, such as: "(1) You used the filter function and lambda expression to filter even numbers, which is the right direction. (2) The filter function returns an 'iterator,' which is an object to be iterated over, not a list. Think about it, (3) Is there a built-in function in Python that can directly convert an iterator into the list we need?" Preferably, the core of S4's continuous learning and optimization of the educational programming large language model using a human feedback-based reinforcement learning (RLHF) mechanism lies in the design of the Reward Model (RM). The input to this RM is the large language model in response to specific prompts (such as student codes and error messages). The generated guidance text is output as a comprehensive reward score r. This score is composed of multiple weighted sub-items, as shown in the following formula: r = w1 * r_effectiveness + w2 * r_pedagogy + w3 * r_conciseness - w4* c_abandonment in: r_effectiveness (effectiveness reward): Measures whether a student successfully solved the problem within a limited number of attempts (e.g., within 3 code commits) after receiving guidance. It is calculated by analyzing subsequent code commit logs; a solution is rewarded positively, while failure is rewarded negatively or zero.

[0022] r_pedagogy (Teaching Methodology Reward): Measures the inspirational nature of the guidance and whether it avoids directly providing answers. This reward is primarily derived from the ranking or rating data of different guidance methods by teachers or high-level users. Higher-ranked (i.e., more inspirational) guidance receives a higher reward.

[0023] r_conciseness (conciseness reward): Rewards concise and clear guidance text that gets straight to the point, and penalizes lengthy, verbose text with low information content. It can be initially assessed using metrics such as text length and information entropy, and then calibrated using human evaluation.

[0024] c_abandonment (abandonment penalty): If a student does not perform any related actions or explicitly indicates abandonment of the current task within a certain period of time after receiving certain instructions, a significant negative reward is applied.

[0025] w1, w2, w3, and w4 are the weight coefficients of the above sub-items, which are adjusted according to teaching objectives and experience.

[0026] The trained reward model RM is used to score the various guidance texts generated by the large language model during the exploration process. Then, through reinforcement learning algorithms such as Proximal Policy Optimization (PPO), these reward signals are used to continuously optimize the policy network of the large language model, so that the guidance content generated is not only grammatically correct but also logically coherent.

[0027] Preferably, the specific process of converting complex code logic into a graphical flowchart in S3.4 is as follows: Input Acquisition: Receives Python function code (Code_python) from user requests and converts them.

[0028] Code parsing into an Abstract Syntax Tree (AST): Using Python's built-in ast library, the input Code_python is parsed into its corresponding Abstract Syntax Tree (AST_tree). The AST_tree structurally represents the syntactic structure of the code.

[0029] AST Traversal and Semantic Mapping: Design a custom AST traverser (e.g., inheriting from ast.NodeVisitor). This traverser accesses each important node in the AST_tree (such as ast.If, ast.For, ast.While, ast.Assign, ast.Return, ast.FunctionDef, etc.) and maps these AST node types and their contents (such as conditional statements, loop variables, assignment expressions, function names, etc.) to a descriptive language of basic flowchart elements (such as diamond decision boxes, loop boxes, rectangular processing boxes, parallelogram input / output boxes, rounded rectangle start / end boxes, etc.).

[0030] For example, the `ast.If` node is mapped as follows: "Creates a diamond-shaped conditional box with the content '[text of the conditional expression]'. If true, it connects to the next element on the 'Yes' path; if false, it connects to the next element on the 'No' path." The `ast.Assign` node is mapped as follows: "Create a rectangular processing box with the content '[text of the assignment operation, such as variable = expression]'. The ast.Return node is mapped as follows: "Create a parallelogram output box with the content 'Return [text of return value expression]'. The flowchart text description prompt, generated by the AST traverser after traversing the entire AST tree, outputs a structured natural language text that details the layout, connections, and internal text content of each element in the flowchart. This text will serve as the input prompt for subsequent text-to-image generation models.

[0031] Text-to-image generation and filtering: Input the flowchart text description Prompt generated in the previous step into a pre-trained text-to-image generation model (e.g., a Diffusion Model-based model such as Stable Diffusion, or a GAN-based model).

[0032] The model generates one or more candidate flowchart images based on the Prompt.

[0033] A pre-trained CLIP (Contrastive Language-Image Pre-Training) model is used to filter the generated candidate images. The CLIP model evaluates the semantic consistency (similarity score) between the image and the original text description Prompt. The image with the highest similarity score is selected as the final output flowchart.

[0034] On the other hand, the present invention also provides a programming intelligent assistance system that combines a large language model and a knowledge graph, which is used to implement the above-mentioned method. The system includes: The User Programming Knowledge Graph Construction Unit is responsible for building and dynamically maintaining a user programming knowledge graph that covers knowledge across the programming domain (such as programming language concepts, syntax rules, library functions, and algorithmic ideas) as well as the individual learning status of learners (such as mastered knowledge points, weaknesses, learning preferences, and learning history). This unit can be further subdivided into: Domain Knowledge Ontology Definition Module: Defines the core concepts, attributes, relationships, and constraints of the programming domain, forming the schema layer of the knowledge graph.

[0035] Knowledge Acquisition and Fusion Module: Automatically extracts programming-related entities and relation triples from various sources (such as online tutorials, code repositories, academic literature, API documentation, user interaction data, etc.), and performs cleaning, alignment, disambiguation, and fusion to build a basic domain knowledge graph.

[0036] Learner profile modeling module: Collects and analyzes learners' basic information, learning behavior data (such as answer records, code submission history, and learning duration), cognitive preferences (such as preference for example-driven learning or theory-driven learning), and ability assessment results to build a refined and dynamically updated learner profile.

[0037] Dynamic Knowledge Tracking Module: Employs deep learning models (e.g., deep knowledge tracking DKT models based on recurrent neural networks (RNN), long short-term memory networks (LSTM), or Transformers) to track learners' mastery of each knowledge point in real time based on their interaction sequences, and updates the learner profile and the corresponding status in the knowledge graph.

[0038] The Educational Programming Large Language Model Unit is the system's intelligent core, used to understand programming-related natural language instructions and the intent of student-submitted code, and to generate personalized teaching content, programming problems, and guidance suggestions. This unit can be further subdivided into: Domain-specific corpus construction and preprocessing module: Responsible for collecting and processing large-scale programming education-related text data (such as programming textbooks, blog posts, forum Q&A), code data (such as open-source code snippets, student assignments), and human-computer interaction data (such as teacher-student dialogues, student-system interaction logs), to build a high-quality corpus specifically for the programming education field.

[0039] Model Training and Fine-Tuning Module: A suitable pre-trained large language model (such as the GPT series, LLaMA series, etc.) is selected as the base model. Supervised Fine-Tuning (SFT) is performed using the domain corpus constructed in the previous step to enable the model to initially possess programming teaching capabilities. Furthermore, a reinforcement learning mechanism based on human feedback (RLHF) is employed to continuously optimize the model using real user interaction data and expert feedback, making its output more aligned with teaching objectives (such as inspiration, effectiveness, and safety) and human preferences.

[0040] Personalized Learning Content Generation and Intelligent Guidance Unit: This unit is closely coupled with the User Programming Knowledge Graph Construction Unit and the Educational Programming Large Language Model Unit, responsible for providing learners with customized learning resources and real-time interactive tutoring. This unit can be further subdivided into: On the other hand, the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method described above.

[0041] Compared with the prior art, the present invention has the following beneficial effects: Significantly enhances personalized teaching: By deeply integrating a refined user programming knowledge graph (including learner profiles and dynamic knowledge tracking) and a powerful educational programming language model, it can provide each learner with comprehensive and highly personalized teaching services, from learning path planning and content delivery to real-time tutoring, accurately meeting individual learning needs.

[0042] Effectively enhances the inspiration and depth of learning guidance: The real-time guidance mechanism based on the Chain of Thought (CoT) guides learners to actively think, discover problems, and explore solutions, effectively cultivating their programming thinking, logical analysis skills, and self-learning abilities, rather than simply providing answers. Combined with knowledge graphs to perceive learners' weaknesses, guidance becomes more targeted.

[0043] Enriching the presentation and comprehensibility of teaching resources: Through the intelligent generation of cross-modal content such as code to flowcharts, complex programming concepts and logic can be presented in a more intuitive and diverse way, reducing learners' cognitive load and improving learning efficiency and depth of understanding.

[0044] Achieving continuous evolution of the teaching system's capabilities: By introducing a reinforcement learning (RLHF) mechanism based on human feedback, the system can learn from real user interactions and evaluations, continuously optimizing the teaching dialogue capabilities and content generation quality of the large language model, thereby enabling the teaching support effect to continuously improve and self-perfect.

[0045] Promote the effective use and innovation of teaching resources: The system can intelligently generate a large number of high-quality and diverse programming problems and teaching content (such as dynamically generated flowcharts), alleviating the reliance on manually compiled teaching resources and providing strong technical support for teaching innovation.

[0046] Effectively integrate heterogeneous knowledge and overcome the limitations of single technologies: Deeply integrate the structured reasoning capabilities of knowledge graphs with the generative intelligence of large language models. Knowledge graphs provide factual evidence and logical constraints for LLM, reducing "illusions," while LLM endows knowledge graphs with stronger expressive and interactive capabilities, thereby providing more reliable and intelligent assistance. Attached Figure Description

[0047] 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 some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0048] Figure 1 This is a structural block diagram of the intelligent programming assistance system provided in an embodiment of the present invention; Figure 2 This is an exemplary structural diagram of a deep knowledge tracing (DKT) model in an embodiment of the present invention; Figure 3 This is a flowchart illustrating the process of fine-tuning a large language model using reinforcement learning (RLHF) based on human feedback in an embodiment of the present invention. Figure 4 A flowchart illustrating the programming intelligent assistance method provided in this embodiment of the invention; Figure 5 This is a schematic diagram of the heuristic guidance generation process of knowledge graph (KG) perception-based CoT in an embodiment of the present invention; Figure 6 This is a schematic diagram of the flowchart generation process from an Abstract Syntax Tree (AST) to a text description in an embodiment of the present invention. Detailed Implementation

[0049] The technical solution of the present invention will be clearly and completely described below with reference to the embodiments. 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 of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0050] Reference Figure 1The present invention provides a structural block diagram of an intelligent programming assistance system 100. The system 100 includes: a user programming knowledge graph construction unit, an educational programming large language model unit, a personalized learning content generation and intelligent guidance unit, and a user interaction and feedback management unit.

[0051] The User Programming Knowledge Graph Construction Unit is responsible for building and dynamically maintaining a user programming knowledge graph that covers programming domain knowledge and the individual learning status of learners.

[0052] This unit can be further subdivided into: Domain Knowledge Ontology Definition Module: Defines the core concepts, attributes, relationships, and constraints of the programming domain, forming the schema layer of the knowledge graph.

[0053] Knowledge Acquisition and Fusion Module: Automatically extracts programming-related entities and relation triples from various sources (such as online tutorials, code repositories, academic literature, API documentation, user interaction data, etc.), and performs cleaning, alignment, disambiguation, and fusion to build a basic domain knowledge graph.

[0054] Learner profile modeling module: Collects and analyzes learners' basic information, learning behavior data (such as answer records, code submission history, and learning duration), cognitive preferences (such as preference for example-driven learning or theory-driven learning), and ability assessment results to build a refined and dynamically updated learner profile.

[0055] Dynamic Knowledge Tracking Module: Employs deep learning models (e.g., deep knowledge tracking DKT models based on recurrent neural networks (RNN), long short-term memory networks (LSTM), or Transformers) to track learners' mastery of each knowledge point in real time based on their interaction sequences, and updates the learner profile and the corresponding status in the knowledge graph.

[0056] Domain Knowledge Graph Construction: In the domain knowledge ontology definition module, taking the Python language as an example, "Python language" can be defined as a core concept, with attributes including "version" and "major features"; its relationships include "is-a programming language" and "has-syntax loop statement". The knowledge acquisition and fusion module automatically extracts entities and relationships such as functions (e.g., print), parameters, and return values ​​from GitHub code repositories, and aligns and links them with concept explanations in online tutorials (e.g., W3Schools, MDN Web Docs) (e.g., "loop statements are used to repeatedly execute code blocks") to construct a comprehensive and accurate domain knowledge graph.

[0057] Learner Profile Modeling: When learner A registers, the system conducts an initial ability assessment to record their mastery of the "Python loop statement" knowledge point (e.g., an initial mastery level of 0.8 assessed using a deep knowledge tracing model). Simultaneously, the system analyzes learner A's interactions with the system, recording their preferred learning style (e.g., preference for "example-driven" learning) and recent learning goals (e.g., "mastering list comprehensions"), forming a dynamically updated and refined learner profile. This profile is linked to the domain knowledge graph, constituting a complete user programming knowledge graph.

[0058] like Figure 2 The Deep Knowledge Tracking (DKT) model shown takes learner interaction sequences (such as skill_t, correct_t) as input, performs data preprocessing and feature engineering, and outputs the learner's mastery probability y_t for each knowledge point through model structures such as RNN / LSTM / Transformer. This output is then used to update the user programming knowledge graph (KG) and learner profile.

[0059] For example, refer to Figure 2 The operation process of the Deep Knowledge Tracking (DKT) model mainly includes learner interactive data input, data preprocessing and feature engineering, DKT model processing, and outputting the knowledge point mastery probability and updating the user profile / knowledge graph.

[0060] 1. Learner interaction data input (Input: (skill_t, correct_t) sequence) Data source: The system's "learner interaction data" is the raw input to the DKT model. For example... Figure 2 The data shown in square brackets includes, but is not limited to: Answer Records: Students' answers to practice questions and tests, including question IDs (which can be mapped to specific knowledge points / skills_t) and answer results (correct / incorrect_t). Code Submissions: Code submitted by students in programming tasks, whose correctness or the knowledge points involved can be determined through static analysis or test case execution. Study Duration: The time students spend on specific learning resources or knowledge points, which can serve as a supplementary feature. Error Types, etc.: The specific types of errors students make during programming or answering questions, which can reflect their weaknesses in more detail.

[0061] Core Input Sequence: The core input to the DKT model is typically a time series of interactions between the learner and the system, represented as a sequence of (skill_t, correct_t) pairs. skill_t: A unique identifier representing the knowledge point or skill interacted with by the learner at time step t. correct_t: Represents the learner's performance on the knowledge point skill_t at time step t, usually a binary value (e.g., 1 for correct, 0 for incorrect).

[0062] This sequence X = {x_1, x_2, ..., x_T}, where each x_t = (skill_t, correct_t).

[0063] 2. Data Preprocessing & Feature Engineering Before inputting the raw interaction data into the DKT model, a series of preprocessing and feature engineering steps are required, such as... Figure 2 As shown in the "Data Preprocessing and Feature Engineering" module, its specific operations may include: Encoding: Skill Encoding: Maps each unique skill point (skill_t) to an integer index. If the number of skill points is small, one-hot encoding can be used. For a large number of skill points, a more common approach is to learn a low-dimensional dense vector representation (skill embedding) for each skill point. This can be achieved by adding an embedding layer during model training.

[0064] Interaction Encoding: For x_t = (skill_t, correct_t), if skill_t has K possible knowledge points and correct_t has 2 possibilities (correct / incorrect), then a common encoding method is to combine skill_t and correct_t to form a unique interaction event ID. For example, if the index of skill_t is s, then a correct interaction can be encoded as s, and an incorrect interaction can be encoded as s + K. This results in a total of 2K possible input features. These interaction event IDs can then be converted into vectors through one-hot encoding or an embedding layer.

[0065] Serialization: Organizing learner interaction data into a fixed-length or variable-length sequence in chronological order. For fixed-length sequences, padding or truncation may be required.

[0066] Feature Extraction (etc.): In addition to the core features (skill_t, correct_t), other auxiliary features can be extracted, such as: Time interval features: the time difference between two interactions; Number of attempts features: the number of times a student attempts a particular knowledge point; Historical performance statistics features: for example, the average accuracy rate of a student in the past N interactions. These auxiliary features can be concatenated with the core interaction features before being input into the model.

[0067] 3. Deep Knowledge Tracking Model (DKT) like Figure 2 As shown, the core of the DKT model can employ sequence models such as recurrent neural networks (RNNs), long short-term memory networks (LSTMs), or Transformers. These models excel at capturing temporal dependencies in sequence data.

[0068] Model structure: Input Layer: Receives a vector representation v_t of the interaction sequence obtained through preprocessing and feature engineering (e.g., the embedding vector of the interaction events).

[0069] Recurrent / Attention Layer: RNN / LSTM: At each time step t, the recurrent layer receives the current input v_t and the hidden state h_{t-1} from the previous time step, computes and outputs the current hidden state h_t. h_t = f(v_t, h_{t-1}), where f is the unit function of the RNN or LSTM. This hidden state h_t is considered a vector representation of the learner's knowledge state at time step t, encoding all the learning history up to that point.

[0070] Transformer: The Transformer model uses a self-attention mechanism to directly capture the dependencies between any two positions in a sequence, not just adjacent positions. It can process all elements in the sequence in parallel and generate a context-aware representation for each element. In DKT, the Transformer can learn the complex relationships between different interaction events in an interaction sequence, thus more accurately modeling the evolution of knowledge states.

[0071] Output Layer: At each time step t, the hidden state h_t (or some transformation thereof) output by the recurrent layer or attention layer is passed through a fully connected layer (usually with a sigmoid activation function) to predict the learner's mastery probability of all knowledge points / skills at the next time step. The output is a vector y_t of dimension K (total number of knowledge points), where y_{t,j} represents the learner's mastery probability of the j-th knowledge point after time step t.

[0072] Working principle: The DKT model automatically learns the dependencies between knowledge points and how the knowledge state evolves during the learning process by learning from a large number of student interaction sequences. When a new interaction (skill_t, correct_t) is input, the model updates its internal hidden state, which represents the model's understanding of the learner's current overall knowledge level. Then, based on this updated knowledge state, the model can predict the learner's future mastery of any knowledge point.

[0073] 4. Output the probability of mastering each knowledge point (Output: y_t (probability of mastering each knowledge point)) Prediction Objective: At each time step t, after the learner completes an interaction x_t, the DKT model outputs a probability vector y_t. The j-th element y_{t,j} of y_t represents the probability P(correct_{t+1, j} = 1 | x_1, ..., x_t) that the learner is predicted to correctly answer a question about knowledge point j in the next interaction. This output probability vector is crucial; it can be used to: assess the learner's mastery of specific knowledge points; identify the learner's weaknesses (knowledge points with low mastery probability); and provide a basis for personalized learning path planning (e.g., recommending knowledge points that the learner has not yet mastered or has not mastered firmly).

[0074] 5. Update status and system integration Update user profiles and knowledge graph: like Figure 2As shown in the diagram, the "Output" is connected to the "User-Programmed Knowledge Graph (KG) Learner Profile" and labeled "Update Status." The mastery probability y_t of each knowledge point output by the DKT model is used to dynamically update the knowledge mastery section of the learner profile. For example, these probability values ​​can be directly stored in the learner profile, or the mastery status of knowledge points can be divided into levels such as "not mastered," "basic mastery," and "proficient mastery" based on the probability values. If the knowledge graph stores associations between learners and knowledge points (e.g., representing the learner's level of mastery of a certain knowledge point), then the DKT output will also be used to update the attribute values ​​of these associations.

[0075] Feedback is used for personalized recommendations: The updated learner profiles and knowledge graphs (containing the latest knowledge mastery information) can be used by other modules of the system (such as... Figure 2 It is not directly shown in the text, but it is present in the overall system. Figure 1 The "Personalized Learning Path Planning Module" is used to provide learners with more accurate personalized learning content recommendations, question recommendations, or path planning.

[0076] KG / Profile is fed back to the DKT model: in addition, Figure 2 The dashed arrow pointing from "User-Programmed Knowledge Graph (KG) Learner Profile" to "Deep Knowledge Tracking Model (DKT)" is labeled "Read Historical State (Optional)". This indicates that in some more complex DKT variants, in addition to the interaction sequence itself, the model's initial state or input features may also be influenced by some prior information from the knowledge graph or learner profile. For example, some background information about a student (such as previous learning experiences) can be used as initial feature input, or the dependencies between knowledge points in the knowledge graph can be used to regularize the model's learning process. However, the core DKT model primarily relies on interaction sequences for learning.

[0077] The large language model unit for educational programming is the intelligent core of the system. Its training and optimization process can be referenced... Figure 3The diagram illustrates a Human Feedback-Based Reinforcement Learning (RLHF) process. First, a pre-trained or supervised fine-tuning (SFT) large language model (LM) is used (Step 1). In response to collected prompts, the LM generates multiple outputs (such as guidance suggestions). Then, human annotators rank or rate these outputs (Step 2), and this annotated data is used to train a reward model (RM) (Step 3), which learns human preferences. Finally, using the RM as the reward function, the LM is fine-tuned using reinforcement learning algorithms such as PPO (Step 4) to obtain the final optimized LM policy. The core of using Human Feedback-Based Reinforcement Learning (RLHF) to continuously learn and optimize a large language model for educational programming lies in the design of the reward model (RM). The input to the RM is the guidance text generated by the large language model for specific prompts (such as student codes and error messages), and the output is a comprehensive reward score r. This score consists of multiple weighted sub-items, as shown in the following formula: r = w1 * r_effectiveness + w2 * r_pedagogy + w3 * r_conciseness - w4* c_abandonment in: r_effectiveness (effectiveness reward): Measures whether a student successfully solved the problem within a limited number of attempts (e.g., within 3 code commits) after receiving guidance. It is calculated by analyzing subsequent code commit logs; a solution is rewarded positively, while failure is rewarded negatively or zero.

[0078] r_pedagogy (Teaching Methodology Reward): Measures the inspirational nature of the guidance and whether it avoids directly providing answers. This reward is primarily derived from the ranking or rating data of different guidance methods by teachers or high-level users. Higher-ranked (i.e., more inspirational) guidance receives a higher reward.

[0079] r_conciseness (conciseness reward): Rewards concise and clear guidance text that gets straight to the point, and punishes lengthy, verbose text with low information content. It can be initially assessed using metrics such as text length and information entropy, and then calibrated using human evaluation.

[0080] c_abandonment (abandonment penalty): If a student does not perform any related actions or explicitly indicates abandonment of the current task within a certain period of time after receiving certain instructions, a significant negative reward is applied.

[0081] w1, w2, w3, and w4 are the weight coefficients of the above sub-items, which are adjusted according to teaching objectives and experience.

[0082] The trained reward model RM is used to score the various guidance texts generated by the large language model during the exploration process. Then, through reinforcement learning algorithms such as Proximal Policy Optimization (PPO), these reward signals are used to continuously optimize the policy network of the large language model, so that the guidance content generated is not only grammatically correct but also logically coherent.

[0083] The personalized learning content generation and intelligent guidance unit is coupled with the user programming knowledge graph construction unit and the educational programming large language model unit, providing learners with customized learning resources and real-time tutoring. The user interaction and feedback management unit provides a user interface, supports learner interaction with the system, and collects feedback data to drive the optimization of the user programming knowledge graph construction unit and the educational programming large language model unit. Learners and teachers / administrators interact with the system through this unit. The personalized learning content generation and intelligent guidance unit includes: The personalized learning path planning module dynamically generates and recommends personalized learning paths for learners based on their current knowledge status, learning goals, and dependencies between knowledge points in the user's programming knowledge graph, using a path planning algorithm. The adaptive programming problem generation module drives the educational programming language model to generate programming practice problems of appropriate difficulty and relevant content based on the current knowledge nodes in the learning path and the learner's ability level. The real-time heuristic programming guidance module is used when the system detects an error E in the code snippet C_current submitted by the learner; locates the key code entity Entity_error that caused the error E; queries the domain knowledge graph KG_domain to obtain the attributes and related operations of Entity_error; and queries the user knowledge graph KG_user to obtain the learner's mastery of related concepts. The code snippet C_current, error E, and structured information obtained from the knowledge graph query are integrated into a rich context and injected into the prompt given to the large language model. This prompt instructs the large language model to act as a heuristic mentor and generate step-by-step thinking chain-like guidance. A cross-modal teaching content generation module is used to parse the input code into an abstract syntax tree (AST_tree) using the AST library of a programming language; an AST traverser is designed to map AST nodes to descriptive language of flowchart elements, such as mapping ast.If to decision box descriptions and ast.Assign to process box descriptions; the AST traverser translates the entire AST tree into a structured natural language text prompt that describes the flowchart layout and content in detail; the generated text prompt is input into a diffusion model to generate a flowchart image, and the CLIP model is used to filter the generated results to ensure consistency between the image and the text description.

[0084] Reference Figure 4 This is a flowchart illustrating the intelligent programming assistance method of the present invention.

[0085] S1: System Initialization. Load the pre-built programming domain knowledge graph ontology and the pre-trained / SFT-tuned educational programming language model. For example, for Python language teaching, load the Python knowledge graph ontology (containing concepts such as "variables", "data types", "control flow", "functions", "classes", etc. and their relationships) and the large language model fine-tuned for Python teaching.

[0086] S2: Learner Registration and Profile Construction. New learner B registers and completes a Python basic knowledge test. The system assesses that they have a good grasp of "variables" and "data types," but are unfamiliar with "control flow (especially loops)." An initial profile is created for them in User Programming Knowledge Graph Construction Unit 10.

[0087] S3: Provides a personalized learning experience.

[0088] S3.1: Learning Path Recommendation. Based on learner B's profile, the path planning module of Personalized Learning Content Generation and Intelligent Guidance Unit 30 recommends the following learning path: "for loop -> while loop -> nested loops -> break / continue statement".

[0089] S3.2: Adaptive Content Learning. Learner B chooses to learn about "for loops," and the system generates the problem: "Print all odd numbers between 1 and 10." B writes the code `for i in range(1, 10): if i % 2 == 1: print(i)` and submits it; the system judges it as correct. Then B tries a more complex problem and makes an error when using the step parameter of the `range` function.

[0090] S3.3: Real-time programming tutoring. After the system detects an error, it invokes the KG-aware CoT heuristic guidance generation process (see [reference]). Figure 5 (Details to follow) This involves generating CoT heuristic guidance based on KG awareness. For example, if analysis reveals that B is unfamiliar with the parameters of the range function, CoT guidance is generated as follows: "What are the meanings of the parameters of the range function? How can the step size be specified to generate only odd or even numbers?" S3.4: Multimodal Understanding. When learning about "nested loops," B was confused about the code implementation of the multiplication table and requested a flowchart. The system call generates a flowchart based on the AST to a text description (see...). Figure 6 Transform nested loop code into a clear double loop structure diagram to help B intuitively understand the logic.

[0091] S4: Interactive Feedback and System Iteration. Learner B gave a positive rating (e.g., 5 stars) for the help provided by the flowchart. The User Interaction and Feedback Management Unit records this data. This data will be used in the next round of RLHF training to optimize the Educational Programming Large Language Model Unit, making it perform better in generating similar multimodal content and recommendation strategies in the future. Simultaneously, B's learning progress and newly acquired knowledge points will be updated in their user profile and knowledge graph.

[0092] Reference Figure 5 This is a schematic diagram of the heuristic guidance generation process of knowledge graph (KG) perception-based CoT in an embodiment of the present invention.

[0093] The initial step involves receiving the learner's submitted code C_current and the system-detected error E. For example, C_current is filter(lambda x: x % 2 == 0, my_list), and error E is TypeError: filterobject is not subscriptable.

[0094] Step alg1_s1: Error Entity Identification. Locate the key code entity that caused the error, Entity_error, which in this case is the filter function call.

[0095] Step alg1_s2: Knowledge graph query and information enhancement.

[0096] Sub-step alg1_s2_1: Query the domain knowledge graph KG_domain. Obtain the attributes of the filter function, which returns an iterator. Obtain relevant operations for the iterator, such as list(), tuple(), and for loop.

[0097] Sub-step alg1_s2_2: Query the user knowledge graph KG_user. Obtain learner A's mastery of the iterator concept (e.g., weak) and mastery of type conversion (e.g., weak).

[0098] Step alg1_s3: Constructing a thought chain to generate prompts (Prompt Engineering). The above structured information (C_current, E, filter returns iterator, related operations of iterator, learner's weak grasp of iterator and type_conversion) is integrated into a rich context and injected into the prompt given to the LLM, instructing the LLM to play the role of a "Socratic tutor" and generate step-by-step thought chain (CoT) style prompts.

[0099] Step alg1_s4: LLM generates CoT heuristics based on the Prompt. For example, LLM generates the following guidance: "(1) You used the filter function and lambda expression to filter even numbers, which is the right direction. (2) The filter function returns an 'iterator,' which is an object to be iterated over, not a list. Think about it, (3) Is there a built-in function in Python that can directly convert an iterator into the list we need?" The final step is to output the heuristic guidance to the learner.

[0100] Regarding the design of the reward model (RM) for RLHF, the reward score r is composed of a weighted average of the effectiveness reward r_effectiveness, the pedagogy reward r_pedagogy, the conciseness reward r_conciseness, and the abandonment penalty c_abandonment.

[0101] r = w1 * r_effectiveness + w2 * r_pedagogy + w3 * r_conciseness - w4* c_abandonment. in: r_effectiveness: Calculated by analyzing students' code submission logs after receiving guidance. If a student successfully corrects the code and solves the problem within N attempts (e.g., N=3), a positive reward (e.g., +1) is given; if the problem is not solved after N attempts, a negative reward (e.g., -0.5) is given; if the problem is partially solved or progressed within N attempts, a smaller positive reward may be given.

[0102] r_pedagogy: Primarily relies on manual annotation. Experienced teachers or high-level users are invited to rank different guidance schemes generated by LLM for the same problem (which is more inspiring, which is more like a direct answer). Higher reward values ​​are assigned to the top-ranked guidance. For example, rewards can be learned from pairwise comparisons using the Elo scoring system or the Bradley-Terry model.

[0103] r_conciseness: This can be evaluated based on the length of the guidance text, the presence of repetitive or verbose expressions, and the inclusion of unnecessary information. For example, an ideal text length range can be set, with points deducted for exceeding it. NLP techniques can also be used to identify redundant information. This item can be calibrated in conjunction with human evaluation.

[0104] c_abandonment: If the system detects that a student does not make any relevant code modifications or interactions within a preset time window (e.g., 10 minutes) after receiving a certain guidance, or explicitly clicks the "abandon" button, then a large negative reward (e.g., -1) is applied to that guidance.

[0105] The weights w1, w2, w3, and w4 are adjusted according to the teaching objectives and experimental results. For example, in the early stages, the emphasis may be on effectiveness, while in the later stages, the weight of inspiration may be increased.

[0106] Reference Figure 6 This is a schematic diagram of the flowchart generation process from an abstract syntax tree (AST) to a text description in an embodiment of the present invention.

[0107] The initial step is to receive the Python function code (Code_python) that the user wants to convert into a flowchart.

[0108] Step alg2_s1: The code is parsed into an abstract syntax tree (AST_tree). Python's ast library is used to parse Code_python into an AST_tree.

[0109] Step alg2_s2: AST Traversal and Semantic Mapping. Design an AST traverser (such as a subclass of ast.NodeVisitor) to traverse the AST_tree. For each AST node (such as ast.If, ast.For, ast.Assign, etc.), map it to a descriptive language of flowchart elements. For example: * The `ast.If(test, body, orelse)` function maps to: "Decision box: condition '[text content of test]'; Yes branch connects to [description of body]; No branch connects to [description of orelse]". The `ast.Assign(targets, value)` method maps to: "Processing box: '[text content of targets] = [text content of value]'". The `ast.Return(value)` function is mapped to: "Output box: 'Returns the text content of [value]'". Step alg2_s3: Generate a flowchart text description Prompt. The traverser translates the entire AST tree into a structured, detailed natural language text Prompt describing the flowchart layout and content.

[0110] Step alg2_s4: Text-to-image generation. The generated text Prompt is input into a pre-trained DiffusionModel to generate a flowchart image.

[0111] Step alg2_s5: CLIP model filters generated results. The CLIP model is used to calculate the semantic similarity between the generated flowchart image and the text Prompt, and the image with the highest similarity is selected as the final output.

[0112] Finally, the present invention also discloses a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method described in the present invention.

[0113] In summary, this invention discloses a programming intelligent assistance method and system that combines a large model and a knowledge graph, including: initializing the system by loading a programming domain knowledge graph ontology and an educational programming large language model; constructing an initial learner profile and associating it with the knowledge graph; providing a personalized programming learning experience, including real-time programming tutoring, generating thought-chain-based heuristic guidance through the large language model combined with knowledge graph information; and conducting interactive feedback and system iteration, continuously optimizing the large language model using a reinforcement learning mechanism based on human feedback. This invention, by deeply integrating the structured knowledge of the knowledge graph with the understanding and generation capabilities of the large language model, aims to solve the problems of insufficient personalization and inspiration in existing programming assistance tools, difficulties in integrating heterogeneous knowledge, single modality of teaching resources, and lack of effective evolutionary mechanisms. It can provide more accurate, personalized, heuristic, and continuously evolving intelligent programming assistance, effectively improving learners' programming thinking and self-learning abilities.

[0114] It should also be understood that, in the embodiments herein, the term "and / or" is merely a description of the relationship between associated objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Additionally, the character " / " in this document generally indicates that the preceding and following associated objects have an "or" relationship.

[0115] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this document.

[0116] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0117] In the embodiments provided herein, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the couplings or direct couplings or communication connections shown or discussed may be indirect couplings or communication connections through some interfaces, apparatuses, or units, or they may be electrical, mechanical, or other forms of connection.

[0118] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of the embodiments described herein, depending on actual needs.

[0119] Furthermore, the functional units in the various embodiments of this document can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0120] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this paper, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this paper. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0121] The above description is merely a preferred embodiment of one or more embodiments of this specification and is not intended to limit the scope of one or more embodiments of this specification. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of one or more embodiments of this specification should be included within the protection scope of one or more embodiments of this specification.

Claims

1. A programming intelligent assistance method combining large language models and knowledge graphs, characterized in that, Includes the following steps: S1: Initialize the system and load the pre-built programming domain knowledge graph ontology and the pre-trained educational programming language model; S2: When learners use the system for the first time, guide them to complete basic information entry and initial ability assessment, build an initial profile of the learner, and record its association with the knowledge graph of the programming domain; S3: Provides a personalized programming learning experience, which includes: S3.3: Real-time programming tutoring. While learners are solving programming problems or engaging in free programming practice, the code snippets submitted by learners are analyzed in real time to identify potential errors. Combined with the code context and the learner's weaknesses in the user's programming knowledge graph, the educational programming language model is used to generate heuristic guidance suggestions based on the thought chain, guiding learners to discover problems and improve their code on their own. S4: Conduct interactive feedback and system iteration, collect learners' behavioral data during the learning process, their evaluation of the system-generated content, and teachers' feedback information, and use the reinforcement learning based on human feedback (RLHF) mechanism to continuously learn and optimize the educational programming language model, while dynamically updating the learners' knowledge status and profile according to their learning progress.

2. The method according to claim 1, characterized in that, In step S3.3, the step of generating heuristic guidance suggestions based on thought chains using the educational programming language model includes: When the system detects an error E in the code snippet C_current submitted by the learner; it locates the key code entity Entity_error that caused the error E; it queries the domain knowledge graph KG_domain to obtain the attributes and related operations of Entity_error, and queries the user knowledge graph KG_user to obtain the learner's mastery of related concepts; The code snippet C_current, error E, and structured information obtained from the knowledge graph query are integrated into a rich context and injected into the prompt given to the large language model. This prompt instructs the large language model to act as a heuristic mentor, generating step-by-step chain-like guidance.

3. The method according to claim 1, characterized in that, The personalized programming learning experience also includes: S3.1: Learning path recommendation: Based on the learner's profile and knowledge tracking results, dynamically generate and recommend personalized learning paths to the learner; S3.2: Adaptive content learning, learners learn along the recommended path, and the system calls the adaptive programming problem generation module to provide programming exercises that match the current learning node; S3.4: Multimodal assisted understanding. When learners request or the system intelligently triggers based on the context, the cross-modal teaching content generation module is invoked to convert complex code logic into a graphical flowchart representation.

4. A programming intelligent assistance system combining a large language model and a knowledge graph, characterized in that, include: User programming knowledge graph construction unit, used to build and dynamically maintain a user programming knowledge graph that covers programming domain knowledge and individual learner learning status; The educational programming large language model unit is used to understand programming-related natural language instructions and student code intent, and generate heuristic guidance suggestions based on thought chains according to the method described in claim 2. The personalized learning content generation and intelligent guidance unit, coupled with the user programming knowledge graph construction unit and the educational programming large language model unit, is used to provide learners with personalized learning resources and real-time interactive tutoring. The user interaction and feedback management unit is used to provide a user interface to support learners in learning, programming practice, asking questions, and viewing feedback, and to collect user feedback in accordance with the method described in claim 3 to optimize the educational programming language model unit.

5. A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method as described in any one of claims 1 to 3.

Images