A human resource platform intelligent customer service management system based on a BPO model

Abstract

The application relates to the technical field of resource management, and discloses a human resource platform intelligent customer service management system based on a BPO model, which comprises the following steps: firstly, converting the request data volume and the node density into basic computing power load; then, evaluating the cache distortion momentum of the node, and calculating the orthogonal penalty loss operation number in combination with a spatial centroid vector; then, converting the queuing waiting time into a dynamic urgency; further, constructing a fitness objective function by fusing the above parameters, and outputting a concurrent routing scheme in combination with a particle swarm algorithm optimization; finally, completing cross-tenant tensor isolation through zero space projection, and performing closed-loop evolution correction on the system operation benchmark constant according to the real operation number fed back by a bottom probe. The application effectively reduces operation shock under a multi-tenant environment.

Description

Technical Field

[0001] This invention relates to the field of resource management technology, and more specifically, to an intelligent customer service management system for a human resources platform based on the BPO model. Background Technology

[0002] With the deepening of digital transformation, multi-tenant intelligent scheduling platforms under the business process outsourcing model are gradually becoming more widespread. In traditional systems, multi-concurrent computing resource scheduling typically employs simple static priorities or relies solely on the similarity of natural language text to assign tasks. However, when employees from different companies simultaneously submit similar inquiries about personnel rules, the system often assigns these highly homogeneous semantic requests to the same underlying node. Due to the significant heterogeneity in rules, policies, and layer distribution among different companies, this severe misalignment between surface semantic homogeneity and underlying logical heterogeneity causes computing nodes to not only be unable to reuse previously accumulated cached data when processing new tasks, but also suffer from strong obstruction due to cache residue pollution. Nodes are forced to repeatedly clear data pages and re-fetch extremely large external knowledge trees, which not only causes drastic fluctuations and astonishing waste of underlying computing resources, but also, in the absence of an effective mechanism for quantifying cross-boundary losses, traditional fixed thresholds are simply unable to adapt to the requirements of high-concurrency scenarios. These inherent defects easily lead to widespread delays in the entire hardware network response and severe data isolation risks, making it impossible to meet the stringent security conditions and extreme performance standards of ultra-large-scale concurrent processing. Summary of the Invention

[0003] This invention provides an intelligent customer service management system for a human resources platform based on the BPO model, which solves the technical problems mentioned in the background.

[0004] This invention provides an intelligent customer service management system for a human resources platform based on the BPO model, applicable to a system comprising an underlying shared computing power cluster and a surface knowledge graph, including: The data volume of the front-end request is obtained, and combined with the local node density and baseline computing power consumption of the exclusive knowledge graph to which the front-end request belongs, the front-end request is converted into a basic computing power load. The historical task queues of each computing node in the underlying shared computing power cluster are evaluated to determine the current cache distortion of each computing node. Combining the current cache distortion, the first centroid vector of the dedicated knowledge graph, and the second centroid vector of the residual data in the compute node cache, calculate the orthogonal loss operation number for allocating the front-end request to each compute node; Obtain the queued latency of the front-end request, and use the queued latency to convert the basic computing load into a dynamic urgent load. The basic computing power load, the orthogonal loss operands, and the dynamic urgent load are integrated to construct a global objective function. The dynamic inertia weight and learning factor of the particle swarm algorithm are combined for iterative optimization to output the objective concurrency allocation scheme. According to the target concurrency allocation scheme, the front-end request is pushed into the optimal computing node. A projection operator is generated using the non-tenant matrix in the optimal computing node. The query vector of the front-end request is projected onto the projection operator to obtain a security tensor and perform logical operations. After the optimal computing node completes the logical operation, the clock operands of the optimal computing node are recovered, and the benchmark computing power consumption is corrected in a closed loop using the clock operands and the basic computing power load.

[0005] The beneficial effects of this invention include: It breaks through the limitations of traditional multi-concurrency scheduling platforms that heavily rely on static preset thresholds, by directly mapping the attributes of front-end abstract requests to the operand burden of the underlying computing power. Through deep interleaving of cache distortion variables that decay over time and the exclusion penalty cost of crossing heterogeneous knowledge boundaries, this invention achieves extremely accurate quantification of underlying resource consumption. Combined with a parameterless, self-driven intelligent allocation algorithm and a high-dimensional orthogonal projection filtering mechanism, this invention can spontaneously find the optimal route allocation with the lowest latency globally, while absolutely ensuring that multi-tenant data does not infect each other. Simultaneously, the introduced dynamic closed-loop feedback mechanism based on actual executed operands allows the system's baseline consumption constant to continuously evolve adaptively with the actual operating state, eliminating memory-level computing power idleness and redundant dissipation caused by concurrent oscillations, greatly enhancing the concurrent processing throughput and ultimate underlying response performance of the scheduling system across the entire domain. Attached Figure Description

[0006] Figure 1 This is a flowchart of the intelligent customer service management system for a human resources platform based on the BPO model of the present invention. Detailed Implementation

[0007] The subject matter described herein will now be discussed with reference to exemplary embodiments. It should be understood that these embodiments are discussed only to enable those skilled in the art to better understand and implement the subject matter described herein, and changes may be made to the function and arrangement of the elements discussed without departing from the scope of this specification. Various processes or components may be omitted, substituted, or added as needed in the examples. Furthermore, features described in some examples may be combined in other examples.

