College student career path navigation method based on dynamic knowledge graph and post portrait

Abstract

This invention belongs to the technical field of data-driven education and career planning. Specifically, it discloses a career path navigation method for college students based on dynamic knowledge graphs and job profiles. The method includes: constructing a node connection graph containing skills, courses, and jobs, and introducing a time decay function and a market event-driven incremental update mechanism for edge weights. Based on the dynamic weights of each edge in the path, a comprehensive score for candidate paths is calculated. Recommendation probabilities are generated using exponential weighting and normalization, and the matching degree between entities is quantified using a vector space cosine similarity algorithm. Finally, the method is visualized through a highlighted topological path or learning roadmap, and supports interactive expansion of branch nodes. This invention achieves automated synchronization with changes in the career environment, improving the logical rigor, market fit, and data visualization effects of career planning path recommendations.

Description

Technical Field

[0001] This invention belongs to the technical field of data-driven education and career planning, and relates to a career path navigation method for college students based on dynamic knowledge graphs and job profiles. Background Technology

[0002] Currently, a major challenge in providing career path planning guidance to university students lies in bridging the information gap between the university curriculum and the rapidly evolving demands of the job market. Market demands for skills are dynamic, with new technology stacks, industry standards, and job responsibilities constantly emerging, while traditional academic courses have relatively long update cycles. This can lead to students lacking timely and effective decision-making support that is strongly linked to their future career goals when planning their studies and developing their skills, thus risking a disconnect between their learning paths and market demands.

[0003] To address this challenge, the solutions commonly adopted in the industry can be categorized into several types. One type is career coaching services based on human consultation, where teachers from school career guidance centers or external career planners provide one-on-one advice. Another type is recommendation systems based on online content platforms; for example, online learning platforms recommend relevant courses based on users' browsing history, while recruitment platforms match and recommend positions based on keywords in users' resumes. In addition, some tools provide pre-set career development roadmaps, planning a standardized sequence of learning steps for specific target positions. These methods provide students with directional guidance to a certain extent.

[0004] However, the aforementioned traditional methods still have some areas for improvement in application. Human-based consultations are limited in quality and breadth of guidance due to the consultant's personal knowledge and industry experience, and their service capacity is difficult to scale, failing to meet the personalized, real-time needs of a large number of students. Content-platform-based recommendation systems rely heavily on shallow keyword matching, potentially failing to reveal deep, structured connections between skills, resulting in a lack of systematic and forward-looking recommendation paths. Pre-set career development path maps, with their fixed path models, struggle to adapt to dynamic market changes. When the demand for a key skill in the path declines or new substitute skills emerge, the model cannot adaptively adjust, potentially misleading users' learning efforts.

[0005] Based on the above problems, this invention aims to solve the limitations of existing career path planning tools in terms of data synchronization, model adaptability, and personalization depth, which makes it difficult for them to provide dynamic adaptive navigation that is synchronized with market demands in real time. Summary of the Invention

[0006] In order to overcome the above-mentioned defects of the prior art and to achieve the above objectives, the present invention proposes the following technical solution: a career path navigation method for college students based on dynamic knowledge graph and job profile, including: S1, acquiring the micro-behavioral signal flow of users from user terminals and the macro-market demand signal flow from recruitment platforms, and maintaining a dynamic knowledge graph of professional skills containing dynamic weight attributes.

[0007] S2. Identify graph change events based on the rate of change between user micro-behavior signal flow and market macro-demand signal flow, trigger incremental updates to the dynamic knowledge graph of professional skills, and generate a graph change flag package containing data on the affected topological neighborhood range.

[0008] S3. Analyze the map change flag package, locate jobs whose core skills fall within the affected topological neighborhood from the real-time job profile database, and generate a set of jobs to be updated.

[0009] S4. For the set of job positions to be updated, perform partial reconstruction of job profiles based on the incrementally updated dynamic knowledge graph of professional skills, and output a list of affected job features containing the updated job requirement feature vectors.

[0010] S5. Perform correlation screening between the list of affected job characteristics and the current path planning status of candidate users, and lock in the set of users to be replanned whose intersection results are not empty.

[0011] S6. For the set of users to be replanned, perform directional path replanning within the affected topological neighborhood of the dynamic knowledge graph of professional skills to generate a revised probabilistic path network.

[0012] S7. Adaptively compress and visualize the revised probabilistic path network, and output dynamic navigation instructions to the user terminal.

[0013] Compared with the prior art, the beneficial effects of the present invention are as follows: (1) The present invention constructs a multi-dimensional occupational data flow monitoring mechanism and maintains a dynamic knowledge graph of occupational skills, and triggers incremental updates by combining graph change events based on signal flow fluctuation recognition. This mechanism can integrate the micro-learning behavior signals of users with the macro-demand signals of the market in real time. By dynamically adjusting the association weights and topological structures between nodes such as skills, courses, and positions in the knowledge graph, the graph itself becomes a real-time model that can reflect the current skill value and knowledge association popularity. This design realizes the transformation of the occupational development knowledge base from a static and lagging state to a dynamic and synchronous state, providing a data foundation consistent with the current market situation for all subsequent path planning.

[0014] (2) This invention employs a cascaded mechanism for retrieving and locking affected domains of job profiles, as well as a path-related screening mechanism for locking target users to be replanned. This mechanism can propagate the impact step by step through graph change flag packets. First, it performs partial reconstruction only on job profiles whose core skills are affected by graph changes. Then, it further filters out users whose current path or target job intersects with these reconstructed jobs. This on-demand triggering and step-by-step filtering calculation mode avoids unnecessary recalculation of all jobs and all users when there are local changes in the market. Thus, while ensuring the system's sensitivity to market changes, it improves the efficiency of computing resource utilization when dealing with a large number of users.

[0015] (3) This invention performs directional path replanning within a limited graph neighborhood, generating a revised probabilistic path network, and adaptively compressing and visually mapping the path network. This method can limit complex path searches to the affected local graph range when path adjustments are necessary due to market changes, and generates multiple alternative paths with selection probabilities and expected returns for the user. Through subsequent critical path extraction and branch folding, the system can transform this complex probabilistic network into a hierarchical navigation command with path convergence nodes as the backbone. This not only provides users with a planning scheme that combines determinism and flexibility, but also reduces the user's decision-making cognitive load by simplifying information presentation, and improves the intuitiveness and executability of the navigation command. Attached Figure Description

[0016] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments 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.

[0017] Figure 1 This is a schematic diagram of the implementation steps of the method of the present invention. Detailed Implementation

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

[0019] Please see Figure 1As shown, the career path navigation method for college students based on dynamic knowledge graph and job profile proposed in this invention includes: S1, acquiring the micro-behavioral signal flow of users from user terminals and the macro-market demand signal flow from recruitment platforms, and maintaining a dynamic knowledge graph of professional skills containing dynamic weight attributes.

[0020] In a preferred embodiment, acquiring the user micro-behavior signal stream from the user terminal and the market macro-demand signal stream from the recruitment platform includes: recording the user's click sequence, learning duration and assessment pass rate for courses or projects through an embedded data acquisition agent to generate the user micro-behavior signal stream;

[0021] By using market data crawling services, we can extract the frequency of mentions of job skill keywords and salary fluctuation data from recruitment platform interfaces to generate a macro market demand signal stream.

[0022] In a further preferred embodiment, maintaining a dynamic knowledge graph of vocational skills that includes dynamic weight attributes includes: constructing a graph topology structure with skills, courses, projects, positions, and certifications as nodes;

[0023] Configure dynamic weight attributes for the edges between nodes that decay over time, and enhance or weaken the dynamic weight attributes in real time based on the micro-behavioral signal flow of users and the macro-demand signal flow of the market.

[0024] The specific implementation process of this invention in constructing a multi-dimensional occupational data flow monitoring mechanism and maintaining a dynamic knowledge graph of occupational skills is as follows:

[0025] First, the system acquires user micro-behavioral signal streams through an embedded data acquisition agent deployed in the user terminal application. The user terminal application is the client of a career development platform or online learning platform. The data acquisition agent records the user's micro-operational behavior sequences within the application in a non-blocking asynchronous manner by listening to the user interface event handlers. This behavioral data includes: click event sequences on the course list page, course details page, and project task page, each event containing a unique resource identifier, timestamp, and session identifier; timestamps of the user entering and exiting course learning video or document pages, used by the system to calculate single and cumulative learning time; and pass / fail boolean values ​​and specific scores returned by the assessment engine after the user completes a chapter quiz or project assessment. The data acquisition agent packages the above raw event data into JSON format data packets according to a preset time window, such as every five seconds or every ten events, and transmits them in real time to the server's data receiving endpoint via encrypted HTTP POST requests. The server-side user behavior analysis service, upon receiving data packets, parses them using FastJSON or a similar library, and writes the parsed data to a specific behavior log table in a time-series database like InfluxDB or a relational database like MySQL, thus completing the persistent storage of user micro-behavioral signal streams. A complete user micro-behavioral signal stream is a time-series set of all the aforementioned data records generated by a user during a continuous session.

