An interview resource scheduling method and system based on markov decision

Abstract

A Markov decision-based interview resource scheduling method and system is presented. The system incorporates the interview stage state machine into the MDP state space, changing the state transition probability matrix during the interview stage. Differentiated routing constraints set three-dimensional constraints: delay, computational budget, and quality. A dual-track quality prediction mechanism addresses the unobservable problem before response quality decisions. Bayesian optimization automatically solves the routing threshold. Online Q-learning learns the optimal strategy in real time. The inference link elastic budget is dynamically adjusted based on the number of floating-point operations. Differentiated lifetime scheduling using key-value caching is implemented. Quality-driven stage transition probabilities transform state transitions into scheduling quality functions. Intrinsic uncertainty robust scheduling guarantees a minimum quality threshold. An Interview Resilience Score (IRS) drives cross-session resource allocation. Response quality improved from 0.78 to 0.88, and computational resource utilization increased from 55.2% to 87.3%.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence and computing resource scheduling technology, specifically to a method and system for scheduling interview resources based on Markov decision-making. Background Technology

[0002] Current Technological Status: Computational resource scheduling for AI inference services has become a key technology for ensuring service quality. Chinese Patent CN117290535B discloses an adaptive routing method for online service requests based on Markov Decision Process (MDP), which uses the Markov Decision Process (MDP) state space containing request type and system load, and solves the routing strategy using policy gradients. Chinese Patent CN118733274A discloses a resource scheduling strategy optimization method based on AI training task metrics, which optimizes computational resource scheduling for AI training tasks through Markov Decision Process (MDP) modeling and deep Q-networks. Chinese Patent CN118194328B discloses an optimal allocation method for heterogeneous resources for AI inference platforms, which uses Markov Decision Process (MDP) modeling of a heterogeneous pool of Graphics Processing Units (GPUs) / Neural Processing Units (NPUs) and iteratively solves the constraint strategy. Chinese Patent CN115329087B discloses a cloud function resource allocation method based on Bayesian optimization, which optimizes Serverless resource allocation through a Gaussian process (GP) + Expectation Improvement (EI) acquisition function. Chinese patent CN121279400A discloses a method for intelligent routing and unified adaptation of large language models, which dynamically selects the optimal large language model instance through a strategy engine and integrates circuit breaker and degradation governance functions. Chinese patent CN121750538A discloses a multi-model intelligent routing method with memory and adaptive capabilities, which selects the target model based on user preferences and real-time service status through a hybrid decision-making strategy.

[0003] The shortcomings of the prior art: The aforementioned prior art has the following common shortcomings: The scheduling resource demanders lack multi-agent negotiation capabilities: the routing decisions of CN121279400A and CN121750538A are executed by a centralized policy engine, and the resource demanders (i.e., the functional agents) cannot participate in the scheduling decision. The applicant's concurrent application, "Interview Assistance Method and System Based on Causal Intervention Perception Multi-Agent Negotiation and Degradation," discloses a multi-agent negotiation mechanism where agents compete for tasks based on causal confidence and provide counter-proposals when overloaded. However, the resource demand signals generated by this negotiation mechanism are not incorporated into the decision input of the scheduling system.

[0004] The scheduling state space lacks awareness of the interview scenario: The MDP state spaces of CN117290535B and CN118733274A only contain pure system metrics such as request type and system load. CN118733274A uses MDP for computational resource scheduling in AI training tasks rather than in the interview scenario, and therefore does not include interview stage information. In the interview scenario, the requirements for latency and computational quality are drastically different at different stages. Existing scheduling methods cannot be aware of the interview stage, resulting in all requests using the same scheduling strategy.

[0005] Routing decision thresholds rely on manual setting: The decision thresholds of existing AI inference routing methods are all manually set, which cannot adapt to changes in data distribution, and the setting process lacks theoretical basis.

[0006] The scheduling optimization objectives lack a computational resource consumption dimension: CN118194328B's optimization objectives are latency and load balancing, neither of which considers floating-point operations (FLOPs) as an optimization dimension. In interview assistance scenarios, the FLOPs consumption varies greatly across different computational levels; ignoring the FLOPs dimension leads to a waste of computational resources.

[0007] Lack of online policy adaptation capability: The Bayesian optimization in CN115329087B is an offline method, which cannot adjust the scheduling strategy in real time according to changes in online traffic.

[0008] In addition, Chinese patent CN116360946A discloses an intelligent scheduling method for cloud gaming scenarios based on deep dual reinforcement learning (DDQN). The cloud gaming task scheduling decision process is constructed as a Markov decision process (MDP). The activation function is constructed with the goal of minimizing service quality and edge cloud costs. The state space includes system indicators such as task bandwidth usage, minimum CPU / GPU usage, frame rate requirements, and latency requirements. However, this patent is aimed at cloud gaming scenarios rather than interview scenarios. The MDP state space does not contain interview stage information. The optimization goal is frame rate and latency rather than response quality and floating-point operations (FLOPs). Furthermore, it adopts deep dual reinforcement learning (DDQN) instead of the Bayesian optimization + Q-learning dual-track mechanism. Chinese patent CN120821575A discloses a GPU cluster scheduling strategy optimization system based on deep reinforcement learning. It transforms the GPU cluster scheduling problem into a Markov Decision Process (MDP) and uses a deep neural network to obtain the optimal scheduling strategy to address the temporal shortsightedness problem of traditional schedulers. However, this patent is geared towards general GPU cluster scheduling rather than interview scenarios. The MDP state space does not include interview stage information, and the optimization objective is resource utilization efficiency rather than a three-dimensional Pareto optimization of latency / quality / floating-point operations (FLOPs). Furthermore, it does not include a quality prediction model or an inference link-aware elastic computing budget. Chinese patent CN118524411A discloses a GPU resource allocation method with interference awareness for edge inference applications. It transforms the long-term queue averaging optimization problem into a single-slot multi-objective optimization using Lyapunov and employs Markov approximation iterative solutions. However, this patent is geared towards edge inference scenarios rather than interview scenarios. The optimization objectives are throughput and deployment model accuracy rather than response quality and FLOPs. It does not include differentiated routing constraints driven by the state machine in the interview stage, nor does it include a dual-track mechanism for the quality prediction model or cross-scenario transfer learning.

[0009] Existing technologies include service level agreement (SLA)-aware multi-objective optimization frameworks, multi-cluster hierarchical reinforcement learning (RL) frameworks, and multi-agent reinforcement learning (MARL) frameworks. However, these solutions are all general cloud resource scheduling methods and do not include interview stage awareness or address the quality unobservability problem. Specifically, Chinese patent CN116257521A discloses a multi-agent cooperative scheduling method for hierarchical Markov decision processes. Its high-level MDP coordinates multi-agent task allocation, and the low-level MDP executes single-agent action selection. This is superficially similar to the hierarchical MDP architecture in this case, but the essential difference is that the high-level decision space of CN116257521A is multi-agent task allocation (general tasks), while the high-level decision space of this case is a state machine-driven stage transition in the interview stage (interview business stage). Furthermore, CN116257521A does not include interview stage constraints, Bayesian optimization initialization of the Q-table, or quality prediction feedback loop. In 2023, Chen et al. published FrugalGPT, which proposed model cascading routing (query → small model → large model) + hint optimization + caching. It is based on complexity adaptive routing and is similar to the ComputeTier hierarchical selection concept in this case. However, FrugalGPT uses rule + threshold routing and does not include MDP framework, Q-learning online learning, interview stage-aware constraints, Bayesian optimization threshold tuning, and FrugalGPT's optimization goal is cost minimization rather than three-dimensional Pareto optimization of latency / quality / floating-point operations (FLOPs). Chinese patent CN116522546A discloses a model parameter optimization method based on Gaussian processes and acquisition functions. Its Matern kernel + Expectation Improvement (EI) acquisition function + Latin Hypercube initialization is similar to the Bayesian optimizer implementation in this case. However, CN116522546A uses Bayesian optimization for model training parameter optimization, while this case uses Bayesian optimization for routing threshold optimization and combines it with Q-learning (Bayesian optimization initializes the Q-table + Q-learning online fine-tuning). This joint optimization scheme has not been reported in the prior art. This invention achieves differentiated scheduling for interview scenarios through a collaborative architecture of interview stage state machine + quality prediction model + Bayesian optimization + Q-learning initial Q-value + Pareto multi-objective + hierarchical MDP. Summary of the Invention

[0010] The technical problem to be solved: Table 1 Overview of Technical Issues and Core Solutions