[0008] like Figure 1 As shown, a human resources platform intelligent customer service management system based on the BPO model is applied to a system that includes an underlying shared computing power cluster and a surface knowledge graph, comprising: The data volume of the front-end request is obtained, and combined with the local node density and baseline computing power consumption of the exclusive knowledge graph to which the front-end request belongs, the front-end request is converted into a basic computing power load. The historical task queues of each computing node in the underlying shared computing power cluster are evaluated to determine the current cache distortion of each computing node. Combining the current cache distortion, the first centroid vector of the dedicated knowledge graph, and the second centroid vector of the residual data in the compute node cache, calculate the orthogonal loss operation number for allocating the front-end request to each compute node; Obtain the queued latency of the front-end request, and use the queued latency to convert the basic computing load into a dynamic urgent load. The basic computing power load, the orthogonal loss operands, and the dynamic urgent load are integrated to construct a global objective function. The dynamic inertia weight and learning factor of the particle swarm algorithm are combined for iterative optimization to output the objective concurrency allocation scheme. According to the target concurrency allocation scheme, the front-end request is pushed into the optimal computing node. A projection operator is generated using the non-tenant matrix in the optimal computing node. The query vector of the front-end request is projected onto the projection operator to obtain a security tensor and perform logical operations. After the optimal computing node completes the logical operation, the clock operands of the optimal computing node are recovered, and the benchmark computing power consumption is corrected in a closed loop using the clock operands and the basic computing power load.

[0009] Preferably, converting the front-end request into a basic computing load includes: Extract the data volume of the front-end request; Determine the maximum traversal depth of the exclusive knowledge graph, count the number of nodes in the exclusive knowledge graph at each depth, and sum the number of nodes to obtain the local node density; Multiplying the data volume, the local node density, and the baseline computing power consumption yields the basic computing power load: in, This refers to the basic computing power load; The data volume; The maximum traversal depth is mentioned above; For each depth; The number of nodes at each depth; This represents the baseline computing power consumption.

[0010] Data volume refers to the total number of bytes generated after the front-end request is converted according to a unified field order, unified encoding method, and unified serialization rules. It can be obtained by directly calculating the byte stream length after the request body, context fields, business slots, and necessary control fields are uniformly serialized at the interface gateway.

[0011] The maximum traversal depth is the outermost level that is allowed to be accessed when the dedicated knowledge graph expands outward layer by layer around the currently requested topic node.

[0012] Each depth is a level number formed by traversing the starting topic node layer by layer, increasing sequentially from 1, 2, 3.

[0013] The number of nodes at each depth is the number of valid nodes in the dedicated knowledge graph that are semantically relevant to the current front-end request and satisfy the permission constraints within the corresponding depth level.

[0014] Local node density is a local graph size representation value formed by summing the number of nodes at each depth, used to reflect the size of the knowledge range that the current request needs to reach.

[0015] The baseline computing power consumption is an initial calibration coefficient that maps data volume and local node density to standard computing power consumption. It is preferably 1, with a value ranging from 0.6 to 1.8. This value is determined by replaying historical standard requests covering high-frequency services before going live, using the median ratio between the actual execution consumption and the theoretical scale product as the calibration benchmark.

[0016] Basic computing load is a standardized estimate of the basic workload caused by front-end requests to underlying computing resources, without considering cache pollution and queuing urgency.

[0017] In practice, regarding data volume, after the front-end request enters the interface gateway, the tenant identifier, session identifier, problem body, context field, business slot, and necessary header fields retained after authentication are first reassembled in a fixed order; then, they are converted into a stable byte stream according to a unified encoding method and unified serialization rules; finally, the total number of bytes in the byte stream is counted as the data volume; compressed transmission messages should be decompressed before being counted; debugging fields, link tracing fields, and transport layer encapsulation fields are not included.

[0018] In practice, for the maximum traversal depth, the starting node should be the topic node that the current front-end request hits in the dedicated knowledge graph; and the traversal should be expanded layer by layer along the allowed relation edges in a breadth-first manner.

[0019] In practice, the statistical rules for the number of nodes at each depth should only count valid nodes within the current dedicated knowledge graph that are related to the intent of this front-end request and have passed the tenant permission verification; even if the same node is repeatedly pointed to by multiple edges, it will only be counted once; invalid nodes, archived nodes and nodes without permissions will not be counted.

[0020] In practice, for the local subgraph range corresponding to the local node density, it is necessary not to take the entire enterprise knowledge graph as the statistical object, but to take the set of topic nodes hit by the current front-end request as the center and construct the local subgraph within the maximum traversal depth.

[0021] In practical implementation, for the baseline computing power consumption, when the system is first launched, at least 1,000 standard historical requests covering high-frequency services need to be selected for offline playback; the ratio of each sample is obtained by dividing the clock operation number by the product of the data volume and the local node density; the median is taken as the initial baseline computing power consumption; this constant represents the standard computation consumption coefficient corresponding to each unit of data size and each unit of local graph size; the update rhythm is preferably executed according to a fixed scheduling cycle, which can be selected to update once every 1,000 requests or every 5 minutes.

[0022] Preferably, the current cache distortion of each computing node is determined, including: Extract the actual workload and completion time of each historical task from the historical task queue of the computing node; The difference between the current clock and the completed clock is used to obtain the completed clock difference value; Obtain the cache read / write limit bandwidth and maximum cache capacity of the computing node; The time decay coefficient is obtained by dividing the product of the completion clock difference and the cache read / write limit bandwidth by the maximum cache capacity, taking the negative value, and performing natural exponentiation. The current cache distortion of each computing node is obtained by multiplying the actual workload of each historical task by its corresponding time decay coefficient and then summing the results. in, For the current cache distortion of each of the aforementioned computing nodes; For each historical task; The actual workload of each historical task; The current clock; For the completion clock; The completed clock difference; This refers to the maximum bandwidth for cache read / write operations; This refers to the maximum cache capacity.