[0026] Simultaneously, the system acquires macro-market demand signals through an independently running market data crawler service. This service uses the Python Scrapy framework or a customized crawler program written in Go, and initiates API calls to one or more pre-configured public data interfaces of recruitment platforms, following a preset scheduling strategy, such as once per hour. These public data interfaces include, for example, job search interfaces provided to developers by platforms like Boss Zhipin and 51job. Request parameters include a preset list of skill keywords, city codes, and posting time ranges. From the JSON response data returned by the interfaces, the crawler service parses and extracts two types of key information: first, the frequency of each preset skill keyword appearing in the returned job description text, i.e., counting the number of times the keyword appears in the job responsibilities and requirements fields; second, the salary range data provided for these jobs, with the system taking the median of the salary range as the reference salary for that job. The crawler service aggregates and calculates the data collected each time, generating data records with skill keywords as the primary key. Each record includes the total mention frequency of that skill keyword within the current sampling period, the average salary of the relevant positions, and the percentage change in salary compared to the previous sampling period. The records are then pushed to a designated topic in the Kafka message queue. The server's market signal consumption service subscribes to this topic, deserializes the messages, and stores them in an Elasticsearch index for rapid range queries and aggregation analysis, forming a macro-level market demand signal stream.

[0027] Subsequently, the system initializes or maintains a dynamic knowledge graph of vocational skills through a graph maintenance service. During the initialization phase, the graph maintenance service connects to the graph database Neo4j or JanusGraph, executes Cypher or Gremlin scripts, and creates the graph schema. This schema defines five types of nodes: skill nodes, course nodes, project nodes, job nodes, and certification nodes. Each node has attributes: skill nodes must include at least the skill name and unique skill identifier; course nodes must include at least the course name, unique course identifier, and platform; project nodes must include at least the project name, unique project identifier, and project category; job nodes must include at least the job name, unique job identifier, and industry; and certification nodes must include at least the certification name, unique certification identifier, and issuing authority. Nodes are connected by directed edges, which represent prerequisite relationships or semantic associations. For example, an edge from course node A to skill node B indicates "Course A teaches skill B"; an edge from skill node C to skill node D indicates "Mastering skill C is a prerequisite for learning skill D." Each edge is accompanied by a dynamic weight attribute, which is a floating-point number. The initial value can be set based on expert experience or historical data statistics. The dynamic weight attribute is also associated with a last update timestamp attribute. The graph maintenance service continuously runs a weight decay and update coroutine. This coroutine periodically scans all edges, and for each edge, applies a time decay function to reduce its weight based on the difference between its last update timestamp and the current time, simulating the natural forgetting or obsolescence of knowledge relevance. Simultaneously, this coroutine listens for event messages from the user behavior analysis service and the market signal consumption service. When a new event is received, such as "User U successfully passed the assessment of course A, which is strongly related to skill B," the graph maintenance service will locate the corresponding "course A" in the graph. For the edge labeled "Skill B", a predefined weight update function is invoked based on the event type, for example, increasing the weight value of the edge by an increment. Similarly, if market signals indicate a significant increase in the frequency of mentions of skill B, the weights of all edges directly associated with skill B may also receive an increment based on the rate of frequency change. Through this continuous decay and event-driven enhancement, the graph weights are dynamically maintained, enabling the dynamic knowledge graph of occupational skills to reflect real-time changes in the popularity of skill associations.

[0028] It's important to note that the dynamic weight attribute is a numerical attribute attached to an edge, whose value changes over time to quantify the current strength or importance of the relationship represented by that edge. Its update mechanism combines time decay and event-driven gain. A typical implementation of the time decay function involves multiplying by a decay coefficient. , It is a number between 0 and 1, such as 0.99, meaning that the weight value is multiplied by 0.99 every day. This is the increment of the event-driven gain. It can be a fixed value (such as 0.1 for each user who passes the assessment) or a variable based on the intensity of the event (such as the normalized value of the assessment score).

[0029] Preset time window, initial weight attenuation coefficient Gain increment The specific values ​​need to be set based on the actual business scenario. For example, assuming the application scenario is a platform with tens of thousands of candidate users per day and market data updated hourly, the user behavior data packaging time window can be set to ten seconds to balance real-time performance and network overhead; the initial weight of the edge The attenuation coefficient can be uniformly set to 1.0. Based on the Ebbinghaus forgetting curve principle, the daily decay rate can be set to approximately 0.96; gain increment The value for the "user passes course assessment" event can be set to 0.05. These parameters need to be calibrated through A / B testing or backtesting with historical data before the system goes live.

[0030] For example, assume the system begins initialization. The graph maintenance service creates nodes in the graph database, inserting a skill node named "Python Programming" with a unique identifier "SK_PY"; and inserting a course node named "Introduction to Python" with a unique identifier "CO_PY_INTRO". A directed edge is created between these two nodes, with a relation type of "TEACHES", and its dynamic weight attribute is initialized. Version 1.0, with the last update timestamp set to the current time. .

[0031] Simultaneously, a market data crawler service was launched, sending requests to the recruitment platform's API to query job postings for the skill keyword "Python" over the past hour. Assuming the API returned 100 job postings, with 80 containing "Python" in their descriptions, and the median salary for these 80 positions averaging 15,000 yuan per month, while the median salary for the previous hour was 14,800 yuan, the crawler service calculated that the frequency of "Python" mentions was 80, with a salary fluctuation percentage of approximately 1.35%. This record was stored in Elasticsearch.