[0011] Technical Solution: To solve the above-mentioned technical problems, this invention provides a method and system for scheduling interview resources based on Markov decision-making. The method runs in a cloud-native environment that includes a multi-level GPU computing cluster and an elastic resource scheduler, and includes the following steps: Step 1: State-space modeling of MDP driven by state machine in the interview stage: The interview process is modeled as a 6-stage state machine (pre-interview preparation, self-introduction, technical questions, behavioral interview, follow-up questions, and post-interview debriefing). Parameters for each stage are shown in Table 2. Stage transition rules: Pre-interview preparation to self-introduction (triggered by the interview session start signal), self-introduction to technical questions (duration > 120 seconds or the interviewer issues a technical question instruction), technical questions to behavioral interview (no follow-up questions for 2 consecutive rounds or the number of rounds reaches the preset limit), behavioral interview to follow-up questions (number of questions reaches 3 or the interviewer issues a follow-up question invitation), follow-up questions to post-interview debriefing (no further questions or duration > 180 seconds). `interview_phase` makes P(s'|s,a) change with the interview stage—the mean delay transition probability of `route_full_llm` in the technical question stage is μ = 800 milliseconds (ms), and in the follow-up question stage, μ = 650 milliseconds (ms). MDP state s=(gpu_util, queue_depth, avg_latency, error_rate, compute_budget, interview_phase, query_complexity), action a∈{route_regex, route_rules, route_lightweight_llm, route_full_llm} four computational levels; Table 2 Interview Stage Parameters

[0012] MDP state space definition: state s = (gpu_util, queue_depth, avg_latency, error_rate, compute_budget, interview_phase, query_complexity), where gpu_util is GPU utilization, queue_depth is request queue depth, avg_latency is average response latency, error_rate is error rate, compute_budget is remaining computational budget (normalized FLOPs, ∈ [0,1]), interview_phase is the current interview phase, and query_complexity is the predicted query complexity. Query complexity prediction: query_complexity = min(1, (token_count / 200×0.3 + jargon_density×0.4 + structure_depth / 3×0.3)), where jargon_density is the proportion of technical terms and structure_depth is the nesting depth of the question; high-complexity queries trigger computational layer upgrades in advance under low-resource conditions instead of waiting for delay timeouts; MDP action space definition: Action a ∈ {route_regex, route_rules, route_lightweight_llm, route_full_llm}, corresponding to four computational levels: regular expression matching (0 FLOPs, 0ms latency), rule engine (0.001 FLOPs, <5ms latency), lightweight large language model (LLM) (0.3 FLOPs, approximately 300ms latency), and full LLM (1.0 FLOPs, approximately 800ms latency); the LLM is a pre-trained model, and this invention only uses its inference interface; Step Two: Differentiated Routing Constraints Perceived During the Interview Stage The priority of constraints varies at different stages of the interview: delay constraints have the highest priority in the technical questioning stage, quality constraints have the highest priority in the behavioral interview stage, and budget constraints have the highest priority in the counter-questioning stage.

[0013] Hard constraint on delay: Scheduling decisions must satisfy latency(s,a) ≤ max_latency(interview_phase), and actions that violate this constraint are excluded; Computational budget constraint: Scheduling decisions must satisfy cumulative_flops ≤ compute_budget(interview_phase); if the budget is exceeded, the process is forcibly downgraded to a low FLOPs action. Quality lower limit constraint: The scheduling decision must satisfy quality(s,a) ≥ min_quality(interview_phase). If the quality does not meet the standard, it will be upgraded to a higher FLOPs action. Step 3: Design of the three-dimensional target reward function This invention treats FLOPs as an explicit optimization dimension rather than a constraint. The non-monotonic relationship between FLOPs and latency allows FLOPs, as an independent optimization dimension, to uncover efficiency improvement opportunities that latency optimization cannot. FLOPs also exhibit an interaction effect with the interview stage: different interview stages have varying tolerances for high-FLOPs actions, resulting in different quality-latency tradeoff curves for the same FLOPs consumption across different interview stages.

[0014] Reward function definition: (Formula 1) r(s,a) = -w1·latency(s,a) / max_latency - w2·flops(a) / max_flops +w3·quality(s,a) Where w1=0.4 is the delay penalty weight, w2=0.3 is the computation cost weight, w3=0.3 is the quality reward weight, and max_latency and max_flops are normalization constants. Quality Prediction Model: Since the response quality (s,a) cannot be directly observed before the action is executed, this invention introduces a quality prediction model that divides the reward calculation into two stages: The expected quality is used in the action selection phase: (Equation 2) r_expected(s,a) = -w1·latency_est(s,a) / max_latency - w2·flops(a) / max_flops + w3·q̂(s,a) The Q-learning update phase uses the actual quality: r_actual(s,a) = -w1·latency_actual / max_latency - w2·flops(a) / max_flops + w3·quality_actual Construction and online updating of the quality prediction model q̂(s,a): Initialize prior values: regular expression matching q̂0(route_regex) = 0.3, rule engine q̂0(route_rules) = 0.5, lightweight LLM q̂0(route_lightweight_llm) = 0.75, full LLM q̂0(route_full_llm) = 0.90. These prior parameters are determined based on the statistical average of N ≥ 10000 historical route records. State-aware correction: q̂(s,a) = q̂0(a) + Δq(s,a), where Δq(s,a) is calculated based on state clustering: the MDP state space is clustered into C=8 clusters according to gpu_util and queue_depth, and the runtime average quality q̄(c,a) is maintained for each cluster c and action a, Δq(s,a) = q̄(c(s),a) - q̂0(a) Training steps for state clustering: 1. Collect N ≥ 10000 historical routing records; 2. Standardize gpu_util and queue_depth using Z-score; 3. Initialize C = 8 cluster centers using K-means++, with a maximum of 300 iterations and a convergence threshold of 0.001; 4. When a new state s arrives, assign it to the nearest cluster c(s); 5. Update the step size η = 0.05 online. Online update: After each action is executed, update the running average of the corresponding cluster with the actual quality: q̄(c,a) ← (1-η)·q̄(c,a) + η·quality_actual The dual machine learning (DML) online estimation switching mechanism uses linear regression as the basic causal effect estimate when there are fewer than 20 historical observations. When there are 20 or more historical observations, it automatically switches to DML online estimation mode, constructing observation vectors from confounding variables Z and ratings Y. It calculates the residual vectors of Z and Y, and obtains the coefficient estimate by dividing the inner product of the residuals by the sum of squared residuals. The denominator threshold is set to 0.001 to prevent division by zero, thus improving the unbiasedness of the causal effect estimation. Step 4: Bayesian optimization to find the optimal route threshold Optimization variable definition: Routing decision threshold θ = (θ_regex, θ_lightweight, θ_quality), where θ_regex is the regular expression matching confidence threshold, θ_lightweight is the lightweight LLM upgrade threshold, and θ_quality is the quality upgrade threshold; θ is the decision boundary for MDP action selection—θ_regex determines whether a request enters the MDP decision process, θ_lightweight determines whether to upgrade to LLM inference, and θ_quality determines whether to trigger a computation level upgrade due to insufficient quality; Gaussian process surrogate model: Construct a surrogate model with GP(θ) as the objective function J(θ) = E[r(s,π_θ(s))]. The value of θ directly determines the action space of the MDP and thus the distribution of the reward function. Bayesian optimization is an integral part of the MDP solution process. The kernel function used is a Matern 5 / 2 kernel, the length scale is l=[1.0,1.0,1.0], the signal variance σ²=1.0, the noise variance σ_n²=0.01, and the initial observation points are 5 (Latin hypercube sampling). The desired improvement to the acquisition function is: EI(θ) = E[max(J(θ)-J_best, 0)], selecting θ with the largest EI as the next evaluation point to balance exploration and utilization; Iterative optimization: Update the GP model after each evaluation of the new threshold, repeat 4.3 until convergence or the maximum number of evaluations (50 times) is reached, and output the optimal threshold θ*; Information transfer between Bayesian optimization and Q-learning: θ* is directly used as the basis for generating the initial Q value of Q-learning, Q(s,a) = r_expected(s,a|θ), forming a collaborative process of "offline optimization → online learning"; Step 5: Pareto Multi-Objective Route Optimization Population initialization: Generate N=100 individuals for scheduling strategies; Multi-objective evaluation: For each individual, calculate the three-dimensional objective values ​​f1 = delay, f2 = -mass, and f3 = floating-point operation count (FLOPs) consumption; Non-dominated ranking: stratifying the population based on Pareto dominance; Crowding degree calculation: sort by crowding degree within the same Pareto level to maintain solution set diversity; Hard constraint filtering during the interview phase: Filter out solutions that violate the hard constraint of delay during the interview phase from the Pareto front; Strategy selection: Select a strategy from feasible Pareto fronts based on the priorities of the current interview stage—prioritize low-latency solutions during the technical questioning stage, and prioritize high-quality solutions during post-interview debriefing. Step Six: Hierarchical Markov Decision Process High-level MDP (Phase Strategy Layer): The state is the interview stage and the overall system state; the action is the phase transition decision; and the reward is the quality and time efficiency of phase completion. The lower-level MDP (Resource Action Layer): In each interview stage, the state is the system computation state of that stage, the action is the selection of the computation level, and the reward is the three-dimensional objective function r(s,a); Inter-layer information transmission: The stage decision of the higher-level MDP triggers the strategy switch of the lower-level MDP; the resource consumption of the lower-level MDP is fed back to the higher-level MDP - when the lower-level MDP continues to select high FLOPs actions, resulting in insufficient computing budget, the higher-level MDP can decide to end the current stage early. Step 7: Adaptive Online Q-learning Strategy Q-table initialization: The initial Q-table is generated using the optimal threshold θ obtained by Bayesian optimization, Q(s,a) = r_expected(s,a|θ); ε-greedy exploration: Exploring by selecting a random action with probability ε=0.1, and using the action with the highest Q value with probability 1-ε; Q-value update: Q(s,a) ← Q(s,a) + α·[r_actual(s,a) + γ·max_a'Q(s',a') - Q(s,a)], where α=0.01 is the learning rate and γ=0.95 is the discount factor; Online updates to the quality prediction model: After each Q-value update, the running average quality of the corresponding state cluster in the quality prediction model is updated synchronously. State encoding for interview phase perception: The state encoding of the Q-table includes the interview phase (interview_phase), enabling different optimal strategies to be learned for different interview phases; Training parameters: ε=0.1, α=0.01, γ=0.95, the Q-table dimension is 8×4=32 Q-values ​​in each interview phase, and a total of 192 Q-values ​​for 6 interview phases. Each interview generates approximately 50-100 routing records for online updates; Step 8: Elastic Computing Budget for Inference Link Awareness Inference chain modeling: The interview assistance request is modeled as an inference chain chain = [planning, retrieval, generation, verification], with the total chain consumption FLOPs_chain = FLOPs_plan + FLOPs_retrieve + FLOPs_gen + FLOPs_verify; Flexible budget dynamic adjustment: When the consumption of the preceding stage is lower than expected, the saved budget is transferred to the generation stage, allowing upgrades to higher computing levels; Flexible adjustment formula: (Equation 3) budget_gen = budget_phase × ρ_gen - (FLOPs_plan_actual + FLOPs_retrieve_actual - FLOPs_plan_expected - FLOPs_retrieve_expected), where ρ_gen is the budget proportion of the generation stage (ρ_gen=0.7 for the technical question stage, ρ_gen=0.5 for the counter-question stage). Step 9: Cold Start Acceleration and Transfer Learning Mechanism: Initialize the Q-table of the new scenario and Bayesian optimization agent model using policy parameters from historical interview scenarios to shorten the cold start convergence time; Step 10: Causal Constraint Propagation in the Interview Stage: Explicitly model the causal path of resource impact across stages through causal constraint graphs, enabling subsequent stages to perceive the consumption impact of preceding stages in their resource budgets. Step 11: KV Cache Live Time Scheduling Aware of the Interview Stage: Incorporate interview stage information into the KV Cache retention / eviction decision to achieve differentiated TTL settings aware of the interview stage and causal constraint-aware KV Cache degradation during stage transitions; Step 12: Mid-process upgrade scheduling based on LLM output entropy: During LLM inference, the output entropy is monitored in real time. When the entropy exceeds a specific threshold for a stage, the computation level is dynamically upgraded to ensure quality during inference. Step Thirteen: Quality-Driven Interview Phase Transition Probability Modeling and Resource Pre-allocation: The interview phase transition is modeled as a quality-driven random event, making the MDP state transition probability a function of scheduling decision quality, and resource pre-allocation or reservation is triggered based on the transition probability; Step Fourteen: Resource-Difficulty Game Equilibrium Control of the Adversarial Resource Upgrade Spiral: Model the difficulty adaptation of the interviewer and the resource allocation of the scheduling system as a game, and control the resource upgrade spiral by solving the resource-difficulty game equilibrium. Step 15: Robust scheduling for inherent uncertainties in irreversible interview paths: Solve for the optimal strategy in the worst case by iteratively solving the min-max values ​​to ensure the minimum guarantee line for interview quality; Step Sixteen: Interview Resilience Rating IRS-Driven Cross-Interview Session Resource Allocation: Define the Interview Resilience Rating IRS to quantify the vulnerability of interview sessions and drive cross-session resource allocation priorities; Beneficial effects

[0015] Compared with the prior art, the present invention has the following beneficial effects: 1. Differentiated scheduling perceiving the interview stage: By incorporating interview stage information into the MDP state space, scheduling decisions are made aware of the differentiated needs of the interview scenario, improving response quality from 0.78 for fixed routes to 0.88 (an improvement of 12.8%), and increasing computing resource utilization from 55.2% to 87.3%.

[0016] 2. Causal constraint propagation avoids cross-stage resource waste: By explicitly modeling the impact of resource consumption in preceding stages on subsequent stages through causal constraint graphs, the problem of excessive consumption in preceding stages leading to quality degradation in subsequent stages is avoided, and the cross-stage resource conflict rate is reduced by about 65%.

[0017] 3. Closed-loop dependency chain ensures scheduling robustness: The closed-loop dependency chain formed in steps thirteen to sixteen enables the mutual reinforcement of stage transition prediction, game equilibrium control, robust scheduling, and resilience scoring. The output of any link provides a key input for the next link, ensuring the minimum quality guarantee line of the scheduling system under the condition of uncertainty of the interviewer's strategy.

[0018] 4. Elastic Budget and Cold Start Acceleration: The elastic budget mechanism of the inference link allows for dynamic allocation of resources within a stage. The cold start transfer learning mechanism transfers strategies from similar scenarios to new scenarios, reducing the cold start time by 80%. Bayesian optimization for warm start reduces the number of convergences from 50 to about 15.

[0019] 5. Technical Relevance (Singleness of Invention) of the Three Sets of Technical Solutions (Steps 1-7, 8-12, and 13-16): The three sets of technical solutions in this invention share the same overall inventive concept—Markov Decision Process Scheduling Aware of the Interview Stage. Steps 1, 2, 3, 4, and 7 constitute the MDP scheduling framework for interview scenario awareness (Steps 5 and 6 are multi-objective optimization enhancements of this framework), Steps 8-12 constitute inference link optimization on this framework, and Steps 13-16 constitute closed-loop quality assurance on this framework. There is an inseparable bidirectional technical relationship among the three sets of technical solutions: 1. Dependence of steps eight to twelve on steps one to seven: The causal constraint propagation in step ten provides a cross-stage causal state dimension for Q-learning in step seven; the KV cache scheduling in step eleven depends on the differentiated TTL setting of the interview stage state machine in step one; the entropy upgrade in step twelve depends on the stage-specific threshold setting of the interview stage state machine in step one; the elastic budget in step eight depends on the computational budget constraint in step two; and the cold start migration in step nine depends on the Bayesian optimization threshold in step four and the Q-table in step seven; 2. Reverse reinforcement of steps eight to twelve on steps one to seven: The causal constraint propagation in step ten adds a causal constraint dimension to the Q-learning state encoding in step seven, enabling the decision to perceive the influence of preceding stages; the KV cache scheduling in step eleven depends on the different TTL setting of the interview stage state machine in step one; the entropy upgrade in step twelve depends on the stage-specific threshold setting of the interview stage state machine in step one; the elastic budget in step eight depends on the computational budget constraint in step two; and the cold start migration in step nine depends on the Bayesian optimization threshold in step four and the Q-table in step seven; Cache scheduling expands the MDP action space of step seven into a joint action space of routing and cache retention; entropy upgrading in step twelve provides positive feedback learning signals for the Q-learning upgrade strategy in step seven; 3. Dependence of steps thirteen to sixteen on steps one to twelve: the quality-driven transition probability of step thirteen takes the output of the quality prediction model in step three as input; the game modeling in step fourteen takes the state machine of the interview stage in step one as boundary conditions; the robust scheduling in step fifteen takes the Q-learning strategy in step seven as the basic policy parameters; and the IRS calculation in step sixteen takes the causal constraint propagation in step ten as the cross-stage causal factor; 4. Reverse reinforcement of steps one to twelve from steps thirteen to sixteen: the quality-driven transition probability of step thirteen provides advance prediction for the stage determination in step one, causing resource pre-allocation to be executed before stage switching; the resource-difficulty game equilibrium output in step fourteen provides game correction terms for the reward function in step three; the robust policy in step fifteen provides the worst-case policy lower bound for step seven; and the IRS feedback in step sixteen adjusts the resource allocation priority of the preceding stages in step ten.After removing steps thirteen through sixteen, steps one through twelve degenerate into an open-loop scheduling system that only adapts to known stage conditions. This results in the inability to predict stage transition timing, leading to a resource pre-allocation delay of approximately 2 seconds; the inability to control the upgrade spiral, causing the GPU budget overrun rate to increase from 3% to 18%; the inability to guarantee the minimum quality under uncertain interviewer strategies, causing the quality variance to increase from 0.05 to 0.15; and the inability to allocate resources according to session vulnerability, causing the failure rate of fragile sessions in concurrent sessions to increase from 2% to 12%.

[0020] Ablation experiment: On a test set of 10352 routing records, steps thirteen through sixteen were progressively removed to verify the contribution of each step. Table 3 Ablation Experiment Results

[0021] Ablation experiments verified the independent contributions and synergistic effects of steps thirteen through sixteen: removing step thirteen resulted in a 3.2% decrease in utilization due to resource pre-allocation delay; removing step fourteen resulted in an uncontrolled upgrade spiral that increased the quality variance from 0.05 to 0.09; removing step fifteen resulted in a worst-case quality variance of 0.12; removing step sixteen resulted in a concurrent vulnerable session failure rate of 2.1% to 8.3%; after removing all steps thirteen through sixteen, the response quality decreased from 0.88 to 0.82 (a decrease of 6.8%), computational resource utilization decreased from 87.3% to 79.5% (a decrease of 7.8%), the cross-stage resource conflict rate increased from 3.5% to 8.2% (an increase of 134%), the quality variance increased from 0.05 to 0.15 (an increase of 200%), and the concurrent vulnerable session failure rate increased from 2.1% to 12.0% (an increase of 471%), indicating that steps thirteen through sixteen are not a simple superposition of steps one through twelve but an indivisible synergistic whole.

[0022] This invention overcomes the following technical biases compared to the prior art: 1. Influenced by general cloud resource scheduling literature, those skilled in the art typically believe that MDP resource scheduling only needs to make decisions based on system metrics (GPU utilization, queue depth, latency) and does not need to incorporate business phase semantics. However, this invention discovers that the dynamic characteristics of MDP in interview scenarios change with the interview phase—the same action produces different state transition probability distributions in different interview phases. The interview phase changes the dynamic characteristics of MDP rather than merely acting as a label. This phase-dynamic coupling relationship is not easily conceived from a general scheduling perspective because traditional MDP scheduling assumes that the state transition probability matrix is ​​fixed or only changes with system metrics. This invention incorporates the interview phase into the MDP state space, enabling the scheduling strategy to adaptively adjust with the phase, improving the response quality from 0.78 to 0.88.

[0023] 2. Influenced by reinforcement learning literature, those skilled in the art typically consider Bayesian optimization and Q-learning to be two independent optimization methods—Bayesian optimization for offline hyperparameter search and Q-learning for online policy learning, with no information exchange required between them. However, this invention discovers that the optimal threshold of Bayesian optimization can be directly used as the basis for generating the initial Q-value in Q-learning, forming a collaborative process of "offline optimization → online learning," which increases the convergence speed of Q-learning by 3 times (from approximately 1500 steps to approximately 500 steps) and eliminates the problem of low policy quality in the cold start phase. This offline-online collaboration is not a conventional choice for those skilled in the art.

[0024] 3. Influenced by robust optimization literature, those skilled in the art generally believe that the uncertainty set is exogenous—independently determined by the environment and unchanging with decision-making. However, this invention finds that the difficulty adjustment range of the interviewer in an interview scenario directly depends on the quality of the answers generated by the scheduling decision, and the uncertainty set itself is a function of the scheduling strategy. This endogenous uncertainty invalidates the exogenous uncertainty assumption of traditional robust MDPs. This invention guarantees the minimum guarantee line of interview quality through robust scheduling with endogenous uncertainty, reducing the quality variance from 0.15 to 0.05. Attached Figure Description

[0025] Figure 1 This is an overall flowchart of the interview resource scheduling method based on Markov decision-making as described in the embodiments of the present invention; Figure 2 This is the overall architecture diagram of the state machine-driven Markov decision process in the interview stage as described in this embodiment of the invention; Figure 3 This is the four-layer computational hierarchy action space diagram described in the embodiments of the present invention; Figure 4 This is a flowchart of the Bayesian optimization process for finding the optimal threshold as described in an embodiment of the present invention; Figure 5 This is the Pareto 3D optimization and interview stage hard constraint filtering diagram described in the embodiments of the present invention; Figure 6 This is the inference link-aware elastic computing budget diagram described in the embodiments of the present invention; Figure 7 This is the cross-stage causal constraint propagation graph described in the embodiments of the present invention; Figure 8 This is the key-value cache (KV Cache) lifecycle scheduling diagram perceived during the interview stage as described in this embodiment of the invention; Figure 9 This is the inference mid-process upgrade scheduling graph based on LLM output entropy as described in the embodiments of the present invention; Figure 10This is the quality-driven interview stage conversion probability modeling and resource pre-allocation graph described in the embodiments of the present invention; Figure 11 This is the resource-difficulty game equilibrium control diagram of the adversarial resource upgrade spiral described in the embodiments of the present invention; Figure 12 This is the robust scheduling graph for inherent uncertainties in irreversible interview paths as described in the embodiments of the present invention; Figure 13 This is the Interview Resilience Score (IRS) driven cross-interview session resource allocation and closed-loop dependency chain diagram of steps thirteen to sixteen as described in the embodiments of the present invention.

[0026] Figure labeling: 1: State-machine driven MDP state space modeling in the interview stage; 1.1: Definition of state machine in the interview stage; 1.2: Definition of MDP state space; 1.3: Query complexity prediction; 1.4: Definition of MDP action space; 2: Differentiated routing constraints perceived in the interview stage; 2.1: Hard constraint on delay; 2.2: Computational budget constraint; 2.3: Quality lower limit constraint; 3: Design of three-dimensional objective reward function; 3.1: Definition of reward function; 3.2: Dual-track mechanism of quality prediction model; 3.3: Construction and implementation of quality prediction model 4: Line Update; 4: Bayesian Optimization for Solving the Optimal Route Threshold; 4.1: Definition of Optimization Variables; 4.2: Gaussian Process Surrogate Model; 4.3: Expected Improvement of Acquisition Function; 4.4: Iterative Optimization; 4.5: Information Transfer in Bayesian Optimization and Q-Learning; 5: Pareto Multi-Objective Route Optimization; 5.1: Population Initialization; 5.2: Multi-Objective Evaluation; 5.3: Non-Dominated Ranking; 5.4: Crowding Calculation; 5.5: Hard Constraint Filtering in the Interview Stage; 5.6: Policy Selection; 6: Hierarchical Markov Decision Process; 6.1: High-Level MDP Stage 6.1 Strategy Layer; 6.2: Low-level MDP Resource Action Layer; 6.3: Inter-layer Information Transfer; 7: Online Q-learning Strategy Adaptation; 7.1: Q-table Initialization; 7.2: ε-greedy Exploration; 7.3: Q-value Update; 7.4: Online Update of Quality Prediction Model; 7.5: State Encoding Aware of Interview Stage; 8: Elastic Computation Budget Aware of Inference Link; 8.1: Inference Link Modeling; 8.2: Dynamic Adjustment of Elastic Budget; 8.3: Budget Borrowing and Returning Mechanism; 8.4: Link-Aware Budget and Stage Constraint Coordination; 9 9.1: Scene Feature Encoding; 9.2: Cross-Scene Policy Transfer; 9.3: Bayesian Optimized Hot Start; 9.4: Negative Transfer Detection and Backtracking; 9.5: Online Scene Library Update; 10: Causal Constraint Propagation in the Interview Stage; 10.1: Causal Constraint Graph Between Stages; 10.2: Causal Constraint Propagation Formula; 10.3: Q-learning State Enhancement with Causal Constraint Awareness; 10.4: Counterfactual Constraint Evaluation; 10.5: Collaboration of Causal Constraints and Flexible Budget; 11: Key-Value Recognition in the Interview Stage Cache liveness time scheduling; 11.1: Differentiated TTL settings for the interview stage; 11.2: Causal constraint-aware KV cache degradation; 11.3: KV cache migration between GPU and CPU; 11.4: Expanding the action space; 12: Mid-inference upgrade scheduling based on LLM output entropy; 12.1: Real-time calculation of LLM output entropy; 12.2: Sliding window average entropy and threshold detection; 12.3: Mid-inference upgrade execution; 12.4: Entropy correction quality feedback; 13: Quality-driven interview stage transition probability modeling and resource pre-allocation; 13.1: Quality-driven stage transition probability modeling; 13.2: Resource pre-allocation triggering; 13.3: Resource reservation triggering; 13.4: Endogenization of MDP state transition probabilities; 14: Resource-difficulty game equilibrium control for adversarial resource upgrade spirals; 14.1: Game modeling; 14.2: Solving resource-difficulty game equilibrium; 14.3: Upgrade spiral detection and suppression; 14.4: Synergy between steps thirteen and fourteen; 15: Robust scheduling for irreversible interview paths with endogenous uncertainty; 15.1: Modeling of endogenous uncertainty sets; 15.2: Iterative solution of min-max values; 15.3: Robust Q-learning synergy; 15.4: Minimum guarantee line for interview quality; 16: Interview resilience score IRS-driven cross-interview session resource allocation; 16.1: Definition of interview resilience score; 16.2: Stage dependency of IRS; 16.3: IRS-driven cross-session resource allocation; 16.4: Online computation of IRS. Detailed Implementation

[0027] The embodiments of the present invention will be further described below with reference to the accompanying drawings and specific implementation details.

[0028] like Figure 1 As shown, the interview resource scheduling method and system based on Markov decision-making described in this invention includes the following steps: Step 1: MDP state space modeling driven by state machine in the interview stage; Step 2: Differentiated routing constraints perceived in the interview stage; Step 3: Design of three-dimensional objective reward function; Step 4: Bayesian optimization to solve for the optimal routing threshold; Step 5: Pareto multi-objective routing optimization; Step 6: Hierarchical Markov decision process; Step 7: Online Q-learning policy adaptation; Step 8: Elastic computation budget perceived by inference links; Step 9: Cold start acceleration and transfer learning mechanism; Step 10: Causal constraint propagation in the interview stage; Step 11: Key-Value pairs perceived in the interview stage. The system consists of sixteen steps: Cache liveness scheduling, Step 12: Mid-inference upgrade scheduling based on LLM output entropy, Step 13: Quality-driven interview stage transition probability modeling and resource pre-allocation, Step 14: Resource-difficulty game equilibrium control of adversarial resource upgrade spiral, Step 15: Robust scheduling for endogenous uncertainty in irreversible interview paths, and Step 16: Interview resilience scoring-driven cross-interview session resource allocation. In Step 4, θ simultaneously affects the initial Q value of Step 7 and the constraint boundary of Step 2. Step 8 and Step 2 form a two-layer budget mechanism. Step 10 provides a cross-stage causal state dimension for Step 7 and provides causal constraint factor adjustment for Step 8. Steps 13 to 16 form a closed-loop dependency chain: Step 13 outputs P(transition) and inputs Step 14; Step 14 outputs (r, d) and inputs Step 15; Step 15 outputs V(s_0) and inputs Step 16; Step 16 outputs IRS and inputs it back to Step 13.

[0029] Step 1: State-machine driven MDP state-space modeling during the interview stage (e.g., Figure 2and Figure 3 (As shown) The inputs to this step are interview session context information (interview stage identifier, types of questions answered, interview duration) and system performance metrics (GPU utilization, request queue depth, average response latency, error rate). The outputs are MDP state vectors s and a set of available actions. This step encodes the interview stage information into an explicit dimension of the MDP state space, enabling routing decisions to be aware of the stage differences in the interview scenario.

[0030] 1.1 Definition of the state machine for the interview stage: The interview process is modeled as a 6-stage state machine, with the following constraint parameters for each stage: Pre-interview preparation (max_latency=5000ms, compute_budget=0.8, min_quality=medium), self-introduction (max_latency=3000ms, compute_budget=0.5, min_quality=low), technical questions (max_latency=2000ms, compute_budget=1.0, min_quality=high), behavioral interview (max_latency=3000ms, compute_budget=0.7, min_quality=medium), follow-up questioning (max_latency=3000ms, compute_budget=0.8, min_quality=medium), post-interview debriefing (max_latency=10000ms, compute_budget=1.0, min_quality=high). The transition rules are as follows: The transition from pre-interview preparation to self-introduction is triggered by the interview session initiation signal; the transition from self-introduction to technical questions is when the self-introduction exceeds 120 seconds or the interviewer issues a technical question instruction; the transition from technical questions to behavioral interviews is when there are no follow-up questions for two consecutive rounds or the number of technical question rounds reaches the preset limit; the transition from behavioral interviews to counter-questioning is when the number of behavioral interview questions reaches 3 or the interviewer issues a counter-questioning invitation; and the transition from counter-questioning to post-interview debriefing is when the candidate has no further questions or the counter-questioning duration exceeds 180 seconds. The transition is automatically determined by the interview session manager based on the interviewer's behavior. During the transition, a Q-learning strategy switch is triggered: Q_{k+1}(s,a) = Q_k(s,a) × 0.5 + r_expected(s,a|θ*) × 0.5, and the average state clustering run of the quality prediction model is reset to the prior value. The interview_phase dimension causes the MDP state transition probability matrix P(s'|s,a) to change with the interview phase—the same action produces different state transition probability distributions under different interview_phases. In the technical question phase, the mean delay transition probability of route_full_llm is μ=800ms, while in the counter-question phase, the mean delay transition probability of route_full_llm is μ=650ms. That is, the interview phase changes the dynamic characteristics of the MDP rather than just serving as a label. 1.2 MDP State Space Definition: State s = (gpu_util, queue_depth, avg_latency, error_rate, compute_budget, interview_phase, query_complexity), with 7 dimensions. gpu_util∈[0,1] is the GPU utilization (sampled every 100ms); queue_depth∈[0,∞) is the request queue depth; avg_latency∈[0,∞) is the average latency (ms) of the last 100 requests; error_rate∈[0,1] is the error rate of the last 100 requests; compute_budget∈[0,1] is the remaining computing budget (normalized FLOPs) for the current stage; interview_phase∈{0,1,2,3,4,5} is the coding for the interview stage (0=pre-interview preparation, 1=self-introduction, 2=technical questions, 3=behavioral interview, 4=reverse questioning, 5=post-interview debriefing); query_complexity∈[0,1] is the predicted query complexity value, calculated by 1.3; 1.3 Query Complexity Prediction: query_complexity = min(1, token_count / 200×0.3 + jargon_density×0.4 + structure_depth / 3×0.3), where token_count is the number of tokens in the query text, jargon_density is the proportion of technical terms (calculated by matching with a domain dictionary containing approximately 5000 technical terms), and structure_depth is the nesting depth of the question (e.g., "Please explain the application of X in Y" has a nesting depth of 2). High-complexity queries (query_complexity>0.7) trigger an upgrade of the computational level in advance under low-resource conditions (gpu_util>0.8 or compute_budget<0.3) instead of waiting for a timeout, avoiding secondary delays caused by substandard quality due to choosing a low computational level and then upgrading. 1.4 MDP Action Space Definition: Action a ∈ {route_regex, route_rules, route_lightweight_llm, route_full_llm}, corresponding to the four computational levels respectively. `route_regex` is a regular expression matching algorithm (0 FLOPs, 0 ms latency), suitable for high-frequency, low-complexity queries; `route_rules` is a rule engine (0.001 FLOPs, <5 ms latency), suitable for structured queries; `route_lightweight_llm` is a lightweight LLM (0.3 FLOPs, approximately 300 ms latency), using a lightweight large language model (dense architecture, 7B total parameters, 4096 hidden dimensions, 32-layer Transformer decoder), suitable for queries requiring semantic understanding but with limited latency budget; `route_full_llm` is a full LLM (1.0 FLOPs, approximately 800 ms latency), using a large parameter-based large language model (Hybrid Expert (MoE) architecture, 671B total parameters, 37B activation parameters, 64-layer Transformer decoder), suitable for queries with high complexity and high quality requirements. The LLMs mentioned are pre-trained models; this invention only uses their inference interfaces. This system deploys an LLM scheduling pool to dynamically allocate model instances based on the interview stage and system load.

[0031] Step Two: Differentiated routing constraints perceived during the interview stage (e.g.) Figure 2 (As shown) The input to this step is the MDP state s and action a output from step one, and the output is the set of available actions after constraint filtering. This step filters out inapplicable actions based on different constraints at each interview stage, ensuring that scheduling decisions meet the triple constraints of latency, computational budget, and quality. The priority of constraints varies at different interview stages: latency constraints have the highest priority in the technical questioning stage (max_latency=2000ms is the most stringent), quality constraints have the highest priority in the behavioral interview stage (behavioral interview questions require semantic understanding), and budget constraints have the highest priority in the questioning stage (compute_budget=0.8 and ρ_gen=0.5 is the most stringent).

[0032] 2.1 Hard Latency Constraint: Scheduling decisions must satisfy latency(s,a) ≤ max_latency(interview_phase), where latency(s,a) is the expected latency of executing action a in state s. Latency estimation formula: latency(s,a) = base_latency(a) × (1 + queue_depth × 0.05 + gpu_util × 0.3), where base_latency is the base latency of the action (route_regex=0ms, route_rules=5ms, route_lightweight_llm=300ms, route_full_llm=800ms), with queue depth and GPU utilization increasing latency. Actions violating the latency constraint are excluded. 2.2 Budget Constraint Calculation: Scheduling decisions must satisfy cumulative_flops + flops(a) ≤ compute_budget(interview_phase), where cumulative_flops is the cumulative FLOPs consumed in the current phase, and flops(a) is the FLOPs consumed by action a. If the budget is exceeded, a forced degradation to a low-FLOPs action is implemented—if route_full_llm causes a budget overrun, it is degraded to route_lightweight_llm; if it still exceeds the budget, it is degraded to route_rules; in the worst case, it is degraded to route_regex to guarantee basic service. 2.3 Quality Minimum Constraint: The scheduling decision must satisfy q̂(s,a) ≥ min_quality(interview_phase), where q̂(s,a) is the expected quality given by the quality prediction model in 3.3. If the quality is not met, the operation is upgraded to a higher FLOPs action—if the quality of route_lightweight_llm is lower than min_quality, it is upgraded to route_full_llm. During the upgrade, both the delay constraint in 2.1 and the budget constraint in 2.2 must be checked simultaneously.

[0033] Step 3: Design of the three-dimensional target reward function The inputs to this step are the MDP state s, action a, and the expected quality q̂(s,a) output by the quality prediction model. The outputs are the expected reward r_expected(s,a) and the actual reward r_actual(s,a). This invention uses FLOPs as an explicit optimization dimension rather than a constraint. FLOPs have a non-monotonic relationship with latency—the computational cost per unit latency of lightweight LLM (0.3 / 300=0.001FLOPs / ms) is lower than that of full LLM (1.0 / 800=0.00125 FLOPs / ms), allowing FLOPs, as an independent optimization dimension, to discover efficiency improvement opportunities that latency optimization cannot detect. There is an interaction effect between FLOPs and the interview stage: the technical questioning stage has a high tolerance for high FLOPs actions (compute_budget=1.0), allowing route_full_llm in exchange for high-quality inference; the questioning stage has a low tolerance for high FLOPs actions (compute_budget=0.8 and ρ_gen=0.5), and tends to choose route_lightweight_llm to save resources; the same FLOPs consumption produces different quality-latency trade-off curves in different interview stages, making the FLOPs optimization dimension have a scenario-specific resource scheduling meaning in the interview scenario.

[0034] 3.1 Reward function definition: r(s,a) = -w1·latency(s,a) / max_latency - w2·flops(a) / max_flops + w3·quality(s,a), where w1=0.4, w2=0.3, w3=0.3, max_latency takes the delay constraint value of the current interview stage, and max_flops=1.0; 3.2 Dual-track mechanism for quality prediction model: Since response quality cannot be directly observed before action execution, this invention introduces a dual-track mechanism. The expected quality is used in the action selection phase: (Equation 2) r_expected(s,a) = -w1·latency_est / max_latency - w2·flops(a) / max_flops + w3·q̂(s,a), where q̂(s,a) is the output of the quality prediction model, and the input is the (s,a) tuple; the actual quality is used in the Q-learning update phase: r_actual(s,a) = -w1·latency_actual / max_latency - w2·flops(a) / max_flops + w3·quality_actual, where quality_actual is the actual quality after action execution, obtained as: quality_actual = 0.6 × user_feedback + 0.4 × llm_self_eval, where user_feedback is the implicit user feedback score (1.0 for adopted suggestions, 0.5 for partial adoption, and 0.0 for ignoring, automatically collected through client interaction events), and llm_self_eval is the LLM self-evaluation score (the generated answer and question are input into the LLM, and the output is a quality score of 0-1. The self-evaluation prompts require the average score from three dimensions: completeness, accuracy, and relevance). The input contains the triplet (s,a,s').

[0035] 3.3 Construction and Online Update of Quality Prediction Model q̂(s,a): A prior value + state-aware correction architecture is adopted. Initialization of prior values: route_regex=0.3, route_rules=0.5, route_lightweight_llm=0.75, route_full_llm=0.90. State-aware correction: q̂(s,a) = q̂0(a) + Δq(s,a), where Δq(s,a) is calculated based on state clustering—the MDP state space is clustered into C=8 clusters according to gpu_util and queue_depth. For each cluster c and action a, the running average quality q̄(c,a) is maintained, Δq(s,a) = q̄(c(s),a) - q̂0(a). Online update: q̄(c,a) ← (1-η)·q̄(c,a) + η·quality_actual, η=0.05. Dual Machine Learning (DML) online estimation switching: Linear regression is used when there are <20 historical observations; when there are ≥20 observations, switching to DML online estimation improves the unbiasedness of causal effect estimation. In this invention, DML is used for online estimation switching of the quality prediction model (upgrading quality prediction within MDP state clusters from linear regression to DML online estimation). This differs from the application scenario of DML used for global causal effect estimation (calculating the causal effect of each factor on interview scores by eliminating overfitting bias through orthogonalized residuals) in the applicant's "Interview Review Score Adjustment Method and System Based on Causal Inference" filed on the same day. This invention utilizes the unbiased estimation characteristics of DML to improve the accuracy of quality prediction to optimize scheduling decisions, while P001 utilizes the causal inference characteristics of DML to eliminate confounding bias to adjust scores.

[0036] Step 4: Bayesian optimization to solve for the optimal route threshold (e.g., Figure 4 (As shown) This step automatically solves for the optimal threshold θ using Bayesian optimization, replacing manual parameter tuning. θ also serves as the basis for generating the initial Q-value for Q-learning and as a reference for the constraint boundary.

[0037] 4.1 Optimization variable definition: θ = (θ_regex, θ_lightweight, θ_quality), which are the regular expression matching confidence threshold, lightweight LLM upgrade threshold, and quality upgrade threshold, respectively; 4.2 Gaussian process surrogate model: A surrogate model is constructed with GP(θ) as the objective function J(θ) = E[r(s,π_θ(s))], using a Matern 5 / 2 kernel, with a length scale l=[1.0,1.0,1.0], signal variance σ²=1.0, noise variance σ_n²=0.01, and 5 initial observation points (Latin hypercube sampling); 4.3 Desired improvement of the acquisition function: EI(θ) = E[max(J(θ)-J_best, 0)], select the θ with the largest EI as the next evaluation point, explore - utilize the balance parameter ξ=0.01; 4.4 Iterative optimization: After each evaluation of the new threshold, update the GP posterior distribution, repeat 4.3 until convergence (J(θ) changes < 0.001 for 5 consecutive times) or the maximum number of evaluations of 50 is reached, and output θ*; 4.5 Information transfer between Bayesian optimization and Q-learning: θ* is directly used as the initial Q value of Q-learning, Q(s,a) = r_expected(s,a|θ), forming a collaborative process from "offline optimization to online learning".

[0038] Step 5: Pareto multi-objective route optimization (e.g.) Figure 5 (As shown) This step uses the Non-Dominated Sorting Genetic Algorithm (NSGA-II) to solve the three-dimensional Pareto front, and then uses hard constraints from the interview stage to filter out infeasible solutions.

[0039] 5.1 Population initialization: Generate N=100 individuals with scheduling strategies, each with a gene encoding 6 parameters: (w1, w2, w3, θ_regex, θ_lightweight, θ_quality); 5.2 Multi-objective evaluation: For each individual, calculate the three-dimensional objective values ​​f1 = delay, f2 = -mass, and f3 = FLOPs consumption; 5.3 Non-dominated ranking: stratifying the population based on Pareto dominance; 5.4 Crowding Degree Calculation: Within the same Pareto level, solutions are sorted by crowding degree to maintain solution diversity; 5.5 Hard Constraint Filtering in the Interview Stage: Filtering solutions that violate the hard constraint of delay in the interview stage from the Pareto front; 5.6 Strategy Selection: Select a strategy based on the priorities of the current interview stage—prioritize low latency for technical questions, high quality for debriefing, and low FLOPs for counter-questions.

[0040] Step Six: Hierarchical Markov Decision Process This step decomposes a single flat MDP into two levels: a high-level MDP and a low-level MDP, to address the time scale differences between stage-level and request-level decisions.

[0041] 6.1 High-level MDP (Phase Strategy Layer): The state is (interview_phase, global_gpu_util, global_compute_budget_remaining), the action is the phase transition decision, the reward is the weighted sum of phase completion quality and time efficiency, and the decision frequency is once per phase; 6.2 Low-level MDP (Resource Action Layer): The state is a 7-dimensional state vector defined in 1.2, the action is a 4-level computational selection defined in 1.4, the reward is a 3-dimensional objective function r(s,a) defined in 3.1, and the decision frequency is once per request; 6.3 Inter-layer information transmission: The phase decision of the higher-level MDP triggers the strategy switching of the lower-level MDP; the resource consumption of the lower-level MDP is fed back to the higher-level MDP, and when compute_budget_remaining<0.2, the higher-level MDP can decide to end the current phase early.

[0042] Step 7: Adaptive Online Q-learning Strategy This step uses Q-learning to adjust the scheduling strategy in real time, enabling the system to adapt to changes in traffic and data distribution shifts.

[0043] 7.1 Q-table initialization: Use θ* to generate the initial Q-table Q(s,a) = r_expected(s,a|θ). Each stage of the Q-table has 8×4=32 Q-values, and a total of 192 Q-values ​​for 6 stages. 7.2 ε Greedy Exploration: ε=0.1 selects a random action, 1-ε selects the action with the maximum Q value, and ε decays linearly to 0.01; 7.3 Q value update: Q(s,a) ← Q(s,a) + α·[r_actual + γ·max_a'Q(s',a') - Q(s,a)], α=0.01, γ=0.95; 7.4 Online update of quality prediction model: After each Q-value update, the running average quality of the corresponding cluster in 3.3 is updated synchronously, so that the quality prediction model and Q-learning co-evolve; 7.5 State Encoding of Interview Stage Perception: The Q-table state encoding includes interview_phase. Different optimal strategies are learned for different interview stages—the strategy of prioritizing low-latency actions is learned during the technical questioning stage (because max_latency=2000ms is the most stringent), the strategy of prioritizing low-FLOPs actions is learned during the questioning stage (because compute_budget=0.8 and ρ_gen=0.5 is the most stressful), and the strategy of prioritizing high-quality actions is learned during the post-interview debriefing (because min_quality=high and max_latency=10000ms allows for high-FLOPs actions).

[0044] Step 8: Elastic computing budget for inference link awareness (e.g.) Figure 6 (As shown) This step upgrades the budget from a phase-level fixed quota to a link-level elastic allocation, transferring the budget saved in the preceding steps to the subsequent steps.

[0045] 8.1 Inference Chain Modeling: The request is modeled as an inference chain chain = [planning, retrieval, generation, verification], with expected costs of planning=0.05, retrieval=0.10, verification=0.05, and generation determined by the computation level; 8.2 Flexible Budget Dynamic Adjustment: budget_gen = budget_phase × ρ_gen - (FLOPs_plan_actual + FLOPs_retrieve_actual - FLOPs_plan_expected - FLOPs_retrieve_expected), where ρ_gen is the generation budget percentage (ρ_gen = 0.7 for technical questions, ρ_gen = 0.5 for counter-questions); 8.3 Budget Borrowing and Repayment Mechanism: When the flexible budget is insufficient, the budget can be borrowed from subsequent stages (borrow_ratio≤0.3), and the borrowed budget must be repaid in subsequent stages; 8.4 Coordination between Link-Aware Budget and Step 2 Phase Constraints: Step 2 defines the phase-level budget upper limit as a hard constraint, while Step 8 defines the link-level elastic allocation as a soft optimization, ensuring that the total link consumption after elastic adjustment does not exceed budget_phase.

[0046] Step Nine: Cold Start Acceleration and Transfer Learning Mechanisms This step uses cross-scenario transfer learning to transfer strategies from similar scenarios to new scenarios, shortening the cold start time.

[0047] 9.1 Scene feature encoding: φ = (industry, position_level, question_type_distribution, avg_complexity); 9.2 Cross-scene strategy migration: Retrieve the most similar scene from the historical scene library, Q_new(s,a) = Q_old(s,a)× sim(φ_new, φ_old). If the similarity is <0.5, no migration is performed; if the similarity is 0.5-0.8, partial migration is performed; if the similarity is >0.8, it is directly reused. Cold start is shortened by 80% (from 100 to 20 scenes). 9.3 Bayesian optimization for hot start: By using the migrating source θ_old as the initial observation point of the new scene, the convergence time was reduced from 50 to about 15. 9.4 Negative migration detection and rollback: When the average reward of the first 10 routes is less than 80% of the zero initialization, a negative migration is identified, and automatic rollback to zero initialization is performed; 9.5 Online Scenario Library Update: Each interview is stored in the scenario library after it is completed, and the Least Recently Used (LRU) strategy is used to maintain the 100 most recent scenarios.

[0048] Step 10: Causal constraint propagation during the interview stage (e.g.) Figure 7 (As shown) This step explicitly models the causal path of resource impact across stages using a causal constraint graph, enabling Q-learning to perceive the causal impact of resource consumption in preceding stages.

[0049] 10.1 Inter-stage causal constraint graph: Construct a directed acyclic graph G_causal, with edge weights: w=0.5 from technical question to behavioral interview, w=0.3 from behavioral interview to follow-up questioning, and w=0.2 from self-introduction to technical question. The causal constraint graph describes "how resources are affected after the transformation," which is the core difference between this and the state machine in step one, which describes "whether the transformation is possible." 10.2 Causal constraint propagation formula: c_i = c_i_base × Π_{j∈pred(i)} (1 - w_{j→i}× overflow_ratio_j), overflow_ratio_j = max(0, (FLOPs_actual_j - FLOPs_budget_j) / FLOPs_budget_j); 10.3 Enhanced Q-learning state for causal constraint awareness: The Q-table state encoding adds the causal constraint dimension causal_constraint, and when causal_constraint<0.8, it tends to select actions with low FLOPs; 10.4 Counterfactual constraint evaluation: Δc = c_i_actual - c_i_counterfactual. When Δc > θ_causal=0.1, the high-level MDP can choose low FLOPs actions in exchange for subsequent constraint relaxation.

[0050] 10.5 Coordination between causal constraints and the flexible budget in step eight: When causal_constraint < 0.8, the flexible budget borrow_ratio in step eight decreases from 0.3 to 0.15 to prevent borrowing from further worsening the constraints in subsequent stages—the causal constraints have already indicated that the previous stage has overspent significantly, and borrowing from the budget at this time would exacerbate the constraint deterioration.

[0051] Step 11: KV Cache Liveness Time Scheduling as Perceived During the Interview Stage (e.g.) Figure 8 (As shown) During LLM inference, the key-value cache (KV Cache) stores intermediate key-value pairs for the attention mechanism, consuming GPU memory and increasing linearly with each dialogue round. Traditional inference engines use a least recently used (LRU) eviction policy to manage the KV Cache, unaware of interview stage information; this invention incorporates interview stage information into the KV Cache retention / eviction decisions, achieving interview stage-aware KV Cache TTL scheduling.

[0052] 11.1 Differentiated TTL Settings for the Interview Stage: The TTL value of the KV Cache is set according to the probability of follow-up questions during the interview stage. In the technical question stage, the probability of follow-up questions is high (approximately 80%), so TTL_tech = 300 seconds is set to retain the KV Cache and avoid refilling, reducing the first-token delay (TTFT) from approximately 800ms to approximately 150ms. In the reverse question stage, the probability of follow-up questions is low (approximately 20%), so TTL_reverse = 60 seconds is set to allow the preceding KV Cache to be evicted early, freeing up GPU memory and reducing GPU memory usage from approximately 4.2GB to approximately 1.8GB. In the behavioral interview stage, TTL_behavior = 180 seconds is set because behavioral interview questions are somewhat related but not as closely related as technical questions. In the post-interview debriefing stage, TTL_review = 600 seconds is set because the debriefing requires reviewing the context of the entire interview process.

[0053] 11.2 Causal Constraint-Aware KV Cache Degradation During Interview Phase Transition: During the interview phase transition, a phase-aware KV Cache degradation strategy is implemented—the old phase's KV Cache is sorted according to the edge weight w_{j→i} of the causal constraint graph G_causal. The top K KV Cache blocks with the largest causal constraint weights with subsequent phases are retained in GPU memory, and the remaining blocks are unloaded to CPU memory. K = ⌊GPU_total × retention_ratio(interview_phase)⌋, where GPU_total is the total GPU cluster memory capacity (in GB), and retention_ratio is dynamically set according to the interview phase: when transitioning from technical questions to behavioral interviews, retention_ratio=0.7 retains most of the context (because the behavioral interview may reference the content of technical questions); when transitioning from behavioral interviews to the Q&A session, retention_ratio=0.3 retains only the core context (because the Q&A session questions are highly independent).

[0054] 11.3 GPU-CPU KV Cache Migration: When the KV Cache time-to-live exceeds the TTL, the KV Cache block of the request is unloaded from GPU memory to CPU memory; when subsequent requests from the same interview session arrive and the KV Cache is still in CPU memory, the KV Cache is loaded back from CPU memory to GPU memory through a low-latency transfer library (such as the Low Latency Transfer Library (NIXL)) to avoid refilling. The loading latency of about 50ms is much lower than the approximately 800ms of refilling.

[0055] 11.4 Expanding the Action Space: KV Cache TTL scheduling expands the MDP action space from 4 routing actions to 4 × 3 = 12 joint actions (routing actions × KV Cache retention policies). The three KV Cache retention policies are: retain all (retain_all), retain the top K based on causal constraints (retain_topk), and evict all (evict_all). Q-learning learns the joint optimal policy perceived during the interview stage within this expanded action space—preferring (route_full_llm, retain_all) during technical questioning and (route_lightweight_llm, evict_all) during counter-questioning.

[0056] Step 12: Mid-inference upgrade scheduling based on LLM output entropy (e.g.) Figure 9 (As shown) This invention uses LLM output entropy to make mid-process upgrade scheduling decisions during interview scenario reasoning, and detects quality deficiencies in real time during the generation process and dynamically upgrades the computation level.

[0057] 12.1 Real-time calculation of LLM output entropy: In each decoding step of LLM inference, the output token probability distribution p(token_i) is obtained, and the Shannon entropy H(t) = -Σp(token_i)·log p(token_i) is calculated. Low entropy indicates that the LLM is confident in the output and tends to have high quality; high entropy indicates that the LLM is uncertain and may need to be upgraded to a larger model.

[0058] 12.2 Sliding Window Average Entropy and Threshold Detection: Maintain the average entropy within the sliding window H_avg = (1 / W)·Σ_{t-W+1}^{t} H(t), with a window size W=5. When H_avg exceeds the stage-specific threshold H_threshold(interview_phase) for N_entropy=3 consecutive steps, trigger mid-inference escalation. H_threshold is dynamically set according to the interview stage: H_threshold=2.5 for the technical question stage (high tolerance, as technical questions themselves may trigger LLM exploratory thinking), H_threshold=2.0 for the behavioral interview stage, and H_threshold=1.8 for the counter-question stage (low tolerance, as counter-question questions are simpler, and high entropy is more likely to indicate insufficient quality).

[0059] 12.3 Mid-Inference Upgrade Execution: After triggering the upgrade, the generated lexical sequence is sent as the input prefix for the new request to the full LLM. Simultaneously, the portion of the lightweight LLM's KV Cache corresponding to the generated lexical units is migrated to the full LLM's KV Cache storage space. After the upgrade, the full LLM continues generation from the breakpoint, with the first lexical unit latency being only about 150ms instead of the approximately 800ms latency of starting from the beginning. Coordination between Mid-Inference Upgrade and 11 KV Cache TTL Scheduling: The upgraded full LLM KV Cache inherits the TTL setting of the current interview stage, ensuring that the KV Cache retention strategy after the upgrade is consistent with that of the interview stage.

[0060] 12.4 Entropy Correction for Quality Feedback: After a mid-upgrade, an entropy correction term is added to the calculation of the actual quality (quality_actual): quality_actual = quality_base + λ_entropy × (H_threshold - H_avg), where H_avg is the average entropy before the upgrade, and λ_entropy = 0.1. When H_avg > H_threshold, the correction term is negative, indicating that the quality before the upgrade was indeed insufficient. After the upgrade, the high-quality responses generated by the full LLM improve quality_base, and the overall quality_actual is higher than in the un-upgraded scenario. This correction term enables Q-learning to learn a positive feedback loop of "high entropy triggering upgrade to improved quality after upgrade," gradually optimizing the threshold and timing of upgrade decisions.

[0061] Step Thirteen: Quality-Driven Interview Stage Conversion Probability Modeling and Resource Pre-allocation (e.g.) Figure 10 (As shown) This invention models interview stage transitions as quality-driven random events, making the state transition probability of the MDP a function of scheduling decision quality. Step one's state machine determines the current interview stage at a macroscopic level (stage determination is deterministic, triggered by the interview session manager based on the interviewer's behavior), while this step predicts the probability of stage transitions at a microscopic level (resource scheduling needs to anticipate stage transition timing in advance, rather than responding only after the transition occurs). These two approaches are not contradictory: the state machine describes "which stage we are currently in" (deterministic determination, confirmed afterward), while the probabilistic model describes "when we might transition to the next stage" (probabilistic prediction, anticipated beforehand)—the probabilistic model predicts transition trends before the state machine determines the transition, providing a time window for resource pre-allocation. The deterministic rule of the state machine is the boundary condition of the probabilistic model: when P(transition) reaches 1.0, the state machine will inevitably trigger a transition.

[0062] 13.1 Quality-Driven Modeling of Stage Transition Probability: The stage transition probability is modeled as a sigmoid function of cumulative quality (Equation 4): P(transition_k to k+1 | Q_cumulative_k) = 1 / (1 + exp(-σ·(Q_cumulative_k - Q_threshold_k))), where Q_cumulative_k is the cumulative answer quality of the current stage k, calculated cumulatively by the actual quality quality_actual of the quality prediction model in step three within the current stage; Q_threshold_k is the transition quality threshold of stage k, set according to the interview stage—Q_threshold_tech=0.85 for the technical question stage (interviewers have high requirements for technical answers and need high quality to be satisfied), and Q_threshold_reverse=0.70 for the counter-question stage (interviewers have lower requirements for the quality of the counter-question stage); σ is the sensitivity coefficient, σ=10.0 controls the steepness of the sigmoid function. The parameters σ and Q_threshold_k of the sigmoid function are fitted using historical interview data and updated every 100 interviews.

[0063] 13.2 Resource Pre-allocation Trigger: When the transition probability P(transition) > P_prealloc = 0.7, resource pre-allocation is triggered—preloading the KV Cache template for the next stage into GPU memory (activated in advance using the KV Cache TTL strategy of 11), and pre-allocating the GPU computing resources required for the next stage. Pre-allocation reduces the first-term latency (TTFT) during stage transition from approximately 800ms to approximately 200ms because the KV Cache template has been preloaded and does not need to be pre-filled from scratch.

[0064] 13.3 Resource Retention Trigger: When P(transition) < P_retain=0.3, resource retention is triggered—extending the current stage's KV Cache TTL (by 50% based on the TTL in 11). Because the interviewer's follow-up questions caused the current stage to be extended, the KV Cache is retained to avoid refilling.

[0065] 13.4 Endogenization of MDP State Transition Probability: The quality-driven stage transition probability makes the MDP state transition probability P(s'|s,a) a function of scheduling decision quality rather than an exogenous parameter. The scheduling system indirectly controls the timing of stage transitions by optimizing response quality, forming a positive feedback loop of "high-quality response to high transition probability to resource pre-allocation hit to low-latency start of the next stage".

[0066] Step Fourteen: Resource-Difficulty Game Equilibrium Control in the Adversarial Resource Upgrade Spiral (e.g.) Figure 11 (As shown) The interview scenario involves a two-way game between the interviewer and the scheduling system, which may result in a resource upgrade spiral.

[0067] 14.1 Game Theory Modeling: The interviewer's difficulty adaptation function is d(q) = d_base + α·(q - q_target). When the answer quality q exceeds the target quality q_target, the interviewer increases the difficulty d; conversely, the difficulty decreases. The scheduling system's resource allocation function is r(d) = r_base + β·(d - d_base). When the interview difficulty d increases, the scheduling system increases the resource r. Parameters α and β are estimated online using historical interview data—α reflects the interviewer's difficulty adaptation strength, and β reflects the scheduling system's resource response sensitivity.

[0068] 14.2 Resource-Difficulty Game Equilibrium Solution: The game has a resource-difficulty game equilibrium (r, d) satisfying r = r_base + β·(d - d_base) and d = d_base + α·(q(r) - q_target), where q(r) is the expected answer quality under resource r. The resource-difficulty game equilibrium point is solved through online gradient descent iteration: r_{t+1} = r_t - η_game·∂L / ∂r, where L = |r - r_base - β·(d - d_base)|² + λ_budget·max(0, r - r_max)², η_game=0.01, λ_budget=10.0 is the budget constraint penalty coefficient, and r_max is the total computing budget of the GPU cluster. The specific algorithm steps for solving the resource-difficulty game equilibrium are as follows: 1. Initialize r_0 = r_base, d_0 = d_base; 2. Iterative update: calculate the interviewer response d_{t+1} = d_base + α·(q(r_t) - q_target), calculate the scheduling system response r_{t+1} = r_base + β·(d_{t+1} - d_base), calculate the gradient ∂L / ∂r = 2·(r_t - r_base -β·(d_t - d_base))·(1 + β·α·∂q / ∂r) + 2·λ_budget·max(0, r_t - r_max), update r_{t+1} = r_t - η_game·∂L / ∂r; 3. Convergence criterion: when |r_{t+1} - r_t| < Convergence is determined when |d_{t+1} -d_t| < 0.01, and the output is (r, d) = (r_{t+1}, d_{t+1}); 4. Iteration limit: The maximum number of iterations is 100. If the number of iterations exceeds this limit, the result of the most recent iteration is taken. 14.3 Upgrade Spiral Detection and Suppression: When an upgrade spiral is detected (d increases for 3 consecutive rounds and r increases), a spiral suppression strategy is implemented—actively reducing the computational level from route_full_llm to route_lightweight_llm, sacrificing the quality of a single answer to ensure q < q_target, triggering the interviewer to reduce the difficulty d, thereby breaking the positive feedback loop. The cost of spiral suppression is absorbed by the quality term in the reward function of step three, but it avoids the greater loss of insufficient resources in subsequent interview stages due to GPU budget exhaustion.

[0069] 14.4 Synergy between Step Thirteen and Step Fourteen: The P(transition) output of Step Thirteen provides a key input for the game model of Step Fourteen. When P(transition) of Step Thirteen is high, the game model of Step Fourteen knows that the current stage is about to end and does not need to invest more resources in the current stage to deal with the upgrade spiral. Instead, it pre-allocates resources to the next stage. When P(transition) is low, Step Fourteen knows that the interviewer is asking follow-up questions and needs to more actively control the upgrade spiral to avoid exhausting resources in the current stage.

[0070] Step 15: Robust scheduling for inherent uncertainties in irreversible interview paths (e.g.) Figure 12 (As shown) The interview scenario is subject to three constraints: irreversibility, path dependence, and finite time window. These constraints mean that the expected cumulative reward optimization of the standard MDP cannot guarantee the interview quality in the worst case.

[0071] This invention proposes a robust MDP for endogenous uncertainties specific to interview scenarios. It utilizes the parameterized structure of the interviewer difficulty adaptation function to achieve efficient solution and guarantees a minimum threshold for interview quality.

[0072] 15.1 Modeling the Endogenous Uncertainty Set: The uncertainty set of the interviewer's strategy is modeled as a function of scheduling decision quality, D(π) = {d: |d(q) - d_base| ≤ α·|q - q_target|, α_min ≤ α ≤ α_max}, where α is the interviewer's difficulty adaptation coefficient, α_min=0.3 (mild interviewer), and α_max is the combination of the stage baseline value and the dynamic adjustment of the game—α_max = α_max_base(interview_phase) + β_game·(r - r_base), where α_max_base(interview_phase) is the baseline value of the interview stage (α_max_base=1.2 for the technical question stage, α_max_base=0.6 for the counter-question stage, and α_max_base=0.9 for the behavioral interview stage), β_game=0.3 is the game response coefficient, r is the equilibrium resource of the 14 resource-difficulty game, and r_base is the baseline resource. This combined formula unifies two logics: α_max_base(interview_phase) reflects the inherent difference in difficulty adaptation intensity during the interview phase (interviewers are naturally more aggressive during the technical question phase), and β_game·(r* - r_base) reflects the causal impact of resource allocation on interviewer behavior (high resources lead to high quality, which in turn leads to more aggressive interviewers).

[0073] 15.2 Iterative Solution of min-max Values: Solve for V_{k+1}(s) = max_a min_{d∈D} {r(s,a,d) +γ·Σ_{s'} P(s'|s,a,d)·V_k(s')}, where the inner min layer solves for the worst-case interviewer policy on the constraint set D, and the outer max layer solves for the optimal scheduling policy. The inner min layer is approximated by performing an equally spaced grid search (taking 5 sampling points α_min, α_min+Δα, α_mid, α_max-Δα, α_max, where Δα=(α_max-α_min) / 4) on the interval α∈[α_min, α_max]. The worst-case scenario for the interviewer policy occurs near the extreme values ​​of α. The grid search refines the sampling near the extreme values ​​to ensure that no worst-case scenario is missed, because α controls the difficulty adjustment range, and extreme values ​​produce the largest quality fluctuations. The specific algorithm steps for iteratively solving the min-max value are as follows: 1. Initialize V_0(s) = 0 for all states s; 2. Outer iteration k=0,1,2,...: For each state s, calculate V_{k+1}(s) = max_a min_{α∈{α_min, α_max}} {r(s,a,α) +γ·Σ_{s'} P(s'|s,a,α)·V_k(s')}, where the inner min calculates the reward and transition probability for the two extreme values ​​of α and takes the smaller value, and the outer max iterates through all possible actions a and selects the action that maximizes V_{k+1}(s); 3. Convergence determination: convergence is determined when max_s |V_{k+1}(s) - V_k(s)| < 0.001; 4. Policy extraction: After convergence, select the action a that maximizes V(s) for each state s as the robust optimal policy π*(s); 15.3 Robust Q-learning Collaboration: The reward signal in Q-learning uses min_{d∈D} r(s,a,d) instead of the standard reward r(s,a), so that the Q-value reflects the expected quality under the worst-case interviewer strategy. Specifically, during each Q-learning update, the rewards r_min and r_max under the two extreme interviewer strategies α_min and α_max are calculated, and the smaller value r_robust = min(r_min, r_max) is taken as the reward signal for Q-value updates. The learned policy π* is robust to any interviewer difficulty adaptation behavior.

[0074] 15.4 Minimum Guarantee Line for Interview Quality: The minimum guarantee line V(s_0) for the interview quality is that the robust scheduler ensures that the cumulative quality is not lower than V(s_0) regardless of the difficulty adaptation strategy adopted by the interviewer (within the constraint set D).

[0075] Step Sixteen: IRS-driven resource allocation across interview sessions based on interview resilience scoring (e.g., Figure 13 (As shown) When multiple interview sessions run concurrently, GPU resources need to be allocated across sessions. Existing GPU scheduling systems use max-min fairness or proportional fairness to allocate resources, without considering the differences in the sensitivity of different sessions to quality degradation. This invention proposes the Interview Resilience Score (IRS) to measure the tolerance for quality degradation during the interview process and implements "interview outcome-oriented" cross-session resource allocation based on the IRS.

[0076] 16.1 Interview Resilience Rating Definition: IRS(phase) = max{δ : min_{d∈D(δ,phase)} V(δ)≥ V_threshold}, where δ is the quality degradation, D(δ,phase) is the uncertainty set of the interviewer's strategy corresponding to the quality degradation δ at the interview stage phase, V(δ) is the cumulative quality of the interview under the quality degradation δ, and V_threshold is the minimum acceptable interview quality (set to 0.75). IRS measures the maximum quality degradation that the interview process can withstand at the current interview stage, while ensuring that the interview result is not lower than V_threshold.

[0077] 16.2 Stage Dependence of IRS: IRS varies with the interview stage because the interviewer's difficulty adaptation coefficient α_max changes with the interview stage. In the technical questioning stage, α_max = 1.5 (aggressive interviewer), quality degradation is easily amplified, and IRS_tech = 0.08 (only 8% quality degradation can be tolerated); in the counter-questioning stage, α_max = 0.8 (moderate interviewer), quality degradation is not easily amplified, and IRS_reverse = 0.18 (18% quality degradation can be tolerated); in the behavioral interview stage, α_max = 1.0, and IRS_behavior = 0.12.

[0078] 16.3 IRS-Driven Cross-Session Resource Allocation: When N interview sessions concurrently compete for GPU resources, the scheduling system calculates the IRS for each session at the current stage, arranges sessions in ascending order of IRS, and assigns the session with the lowest IRS the highest GPU resource priority. When GPU resources are insufficient to meet the needs of all sessions, priority is given to ensuring that the computational level of the session with the lowest IRS does not degrade, while allowing sessions with higher IRS to degrade to lower FLOPs actions—because sessions with higher IRS can withstand quality degradation while sessions with lower IRS cannot.

[0079] 16.4 Online Computation of IRS: IRS is solved online via binary search—initializing δ_low=0, δ_high=1.0, iteratively calculating V(δ_mid) until |δ_high - δ_low| < 0.01, each iteration calling the min-max value of 15 to iterate and calculate V(δ_mid). Since the min-max value iteration of 15 is already running online, the incremental computation overhead of IRS is only about 5 additional value iterations, with a computation latency of about 50ms, meeting the real-time scheduling requirements.

[0080] Steps 13 to 16 form a closed-loop dependency chain. The output of each step is a necessary input for the next step. Removing any step will break the closed loop, causing the entire scheduling system to degrade to unusable status. 1. Steps Thirteen to Fourteen: The output P(transition) of Step Thirteen is input into Step Fourteen. Step Fourteen requires P(transition) to determine the time range of the game strategy. Removing Step Thirteen degenerates the resource-difficulty game equilibrium solution into a static game without time constraints.

[0081] 2. Steps Fourteen to Fifteen: The output of Step Fourteen (r, d) is input to Step Fifteen. Step Fifteen requires α_max = α_max_base(interview_phase) + β_game·(r* - r_base) to define the boundary of the uncertainty set. Removing Step Fourteen degenerates α_max into a fixed value, and robust scheduling degenerates into a standard robust MDP.

[0082] 3. Steps 15 to 16: The output V(s_0) from step 15 is input into step 16. Step 16 requires V_threshold = V(s_0) - Δ_margin as the benchmark for IRS calculation. Removing step 15 degenerates V_threshold into a manually set value, and the IRS loses its mathematical basis for robustness guarantee.

[0083] 4. Steps Sixteen to Thirteen: The IRS output from Step Sixteen is fed back into Step Thirteen. Step Thirteen requires the IRS to determine the priority of cross-session resource pre-allocation. Removing Step Sixteen degrades resource pre-allocation to a sorting based solely on P (transition), disregarding session vulnerability differences.

[0084] This closed-loop dependency chain makes steps thirteen through sixteen constitute a technically related whole—no scheduling system in the prior art has been found to include this closed-loop dependency chain.

[0085] System Architecture: The system described in this invention includes a core module and enhancement modules. The core module corresponds to steps one, two, three, four, and seven of claim 1, and includes: an interview stage state machine module, an MDP modeling module, a routing constraint module, a quality prediction module, a Bayesian optimization module, a Q-learning online learning module, and a routing execution module. The enhancement modules correspond to steps five, six, eight, and sixteen of claims 2 to 4, and include: a Pareto multi-objective module, a hierarchical MDP module, an inference link elastic budget module, a cold start acceleration module, a causal constraint propagation module, a KVCache TTL scheduling module, an LLM output entropy monitoring and mid-course upgrade module, a quality-driven stage transition probability module, an adversarial resource upgrade spiral control module, an endogenous uncertainty robust scheduling module, and an interview resilience scoring module. Each module corresponds one-to-one with steps one through sixteen, as detailed in the invention description.

[0086] AI Model Training and Data Description: The data comes from the computing resource scheduling logs of the Lingjing Weiran platform from January 2024 to December 2025, containing N≥10000 routing records. The response quality score is calculated by weighting user feedback (weight 0.6) and LLM self-assessment (weight 0.4). The dataset is divided in an 8:1:1 ratio. The model components include: Q-learning (tabular, 6 stages with 192 Q values, α=0.01, γ=0.95, ε=0.1 to 0.01 linearly decaying), GP surrogate model (Matern 5 / 2 kernels), K-means++ state clustering (C=8), non-dominated sorting genetic algorithm (NSGA-II) (population 100, maximum number of generations 200), and LLM inference engine (lightweight model with 7B parameter dense architecture, full model with 671B parameter hybrid expert architecture, both are pre-trained models that only use the inference interface, and the LLM scheduling pool dynamically allocates model instances based on system load and interview stage).

[0087] Example 1: MDP Scheduling during the Technical Inquiry Phase (Refer to) Figure 2 , Figure 3 ) During the technical Q&A session, a job seeker asked, "Please explain the CAP theorem."

[0088] 1.1 Interview Phase Identification: interview_phase = technical questions, max_latency = 2000ms, compute_budget = 1.0, min_quality = 0.8 1.3 Query Complexity: token_count=8, jargon_density=0.5 (CAP theorem is a technical term), structure_depth=1, query_complexity=min(1, 8 / 200×0.3+0.5×0.4+1 / 3×0.3)=min(1, 0.012+0.2+0.1)=0.312 1.2 State s = (gpu_util=0.45, queue_depth=3, avg_latency=350ms, error_rate=0.02, compute_budget=0.7, interview_phase=technical question, query_complexity=0.31) 1.4 Action Evaluation: route_regex confidence 0.3 < θ_regex = 0.6, excluded; route_rules confidence 0.5 < θ_lightweight = 0.7, excluded; route_lightweight_llm quality 0.75 < 0.8, does not meet the 2.3 quality constraint; route_full_llm delay 800 × (1 + 3 × 0.05 + 0.45 × 0.3) = 800 × 1.285 = 1028ms < 2000ms, meets the 2.1 delay constraint; FLOPs = 1.0 ≤ 1.0 meets the 2.2 budget constraint; quality 0.92 > 0.8 meets the 2.3 quality constraint. 3.1 Choosing route_full_llm, the expected reward r_expected = -0.4×1028 / 2000 - 0.3×1.0 / 1.0 + 0.3×0.90 = -0.206-0.30+0.27 = -0.236 3.2 After the action is executed, the observed quality_actual = 0.92, and the actual reward r_actual = -0.4×1028 / 2000 - 0.3×1.0 / 1.0 + 0.3×0.92 = -0.206-0.30+0.276 = -0.230 7.3 Q-value update: Q(s,route_full_llm) ← -0.230 + 0.01×[-0.230 + 0.95×max_a'Q(s',a') - (-0.230)] 7.4 Quality Prediction Model Update: q̄(c,route_full_llm) ← 0.95×q̄(c,route_full_llm)+ 0.05×0.92 Example 2: Bayesian optimization for solving routing thresholds (refer to...) Figure 4 ) 4.1 Initial threshold θ0 = (0.5, 0.6, 0.7) (manually set), J(θ0) = -0.25 4.2 GP Model Initialization: J(θ) is evaluated using 5 Latin hypercube sampling points to construct the initial GP posterior. 4.3 EI Acquisition Function Selection: The next evaluation point is selected as θ1 = (0.6, 0.7, 0.8), J(θ1) = -0.18 4.4 Convergence after 50 iterations: θ = (0.62, 0.72, 0.78), J(θ) = -0.12, a 52% improvement compared to the initial J(θ0) = -0.25. 4.5 θ as the initial Q-value for Q-learning: Q(s,route_full_llm) = r_expected(s,route_full_llm|θ) = -0.12 Example 3: Pareto Multi-Target Routing – Interview Phase Switching (Refer to...) Figure 5 ) 5.1 Population Initialization: N=100 individuals with scheduling strategies 5.2 Multi-objective evaluation: Three-dimensional target values ​​in the technical questioning phase 5.3 Non-dominated sorting: Obtaining the Pareto front 5.4 Crowding Degree Calculation: Solutions within the same undominated layer in the Pareto front are sorted by crowding degree. 5.5 Hard Constraint Filtering During the Interview Stage: Filtering out solutions with an average latency >2000ms during the technical questioning stage. 5.6 Technical Q&A Phase: Select a low-latency solution from the Pareto front (200ms delay, 0.85 quality, 0.8 FLOPs). Phase 5.7 Switches to the questioning phase: Relax the constraint max_latency=3000ms, tighten compute_budget=0.8 5.8 Reselect from the Pareto front: Medium delay solution (delay 500ms, quality 0.90, FLOPs 0.5) Example 4: Elastic Computation Budget Aware of Inference Links (Refer to) Figure 6 ) During the technical question phase, the execution process of the inference chain for a certain request is as follows: 8.1 Planning phase: Expected FLOPs = 0.05, actual FLOPs = 0.03 (saving 0.02) 8.2 Retrieval stage: Expected FLOPs = 0.10, actual FLOPs = 0.08 (saving 0.02) 8.3 Flexible budget for the generation stage: budget_gen = 1.0 × 0.7 - (0.03 + 0.08 - 0.05 - 0.10) = 0.7 + 0.04 = 0.74 8.4 Flexible budget 0.74 > 0.3 (lightweight LLM threshold), route_full_llm can be selected (FLOPs=1.0 requires borrowed budget) 8.5 Borrowing amount = 1.0 - 0.74 = 0.26 < 0.3 (30% of the total budget), therefore, borrowing is permitted. 8.6 The available budget for the verification phase = 1.0 - 0.03 - 0.08 - 1.0 + 0.26 = 0.15 (still needs to be reserved for verification after borrowing). The total link consumption 0.03 + 0.08 + 1.0 + 0.15 = 1.26 > 1.0, so it needs to be readjusted—the actual borrowed amount is adjusted to 0.26 - 0.26 = 0, and selecting route_lightweight_llm (FLOPs = 0.3) will meet the quality requirements. Example 5: Causal Constraints Propagation – Cross-Stage Budget Impact (Refer to) Figure 7 ) 10.1 Technical Q&A Phase: Actual FLOPs consumed = 1.2, Overspending ratio = (1.2 - 1.0) / 1.0 = 0.2 10.2 Causal Constraint Propagation: Actual budget for the behavioral interview stage = 0.7 × (1 - 0.5 × 0.2) = 0.7 × 0.9 = 0.63 10.3 Q-learning State Augmentation: causal_constraint=0.9, this dimension is added to the Q-table in state encoding. 10.4 Counterfactual Assessment: If route_lightweight_llm (FLOPs=0.3) is selected during the technical questioning phase, then the behavioral interview budget = 0.7 × 1.0 = 0.7, Δc = 0.7 - 0.63 = 0.07 10.5 When Δc = 0.07 < θ_causal = 0.1, constraint relaxation is not triggered, and the current policy continues. Example 6: End-to-end operation process (refer to) Figure 1 ) like Figure 1 As shown, the complete operation flow of the interview resource scheduling method and system based on Markov decision-making described in this invention is as follows: Step 1: The interview session manager identifies the current interview stage, constructs an MDP state vector s containing interview stage information, predicts query complexity, and defines a four-layer computational action space. Step 2: Filter out inoperable actions based on the current interview stage's hard constraints on delay, computational budget constraints, and quality lower bound constraints to ensure that scheduling decisions meet the triple constraints; Step 3: Calculate the three-dimensional target reward function. The quality prediction model provides the expected quality for action selection, and the actual quality is obtained after the action is executed for Q-learning updates. Step 4: Bayesian optimization automatically solves for the optimal route threshold θ, replacing manual parameter tuning. θ also serves as the initial Q value for Q-learning and a reference for the constraint boundary. Step 5: Solve the three-dimensional Pareto front using Pareto multi-objective optimization, filter infeasible solutions using hard constraints during the interview stage, and select strategies based on stage priorities; Step Six: Layered MDP decomposes stage-level decisions and request-level decisions into two layers, and information transfer between layers enables cross-stage global optimization; Step 7: Online Q-learning adjusts the scheduling strategy in real time, ε-greedy exploration balances exploration and utilization, and the quality prediction model and Q-learning co-evolve; Step 8: The elastic computing budget of the inference link awareness transfers the budget saved in the previous stage to the subsequent stage, and the budget borrowing and repayment mechanism is used to deal with temporary budget shortages. Step 9: Cold start transfer learning transfers the Q-table and Bayesian optimized threshold from similar scenarios to the new scenario, and negative transfer detection prevents poor transfer. Step 10: Explicitly model the causal path of cross-stage resource impacts by propagating causal constraints. The Q-learning state enhancement of causal constraint perception enables decision-making to perceive the impact of resource consumption in preceding stages. Step 11: Key-value cache (KV Cache) lifetime scheduling during the interview stage. The cache lifetime is set according to the differences in the interview stage, and cache migration between the graphics processing unit (GPU) and the central processing unit (CPU) reduces video memory usage. Step 12: Mid-process upgrade scheduling based on the output entropy of the Large Language Model (LLM). When the output entropy exceeds a threshold, a computational level upgrade is triggered to avoid wasting subsequent budget due to low-quality responses. Step Thirteen: Quality-driven interview stage transition probability modeling and resource pre-allocation, modeling state transitions as a function of scheduling quality, and pre-allocating computing resources for the next stage; Step Fourteen: Resource-Difficulty Game Equilibrium Control of the Adversarial Resource Upgrade Spiral. Game theory modeling is used to prevent the positive feedback of resource consumption from getting out of control and to maintain the stable operation of the system. Step 15: Robust scheduling for the inherent uncertainty of irreversible interview paths, ensuring minimum quality constraints under worst-case uncertainty, and ensuring that key interview stages do not fail due to insufficient resources; Step 16: Interview Resilience Score (IRS)-driven cross-interview session resource allocation. Based on the resilience score of historical sessions, cross-session resource quotas are dynamically adjusted to achieve global resource optimization.

[0089] Technical Verification: Using 10352 routing records, the technical solution described in this invention improved response quality from 0.78 to 0.88 (a 12.8% improvement), increased computational resource utilization from 55.2% to 87.3%, and reduced cross-stage resource conflict rate by approximately 65%. These technical effects directly stem from the combination of features in this invention: stage-aware MDP + dual-track quality prediction + Bayesian optimization of Q-learning initial values ​​+ closed-loop dependency chains in steps thirteen to sixteen. Existing fixed routing solutions have a computational resource utilization of only 55.2%, while the stage-aware differentiated scheduling and closed-loop robust control of this invention increase resource utilization to 87.3%.

[0090] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the technical scope disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A Markov decision-based interview resource scheduling method, running in a distributed computing system containing a GPU inference server cluster, characterized in that, Includes the following steps: Step 1: Model the interview process as a multi-stage state machine, incorporating interview stage information into the state space of a Markov Decision Process (MDP). This state space includes GPU utilization, queue depth, average latency, error rate, computational budget, interview stages, and query complexity. The action space includes four computational levels: regular expression matching, rule engine, lightweight large language model (LLM), and full large language model (LLM). The interview stage state machine comprises six stages: pre-interview preparation, self-introduction, technical questions, behavioral interview, counter-questioning, and post-interview debriefing. Each stage has corresponding maximum latency, computational budget, and quality requirements. The interview stage dimension causes the MDP's state transition probability matrix to change with each interview stage. Step 2: Based on the state machine of the interview stage, set differentiated routing constraints for different stages, including hard latency constraints, computation budget constraints, and quality minimum constraints. Scheduling decisions must simultaneously satisfy the three-dimensional constraints of the current interview stage. Each interview stage has a different priority for the three-dimensional constraints. When a scheduling decision violates the hard latency constraint, the action is excluded. When the computation budget is exceeded, it is forcibly downgraded to a low floating-point operation (FLOPs) action. When the quality is not up to standard, it is upgraded to a high floating-point operation (FLOPs) action. Step 3: Design a reward function with three-dimensional objectives: latency, computational efficiency, and response quality. Floating-point operations (FLOPs) are used as an explicit optimization dimension rather than a constraint. FLOPs, as an explicit optimization dimension, have an interaction effect with the interview stage; the same FLOPs consumed in different interview stages produce different quality-latency tradeoff curves. A quality prediction model is introduced to divide reward calculation into two stages: the action selection stage uses expected quality to calculate expected rewards for decision-making. The input of expected quality is a pair of the current state and candidate actions, excluding the next state after action execution. The Q-learning update stage uses actual quality to calculate actual rewards for learning. The input of actual quality includes the next state after action execution. The difference between expected and actual quality inputs ensures that the decision-making stage relies only on pre-decision observable information, while the learning stage uses post-decision observable information to correct the strategy. Step 4: Use Bayesian optimization to automatically solve for the optimal threshold for routing decisions. Iterate through Gaussian process surrogate model and expected improvement of acquisition function to eliminate manual threshold setting. The optimal threshold is directly used as the basis for generating the initial Q value of Q-learning, forming a collaborative process of offline optimization and online learning. Step 7: Use the online Q-learning method to learn the optimal scheduling strategy in real time. The state encoding of the Q table includes the interview stage, so that different optimal strategies are learned at different interview stages. Use the ε-greedy strategy to balance exploration and exploitation. The Q value is updated using the actual reward. Steps one, two, three, four, and seven constitute a Markov decision process scheduling framework for interview scenario awareness. Subsequent steps are based on this framework to perform multi-objective optimization, inference link optimization, and closed-loop quality assurance.

2. The method according to claim 1, characterized in that, The method also includes the following multi-objective optimization steps: Step 5: Use a non-dominated sorting genetic algorithm to solve the three-dimensional Pareto front of delay / quality / floating-point operations (FLOPs), filter out solutions that violate the hard constraint of delay in the interview stage from the Pareto front, and select a strategy from the feasible Pareto fronts according to the priority of the current interview stage. Step Six: Upgrade the flat MDP to a layered MDP. The high-level MDP makes decisions at the minute-scale time scale, while the low-level MDP makes resource allocation decisions at the second-scale time scale in each interview stage. The strategies of the two levels are optimized independently and work collaboratively through inter-level information transmission.

3. The method according to claim 1, characterized in that, The method also includes the following inference link optimization steps: Step 8: Elastic computing budget with inference link awareness: Upgrade the computing budget from a fixed quota at the stage level to an elastic quota with inference link awareness, model the interview assistance request as an inference link, dynamically adjust the available budget of the generation stage according to the actual FLOPs consumption of each link, and transfer the budget saved in the preceding stages to the generation stage to allow upgrades to higher computing levels. Step 9: Cold Start Acceleration and Transfer Learning: Encode the interview scenario into a feature vector, retrieve the most similar scenario from the historical scenario library, and transfer the Q-table and Bayesian optimization threshold of the similar scenario to the new scenario as initialization; This includes negative migration detection and rollback mechanisms; Step 10: Causal Constraint Propagation in the Interview Stage: Construct a causal constraint graph between stages to describe the causal path of resource impact between interview stages. Calculate the actual constraint of the current stage using the causal constraint propagation formula—the actual constraint of the current stage i is the causal decay product of the basic constraint of this stage and the overspending ratio of the preceding stage. Add a causal constraint dimension to the Q-learning state encoding so that Q-learning can perceive the causal impact of resource consumption in the preceding stage on the current stage when making decisions. Step 11: Key-Value Cache (KV Cache) Time-To-Live (TTL) Scheduling Aware of Interview Stages: Different time-to-live (TTL) settings are assigned to KV Caches at different stages based on interview stage information. During interview stage transitions, a stage-aware KV Cache degradation strategy is executed—the KV Caches of the old stage are sorted according to the edge weights of the causal constraint graph, retaining the top K KV Cache blocks with the largest causal constraint weights with subsequent stages, and evicting the remaining blocks. The value of K is dynamically set based on the interview stage. This KV Cache TTL scheduling expands the MDP action space from routing actions to a joint action space of routing actions and KV Cache retention strategies. Step 12: Mid-Inference Upgrade Scheduling Based on LLM Output Entropy: During the LLM response generation process, the output probability distribution entropy of each generation step is calculated in real time, and the entropy is used as an intrinsic signal of response quality. When the entropy of multiple consecutive steps in the generation process exceeds a specific threshold for a particular stage, a mid-inference upgrade is triggered—the current lightweight LLM generation state is migrated to the full LLM for continued generation. The specific threshold for a particular stage is dynamically set according to the interview stage. After the mid-inference upgrade, an entropy correction term is added to the calculation of the actual quality, enabling Q-learning to learn the positive feedback loop of the upgrade strategy.

4. The method according to claim 1, characterized in that, The method also includes the following closed-loop quality assurance steps: Step Thirteen: Quality-Driven Interview Stage Transition Probability Modeling and Resource Pre-allocation: The interview stage transition is modeled as a random event driven by the cumulative answer quality, and the stage transition probability is modeled as a sigmoid function of the cumulative quality. When the stage transition probability exceeds the pre-allocation threshold, resource pre-allocation is triggered—preloading the KV Cache template for the next stage to the GPU memory and pre-allocating the GPU computing resources required for the next stage. When the stage transition probability is lower than the retention threshold, resource retention is triggered—extending the KV Cache TTL of the current stage. The quality-driven stage transition probability makes the state transition probability of the MDP a function of the scheduling decision quality rather than an exogenous parameter. Step Fourteen: Resource-Difficulty Game Equilibrium Control for Adversarial Resource Upgrade Spiral: Model the interviewer's difficulty adaptation strategy and the scheduling system's resource allocation strategy as a two-player game, and solve for the game equilibrium point (approximately solved by optimizing the proxy loss function through online gradient descent); when an upgrade spiral is detected, execute the spiral suppression strategy—actively reduce the computational level so that the answer quality is lower than the target quality, triggering the interviewer to reduce the difficulty, thereby breaking the positive feedback loop; Step 15: Robust Scheduling for Irreversible Interview Paths with Endogenous Uncertainty: The scheduling problem is modeled as a robust MDP with endogenous uncertainty, optimizing the expected cumulative quality under the worst-case interviewer strategy. The uncertainty set is endogenous—a constraint set driven by the quality of scheduling decisions. The uncertainty set itself is a function of the scheduling strategy. The essential difference between this and the exogenous uncertainty set in existing robust MDPs is that exogenous uncertainty sets assume environmental disturbances are independent of scheduling decisions, while the difficulty adjustment range of the interviewer in the endogenous uncertainty set directly depends on the quality of the answers generated by the scheduling decisions. The minimum guarantee line for interview quality is ensured by solving the min-max value iteratively. Step Sixteen: Interview Resilience Score (IRS)-Driven Cross-Interview Session Resource Allocation: Define the Interview Resilience Score to measure the tolerance for quality degradation at the current interview stage. The IRS is stage-dependent. When multiple interview sessions concurrently compete for GPU resources, the scheduling system will prioritize allocating GPU resources to the interview session with the lowest IRS—because the session with the lowest IRS is the most vulnerable, and quality degradation is most likely to lead to interview failure. The essential difference between the IRS-driven resource allocation and the existing fair scheduling is that fair scheduling allocates resources based on demand, while IRS scheduling allocates resources based on vulnerability. Steps thirteen through sixteen form a closed-loop dependency chain. The output of each step is a necessary input for the next step. Removing any step will break the closed loop and cause the scheduling system performance to degrade significantly (to the standard method): the stage transition probability output of step thirteen is input to step fourteen, the resource-difficulty game equilibrium output of step fourteen is input to step fifteen, the minimum guarantee line output of step fifteen is input to step sixteen, and the IRS feedback output of step sixteen is input to step thirteen.

5. The method according to claim 1, characterized in that, In step one, the specific mechanism by which the state machine's stage transition triggers the Q-learning policy switch during the interview stage is as follows: when the interview stage transitions from stage k to stage k+1, the current policy of Q-learning switches from π_k to π_{k+1}, and the Q-table of π_{k+1} is initialized as a weighted mixture of the historical Q-table and the initial Q-value of Bayesian optimization; during the stage transition, the prior value of the quality prediction model remains unchanged, but the running average of the state clustering is reset to the prior value.

6. An interview resource scheduling system based on Markov decision-making, characterized in that, It includes a processor and a memory, the memory storing a computer program, and the processor executing the computer program to perform the functions of the following modules: The interview stage state machine module is used to model the interview process as a multi-stage state machine, manage stage transitions, and trigger Q-learning strategy switching during stage transitions; The MDP modeling module is used to incorporate interview stage information into the MDP state space, define the action space and three-dimensional objective reward function, and the interview stage dimension makes the MDP state transition probability matrix change with the interview stage. The routing constraint module is used to set differentiated routing constraints for different stages based on the state machine of the interview stage; The quality prediction module is used to build a quality prediction model based on state clustering. In the action selection stage, it provides the expected quality to calculate the expected reward. In the Q-learning update stage, it receives the actual quality to calculate the actual reward and updates it online. The input difference between the expected quality and the actual quality makes the decision stage rely only on the observable information before the decision and the learning stage use the observable information after the decision to correct the strategy. The Bayesian optimization module is used to automatically solve for the optimal threshold for routing decisions using a Gaussian process proxy model and an expected improved acquisition function. The optimal threshold is directly used as the initial Q value for Q-learning. Q-learning is an online learning module used to learn the optimal scheduling strategy in real time, and the status coding includes the interview stage. The routing execution module is used to make routing decisions based on the current policy.

7. The system according to claim 6, characterized in that, The system also includes the following enhancement modules: The Pareto multi-objective module is used to solve the 3D Pareto front, perform hard constraint filtering during the interview stage, and select strategies. The hierarchical MDP module is used for high-level MDP phase transition decisions and low-level MDP resource allocation decisions, as well as inter-layer information transmission. The inference link flexible budget module is used for inference link FLOPs modeling, dynamic adjustment of the flexible budget, and budget borrowing and repayment mechanism; The cold start acceleration module is used for scene feature encoding, cross-scene policy transfer, Bayesian optimization of warm start, negative transfer detection and rollback; The causal constraint propagation module is used to construct the causal constraint graph between stages, calculate the actual constraints of the current stage through the causal constraint propagation formula, and add the causal constraint dimension to the Q-learning state encoding. The causal constraint propagation module includes: a causal constraint graph construction submodule, a causal constraint propagation calculation submodule, and a causal constraint awareness Q-learning state enhancement submodule. The KV Cache TTL scheduling module is used to set differentiated TTL values ​​for the KV Cache according to the interview stage, and to execute a causal constraint-aware KV Cache degradation strategy during the interview stage transition. The KV Cache TTL scheduling module includes: an interview stage TTL setting submodule, a causal constraint-aware degradation submodule, and a GPU-CPU migration submodule. The KV Cache TTL scheduling expands the action space of MDP from routing actions to a joint action space of routing actions and KV Cache retention strategies. The LLM output entropy monitoring and mid-process upgrade module is used to calculate the output entropy of the LLM generation process in real time. When the entropy exceeds a specific threshold in the interview stage, a mid-process upgrade is triggered during inference. The LLM output entropy monitoring and mid-process upgrade module includes: an output entropy calculation submodule, a sliding window average entropy submodule, a mid-process upgrade execution submodule, and an entropy correction quality feedback submodule. The quality-driven stage transition probability module is used to model the interview stage transition probability as a sigmoid function of cumulative quality. When the transition probability exceeds the pre-allocation threshold, resource pre-allocation is triggered, making the MDP state transition probability a function of scheduling decision quality. The quality-driven stage transition probability module includes: a stage transition probability modeling submodule, a resource pre-allocation submodule, a resource reservation submodule, and an MDP state transition probability endogenization submodule. The adversarial resource upgrade spiral control module is used to model a two-player game between the interviewer's difficulty adaptation strategy and the scheduling system's resource allocation strategy, solve for the game equilibrium point (approximately solved by optimizing the proxy loss function through online gradient descent), detect upgrade spirals, and execute spiral suppression strategies. The adversarial resource upgrade spiral control module includes: a game modeling submodule, a resource-difficulty game equilibrium solution submodule, and an upgrade spiral detection and suppression submodule. The endogenous uncertainty robust scheduling module is used to model the uncertainty set of the interviewer's strategy as a function of the scheduling decision quality, and solves the optimal scheduling strategy under the worst interviewer strategy by iteratively solving the min-max value; the endogenous uncertainty robust scheduling module includes: an endogenous uncertainty set modeling submodule, a min-max value iterative solution submodule, a robust Q-learning collaborative submodule, and a minimum guarantee line for interview quality submodule; The interview resilience scoring module is used to calculate the interview resilience score of each interview session at the current stage. When multiple interview sessions compete for GPU resources concurrently, the sessions are ranked in ascending order of their scores, and resources are allocated to the most vulnerable session first. The interview resilience scoring module includes: an interview resilience score definition submodule, an interview resilience score stage dependency submodule, an interview resilience score-driven cross-session resource allocation submodule, and an interview resilience score online calculation submodule.

8. The system according to claim 7, characterized in that, The specific implementation of the causal constraint propagation module is as follows: A causal constraint graph between stages is constructed to describe the causal path of resource impact between interview stages. The actual constraint of the current stage is calculated using the causal constraint propagation formula as the causal decay product of the basic constraint of this stage and the overspending ratio of the preceding stage. A causal constraint dimension is added to the Q-learning state encoding to enable decision-making to perceive the impact of preceding stages. The specific implementation of the KV Cache TTL scheduling module is as follows: A TTL value is set according to the probability of continuous follow-up questions within the interview stage. During the interview stage transition, KV Cache blocks are sorted according to the edge weights of the causal constraint graph and the first K blocks are retained. Timeout KV Cache is unloaded from GPU memory to CPU memory and then reverse-loaded. The specific implementation of the LLM output entropy monitoring and mid-process upgrade module is as follows: The probability distribution of the lexical units is obtained and the Shannon entropy is calculated in each decoding step. The average entropy within the sliding window is maintained and continuous over-threshold detection is performed. The generated lexical unit sequence and KV... The cache is migrated to the full LLM and generation continues from the breakpoint. An entropy correction term is added to the actual quality calculation after the upgrade, enabling Q-learning to learn the value of the upgrade strategy. The specific implementation of the quality-driven stage transition probability module is as follows: the stage transition probability is modeled as a sigmoid function of cumulative quality. When the transition probability exceeds a pre-allocation threshold, the next stage KV Cache template is pre-loaded into GPU memory and GPU computing resources are pre-allocated. When the transition probability is below a retention threshold, the current stage KV Cache is extended. TTL makes the state transition probability of the MDP a function of the scheduling decision quality; the specific implementation of the adversarial resource upgrade spiral control module is as follows: modeling the interviewer difficulty adaptation function and the scheduling system resource allocation function, solving the game equilibrium point through online gradient descent iteration (approximately solved by optimizing the proxy loss function through online gradient descent), detecting upgrade spirals and executing spiral suppression strategies; the specific implementation of the endogenous uncertainty robust scheduling module is as follows: modeling the uncertainty set of the interviewer strategy as a function of the scheduling decision quality, solving the optimal scheduling strategy under the worst interviewer strategy through min-max value iteration, replacing the reward signal of Q-learning with the expected quality under the worst interviewer strategy, ensuring that the cumulative quality is not lower than the minimum guarantee line; the specific implementation of the interview resilience scoring module is as follows: calculating the tolerance of the interview stage to quality degradation, calculating the stage-dependent score value according to the change of the interviewer difficulty adaptation coefficient with the interview stage, when multiple interview sessions compete for GPU resources concurrently, arranging the sessions in ascending order of score, and prioritizing the allocation of GPU resources to the most vulnerable session with the lowest score, solving the interview resilience score through online binary search.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 5.

10. An electronic device comprising a processor and a memory, characterized in that, The processor is configured to perform the steps of the method according to any one of claims 1 to 5 by executing executable instructions in the memory.

Images