[0023] The historical task queue is a collection of tasks that have been completed by compute nodes and for which execution records are retained. It can be obtained by reading the node's task completion log, scheduling write-back records, and local cache index table.

[0024] Each historical task is a single task record in the historical task queue. It can be obtained by reading the task identifier, tenant identifier, execution summary, and performance record one by one.

[0025] Actual workload is the standardized amount of work consumed by a historical task during its actual execution. It can be obtained by collecting clock operands, cache accesses, main memory accesses, and graph traversal data through the underlying monitoring module, and then writing it back to the task record according to a unified conversion rule.

[0026] The completion clock is the end time recorded when a historical task completes execution on a computing node. It can be obtained in real time when the task completion event is triggered through a unified monotonic clock service.

[0027] The current clock is the real-time time read by the system when calculating the current cache distortion. It can be obtained directly at the start of the calculation through the unified monotonic clock service.

[0028] The completion clock difference is the time difference between the current clock and the completion clock, used to measure how close a historical task is to the current moment.

[0029] The cache read / write limit bandwidth is the peak read / write capability that the target cache level of a compute node can provide under the current hardware configuration. It can be obtained by combining node hardware description information, actual measured data of the cache controller, and performance stress test records.

[0030] The maximum cache capacity is the actual available capacity of the target cache level of the computing node for the business tasks of this invention. It can be obtained by combining the node cache configuration table, runtime available capacity detection, and resource isolation quota information.

[0031] The time decay factor is a decay weight calculated based on the completion clock difference, cache read / write limit bandwidth, and maximum cache capacity. It is used to reduce the impact of earlier historical tasks on the current cache state.

[0032] Current cache distortion is a comprehensive quantity obtained by multiplying the actual workload of each historical task by the corresponding time decay coefficient and then summing them. It is used to characterize the potential disturbance intensity caused by the current cache residue of the computing node to new requests.

[0033] In practice, the sampling window and retention strategy for the historical task queue should be as follows: each computing node should retain only the 512 most recently completed task records within the last 30 minutes; if there are fewer than 512 tasks within 30 minutes, all tasks should be retained; if there are too many tasks, they should be truncated from the most recent to the oldest based on the completion clock; each record in the queue should contain at least the task identifier, tenant identifier, actual workload, completion clock, and cache summary.

[0034] In practical implementation, regarding the statistics and conversion mechanism of actual workload, considering that the physical units of graph traversal steps and cache misses are significantly different from those of pure processor cycles and the resulting latency magnitudes, the system establishes an equivalent clock cycle as a unified benchmark for a single workload. During each historical task recording phase, a fixed penalty conversion coefficient is assigned to each indicator according to a preset hardware access latency ladder table. The specific conversion formula is as follows: in, This represents the final calculated actual workload. The actual core computing cycles consumed; This represents the number of cache misses in the last-level cache (L3Cache). The penalty for a single miss requiring access to main memory is the experience cycle penalty (e.g., 300 cycles). To maintain a large number of persistent main memory accesses, This corresponds to the page fault or I / O penalty cycle; The number of logical jump steps executed by the graph pathfinding module. This is the estimated equivalent periodicity coefficient for single-time graph node deserialization. This absolute latency penalty accumulation model eliminates evaluation gaps across different dimensions, making workload values ​​absolutely comparable across nodes. In specific implementation, for obtaining the cache read / write limit bandwidth and maximum cache capacity, the cache read / write limit bandwidth should be taken as the measured peak read / write capability of the target cache level of the computing node participating in the scheduling of this invention; the maximum cache capacity should be taken as the actual available capacity of the same target cache level for business tasks; if a node contains multiple levels of cache, the last-level shared cache should be uniformly selected as the statistical object.

[0035] In practice, regarding the boundary handling of the time decay coefficient and the current cache distortion, when the historical task queue is empty, the current cache distortion should be directly recorded as 0; when the completion clock difference is too large, the time decay coefficient can decay to close to 0, but should not be negative; when the maximum cache capacity is abnormally read or is 0, it should fall back to the default capacity parameter when the node is registered.

[0036] Preferably, calculating the orthogonal loss operands for allocating the front-end requests to each of the computing nodes includes: Extract the first centroid vector of the proprietary knowledge graph; Extract the second centroid vector of the residual data cached by the computing node; Perform a dot product operation between the first centroid vector and the second centroid vector, and divide by the product of the magnitudes of the first centroid vector and the second centroid vector to obtain the cosine similarity. The repulsion coefficient is obtained by subtracting the cosine similarity from the numerical value. Multiplying the current cache distortion by the repulsion coefficient yields the orthogonal loss operands used to distribute the frontend request to each computing node: in, For the orthogonal loss operand; This refers to the current cache distortion; Let this be the first centroid vector; This is the second centroid vector; Let be the magnitude of the first centroid vector; Let be the magnitude of the second centroid vector.

[0037] The first centroid vector is the weighted center representation of the local subgraph formed by the dedicated knowledge graph around the current front-end request in the unified semantic vector space.

[0038] Compute node cache residual data consists of knowledge fragments, vector indices, and intermediate result data that remain in the cache after a compute node has finished processing historical tasks. It can be obtained by extracting the last-level cache index, hotspot key-value maps, and resident vector snapshots after a node task switch.

[0039] The second centroid vector is the weighted center representation of the residual data in the cache of the computing nodes in the unified semantic vector space.

[0040] Cosine similarity is a quantification of the degree of alignment between the first and second centroid vectors, used to characterize the similarity between the current requested knowledge space and the cached residual space.

[0041] The magnitude of the first centroid vector is its length in the unified semantic vector space, and it is used to participate in the cosine similarity calculation.