[0032] At this moment, User A is learning the "Introduction to Python" course on the client side. Data acquisition agent records events: timestamps. Event type "Start Learning", resource ID "CO_PY_INTRO". (In the timestamp) ( User A exits the course page, and the agent records the "End Learning" event. The user behavior analysis service calculates the learning time as 7200 seconds (2 hours) and updates the user's cumulative learning time for the course "CO_PY_INTRO". Subsequently, user A completes the course assessment and receives a score of 90 (out of 100). The assessment pass event is recorded and sent to the server. The user behavior analysis service determines that the assessment was passed and publishes this event as a message.

[0033] The weight update goroutine of the graph maintenance service consumes this message and locates the "TEACHES" edge from "CO_PY_INTRO" to "SK_PY". Assume the current time is... The last update time of this side is The time difference is Coroutines first apply time decay, based on a preset daily decay coefficient. The weights after decay are calculated as follows: Next, based on the "user passed the course assessment" event, the update function is called to add a gain to the edge weight. For example, 0.05. Finally, the weight of the edge is updated to a new value, and its last update timestamp is updated to... .

[0034] On the other hand, when the market signal consumption service processes news of a salary increase for the "Python" skill, it may trigger a fine-tuning of the weights of edges associated with the "SK_PY" node. For example, it could add a small increment based on the increase (1.35%) to all job relationship edges that require "SK_PY".

[0035] Through the above example process, the system completes a full cycle from data acquisition to dynamic maintenance of the map.

[0036] S2. Identify graph change events based on the rate of change between user micro-behavior signal flow and market macro-demand signal flow, trigger incremental updates to the dynamic knowledge graph of professional skills, and generate a graph change flag package containing data on the affected topological neighborhood range.

[0037] In a preferred embodiment, step S2 includes: calculating the magnitude of the change in the association weight of the skill node and the number of newly added association relationships;

[0038] When the magnitude of the change in associated weights or the number of new additions exceeds the preset change threshold, it is determined to be a map change event;

[0039] Extract the nodes affected by the graph change event and their adjacent nodes within a preset hop count range, define them as the affected topological neighborhood range data, and encapsulate them into a graph change flag package.

[0040] The specific implementation process of this invention in triggering incremental updates of the map and generating map change flag packages is as follows:

[0041] Internally, the graph maintenance service runs a graph change event detector. This detector continuously subscribes to the event message bus published by the user behavior analysis service and the aggregated result stream output by the market signal consumption service. For each skill node in the graph, the detector maintains a sequence of association weight changes and a count of new associations within a sliding time window.

[0042] Specifically, the detector periodically, for example every minute, performs the following operations for each skill node: First, it queries the graph database for the dynamic weight attribute values ​​of all associated edges of that node at the current moment, forming the current weight vector. Simultaneously, the historical weight vector recorded in the previous detection cycle is read from the local cache. Next, calculate the current weight vector. With historical weight vector The measure of change between them.

[0043] In this step, the determination of graph change events involves the quantitative calculation of the weight change rate. For existing related edges: that is, edges that existed in the previous detection period and... The edges. Calculate the absolute rate of change for each stock-related edge. ,in, These represent the corresponding skill nodes within the detection period. The current and historical weights of each associated edge are determined. Then, the arithmetic mean of the absolute change rates of all existing associated edges under that node is taken to obtain the average change rate of that node. If the node has no existing associated edges in the current period, then Record it as 0.

[0044] For newly added related edges: these are edges that did not exist in the previous detection period but are newly generated in the current period. Since these edges have a historical weight of 0, they are not included in the above average change rate. The calculation formula is used to avoid logical errors where the denominator is zero. The detector directly counts the number of newly added edges originating from or ending with the skill node within the past detection period by comparing the current graph snapshot with historical snapshots, and records this as... .

[0045] The calculated average rate of change Compared with the preset rate of change threshold Compare and add the number of edges. With the preset threshold for new relationships Compare them. If the average rate of change... Greater than the rate of change threshold or increase the number of edges Greater than the threshold for adding new relationships If a graph change event occurs, the graph change event detector determines that a graph change event has occurred around that skill node and immediately generates an event trigger signal. The event trigger signal includes at least the unique identifier of the triggering node, the detected event type (weight change or relation addition), and the calculated change metric.

[0046] Once an event trigger signal is generated, the graph incremental update engine within the system is activated. The graph incremental update engine receives the event trigger signal and, using the trigger node specified in the signal as the core, performs a limited-range graph update. First, the engine calculates the number of hops based on a preset neighborhood parameter. Perform a breadth-first search query in the graph database to retrieve data centered on the trigger node. The set of all nodes within the hop range and the edges connecting them; this set is defined as the affected topological neighborhood subgraph. Parameters Typically, this value is set to 1 or 2 to balance the locality of the update with the propagation effect. Next, the engine implements incremental update logic for the affected topological neighborhood subgraph. For events involving weight changes, the engine applies a weight propagation function based on the change metric in the event trigger signal, updating the dynamic weight attributes of all edges in the affected topological neighborhood subgraph. The weight propagation function can be designed so that edges farther from the trigger node receive smaller weight adjustments, for example, by multiplying by a decay factor that decreases with increasing hop count. ( For events involving newly added relationships, the engine inserts the newly discovered relationships (such as new "course-skill" pairs mined from user behavior sequences) as new edges into the affected topological neighborhood subgraph and sets initial dynamic weights for them. After completing the above update calculations, the engine sends a batch of Cypher update statements to the graph database, modifying only the attributes of nodes or edges and topological connections within the affected topological neighborhood subgraph, thereby achieving incremental updates to the graph structure and avoiding full graph scanning and recalculation.

[0047] After the incremental update operation is successfully submitted to the graph database, the system immediately starts the graph change flag packet generator. The graph change flag packet generator takes the metadata of the affected topological neighborhood subgraph, information from the event trigger signals, and the operation log of this incremental update as input to construct a structured data packet. The graph change flag packet is serialized in JSON or Protocol Buffers format, and its required fields include: a globally unique batch identifier (UUID) for this change; an array containing unique identifiers of the triggering nodes; an enumerated change type field, whose value is derived from the event type in the event trigger signal; and a field describing the affected scope, which stores a list of unique identifiers for all nodes in the affected topological neighborhood subgraph, or more efficiently, stores the triggering node and hop count. The defined neighborhood query conditions and a timestamp field record the generation time of the flag packet. Once generated, the graph change flag packet is published to a high-priority internal message queue topic, such as a RabbitMQ or Kafka topic named "Graph_Change_Flag," serving as the sole trigger signal for subsequent cascading processing. The entire S2 step is now complete, and the system resumes continuous monitoring of the data stream, awaiting the next graph change event.

[0048] It should be noted that the magnitude of change specifically refers to the average rate of change of the weights of the edges associated with the skill nodes. Change thresholds include rate of change thresholds. and the threshold for adding new relationships .

[0049] Rate of change threshold It is a decimal between 0 and 1, typically ranging from 0.1 to 0.3. Its setting is based on analyzing historical data on changes in the graph to determine a critical value that can distinguish between "small daily fluctuations" and "significant trend changes." For example, based on statistics from the past year, it was found that when the daily average weight change exceeds 15%, it usually corresponds to a substantial shift in market demand for a certain skill or a major update to the syllabus of a course. Therefore, it can be used as a threshold. Set to 0.15.

[0050] New Relationship Threshold It is a positive integer, typically ranging from 3 to 10. The basis for this setting is that if the number of newly associated skills within a single detection period exceeds this threshold, it indicates that the skill is rapidly establishing connections with new learning resources or job positions, representing an expansion event of the knowledge structure.

[0051] Preset neighborhood hop count parameter The propagation range of incremental updates is defined, typically set to 1 or 2 hops. Setting it to 1 hop means only nodes and edges directly connected to the triggering node are updated; setting it to 2 hops considers indirect effects and better captures the ripple effect of changes, but the computational cost is slightly higher. The choice depends on the balance between business assumptions about the scope of change propagation and system performance.

[0052] The graph change flag package is a standardized data structure used to transmit change information between modules within the system. Its core function is to accurately describe "where and what kind of change has occurred." The affected topological neighborhood range data it defines (i.e., the list of node IDs or neighborhood query conditions) is the key input for targeted retrieval in the subsequent step S3, avoiding the need for subsequent modules to analyze the entire graph, thus achieving computational omission.

[0053] For example, following the example of step S1, assume that at time At the end of the next testing cycle The graph change event detector analyzes the skill node "SK_PY". The detector queries the graph database and finds that the "SK_PY" node currently has two edges: [edge name missing] Current weight (from the "CO_PY_INTRO" node, with the relationship "TEACHES") For 1.1 (updated from example S1), edge (Current weight of the node leading to the "Machine Learning Engineer" job posting, with the relationship "REQUIRES") It is 1.02. In the local cache, the previous cycle Historical weights recorded in time It is 1.0. It is 1.0.

[0054] First, calculate the rate of change for each edge: ; Average rate of change Meanwhile, the detector found that no new edges were added to "SK_PY" during this period, therefore... .

[0055] Assuming the system has a preset rate of change threshold Add a new relationship threshold .because ,and Therefore, no map change event was triggered this time.

[0056] In another scenario, during a certain period, market signals strongly indicate a surge in demand for "Python" skills, leading to... The weight was quickly updated from 1.0 to 1.25, and three new "ENHANCES" relationship edges were added from different newly launched practical project nodes to "SK_PY". The calculated result is as follows: , ; , . , Average rate of change Number of newly added edges .because If the conditions are met, the map change event is determined to have occurred, and the triggering node is "SK_PY".

[0057] The map incremental update engine then starts, with a preset number of hops. It retrieves a subgraph consisting of "SK_PY" and all its directly adjacent nodes ("CO_PY_INTRO", "Machine Learning Engineer", and three newly added project nodes). The engine applies weight propagation, assuming a decay factor. Then for directly connected edges and Its weights are updated based on the strength of market signals (e.g., It might be directly set to the new value of 1.25. (A slight enhancement is obtained). For newly added edges, they are inserted into the graph and assigned initial weights.

[0058] After the update is complete, the graph change flag packet generator creates a data packet: the change batch ID is "UUID-XXXX", the trigger node list is ["SK_PY"], the change type is "significant weight change", the affected range field stores the ID list of "SK_PY" and its five adjacent nodes, and the timestamp is... Finally, the flag packet was published to the "Graph_Change_Flag" message topic.

[0059] S3. Analyze the map change flag package, locate jobs whose core skills fall within the affected topological neighborhood from the real-time job profile database, and generate a set of jobs to be updated.

[0060] In a preferred embodiment, generating a set of jobs to be updated includes: extracting affected topological neighborhood range data from the map change flag package;

[0061] Traverse the real-time job profile database to determine whether there is any overlap between the core skill node list of each job and the affected topological neighborhood range data.

[0062] Jobs that overlap are marked as invalid and added to the set of jobs to be updated.

[0063] The specific implementation process of this invention, which executes the response graph change flag package and performs cascading job profile affected domain retrieval and locking, is as follows:

[0064] The job profile status monitoring service within the system continuously subscribes to message queue topics that carry graph change flag packets. When a new graph change flag packet arrives at the message queue, the consumer instance of the job profile status monitoring service retrieves the message from the queue. The consumer first deserializes the message body to reconstruct a structured graph change flag packet object. Subsequently, the monitoring service calls a flag packet parser to extract key fields from the graph change flag packet object. The parser reads the change type parameter and records it to the audit log; most importantly, the parser extracts the affected topological neighborhood range data. Depending on the format of the flag packet, the affected topological neighborhood range data may be a list of explicit node unique identifiers, or it may be a list of triggering nodes and hop counts. Defined query conditions. If it is the latter, the parser needs to immediately initiate a lightweight query to the graph database, execute the neighborhood query condition, and obtain a list of exact unique identifiers of affected nodes in the current graph state, denoted as the list. List It contains identifiers for all nodes such as skills, courses, and projects that are considered to be affected in terms of structure or weight due to this graph change.

[0065] Next, the system launches the affected job search engine. This engine connects to a database storing real-time job profiles; the database can be Elasticsearch, MongoDB, or a relational database. Each stored real-time job profile is a document or record, and its data structure must include a field called "Core Skill Node List," which stores an array of unique identifiers for the skill nodes that constitute the core competency requirements of this job. The search engine iterates through all valid job profile records in the real-time job profile database. For each job profile record... The engine reads its "core skill node list" and records it as a list. Then, the engine performs a set operation to evaluate the list. List obtained from parsing the map change flag package Does the list have an intersection? In practice, to improve traversal efficiency, the list can be pre-defined. Load the hash set into memory, and then for each job profile list... The system checks if any skill node identifier exists in the hash set. If it does, it determines that the core skill node of the job profile falls within the affected topological neighborhood, meaning that the skill requirement model for the job may be outdated or needs to be re-evaluated due to changes in the underlying graph.

[0066] For all job profiles identified as having affected core skill nodes, the system performs a locking operation. This locking operation is executed by the job status marker. The job status marker sends an update command to the real-time job profile database, modifying the status field in the identified job profile records to "invalid." Database updates are performed in batches to improve efficiency. Simultaneously, the job status marker collects unique identifiers for all job profiles marked as "invalid," adding them to a temporary memory list or writing them to a temporary database table. This set is formally defined as the set of jobs to be updated. Job profiles not identified as affected remain unchanged in status, and the search engine does not perform any operations on them, thus omitting calculations. Finally, the set of jobs to be updated serves as the output of this step, providing a clear and scope-limited processing target for subsequent steps. After completing this round of retrieval and locking, the job profile status monitoring service continues to wait for the next graph change flag packet.

[0067] It should be noted that the real-time job profile database is a data storage area for the system to persistently store all modeled job data. Each job profile is a data structure that includes at least a globally unique identifier for the job, the job name, the job status, and a list of core skill nodes.

[0068] The core skill node list is an array, where each element is a unique identifier for a skill node within the dynamic knowledge graph of occupational skills. This list is generated from the results of skill entity extraction and relationship linking of job description texts using natural language processing techniques over historical periods, and is stored in a profile database.

[0069] The "Invalid" status is one of the optional values ​​for an attribute field in a job profile. It indicates that the underlying knowledge (skill associations, weights) upon which the profile is based has changed, and the current profile data (such as requirement subgraphs and matching scores) is no longer accurate and needs to be reconstructed in subsequent steps. Its opposite status can be "Valid" or "Latest".

[0070] For example, following the example of step S2, assuming that the graph change flag packet has been published to the message queue, the list of its affected topological neighborhood range data is obtained after the parser queries the graph database. The node contains: ["SK_PY", "CO_PY_INTRO", "PROJ_ML1", "PROJ_WEB1", "JOB_ML_ENGINEER"]. Here, "JOB_ML_ENGINEER" is the node ID for the "Machine Learning Engineer" job title.

[0071] The job profile status monitoring service consumes this flag packet and parses out the list. Subsequently, the search engine for affected positions began scanning the real-time job profile database. Assume there are three job profile records in the database:

[0072] Record 1: Job ID = "JOB_ML_ENGINEER", Core Skills Node List = ["SK_PY", "SK_ML", "SK_LINUX"], Status = "Valid".

[0073] Record 2: Job ID = "JOB_WEB_DEV", Core Skills Node List = ["SK_JS", "SK_HTML", "SK_CSS"], Status = "Valid".

[0074] Record 3: Job ID = "JOB_DATA_ANALYST", Core Skills Node List = ["SK_PY", "SK_SQL", "SK_STATS"], Status = "Valid".

[0075] The search engine will list Loaded as a hash set. Check record 1: "SK_PY" exists in its core skill list. In the set, record 1 is therefore affected. Checking record 2: none of its core skills appear in the list ["SK_JS", "SK_HTML", "SK_CSS"]. Since the set is in place, record 2 is unaffected. Check record 3: "SK_PY" exists in its core skill list. Therefore, record 3 is affected by the set.

[0076] Based on the judgment result, the job status marker sends a batch update to the database, updating the status fields of record 1 (JOB_ML_ENGINEER) and record 3 (JOB_DATA_ANALYST) to "invalid". Simultaneously, a set of jobs to be updated is generated, containing ["JOB_ML_ENGINEER", "JOB_DATA_ANALYST"]. Record 2 (JOB_WEB_DEV) retains its "valid" status and is not added to the update set.

[0077] At this point, the system has only locked down two affected positions, completely skipping the processing of JOB_WEB_DEV and its related calculations.

[0078] S4. For the set of job positions to be updated, perform partial reconstruction of job profiles based on the incrementally updated dynamic knowledge graph of professional skills, and output a list of affected job features containing the updated job requirement feature vectors.

[0079] In a preferred embodiment, a partial reconstruction of job profiles is performed based on the incrementally updated dynamic knowledge graph of occupational skills, including: extracting a job requirement subgraph centered on the core skills of each job in the set of jobs to be updated from the incrementally updated dynamic knowledge graph of occupational skills.

[0080] The node vector representation of the job requirement subgraph is calculated using a graph embedding algorithm, and the job requirement feature vector is generated by aggregating the vectors of the core skill nodes.

[0081] The specific implementation process of this invention, which performs local reconstruction of the job profile of the locked target based on graph morphology and outputs a list of affected job features, is as follows:

[0082] The system's job profile partial reconstruction engine is activated, taking the set of jobs to be updated as input. This engine uses an iterative approach, sequentially processing each unique identifier for a job in the set. For the currently processed job identifier... The engine first accesses the real-time job profile database and reads the jobs that are in an "invalid" state. From the complete profile data, extract the list of its core skill nodes, denoted as list. Next, the engine initiates a subgraph extraction query into the graph database containing the incrementally updated dynamic knowledge graph of professional skills. This query uses a graph query language (such as Cypher) to retrieve a list of subgraphs. Using all skill nodes as starting nodes, extract a subgraph with a limited number of jumps. For example, the query condition can be set to: match all nodes from the list. Starting from any node in the subgraph, retrieve all nodes within a 2-hop path and the edges between them. The returned result includes the attributes of all nodes in the subgraph (such as node type, ID) and the attributes of all edges (such as relationship type, updated dynamic weight). This extracted subgraph is defined as a job posting. Updated job requirements sub-graph It reflects a skills ecosystem network based on the latest knowledge connections and centered on core job skills.

[0083] Obtain the job requirements sub-graph Then, the engine calls the graph embedding computation service. The graph embedding computation service loads a pre-configured graph embedding algorithm, such as the Node2Vec algorithm. The service first subgraphs... The topology (adjacency list) and edge weight data are converted into the input format required by the algorithm. Then, a random walk process of Node2Vec is performed: starting from each node in the subgraph, multiple rounds of length... A random walk is performed to generate a corpus of node sequences. The return parameters in the walk strategy... and input / output parameters Based on the characteristics of the occupational graph, such as a tendency to walk along strongly related edges (high weight), the algorithm is then trained on the generated sequence corpus using the Word2Vec Skip-gram model (implemented via the gensim library) to learn the behavior of each node. 3D vector representation. After training, the subgraph... Each node in the array corresponds to a Dimensional embedding vector.

[0084] To represent the overall demand for the position, the engine filters out the corresponding position from all node vectors. Original Core Skill Node List The vectors of those nodes are then used. Next, aggregation operations are performed on the vectors of these core skill nodes, such as calculating a weighted average vector. The weights can be taken from the sum of the edge weights of the node and other nodes in the subgraph, or the vectors can be directly concatenated to generate a vector representing the job position. Feature vectors of the latest requirements Additionally, the engine can optionally analyze subgraphs. The distribution of association strength between nodes, for example, calculating the average weight of edges between core skill nodes, can be used as an indicator of association strength. .

[0085] The graph embedding algorithms (such as Node2Vec) involved in this step and their internal Word2Vec models contain complex objective functions, but their specific mathematical forms fall within the scope of well-known algorithms in this field and are not specific calculation formulas newly added to this solution. The key to this solution lies in applying this algorithm to a specific dynamic subgraph and aggregating the results. The aggregation operation of node vectors, such as weighted averaging, can be expressed as follows: Let the job... have The first core skill node, the Each node The dimensional embedding vector is Its weight is (Normalizable), then the aggregated job requirement feature vector It can be calculated using the following formula:

[0086]

[0087] Among them, weight This can be set to the sum of the weights of all edges related to the node in the job requirements subgraph, reflecting the overall relevance of the skill within the current location context. If vector concatenation is used, then... for Formed by connecting them sequentially Dimensional vector.

[0088] Subsequently, the engine constructs a job profile update record. This record is organized in key-value pairs or a JSON object and must include the following field: a unique identifier for the job (i.e., ...). ), and the latest demand feature vector calculated. Optionally, a correlation strength index may be included. And a snapshot of the subgraph node list. The engine appends this record to a continuously building list, defined as the list of affected job characteristics. Job evaluation is completed in memory. After all processing is complete, the engine immediately initiates an update operation to the real-time job profile database: [update the job profile]. The feature vector field in the portrait data is updated to This update re-enters the derived fields, such as correlation strength, with the calculated values, and changes the status field for that position from "invalid" to "valid" or "updated." This operation ensures that the database status is synchronized with the latest map.

[0089] The engine iteratively processes each job in the set of jobs to be updated, repeating the process of extracting subgraphs, calculating embeddings, aggregating vectors, updating the database, and adding to the list. Once all jobs in the set have been processed, the list of affected job features is completed, containing the latest feature representations of all reconstructed jobs. This list, as the core output of this step, will be cached in memory or written to temporary storage for use in subsequent steps.

[0090] It should be noted that the job requirement subgraph is a finite subnetwork obtained through graph traversal within the dynamic knowledge graph of occupational skills, starting from the set of core skill nodes for a specific job. It includes core skill nodes, other skill nodes directly or indirectly related to these core skills, and entity nodes such as courses and projects connecting these nodes. Its scope is controlled by the number of traversal hops, typically set to 2 hops, to cover core skills and their closely related prerequisite skills, extended skills, and teaching resources.

[0091] Graph embedding algorithms are methods that map graph nodes to a low-dimensional continuous vector space, ensuring that similar nodes in the graph (with similar connectivity or neighboring nodes) are also similar in the vector space. The Node2Vec algorithm illustrated in this implementation flexibly captures both structural and functional similarities of the network by adjusting random walk parameters. Parameters such as walk length... Number of walks, return parameters Input / output parameters and the final generated vector dimension It needs to be pre-configured. For example, based on the fact that the number of nodes in the occupational graph is typically in the tens of thousands to hundreds of thousands, it can be set... Each node is visited 10 times. , , These parameters are based on empirical values ​​and can be fine-tuned through downstream tasks, such as job matching accuracy.

[0092] A requirement feature vector is a digital, dense vector representation of the skill set required for a job. It is composed of graph embedding vectors of the core skill nodes for that job, encoding the topological relationships between skills. The vector dimension depends on the number of core skills. and embedding dimension If splicing is used, then it is If the average is used, then it is .

[0093] The Affected Job Feature List is a data structure used to convey the latest features of all jobs restructured during this graph change cycle. It is an array, with each element corresponding to a job and containing key information such as the job ID and its feature vector. This list serves as a crucial data bridge connecting "graph update - job restructuring" with "user path replanning," ensuring that the impact of changes is accurately delivered to users who need to update their paths.

[0094] For example, following the example from step S3, the set of jobs to be updated is ["JOB_ML_ENGINEER", "JOB_DATA_ANALYST"]. The job profile partial reconstruction engine first processes "JOB_ML_ENGINEER". The engine reads its core skill node list from the profile library. Then, a Cypher query is sent to the graph database: with Starting from the three nodes, match all nodes and edges within a two-hop path. Assume the query returns a subgraph. It includes nodes such as SK_PY, SK_ML, SK_LINUX, CO_PY_INTRO, PROJ_ML1, and SK_ALG, as well as the edges between them, and all edges have carried the dynamic weights updated in step S2.

[0095] Next, the graph embedding computing service receives... Run the Node2Vec algorithm. Set the parameters: vector dimension. Length of travel After training with random walks and Skip-grams, the algorithm generates a 128-dimensional vector for each node in the subgraph. The engine extracts the vectors corresponding to the core skill nodes SK_PY, SK_ML, and SK_LINUX, assuming they are respectively... The engine uses a weighted average aggregation to calculate the weight of each node. For example, the sum of the weights of all edges in the subgraph for node SK_PY is 2.5, for SK_ML it's 2.1, and for SK_LINUX it's 1.8. The resulting weighted average is the job requirement feature vector. .

[0096] The engine will ("JOB_ML_ENGINEER", Add it to the list of affected job features currently being built. Simultaneously, update the database to set the feature vector field of the JOB_ML_ENGINEER profile to... The status has been changed to "valid".

[0097] Similarly, the engine processes "JOB_DATA_ANALYST", extracts its core skill list ["SK_PY", "SK_SQL", "SK_STATS"], obtains its updated requirement subgraph, and calculates new feature vectors. And update the database.

[0098] Ultimately, the generated list of affected job features contains two entries: [{"Job ID":"JOB_ML_ENGINEER","Feature Vector": },{“Job ID”:“JOB_DATA_ANALYST”,“Feature Vector”: This list serves as the output of step S4.

[0099] S5. Perform correlation screening between the list of affected job characteristics and the current path planning status of candidate users, and lock in the set of users to be replanned whose intersection results are not empty.

[0100] In a preferred embodiment, locking the set of users to be replanned whose intersection results are not empty includes: obtaining the current path planning status of candidate users, wherein the candidate users are determined based on the time difference between their latest interaction timestamp and the current system time being within a preset activity threshold; the current path planning status includes the skill nodes that the user has mastered and the original target job nodes.

[0101] Determine whether the original target job node or the skill node already mastered is included in the list of affected job characteristics;

[0102] Candidate users whose judgment result is yes are marked as pending objects, and a set of users to be replanned is generated.

[0103] The specific implementation process of this invention for dynamically locking the target user association set that requires replanning based on path association screening is as follows:

[0104] The user path correlation screening service within the system is activated, taking as input a list of affected job characteristics. This service first retrieves the current path planning status of all candidate users within the system from persistent storage. Persistent storage can be a Redis cache or a user progress table from a relational database. A user is defined as a candidate user if their most recent interaction occurred within a preset time window, such as the past 7 days. For each candidate user... The current path planning status is a structured data object containing at least two key fields: First, a "List of Mastered Skill Nodes," which records the node identifiers in the knowledge graph for each skill the user has mastered, inferred by the system from the user's completed learning records (courses, projects, certifications); second, a "Previously Planned Target Job Node," which records the unique identifier of the job node corresponding to the user's chosen final career goal in the dynamic knowledge graph of professional skills during the user's last path planning or self-setting. The service loads the current path planning status of all candidate users into memory through batch queries, forming a user status set.

[0105] Next, the service performs path correlation determination. This determination process examines each candidate user in the user state set. Performed independently. The decision engine reads the user's... Given the current path planning status, extract its "original target job node" identifier, and denot it as... At the same time, extract user information. The "List of Skills Mastered" is denoted as Then, the engine iterates through each entry in the list of affected job characteristics, and for each entry in the list, the engine reads the unique job identifier it contains. .

[0106] The judgment is conducted in two levels: the first level involves checking the user's original target job node. Is it equal to any job identifier in the list? If they are equal, it means the user... The original target position happened to be one of the positions affected by this map change, and its path endpoint requirements have changed. At the second level, if the first level doesn't match, a deeper check is performed: each position in the affected position feature list is retrieved. The corresponding updated job requirement subgraph (or the range of affected skills derived from its core skills list) reconstructed in step S4. Check the user. The "List of Skills Acquired" Does the graph contain any skill node that falls within the scope of the affected skills? If so, it means that even if the user's target job is not directly affected, the value or future development path of the skills they currently possess, which serve as intermediate nodes in their path, may change due to the graph change, thus indirectly affecting the user's path planning.

[0107] The above determination process is logically equivalent to a set intersection operation. (The user...) The relevant states are considered as a set All the information affected in this incident will be considered as a set. It contains all job identifiers in the affected job feature list and their corresponding core skill node identifiers (which can be obtained from the job requirement subgraph associated with the feature list). System calculation and The intersection of. This operation is performed by... Preloaded into a hash set, then quickly checked. The existence of each element in the hash set is determined by whether it exists in the hash set.

[0108] Based on the result of the intersection operation, the service performs a locking operation. If for the user... The intersection result is an empty set, i.e. If the current path replanning result is not empty, it indicates that the change in the current path graph does not directly affect the target position or the skill nodes already mastered. The system determines that the user does not need to immediately replan their path, their existing path planning status remains valid, and the service does not modify the user's record. Conversely, if the intersection result is not empty, i.e. Then determine the user This is the object to be processed. The service adds the user's unique identifier to a temporary list. After iterating through all candidate users, this temporary list is formally defined as the set of users to be replanned. The generation of this set allows for the precise filtering from the global candidate user pool of users whose core skills or target positions are indeed affected by this graph change. This defines a clear and necessary processing scope for subsequent calculation steps, enabling the omission of calculations to initiate subsequent processes on demand.

[0109] The core operations in this step are logical judgment and set operations; the essence of the judgment is to check whether two sets have an intersection. Let the user... The set of states is The set of impacts of this change is as follows The judgment criteria are:

[0110]

[0111] in, This represents the empty set.

[0112] It should be noted that the current path planning status is a data snapshot maintained by the system for each candidate user, reflecting their current position and goals in their career development.

[0113] The list of mastered skill nodes is a list of identifiers mapped to the corresponding skill nodes in the dynamic knowledge graph of professional skills, based on the learning outcomes that the user has confirmed have been completed or verified through system assessments (such as course completion certificates, project submissions that have passed review, and certification exam scores). This list is dynamically updated as the user's learning progresses.

[0114] The original target job node is the node identifier in the map of the job that the user sets in the current navigation session, or that the system recommends based on the user's historical preferences and which the user adopts, and which the user hopes to reach.

[0115] The job identifiers and their associated core skill node lists in the affected job characteristic list (which can be obtained directly from the entries in this list, or by querying the reconstructed job requirement subgraph in S4 through job ID association) together constitute the set of impacts of this change. .

[0116] The set of users to be replanned consists of all those who meet the following conditions. The list consists of unique identifiers of candidate users who meet the criteria. This set is a key component of this scheme to achieve cascading triggering and precise allocation of computing resources. It ensures that subsequent time-consuming path replanning algorithms are only executed for users who truly need updates, thereby achieving efficient response at the system level in large-scale user scenarios.

[0117] For example, following the example from step S4, the generated list of affected job characteristics contains two jobs: JOB_ML_ENGINEER and JOB_DATA_ANALYST. Assume that from this list and related data, it can be determined that the core skill nodes affected mainly include SK_PY, SK_ML, SK_LINUX, SK_SQL, SK_STATS, etc. Then the affected set...

[0118] .

[0119] The user path association screening service loads the current candidate user status. Assume there are the following three candidate users:

[0120] User U123: The original target job node was "JOB_ML_ENGINEER", and the list of skills already mastered is ["SK_PY", "SK_ALG"].

[0121] User U456: The original target job node was "JOB_WEB_DEV", and the list of skills already mastered is ["SK_JS", "SK_HTML"].

[0122] User U789: The original target job node was "JOB_DATA_SCI", and the list of skills already mastered is ["SK_PY", "SK_STATS", "SK_SQL"].

[0123] First, check user U123: Because "JOB_ML_ENGINEER" is in In the given set, the intersection is not empty, therefore U123 is marked as an object to be processed.

[0124] Next, check user U456: All elements in this set are not In the given set, the intersection is empty, therefore U456 is not marked.

[0125] Finally, check user U789: Although the target position "JOB_DATA_SCI" is not listed. However, they have already mastered the skills "SK_PY", "SK_STATS", and "SK_SQL". In the intersection, the set is not empty, so U789 is also marked as an object to be processed.

[0126] After the screening service completes its traversal, a set of users awaiting path replanning is generated as ["U123", "U789"]. User U456 has been successfully filtered out, and the system will not initiate a path replanning process for him / her, thus saving computing resources.

[0127] S6. For the set of users to be replanned, perform directional path replanning within the affected topological neighborhood of the dynamic knowledge graph of professional skills to generate a revised probabilistic path network.

[0128] In a preferred embodiment, for the set of users to be replanned, directional path replanning is performed within the affected topological neighborhood of the dynamic knowledge graph of occupational skills, including: taking the mastered skill nodes of each user in the set of users to be replanned as the starting point and the corresponding job requirement subgraph in the list of affected job features as the ending point;

[0129] Perform multi-objective path search within the affected topological neighborhood and calculate the transition probability of each path branch based on the inverse of the dynamic weight attribute.

[0130] In a further preferred embodiment, generating the revised probabilistic path network includes: simulating a new state vector after the user completes a path branch using graph embedding vectors;

[0131] Calculate the cosine similarity change between the new state vector and the job requirement feature vector to generate the expected matching benefit;

[0132] By associating the transition probability with the expected matching degree reward to the corresponding path branch, a revised probabilistic path network is constructed.

[0133] The specific implementation process of this invention, which performs directional path replanning within a restricted graph neighborhood to generate a revised probabilistic path network, is as follows:

[0134] The system's directional path replanning engine is activated, taking as input the set of users to be replanned and the list of affected job characteristics. This engine uses multi-threading or asynchronous task queues to process each user identifier in the set in parallel. For the currently processed user... The engine first retrieves the user's current path planning state from the user's state storage, obtains the list of mastered skill nodes, and denotes it as the starting point node set. At the same time, the engine depends on the user. Original target job node identifier Find the corresponding entry in the list of affected job features and obtain the updated requirement feature vector for that job. And related job requirement sub-map information. If the user If the target job position does not appear directly in the affected list (i.e., the user is included in the set because of the skills they have already acquired), the engine needs to extract the demand subgraph for that job position from the latest graph as the endpoint constraint.

[0135] Next, the engine determines the restricted topological neighborhood range for this path search. This range is directly inherited from the affected topological neighborhood range data (i.e., the list) defined in step S2 that triggered this cascading process. The engine uses this range information as a filter for graph queries, ensuring that all path search operations are performed only within the local subgraph formed by nodes and edges affected by graph changes, thereby significantly reducing the search space.

[0136] Within a defined, restricted neighborhood, the engine executes a restricted multi-objective path search algorithm. The specific implementation of this algorithm can be based on an improved Dijkstra's algorithm or the A* algorithm. The search... Each skill node in the process serves as an independent starting point, based on the job position. The set of core skill nodes in the demand subgraph is used as the target node set. The cost (or distance) of an edge is defined as the reciprocal of its dynamic weight attribute; that is, edges with higher weights (stronger connections) have lower traversal costs and are more likely to be selected in the path. During the search, the algorithm records the previous steps from each starting point to each reachable target node. Optimal path ( Typically 3 to 5), its optimality is based on minimizing the total cost of the path. Each searched path It is a sequence of nodes, such as [Skill A] Course X Skill B Project Z Skill C], where Skill C is one of the target skill nodes.

[0137] The engine then calculates the transition probability for each found path branch. The transition probability quantifies the likelihood of moving from the current node to the next node on the path. One calculation method is based on the normalization of local edge weights: for a path... The first Nodes Considering all possible outgoing edges (pointing to the next hop reachable node) within its restricted neighborhood, calculate the next node in the actual path selection. The step transition probability is :connect and The dynamic weight of the edge, divided by the weight from The sum of the dynamic weights of all valid outgoing edges from the starting point; the entire path. transition probability It can be approximated as the product of the transition probabilities of each step.

[0138] Another approach is to perform Softmax normalization based on the global score of the path: first, for each path... Calculate a score For example, it equals the negative of the total path cost (the lower the cost, the higher the score); then, for the set of all candidate paths from a starting point to the same destination node... ,path Probability of being recommended Calculated as Divide by all candidate paths The sum of This is an exponential function with the natural constant e as its base. Therefore, the better (lower-cost) path will receive a higher probability of being recommended.

[0139] Simultaneously, the engine needs to re-evaluate the expected matching benefit of each path branch. To this end, the engine maintains a matching prediction model. This model uses the user's current state vector (aggregated from the graph embedding vectors of the skill nodes they have mastered) and a path... As input. The model will use the path The graph embedding vectors of the new skill nodes learned in the plan are progressively superimposed onto the user's current state vector to simulate the user's new state vector after completing the path. Then, the simulated new state vector and the target job feature vector are calculated. The cosine similarity. This similarity is related to the user's current state and... The difference in similarity is the expected matching benefit along this path. .

[0140] This step involves calculating candidate path scores and normalizing their probabilities, as well as evaluating the expected matching benefit. Path Score It can be based on its total cost Calculation. Assume the path. Include edge, the first The dynamic weight of the edge is , Representing a path The sequential step index of the directed edge has a value ranging from 1 to 1. , Then its total cost can be defined as the sum of the costs of each side, where the cost of one side is... With weight Negative correlation, for example .therefore:

[0141]

[0142] The path score can then be defined as:

[0143]

[0144] For those traveling from the same starting point to the same target node Candidate paths, paths Probability of being recommended Calculated using the Softmax function:

[0145]

[0146] in, It is a temperature parameter used to control the sharpness of the probability distribution. . The comprehensive evaluation score representing the k-th candidate path is calculated based on the dynamic weight attribute W of all directed edges traversed by the path. Since the dynamic weight decays over time and increases with events, this score reflects the real-time relevance of the path. The first one in the candidate path set The scores of each path are obtained by exponentially normalizing the scores of all paths to generate the recommendation probability distribution for each path. This represents the index of the traversal variable in the candidate path set, used to sum all n candidate paths in the normalized denominator of the Softmax function.

[0147] Expected matching benefit The calculation is based on vector similarity. Let the user's current state vector be... Simulate the completion path The new state vector is The feature vector of the target position is .but:

[0148]

[0149] in, For cosine similarity, for any vector and Its definition is as follows:

[0150]

[0151] Representing vectors with vector dot product, Represents the magnitude of a vector. The larger the value, the more significant the expected improvement in the user's career matching effect of the path.

[0152] Finally, the engine aggregates the results and generates a user-specific... The revised probabilistic path network is a graph data structure where nodes are related entities within a restricted neighborhood, and edges include not only relationships from the original graph but also path branch information computed in this search. Specifically, for each searched candidate path... Generate a path description object, which contains: the path node sequence and the overall path transition probability. (or path selection probability) ), Path expected matching degree benefit And the estimated total time for the route (which can be estimated based on the average completion time of courses and projects within the route). All for users. The generated set of path description objects, along with their associated nodes and edges, constitutes a probabilistic path network. After processing all users in the set of users requiring replanning, the engine generates a corresponding revised probabilistic path network for each user.

[0153] It is important to note that restricted multi-objective path search algorithms are algorithms that find multiple optimal paths from a set of origin nodes to a set of destination nodes within a local subnet of a given graph structure. Their restriction lies in the fact that the search space is strictly limited to the affected topological neighborhood. "Multi-objective" refers to the objective being a set of nodes (e.g., the set of nodes representing core job skills). Common implementations include Yen'sK shortest path algorithm or heuristic search algorithms with pruning.

[0154] Transition probability represents the estimated likelihood that, at a certain decision point (node) on a path, the system will recommend the user move to the next specific node. Its calculation can be based on locally normalized edge weights (reflecting immediate correlation strength) or on Softmax normalization of the path's global score (reflecting the overall quality of the path). Temperature parameter. Used to adjust the concentration of the probability distribution. The larger the value, the more concentrated the probability of high-scoring paths; a typical value can be set to 1.0.

[0155] Expected matching benefit is a quantitative assessment of the anticipated contribution of a development path to improving the matching degree between users and target positions. It is measured by comparing the change in similarity between the user's feature vector and the position's feature vector before and after completing the path. Its calculation relies on a simulated state update process that assumes that successfully completing the learning unit on the path will lead to mastery of the corresponding skill, and integrates the embedding vector of that skill node into the user's state vector in some way (such as vector addition or averaging).

[0156] The revised probabilistic path network is the core output of this replanning project. It is a composite data structure containing topological information and metadata. It not only includes nodes and edges, but also labels several candidate paths with probability and reward, forming a weighted directed hypergraph that can be used for decision support.

[0157] For example, following the example from step S5, the set of users to be replanned includes users U123 and U789. Taking user U789 as an example, their list of mastered skill nodes... The original target position was "JOB_DATA_SCI". It is assumed that while "JOB_DATA_SCI" is not directly affected by this change, some of its core skills overlap with the affected skills.

[0158] The directional path replanning engine first determines the restricted neighborhood as The corresponding node range. Assume that the core skill requirements for the target position "JOB_DATA_SCI" in U789 in the latest skill graph are ["SK_PY", "SK_STATS", "SK_SQL", "SK_ML_BASIC"]. The engine uses... Starting from [SK_ML_BASIC], and using [SK_ML_BASIC] as the set of new target skill nodes to be acquired (since other skills have already been mastered), a path search is performed within a restricted neighborhood. Assume there are two paths from "SK_PY" to "SK_ML_BASIC" within the neighborhood: Path :[SK_PY CO_ML_INTRO [SK_ML_BASIC], with edge weights of 1.1 and 1.3 respectively. Path :[SK_PY PROJ_DATA1 SK_DATA_PROCESS CO_DP_TO_ML [SK_ML_BASIC], with edge weights of 1.0, 0.9, 1.2, and 1.1 respectively.

[0159] Calculate path cost: ; ;Score: , .

[0160] Use Softmax to calculate the selection probability, let : , The total is 0.208. Therefore... , .

[0161] Next, we evaluate the benefits. Assume user U789's current state vector... With JOB_DATA_SCI feature vector The similarity is 0.7. Simulation complete. Afterwards, the user masters SK_ML_BASIC, the new state vector. Obtained through vector operations, and its relation to The similarity was calculated to be 0.8, then Simulation complete. Afterwards, although it also mastered SK_ML_BASIC, the path was longer and might involve redundant learning. The similarity calculation was 0.75. .

[0162] Ultimately, the revised probabilistic path network generated for user U789 contains two main path branches: path (Probability 0.90, Expected Return +0.10) and Path (Probability 0.10, expected return +0.05). The engine performs calculations for user U123 in a similar manner. All results are stored in a structured format, awaiting further visualization and compression processing.

[0163] S7. Adaptively compress and visualize the revised probabilistic path network, and output dynamic navigation instructions to the user terminal.

[0164] In a preferred embodiment, outputting dynamic navigation instructions to the user terminal includes: identifying nodes in the revised probabilistic path network whose frequency of occurrence exceeds a preset threshold and marking them as path convergence nodes;

[0165] Based on the path convergence node, the system performs graph structure backbone extraction on the path network and aggregates a set of nodes with multiple branch paths into a single logical node or decision cluster to generate hierarchical navigation visualization data.

[0166] Push navigation visualization data to the user terminal to drive the user terminal's interface rendering update and output real-time action guidance.

[0167] The specific implementation process of this invention, which performs adaptive compression and visualization mapping of the path network and outputs dynamic navigation instructions, is as follows:

[0168] The system's path compression and visualization engine is activated, taking into account a revised probabilistic path network tailored to a specific user. The engine first performs critical path extraction. It then iterates through all candidate paths in the revised probabilistic path network, each labeled with a path selection probability. It sets a probability threshold. For example, 0.2. The engine filters out all paths with a probability greater than 0.2. The high-probability paths constitute a set of high-probability paths. Next, the engine processes the collection. It performs a node sequence alignment analysis on all paths. It calculates the frequency of each node's occurrence in these high-probability paths. If a node appears in the set... In paths that exceed a certain proportion (e.g., 80%), the node is marked as a path convergence node. The engine then sorts all identified path convergence nodes according to their topological order on the user's typical development path (usually based on prerequisite relationships in the graph or their position in the path sequence), forming a convergence node sequence. .

[0169] Subsequently, the engine converges based on the path convergence node sequence. The engine performs backbone merging and branch folding on complex probabilistic path networks. On the graph data structure, the engine performs the following operations: First, it uses a sequence of convergent nodes... The nodes in the framework form a backbone path. This backbone path clearly outlines the core development stages from the user's current skills (usually the first convergence node or starting point) to the core skills of the target position. Then, the engine processes path branches that are not on the backbone but connect between two consecutive convergence nodes or branch off from a convergence node. For these branches, the engine aggregates their representation based on their path selection probability and expected matching benefit. Specifically, for branches connecting convergence nodes... and convergence node The engine folds the multiple optional branches into a logical "decision cluster." The metadata of this decision cluster includes: the number of optional branches, a brief description of the branch with the highest probability (such as the first two nodes), and the overall recommendation probability of the cluster (i.e., the sum of the probabilities of all branches). At the visualization level, these branches are not fully expanded, but are compressed into an interactively expandable node or an labeled aggregated edge.

[0170] After logical compression, the engine generates hierarchical navigation visualization data. This data is a structured object following a specific JSON Schema. Its top layer contains basic user information, target job title, and a sequence of main convergence nodes. Each convergence node object includes: node ID, node name (e.g., skill or course name), node type, estimated total learning time required to reach this stage, and a list of action suggestions associated with this node (e.g., "Start learning course X"). The "decision clusters" connecting the convergence nodes are represented as a special type of edge object, containing a cluster ID, start and end convergence node IDs, aggregate recommendation probability, and an array of sub-branches containing limited summary information. The entire structure forms a tree-like or hierarchical navigation plan with a clear main branch and controllable details.

[0171] Finally, the engine sends the navigation visualization data to the corresponding user's terminal via push notification service. The push service looks up the user's registered device token or session WebSocket connection based on their user ID, and uses Firebase Cloud Messaging or establishes a WebSocket push to send the data packet. Upon receiving the data, the user's terminal application (such as a mobile app or web frontend) has its rendering engine parse the JSON data, driving the UI components to dynamically refresh the career development path map. The path map is presented in the form of a roadmap, time-series path map, or node connection graph, with the main path highlighted and aggregation branches offering dropdown or click-to-expand details. Simultaneously, based on the most recent convergence node and its action suggestions, an instant action suggestion card is generated and displayed on the interface, such as "Next step recommendation: Start learning the 'Introduction to Machine Learning' course within 3 days to solidify your SK_ML_BASIC skills." This completes the entire closed loop from path map changes to final user interface updates.

[0172] It should be noted that critical path extraction is an algorithmic process for identifying common critical nodes from multiple candidate paths.

[0173] probability threshold This is used to filter high-probability paths, and its value typically ranges from 0.1 to 0.3. The rationale is to retain paths with recommendation value (not extremely low probability) for commonality analysis; too low a value may include too many noisy paths, while too high a value may miss valuable alternatives. For example, by analyzing historical user adoption rate data for recommended paths, it was found that paths with a probability higher than 0.25 had an adoption rate exceeding 70%, therefore, paths with a probability higher than 0.25 can be considered high-probability paths. Set to 0.25.

[0174] A path convergence node is a node that appears in most high-probability paths and represents a key development stage where skills cannot be bypassed. Its judgment ratio (e.g., 80%) is an adjustable parameter.

[0175] Backbone merging and branch folding is an information aggregation technique used to reduce the visual complexity and cognitive load of path networks. It abstracts multiple topologically similar and functionally substitutable path branches into an interactive aggregation unit.

[0176] Navigation visualization data is a structured data exchange format designed specifically for front-end rendering engines. It uses common formats such as JSON and defines specific fields and nested structures required in the job navigation domain to achieve separation of data and presentation.

[0177] Dynamic refresh refers to the user interface updating its path map and suggested content in real time by receiving new data pushed by the server, without requiring manual refresh, to provide a seamless experience.

[0178] For example, following the example from step S6, the revised probabilistic path network generated for user U789 contains two main path branches: (probability 0.90) and (Probability 0.10). The path compression and visualization engine receives this network. Set the probability threshold. Then the set of high-probability paths Only contains (Because 0.90 > 0.2, while 0.10 < 0.2).

[0179] analyze The node sequence is: [SK_PY, CO_ML_INTRO, SK_ML_BASIC]. Since there is only one high-probability path, all nodes on this path satisfy the condition of "100% occurrence rate". Assuming the business rules require that mandatory nodes must appear on a 100% high-probability path, then SK_PY, CO_ML_INTRO, and SK_ML_BASIC are all marked as path convergence nodes. The resulting sequence is after sorting. Since there are no other high-probability branches, complex branch folding is unnecessary. The main path is... .

[0180] The engine generates hierarchical navigation visualization data, the main part of which is described as follows: Starting from the current state (having mastered SK_PY, etc.), the first step is to complete the convergence node "CO_ML_INTRO" (an introductory course in machine learning), and finally reach the convergence node "SK_ML_BASIC" (mastering basic machine learning skills). An action suggestion is generated for the convergence node "CO_ML_INTRO": "Immediately register on platform Y and start learning the 'Introduction to Machine Learning' course, estimated to take 40 hours." The entire data package is pushed to user U789's terminal app. The app interface refreshes; where a complex network diagram might have been previously displayed, a clear progress path line with three nodes is now shown. The current node is "SK_PY" (already mastered), and the next node is "CO_ML_INTRO," accompanied by the aforementioned action suggestion prompt. User U123's interface is also updated and simplified in a similar way based on their replanned path network.

[0181] The above content is merely an example and illustration of the concept of the present invention. Those skilled in the art can make various modifications or additions to the specific embodiments described, or use similar methods to replace them, as long as they do not deviate from the concept of the invention or exceed the scope defined by the present invention, and all such modifications and additions should fall within the protection scope of the present invention.

Claims

1. A method for navigating the career path of college students based on dynamic knowledge graphs and job profiles, characterized in that: include: S1. Obtain the micro-behavioral signal flow from the user terminal and the macro-market demand signal flow from the recruitment platform, and maintain a dynamic knowledge graph of professional skills containing dynamic weight attributes; Acquire user micro-behavioral signal streams from user terminals and market macro-demand signal streams from recruitment platforms, including: By using an embedded data acquisition agent to record users’ click sequences, learning duration and assessment pass rates for courses or projects, a stream of user micro-behavioral signals is generated. By using market data crawling services, we can extract the frequency of mentions of job skill keywords and salary fluctuation data from recruitment platform interfaces to generate a macro market demand signal stream. S2. Identify graph change events based on the rate of change between user micro-behavior signal flow and market macro-demand signal flow, trigger incremental updates of the professional skills dynamic knowledge graph, and generate a graph change flag package containing data on the affected topological neighborhood range. S3. Analyze the map change flag package, lock the jobs whose core skills fall within the affected topological neighborhood from the real-time job profile database, and generate a set of jobs to be updated; S4. For the set of positions to be updated, perform partial reconstruction of the position profile based on the incrementally updated dynamic knowledge graph of occupational skills, and output a list of affected position features containing the updated position requirement feature vectors. S5. Perform correlation screening between the list of affected job characteristics and the current path planning status of candidate users to identify the set of users whose intersection results are not empty and need to be replanned. S6. For the set of users to be replanned, perform targeted path replanning within the affected topological neighborhood of the dynamic knowledge graph of professional skills to generate a revised probabilistic path network. S7. Adaptively compress and visualize the revised probabilistic path network, and output dynamic navigation instructions to the user terminal.

2. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Maintaining a dynamic knowledge graph of occupational skills that includes dynamic weighted attributes, including: Construct a graph topology with skills, courses, projects, positions, and certifications as nodes; Configure dynamic weight attributes for the edges between nodes that decay over time, and enhance or weaken the dynamic weight attributes in real time based on the micro-behavioral signal flow of users and the macro-demand signal flow of the market.

3. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Step S2 includes: Calculate the magnitude of changes in the association weights of skill nodes and the number of newly added associations; When the magnitude of the change in associated weights or the number of new additions exceeds the preset change threshold, it is determined to be a map change event; Extract the nodes affected by the graph change event and their adjacent nodes within a preset hop count range, define them as the affected topological neighborhood range data, and encapsulate them into a graph change flag package.

4. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Generate a set of job postings to be updated, including: Extract the affected topological neighborhood range data from the map change flag package; Traverse the real-time job profile database to determine whether there is any overlap between the core skill node list of each job and the affected topological neighborhood range data. Jobs that overlap are marked as invalid and added to the set of jobs to be updated.

5. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Based on the incrementally updated dynamic knowledge graph of professional skills, a partial reconstruction of job profiles is performed, including: In the incrementally updated dynamic knowledge graph of occupational skills, extract the job requirement subgraph centered on the core skills of each job in the set of jobs to be updated; The node vector representation of the job requirement subgraph is calculated using a graph embedding algorithm, and the job requirement feature vector is generated by aggregating the vectors of the core skill nodes.

6. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Lock the set of users to be replanned whose intersection results are not empty, including: The current path planning status of candidate users is obtained. The candidate users are determined based on the time difference between their latest interaction timestamp and the current system time being within a preset activity threshold. The current path planning status includes the skill nodes that the user has mastered and the original target job nodes. Determine whether the original target job node or the skill node already mastered is included in the list of affected job characteristics; Candidate users whose judgment result is yes are marked as pending objects, and a set of users to be replanned is generated.

7. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, For the set of users requiring replanning, targeted path replanning is performed within the affected topological neighborhood of the dynamic knowledge graph of professional skills, including: Starting with the mastered skill nodes of each user in the set of users to be replanned, and ending with the corresponding job requirement subgraph in the list of affected job characteristics; Perform multi-objective path search within the affected topological neighborhood and calculate the transition probability of each path branch based on the inverse of the dynamic weight attribute.

8. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 7, characterized in that, Generate the revised probabilistic path network, including: Graph embedding vectors are used to simulate the new state vector of a user after completing a path branch; Calculate the cosine similarity change between the new state vector and the job requirement feature vector to generate the expected matching benefit; By associating the transition probability with the expected matching degree reward to the corresponding path branch, a revised probabilistic path network is constructed.

9. The method for college student career path navigation based on dynamic knowledge graph and job profile as described in claim 1, characterized in that, Output dynamic navigation instructions to the user terminal, including: Nodes that appear more frequently than a preset threshold in the revised probabilistic path network are identified and marked as path convergence nodes; Based on the path convergence node, the system performs graph structure backbone extraction on the path network and aggregates a set of nodes with multiple branch paths into a single logical node or decision cluster to generate hierarchical navigation visualization data. Push navigation visualization data to the user terminal to drive the user terminal's interface rendering update and output real-time action guidance.

Images