[0042] The magnitude of the second centroid vector is its length in the unified semantic vector space, and it is used to participate in the cosine similarity calculation.

[0043] The repulsion coefficient is a differential weight obtained by subtracting the cosine similarity from the value 1, and is used to represent the degree of repulsion between the current request and the cache residue.

[0044] The orthogonal loss operand is the additional loss obtained by multiplying the current cache distortion by the repulsion coefficient. It is used to quantify the cache pollution cost when allocating the current frontend request to a certain computing node.

[0045] In practice, the construction of the first centroid vector requires first extracting the local subgraph nodes involved in the current front-end request from the dedicated knowledge graph; then mapping each node to a unified semantic vector space of fixed dimensions (e.g., 768 dimensions) through a pre-set deep learning text embedding model (preferably a Sentence-BERT model fine-tuned based on human resources corpus); subsequently assigning weights to nodes according to their business importance, access frequency, and relational connectivity in the current local subgraph, where the business importance is specifically quantified as the TF-IDF (term frequency-inverse document frequency) value of the core attribute words contained in the node in the global text of the dedicated knowledge graph, thereby eliminating the uncertainty of subjective evaluation; finally, a weighted average of all node vectors is performed to obtain the first centroid vector.

[0046] In practice, the construction of the second centroid vector requires scanning the data blocks, vector indexes and knowledge fragments still residing in the current cache after the computing node completes the preceding tasks; mapping them uniformly to the same semantic vector space as the dedicated knowledge graph; then assigning weights according to residence time, access popularity and occupied capacity; and finally performing a weighted average to obtain the second centroid vector.

[0047] In practice, for the common vector space and dimension alignment rules of the first centroid vector and the second centroid vector, the two vectors must use the same set of feature vocabulary, the same dimension length, and the same normalization rule; if the exclusive knowledge graph vector and the cached residual vector have different sources, they should first be converted to the common vector space through a unified mapping layer; when the dimensions are inconsistent, cosine similarity should not be calculated directly.

[0048] In practical implementation, for handling cosine similarity in zero-magnitude scenarios, when the magnitude of the first centroid vector or the second centroid vector is 0, or below the minimum effective threshold (e.g., when the node cache is completely cleared, or the request fails to extract any effective features), cosine similarity should not be directly calculated; in this case, cosine similarity should be recorded as 0, and the repulsion coefficient as 1. The physical meaning of this mathematical setting is that when any spatial vector is missing, it means that semantic reuse between the current front-end request and the underlying cache residue is completely impossible (i.e., a 100% cache cold start occurs). Therefore, the system must be subjected to the maximum degree of repulsion penalty (the repulsion coefficient is set to the maximum value of 1) to truly quantify the complete distortion loss that the underlying computing nodes must bear to re-fetch the massive external knowledge tree.

[0049] In practice, the theoretical range of the repulsion coefficient should be controlled between 0 and 2 to limit the repulsion coefficient and the orthogonal loss operand. When the calculation result exceeds this range due to numerical error, truncation correction should be performed. The orthogonal loss operand must not be negative.

[0050] Preferably, utilizing the queued waiting time to transform the basic computing load into a dynamic, urgent load includes: Obtain the arrival clock of the front-end request, and subtract the arrival clock from the current clock to obtain the queued delay time; Obtain the global average processing time from system power-on to the current clock; Divide the queued delay time by the global average processing time and perform a natural exponential calculation to obtain the system's macro-urgency factor. Multiplying the basic computing power load by the system's macroscopic urgency factor yields the dynamic urgency load: in, For the aforementioned dynamic urgent load; This refers to the basic computing power load; The current clock; For the arrival clock; The aforementioned queueing time; The global average processing time is denoted as .

[0051] The arrival clock is the starting time recorded when a frontend request is authenticated and officially enters the scheduling waiting queue. It can be obtained by calling the unified monotonic clock service at the moment the request is written into the waiting queue at the scheduling entry gateway.

[0052] Queued waiting time is the time difference between the current clock and the arrival clock, used to characterize the waiting time of the current request in the queue.

[0053] The global average processing time is the average value obtained by statistically analyzing the processing time of completed requests from system startup to the current clock, and is used to characterize the overall processing baseline of the system.

[0054] The system macro urgency factor is a macro urgency measure formed by the natural exponential amplification of the gap between the queued waiting time and the global average processing time.

[0055] Dynamic urgency load is a time priority-corrected load obtained by multiplying the basic computing power load by the system's macro-urgency factor, and is used to improve the scheduling priority of long-queued requests.

[0056] In practice, the recording position and starting point of the arrival clock should be recorded at the moment when the front-end request passes authentication and officially enters the scheduling waiting queue, rather than when the user clicks submit or the answer is generated. If the request is retried or forwarded, the time of first entry into the effective scheduling queue should be used as the standard.

[0057] In practice, for the statistical window of global average processing time and the rules for handling outliers, the completed requests in the most recent scrolling window after the system boots up should be used as samples. The most recent 1000 requests or all completed requests in the most recent 10 minutes can be selected. First, timeout failure requests and significantly abnormally slow requests should be removed. Then, the average value should be calculated.

[0058] In practical implementation, to limit the macro-urgency factor of the system, the result after the natural index calculation should be set with an upper and lower limit to prevent extreme queuing time from causing numerical explosion or complete desensitization; preferably, the macro-urgency factor of the system should be limited to between 1 and 20.

[0059] In practice, for the scheduling and usage of dynamic urgent loads, the load should not directly replace the basic computing power load, but should be included in the global objective function as a time priority adjustment amount parallel to the basic computing power load; when the node capabilities are similar, requests with higher dynamic urgent loads should be allocated first.

[0060] Preferably, the particle swarm optimization algorithm is combined with dynamic inertia weights and learning factors to perform self-driven iterative optimization and output a target concurrent allocation scheme, including: The global objective function is constructed by summing the basic computing load, the orthogonal loss operands, and the dynamic demand load, dividing by the clock speed of each computing node, and combining this with the allocation probability. An exponential decay term is constructed using the negative value of the quotient of the current global optimal fitness value divided by the current iteration fitness value in the global objective function. The dynamic inertia weight is generated by subtracting the exponential decay term from the numerical value. The individual learning factor is generated by dividing the individual's optimal fitness value by the sum of the current iteration's fitness value and the individual's optimal fitness value. The global learning factor is generated by subtracting the individual learning factor from the numerical value. The individual learning factor and the global learning factor together constitute the learning factor. Combining the dynamic inertia weight, the individual learning factor, the global learning factor, and the random perturbation value, the iterative operator of the concurrent routing allocation scheme of the particle swarm optimization algorithm is updated to solve the global objective function until the convergence condition is met and the objective concurrent allocation scheme is output. in, Let the global objective function be... Assign the probability; This refers to the basic computing power load; For the orthogonal loss operand; For the aforementioned dynamic urgent load; The clock speed of each computing node; The dynamic inertia weight; This refers to the current globally optimal fitness value; The fitness value of the current iteration; The individual learning factor; This represents the optimal fitness value for the individual. is the global learning factor.

[0061] Clock speed is the effective processing frequency that each computing node can stably provide within the current scheduling cycle. It can be obtained by reading the processor hardware description information and combining it with runtime frequency sampling results.

[0062] The allocation probability is the probability value that the current front-end request will be assigned to a certain candidate computing node, which is used to represent the routing scheme's preference for each node.

[0063] The global objective function is an overall evaluation value that combines the basic computing power load, orthogonal loss operands, dynamic urgent load, main frequency speed, and allocation probability. Generally, the smaller the value, the better the routing scheme.

[0064] The current global optimal fitness value is the best evaluation value among all the historical best results of all particles in the current iteration.

[0065] The fitness value of the current iteration is the evaluation value of the routing scheme corresponding to a particle in the current iteration.

[0066] The exponential decay term is a decay amount generated by the ratio between the current global optimal fitness value and the current iteration fitness value, and is used to adjust the dynamic inertia weight.

[0067] Dynamic inertia weights are weight values ​​that the particle swarm optimization algorithm uses to retain the search trend from the previous round in the current iteration, in order to balance global exploration and local exploitation.

[0068] The optimal fitness value of an individual is the best fitness value that a particle has achieved from initialization to the current moment.

[0069] The individual learning factor is a learning weight generated from the relationship between an individual's optimal fitness value and the current iteration's fitness value. It is used to guide particles toward their historical best position.

[0070] The global learning factor is the learning weight obtained by subtracting the individual learning factor from the value 1, and is used to guide particles toward the global historical best position.

[0071] The learning factor is a collective term for individual learning factors and global learning factors, which are used to jointly determine the search direction and search intensity of particles.

[0072] The random perturbation value is a random exploration quantity introduced to prevent the particle swarm optimization algorithm from getting trapped in local optima. It is preferably a uniform random number between 0 and 1. This range can ensure the diversity of the search while avoiding the solution from being severely jittered due to an excessively large single perturbation.

[0073] Iterative operators are operational rules for updating particle states based on dynamic inertia weights, individual learning factors, global learning factors, and random perturbation values.

[0074] The convergence condition is the termination rule used to determine whether the particle swarm optimization algorithm stops iterating and outputs the final solution. Preferably, the rate of change of the global objective function is no higher than 0.001 for 10 consecutive iterations, or the cumulative number of iterations reaches 100. This combination ensures sufficient optimization while avoiding excessive iteration that increases scheduling latency.

[0075] The target concurrent allocation scheme is the optimal routing result obtained after the particle swarm algorithm has completed its iterations. It is used to determine the computing node that the current front-end request should be pushed to.

[0076] In practice, the encoding and constraints of the allocation probability require that each particle corresponds to a set of allocation probability vectors for candidate computing nodes; each allocation probability in the vector is not less than 0 and not greater than 1; the sum of all allocation probabilities corresponding to the same request is always equal to 1; if a particle updates and a negative value or the sum is not 1, it should be truncated and then normalized.

[0077] In practical implementation, regarding the summation range and optimization direction of the global objective function, the summation range should cover all candidate computing nodes currently participating in the competition; each candidate node's allocation probability multiplied by its comprehensive load contribution per unit clock frequency is included in the overall objective; the objective direction should be set to be as small as possible. It is important to note that in a real-world hardware environment, the effective clock speed of computing nodes exhibits non-linear thermal throttling as the concurrent allocation probability increases. Simultaneously, the solution space of the allocation probability vector is strictly constrained by the non-convex boundary of each node's real-time remaining memory capacity. This results in a highly complex non-convex characteristic in the feasible solution space of the global objective function during actual scheduling, making traditional linear programming or greedy algorithms prone to local deadlocks and causing computational power fluctuations. Therefore, this system must combine particle swarm optimization (PSO) with its dynamic inertia weights and learning factors to conduct self-driven global exploration in a non-convex multidimensional constrained space, thereby accurately finding and optimizing the target concurrent allocation scheme.

[0078] In practice, the nominal clock speed of the processor is not used directly, but rather the effective clock speed that truly reflects the physical computing power of the computing node within the current scheduling cycle. The effective clock speed is dynamically reduced based on the hardware nominal clock speed, combined with thermal throttling and resource contention factors. Its calculation expression is: in, The nominal clock speed of the hardware; The current core temperature collected by the underlying sensors; and These are the set safe temperature threshold and critical frequency reduction temperature, respectively (the plus sign outside the parentheses indicates that if the calculation result is negative, it will be 0, indicating that the overheat shutdown protection is triggered). StealTime is the percentage of CPU time preempted by other virtual machines or containers on the same host machine, as monitored by the operating system's virtualization layer in the current cycle.

[0079] In practice, for updating the iterative operator, it is necessary to first retain the trend of the previous round of allocation probability changes based on the dynamic inertia weight; then add the pull term of the individual learning factor pointing to the individual's historical optimal solution; then add the pull term of the global learning factor pointing to the global historical optimal solution; finally add the random perturbation value to form the exploration term; after the update, the allocation probability of each dimension is nonnegated and normalized.

[0080] In practice, regarding the generation distribution and injection method of random perturbation values, random perturbation values ​​need to be generated independently in each iteration, for each particle, and for each candidate node dimension; a uniform random distribution between 0 and 1 is preferred; this value only participates in the update as an incremental weight and does not directly replace the allocation probability itself.

[0081] Preferably, the front-end request is pushed into the optimal computing node according to the target concurrency allocation scheme. A projection operator is generated using the non-tenant matrix in the optimal computing node. The query vector of the front-end request is projected onto the projection operator to obtain a security tensor and perform logical operations, including: The optimal computing node is determined according to the target concurrency allocation scheme, and all non-tenant matrices residing in the cache of the optimal computing node are extracted; Multiply the transpose of the non-tenant matrix by itself to obtain its inverse, then multiply this inverse by the transpose of the non-tenant matrix, and finally left-multiply by the non-tenant matrix to obtain the residual attribute projection matrix: The projection operator is obtained by subtracting the residual attribute projection matrix from the identity matrix: The query vector from the front-end request is multiplied by the projection operator to obtain the absolutely isolated security tensor, and the security tensor is input into the optimal computing node for the logical operation: in, The residual attribute projection matrix; For the non-tenant matrix; This is the transpose of the non-tenant matrix; The projection operator; The identity matrix; For the security tensor; Let be the query vector.

[0082] The optimal computing node is the target computing node that is finally selected based on the target concurrency allocation scheme and used to execute the current front-end request logic operation.

[0083] The non-tenant matrix is ​​a boundary representation matrix composed of the feature data of other tenants residing in the cache of the best computing node. It is used to describe the attribute space of non-tenants that should be isolated and removed.

[0084] The transpose of a non-tenant matrix is ​​a matrix formed by performing row and column transformations on the non-tenant matrix, and is used for subsequent projection operations.

[0085] The inverse matrix is ​​the inverse of the invertible matrix corresponding to the transpose of a non-tenant matrix multiplied by itself, and is used to construct projection relationships.

[0086] The residual attribute projection matrix is ​​a matrix that projects the original query information onto the residual attribute subspace of non-tenant properties, and is used to characterize the direction of contamination that should be removed.

[0087] The identity matrix is ​​a standard matrix with the same feature dimension as the query vector, where the main diagonal elements are 1 and the rest are 0.

[0088] The projection operator is obtained by subtracting the residual attribute projection matrix from the identity matrix, and is used to remove non-tenant boundary components.

[0089] A query vector is the original vector representation of a front-end request in a unified feature space, used to carry the request body, context, and business tag information.

[0090] The security tensor is the isolation result formed after the query vector is processed by the projection operator. It is used to ensure that subsequent logical operations are only performed within the security boundary of this tenant.

[0091] Logical operations are knowledge retrieval, rule matching, graph traversal, path reasoning, and answer organization and processing performed by the optimal computing node based on the security tensor.

[0092] In practice, to determine the optimal computing node, we need to first select the computing node with the highest allocation probability and that meets the safety constraints according to the target concurrent allocation scheme; if there are multiple nodes with the same allocation probability, we should give priority to the node with the lower contribution value of the global objective function; if they are still the same, we should select the node with fewer queued tasks.

[0093] In practical implementation, regarding the generation and stacking rules of non-tenant matrices, to avoid dimensional explosion and matrix singularity-induced inversion failures caused by multi-tenant data overlap, the system executes: First, the features of each extracted non-tenant data fragment must be transformed into a dimension-constant form through a unified mapping layer. Standard column vector Secondly, the resident... The column vectors of non-tenants are concatenated column by column to form the initial... dimensional original residual matrix .because Often much larger than Furthermore, it exhibits numerous linear correlation characteristics, requiring the system to... Perform singular value decomposition (SVD) or Gram-Schmidt-based orthogonalization to extract the top variance contributors whose cumulative variance contribution rate exceeds a preset threshold (e.g., 95%). These are orthogonal basis vectors, given by... The non-tenant matrix is ​​composed of orthogonal basis column vectors. (its dimensions are) And full rank).

[0094] In practice, for the invertibility and degeneracy of the inverse matrix, it is necessary to first perform condition number detection on the product of the transpose of the non-tenant matrix and itself; when the matrix is ​​full rank, the inversion is directly calculated; when the matrix is ​​not full rank or close to singular, a stabilization method of adding a small positive value on the diagonal should be adopted before inverting.

[0095] In practice, regarding the encoding method and dimension matching rules of the query vector, the question body, context, slot information and tenant business tags in the front-end request need to be encoded into a query vector of uniform length first; the feature dimensions of this vector must be completely consistent with the projection operator; if they are inconsistent, dimension alignment should be performed first through a unified mapping layer.

[0096] In practice, for the execution of the security tensor after entering the logical operation, the projection operator needs to be used first to eliminate the components in the query vector that are in the same direction as the residual attributes of non-tenants, forming a security tensor; then the security tensor is sent to the graph retrieval, rule matching, path reasoning and answer organization modules; finally, the response result is output based only on the knowledge boundary of the tenant.

[0097] Preferably, after the optimal computing node completes the logical operation, the clock operands of the optimal computing node are recovered, and the baseline computing power consumption is corrected in a closed loop using the clock operands and the basic computing power load, including: After the logic operation on the security tensor is completed on the optimal computing node using the low-level probe, the clock operands consumed during the execution are recovered. The difference is obtained by subtracting the base computing load from the clock operand, and then dividing the difference by the base computing load and performing natural exponentiation to obtain the evolution factor. Multiplying the current baseline computing power consumption by the evolution factor yields the baseline computing power consumption for the next cycle after closed-loop correction. in, The baseline computing power consumption for the next cycle after closed-loop correction; This represents the current baseline computing power consumption; For the clock operand; This refers to the basic computing power load.

[0098] It is important to note that the BPO (Business Process Outsourcing) model described above is specifically embodied in a physical sharing and logical isolation mechanism with a single master and multiple tenants at the underlying system architecture. In BPO business scenarios, the platform needs to simultaneously handle HR inquiries from multiple different companies (i.e., different tenants). The policies and rules of different companies are highly heterogeneous and subject to strict confidentiality restrictions, yet they must share the underlying computing power cluster. This system, through projection operators (targeted filtering of non-tenant attributes) and cross-tenant cache exclusion coefficients, ensures anti-penetration isolation and immunity to computing power loss when data from multiple companies flows concurrently on the same physical node under the BPO model.

[0099] Clock operands represent the actual number of operations consumed when an optimal computing node performs logical operations on a safety tensor. They can be obtained by reading processor cycle counts, completed instruction counts, and multi-core execution time using low-level probes, and then normalizing them according to a unified conversion rule.

[0100] In practical implementation, regarding the deployment of low-level probes and the reclamation of clock operands, the low-level probes preferably employ kernel-level monitoring probes based on eBPF (Extended Berkeley Packet Filter) technology. These probes are directly mounted to the performance monitoring unit of the operating system kernel, collecting hardware-level events non-intrusively. For the unified conversion rule, the system does not directly perform simple physical accumulation on multi-core execution cycles, but instead uses an equivalent scalar operand conversion model. Specifically, the clock operands... The calculation formula is defined as follows: in, The total number of physical threads participating in the front-end request logic operation; and The probe collected the first Processor cycle count and instruction count completed for each thread (IPC evaluation). and Preset weighting coefficients for hardware microarchitecture features (e.g., in computationally intensive graph inference). Take 0.3, Take 0.7); For multi-core concurrency; The base for multi-threaded synchronization overhead penalty (range of values) This rule normalizes the complex overhead of parallel hardware into a standard absolute workload.

[0101] The difference is the deviation obtained by subtracting the base computing load from the clock operands, and is used to reflect the degree of deviation between the theoretical load estimate and the actual execution consumption.

[0102] The evolution factor is a correction coefficient obtained by performing a natural exponential operation on the ratio of the difference to the base computing power load. It is used to drive adaptive adjustment of the baseline computing power consumption.

[0103] The baseline computing power consumption for the next cycle after closed-loop correction is a new calibration value formed by correcting the current baseline computing power consumption with an evolution factor, and is used for calculating the basic computing power load for the next scheduling cycle.

[0104] In practice, the deployment and sampling of the underlying probes should be carried out between the runtime environment of the optimal computing node and the operating system monitoring layer; the sampling range should at least cover processor cycles, memory access, cache hits and misses, graph retrieval calls and logical operation execution time.

[0105] In practical implementation, the measurement of clock operands should be based on the total effective execution consumption from the start of the task entering the logical operation from the security tensor to the completion of the result generation. In multi-threaded and multi-core execution scenarios, the effective cycle of each execution unit should be normalized and summed. Idle time waiting for external interface returns but not occupying local computing resources is not included.

[0106] In practical implementation, for the stabilization and anomaly protection of the evolution factor, when the basic computing power load is too small, close to 0 or obviously distorted, it should first be replaced with the minimum effective load threshold, and then the difference ratio should be calculated; the evolution factor after the natural exponent calculation should be set with an upper and lower limit, preferably limited to between 0.8 and 1.25.

[0107] In practice, for the storage, activation, and rollback of the baseline computing power consumption in the next cycle after the closed-loop correction, the correction results should be written to the configuration center or scheduling parameter storage immediately after the current request ends; the new value will take effect in the next scheduling cycle and will not be written back to the currently being processed request.

[0108] The embodiments of this example have been described above. However, this example is not limited to the specific implementation methods described above. The specific implementation methods described above are merely illustrative and not restrictive. Those skilled in the art can make many other forms based on the guidance of this example, and all of them are within the protection scope of this example.

Claims

1. A human resources platform intelligent customer service management system based on the BPO model, applied to a system comprising an underlying shared computing power cluster and a surface knowledge graph, characterized in that, Configured to execute sequentially: The data volume of the front-end request is obtained, and combined with the local node density and baseline computing power consumption of the exclusive knowledge graph to which the front-end request belongs, the front-end request is converted into a basic computing power load. Evaluate the historical task queues of each computing node within the underlying shared computing power cluster to determine the current cache distortion of each computing node; By combining the current cache distortion, the first centroid vector of the dedicated knowledge graph, and the second centroid vector of the residual data in the compute node cache, the orthogonal loss operation number for allocating front-end requests to each compute node is calculated. Obtain the queued latency of frontend requests and use the queued latency to transform the basic computing load into a dynamic urgent load. The basic computing power load, orthogonal loss operands and dynamic urgent load are integrated to construct a global objective function. The dynamic inertia weight and learning factor of the particle swarm algorithm are combined for iterative optimization to output the objective concurrency allocation scheme. According to the target concurrency allocation scheme, the front-end request is pushed into the optimal computing node. The non-tenant matrix in the optimal computing node is used to generate a projection operator. The query vector of the front-end request is projected onto the projection operator to obtain the security tensor and perform logical operations. After the optimal computing node completes the logical operation, the clock operands of the optimal computing node are recovered, and the benchmark computing power consumption is corrected in a closed loop using the clock operands and the basic computing power load.

2. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 1, characterized in that, Converting the front-end request into a basic computing load includes: Extract the data volume of the front-end request; Determine the maximum traversal depth of the exclusive knowledge graph, count the number of nodes in the exclusive knowledge graph at each depth, and sum the number of nodes to obtain the local node density; The basic computing load is obtained by multiplying the data volume, the local node density, and the baseline computing power consumption.

3. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 2, characterized in that, The current cache distortion of each computing node is determined, including: Extract the actual workload and completion clock of each historical task from the historical task queue of the computing node; The difference between the current clock and the completed clock is used to obtain the completed clock difference value; Obtain the cache read / write limit bandwidth and maximum cache capacity of the computing node; The time decay coefficient is obtained by dividing the product of the completion clock difference and the cache read / write limit bandwidth by the maximum cache capacity, taking the negative value, and performing natural exponentiation. The current cache distortion of each computing node is obtained by multiplying the actual workload of each historical task by the corresponding time decay coefficient and summing the results.

4. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 3, characterized in that, Calculating the orthogonal loss operands for distributing the front-end requests to each of the computing nodes includes: Extract the first centroid vector of the proprietary knowledge graph; Extract the second centroid vector of the residual data cached by the computing node; Perform a dot product operation between the first centroid vector and the second centroid vector, and divide by the product of the magnitudes of the first centroid vector and the second centroid vector to obtain the cosine similarity. The repulsion coefficient is obtained by subtracting the cosine similarity from the numerical value. Multiplying the current cache distortion by the repulsion coefficient yields the orthogonal loss operands for allocating the frontend requests to each computing node.

5. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 4, characterized in that, Utilizing the pre-queued latency to transform the basic computing power load into a dynamic, urgent load includes: Obtain the arrival clock of the front-end request, and subtract the arrival clock from the current clock to obtain the queued delay time; Obtain the global average processing time from system power-on to the current clock; Divide the queued delay time by the global average processing time and perform a natural exponential calculation to obtain the system's macro-urgency factor. The dynamic urgency load is obtained by multiplying the basic computing power load by the system macroscopic urgency factor.

6. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 5, characterized in that, Combining the dynamic inertia weights and learning factors of the particle swarm optimization algorithm, a self-driven iterative optimization is performed to output a concurrent target allocation scheme, including: The global objective function is constructed by adding the basic computing power load, the orthogonal loss operands, and the dynamic urgent load, dividing by the main frequency speed of each computing node, and combining the allocation probability. An exponential decay term is constructed by dividing the current global optimal fitness value in the global objective function by the negative value of the current iteration fitness value, and the dynamic inertia weight is generated by subtracting the exponential decay term from the numerical value. The individual learning factor is generated by dividing the individual's optimal fitness value by the sum of the current iteration fitness value and the individual's optimal fitness value. The global learning factor is generated by subtracting the individual learning factor from the numerical value, and the individual learning factor and the global learning factor together constitute the learning factor. By combining the dynamic inertia weight, the individual learning factor, the global learning factor, and the random perturbation value, the iterative operator of the concurrent routing allocation scheme of the particle swarm optimization algorithm is updated to solve the global objective function until the convergence condition is met and the objective concurrent allocation scheme is output.

7. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 6, characterized in that, According to the target concurrency allocation scheme, the front-end request is pushed into the optimal computing node. A projection operator is generated using the non-tenant matrix in the optimal computing node. The query vector of the front-end request is projected onto the projection operator to obtain a security tensor and perform logical operations, including: The optimal computing node is determined according to the target concurrency allocation scheme, and all non-tenant matrices residing in the cache of the optimal computing node are extracted; The inverse matrix is ​​obtained by multiplying the transpose of the non-tenant matrix with itself, then multiplying it with the transpose of the non-tenant matrix, and finally left-multiplying the non-tenant matrix to obtain the residual attribute projection matrix. The projection operator is obtained by subtracting the residual attribute projection matrix from the identity matrix. The query vector requested by the front end is multiplied by the projection operator to obtain the absolutely isolated security tensor, and the security tensor is input into the optimal computing node for the logical operation.

8. The intelligent customer service management system for a human resources platform based on the BPO model according to claim 7, characterized in that, After the optimal computing node completes the logical operation, the clock operands of the optimal computing node are recovered. The clock operands and the base computing load are then used to perform a closed-loop correction of the baseline computing power consumption, including: After the logic operation on the security tensor is completed on the optimal computing node using the low-level probe, the clock operands consumed during the execution are recovered. The difference is obtained by subtracting the base computing load from the clock operand, and the difference is divided by the base computing load and subjected to natural exponentiation to obtain the evolution factor. Multiply the current benchmark computing power consumption by the evolution factor to obtain the benchmark computing power consumption for the next cycle after closed-loop correction.

Images