A human resource deployment method and device for elevator maintenance, an electronic device, a medium and a program product

Abstract

The present application belongs to the technical field of data processing, and specifically discloses a human resource allocation method and device for elevator maintenance, an electronic device, a medium and a program product. The method comprises the following steps: detecting a temporary redeployment event of personnel and recording key information, constructing and updating a task-personnel dependency graph containing task nodes, personnel nodes, time sequence edges, cooperation edges and the like; propagating delay from an event source node to determine an affected task set, evaluating a task impact weight based on urgency, default cost and other parameters, and extracting high-weight tasks; taking the event source as the center, combining multi-dimensional threshold to extract a local optimization domain and freeze the allocation outside the domain, inputting the information in the domain into a large model to generate a candidate strategy, and finally screening an optimal scheme based on constraint conditions and objective functions. The present application realizes efficient human resource reallocation under local minimum disturbance, reduces delay cost and default risk, and improves the utilization rate of human resources.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of data processing, and particularly relates to a human resource allocation method and device for elevator maintenance, an electronic device, a medium and a program product. BACKGROUND

[0002] In the existing elevator maintenance work, temporary personnel redeployment events occur frequently, which can easily cause task delays, breach risks and customer complaints. Traditional human resource allocation methods rely on manual experience and lack systematic consideration of the association between tasks and personnel. They cannot dynamically assess the delay propagation path and priority, resulting in uneven resource allocation, key task delays and overall efficiency decline. At the same time, tasks involve multi-dimensional constraints such as skill matching, time window constraints, collaboration relationships and shared resources, and manual allocation cannot balance optimality and feasibility. Especially in the scenario of multiple tasks and multiple personnel in parallel, the existing method lacks the ability to quickly reallocate local high-impact tasks and is difficult to efficiently generate a feasible allocation scheme within the minimum disturbance range. SUMMARY

[0003] To solve the above technical problems, the present application provides a human resource allocation method and device for elevator maintenance, an electronic device, a medium and a computer program product.

[0004] The present application provides a human resource allocation method for elevator maintenance, comprising the following method steps:

[0005] Step S1, when a temporary personnel redeployment event is detected, record the event trigger time and the affected personnel identifier;

[0006] Step S2, construct a task-personnel dependency graph, the dependency graph contains multiple nodes and multiple edges and their corresponding attributes, wherein the nodes include task nodes and personnel nodes, the edges include time sequence edges, collaboration edges, resource edges and supervision edges, and the available time window of the affected personnel and the related edge attributes are updated based on the temporary redeployment event;

[0007] Step S3, starting from the event source node, propagate the delay along the dependency graph, and calculate the affected task set, wherein the event source node is the temporarily redeployed personnel node;

[0008] Step S4, based on the impact parameter, evaluate the impact weight of the affected task, and obtain the top k tasks with the highest weight, wherein k>0, the impact parameter includes the urgency of the task, the breach cost, the customer criticality and the site sensitivity;

[0009] Step S5, taking the event source node as the center, extracting the local optimization domain of the dependency graph based on multi-dimensional threshold, and freezing the task and personnel allocation outside the optimization domain, wherein the multi-dimensional threshold includes the graph distance threshold, the travel time threshold and the time window overlap threshold.

[0010] Step S6: Input the relevant information of the nodes in the optimization domain into the large model to generate candidate strategies for human resource allocation, wherein the relevant information of the nodes includes at least task information, personnel information and travel time matrix summary;

[0011] Step S7: Select the optimal solution from the candidate strategies based on the constraints and objective function.

[0012] In another aspect, this application also provides a human resource allocation device for elevator maintenance, comprising:

[0013] The temporary personnel reassignment event detection module is used to record the event trigger time and the identifier of the affected personnel when a temporary personnel reassignment event is detected.

[0014] The dependency graph construction and update module is used to construct a task-person dependency graph, which contains multiple nodes and multiple edges and their corresponding attributes. The nodes include task nodes and personnel nodes, and the edges include time-series edges, collaboration edges, resource edges and supervision edges. The module updates the available time windows and related edge attributes of affected personnel based on temporary transfer events.

[0015] The affected task set determination module is used to calculate and obtain the affected task set by propagating the delay along the dependency graph starting from the event source node, wherein the event source node is the node of the temporarily transferred personnel;

[0016] The impact weight calculation module is used to evaluate the impact weight of the affected tasks based on the impact parameters, and obtain the top k tasks with the highest weights, where k>0. The impact parameters include the urgency of the task, the cost of breach of contract, the criticality of the customer, and the sensitivity of the location.

[0017] The optimization domain determination module is used to extract local optimization domains of the dependency graph centered on the event source node based on multi-dimensional thresholds, and freeze the allocation of tasks and personnel outside the optimization domain. The multi-dimensional thresholds include graph distance threshold, travel time threshold, and time window overlap threshold.

[0018] The candidate strategy generation module is used to input the relevant information of nodes in the optimization domain into the large model to generate candidate strategies for human resource allocation, wherein the relevant information of nodes includes at least task information, personnel information and travel time matrix summary;

[0019] The optimal solution selection module is used to select the optimal solution from the candidate strategies based on constraints and objective functions.

[0020] This application also provides an electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform a human resource allocation method for elevator maintenance as described above.

[0021] In another aspect, this application provides a computer-readable storage medium having stored thereon computer program instructions that can be executed by a processor to implement a human resource allocation method for elevator maintenance as described above.

[0022] Another aspect of this application provides a computer program product, including a computer program that, when executed by a processor, implements a human resource allocation method for elevator maintenance as described above.

[0023] This invention constructs a task-personnel dependency graph and combines it with delay propagation analysis to accurately identify task sets affected by temporary personnel reassignment. It then quantifies priorities based on parameters such as urgency and breach of contract costs, ensuring high-impact tasks are prioritized. Multidimensional thresholds are used to define local optimization domains and freeze out-of-domain allocations, effectively controlling the scope of scheduling disturbances. A large-scale model based on GPT is introduced to generate candidate allocation strategies, and the optimal solution is selected by combining constraints such as skill matching, time windows, resource conflicts, and travel time, achieving intelligent allocation. This method can significantly improve emergency response speed, reduce breaches of contract and customer complaints, and optimize human resource utilization. Attached Figure Description

[0024] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some embodiments of the present invention and should not be regarded as a limitation on the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0025] Other features, objects, and advantages of this application will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0026] Figure 1 A flowchart illustrating a human resource allocation method for elevator maintenance, provided as an embodiment of the present invention.

[0027] Figure 2 A flowchart for obtaining the set of affected tasks provided in an embodiment of the present invention.

[0028] Figure 3This is a schematic diagram of the large model structure provided in an embodiment of the present invention.

[0029] Figure 4 This is a schematic diagram of a human resource allocation device for elevator maintenance provided in an embodiment of the present invention.

[0030] Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0031] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0032] This application proposes a method for allocating human resources for elevator maintenance. The technical solution of this application will be described in detail below with reference to various embodiments.

[0033] like Figure 1 As shown in the figure, an embodiment of the present invention discloses a human resource allocation method 100 for elevator maintenance, including the following method steps:

[0034] Step S1: When a temporary personnel reassignment event is detected, record the event trigger time and the identifier of the affected personnel.

[0035] In some embodiments, this step is used to capture temporary personnel reassignment events and record key information to provide basic data for subsequent dependency graph updates and delay propagation analysis.

[0036] Specifically, temporary reassignment events include, but are not limited to, emergency alarm signals: such as high-priority events from elevator entrapment rescue systems and property emergency repair platforms (e.g., "People are trapped in elevator No. 3 of XX Building, and rescuers need to be dispatched immediately"); dispatch center instructions: such as temporary personnel reassignment instructions issued by management personnel (including instruction number, reason for reassignment, and execution time limit). For example, when the above signals contain keywords such as "temporary reassignment," "emergency task," and "personnel reassignment," and meet the characteristics of being unplanned tasks and having a higher priority than the original tasks, they are determined to be temporary personnel reassignment events.

[0037] In one embodiment, after the event is confirmed, the following data is recorded, for example: the event trigger time t0, which serves as the reference point for subsequent time window calculations; the affected personnel identifier: a unique code for the personnel being transferred (e.g., “EMP00123”), which is directly associated with personnel node attributes (skill set, original planned task chain, etc.) for subsequent location of the affected personnel node and associated tasks.

[0038] Step S2: Construct a task-person dependency graph. The dependency graph contains multiple nodes and multiple edges and their corresponding attributes. The nodes include task nodes and personnel nodes. The edges include time-series edges, collaboration edges, resource edges, and supervision edges. Based on the temporary transfer event, update the available time window and related edge attributes of the affected personnel.

[0039] In some embodiments, this step is used to construct and dynamically update a task-person dependency graph based on planned tasks, and to characterize the relationship between tasks and personnel through the attributes of nodes and edges.

[0040] Specifically, the dependency graph is represented by a directed graph structure G=(V,E), where V is the set of nodes and E is the set of edges. For example, the specific construction rules are as follows:

[0041] The node set V includes, for example, task nodes and personnel nodes. Specifically, each task node corresponds to a unique task number (e.g., t001), and its attributes include:

[0042] Skill requirements: Skill tags required to complete the task (e.g., "trapped person rescue", "inverter repair");

[0043] Time window: The time interval during which the task is allowed to execute [start, end] (e.g., [2024-05-20 10:00, 12:00]).

[0044] Baseline duration: Estimated execution time under normal operating conditions (unit: minutes);

[0045] Service Level Agreement (SLA) Costs: Breach of Service Window Fees (Unit: Yuan / Minute).

[0046] Specifically, each personnel node corresponds to a unique personnel identifier (e.g., EMP001), and its attributes include:

[0047] Skill set: The set of skill tags possessed by personnel (e.g., "trapped person rescue", "routine inspection").

[0048] Available time window: The time interval during which personnel can perform tasks [avail_start, avail_end];

[0049] Location: The geographical location of the personnel in their current or next task (which can be latitude and longitude coordinates).

[0050] The edge set E, for example, includes four types of edges: temporal edges, collaborative edges, resource edges, and regulatory edges, specifically:

[0051] Temporal edge: Connects consecutive task nodes of the same person (e.g., t001→t002), with the attribute "minimum interval time" (including travel time and preparation time from the end of the preceding task to the start of the following task).

[0052] Collaboration edge: Connects the collaborative task and the participating personnel nodes (e.g., t003↔EMP001, t003↔EMP002), with attributes of "minimum number of collaborators" and "skill combination requirements" (e.g., "≥2 people, including 1 electrical engineer").

[0053] Resource edge: Connects task nodes with shared resources (such as special tools and spare parts), with attributes of "resource occupation time period" (e.g., [2024-05-20 09:00, 11:00]) and "resource priority" (e.g., "high / medium / low").

[0054] Supervisory edge: Connects task nodes and supervisory personnel nodes (e.g., t004→SUP001), with attributes of "supervision deadline" (e.g., 2024-05-2015:00) and "supervision level" (e.g., "regional supervisor level").

[0055] In some embodiments, when step S1 detects a temporary personnel reassignment event, the dependency graph is updated, specifically including updating personnel node attributes and updating edge attributes in conjunction.

[0056] Specifically, for updating personnel node attributes, for example, the affected personnel node is located, its available time window is adjusted to the interval after removing the withdrawal period (for example, the original [9:00, 18:00] is updated to [14:00, 18:00], assuming the withdrawal period is 9:00-14:00), and the status is marked as "temporary occupation".

[0057] Specifically, for edge attribute linkage updates, for example, for time-series edges, if the original task chain of the affected personnel contains time-series edges (e.g., t001→t002), the "minimum interval time" is recalculated (because t001 is delayed due to personnel transfer, the interval time of t002 needs to be extended).

[0058] For collaborative edges, for example, if the person is a participant in a collaborative task (e.g., the collaborative edge of t003 involves EMP001), update the "minimum number of collaborators" attribute (e.g., the original "≥2 people" is adjusted to "1 additional person is needed").

[0059] For resource edges, for example, if the shared resource occupied by the person is adjusted due to the time period, the "resource occupation time period" is updated synchronously (for example, the occupation time period of device R is delayed due to the delay of task t001).

[0060] For the supervisory side, for example, if the person is a supervisor (e.g., SUP001 is reassigned), update the "supervisory deadline" (e.g., extend it by 2 hours) or associate it with the alternative supervisor node.

[0061] Step S3: Starting from the event source node, propagate the delay along the dependency graph and calculate the set of affected tasks, wherein the event source node is the node of the temporarily transferred personnel.

[0062] In some embodiments, this step starts from the event source node, traces the propagation path of the delay along the task-person dependency graph, and determines the set of tasks affected.

[0063] Preferably, such as Figure 2 As shown, the calculation of the affected task set includes: Step S301, set initialization, adding the initial task node associated with the event source node to the set; Step S302, starting from the initial task node, traversing the associated nodes along different types of edges in the dependency graph, determining whether the associated node causes the task to be unable to be executed as originally planned due to the delay of the preceding task, and if the condition is met, adding the task to the set; Step S303, when all associated nodes have been traversed and no new task meets the addition condition, the propagation stops.

[0064] Specifically, based on the affected personnel identifiers recorded in step S1, the corresponding personnel node (e.g., EMP001) is located in the dependency graph constructed in step S2. This node is the starting point for delay propagation, and its associated original planned task chain is the initial disturbance source.

[0065] Next, extract all unexecuted task nodes of the event source node (temporarily reassigned personnel) after the trigger time t0, and include them as the initial affected tasks in the affected task set AffectSet. For example, if EMP001 was originally scheduled to execute tasks t002 (10:00-11:00) and t005 (11:30-12:30) after t0 (e.g., 09:35), then t002 and t005 will be added to AffectSet.

[0066] For example, differentiated propagation rules are formulated along the four types of edges in the dependency graph (sequential edges, collaborative edges, resource edges, and regulatory edges). Specifically:

[0067] For time-series edge propagation, for example, if tasks T1 and T2 are connected by a time-series edge (T1→T2), and T1 is included in the AffectSet due to personnel reassignment, then calculate the delay time Δt of T1 (the difference between the original planned start time and the actual start time). If Δt causes the planned start time of T2 to exceed its time window or fail to meet the minimum interval time, then T2 is included in the AffectSet.

[0068] For collaborative edge propagation, for example, if task T is a collaborative task (associated with personnel P1, P2, ..., Pn through collaborative edges), and one of the personnel Pi is reassigned, causing T to be delayed, then check the subsequent tasks of other participants (e.g., task T3 of Pj): if the delay of T causes Pj's available time window to be pushed back, making it impossible for T3 to be executed as originally planned, then add T3 to the AffectSet.

[0069] For resource edge propagation, for example, if task Ta occupies shared resource R through a resource edge, and the release time of R is delayed due to Ta's delay, then check the subsequent task Tβ that depends on R: if the planned start time of Tβ is earlier than the actual release time of R, then add Tβ to AffectSet.

[0070] For monitoring edge propagation, for example, if task Th needs to be monitored by the assigned personnel Ps (connected via monitoring edge), the completion time of Th will be delayed due to the lack of monitoring. Then, the subsequent task Ti that depends on the result of Th will be checked. If the delay of Th causes Ti to be unable to start within its time window, Ti will be included in AffectSet.

[0071] In this embodiment, starting from the initial task node in AffectSet, all associated nodes are traversed along the dependency graph according to the above rules to determine whether they meet the inclusion conditions. If a new task is included in AffectSet, the propagation continues from this task as the new starting point until all reachable nodes have been traversed. After each iteration, the delay reason of the new task is recorded (e.g., "t005 cannot be executed due to the delay of t002") to ensure that the propagation path is traceable.

[0072] For example, delay propagation stops when any of the following conditions are met:

[0073] After traversing all nodes in the dependency graph that have path connections to the event source node, and finding no new tasks that meet the inclusion criteria;

[0074] The delay of a new task has an impact on its subsequent tasks that exceeds the tolerance range of the task time window (e.g., the delay makes subsequent tasks completely impossible to execute, without further propagation).

[0075] After the propagation ends, AffectSet becomes the final set of affected tasks.

[0076] Step S4: Evaluate the impact weight of the affected tasks based on the impact parameters, and obtain the top k tasks with the highest weights, where k>0. The impact parameters include the urgency of the task, the cost of breach of contract, the criticality of the customer, and the sensitivity of the location.

[0077] In some embodiments, this step is used to assess the impact of delays on affected tasks and to filter out tasks that need to be prioritized by calculating impact weights.

[0078] Preferably, the local optimization domain of the dependency graph is extracted based on multi-dimensional thresholds, including: selecting a set of candidate tasks, a set of candidate personnel, and related edges that meet the conditions from global tasks and personnel based on the graph distance threshold, travel time threshold, and time window overlap threshold, to form a preliminary local domain; and incorporating the top k tasks with the highest weights into the local domain to form the local optimization domain.

[0079] Specifically, from the affected task set AffectSet determined in step S3, four impact parameters for each task i are extracted and standardized:

[0080] Urgency σi: Calculated based on the task's SLA time window, the formula is σi=1-(remaining time until the end of the time window / task baseline time), with a value range of [0,1] (the larger the value, the more urgent the task).

[0081] Default cost Ci: Taken from the "SLA cost" attribute in the task node, normalized according to the company's annual average default cost (e.g., Ci'=Ci / Annual maximum default cost), with a value range of [0,1].

[0082] Customer criticality αᵢ: Based on the customer level (e.g., VIP customer, contracted customer, temporary customer), a preset weight is assigned, with values ​​of 0.8-1.0, 0.5-0.7, and 0.1-0.4 respectively, and the value range is [0,1].

[0083] Location sensitivity βᵢ: Set according to the type of location where the task is located (e.g., hospital, shopping mall, residence). The value is 0.8-1.0 for hospitals / transportation hubs, 0.5-0.7 for shopping malls / office buildings, and 0.1-0.4 for ordinary residences. The value range is [0,1].

[0084] Next, the delay impact weight wi for each task i is calculated using a weighted summation formula; for example, the formula for calculating wi is:

[0085]

[0086] Wherein, λ1, λ2, λ3, and λ4 are the weighting coefficients of the four parameters, satisfying λ1+λ2+λ3+λ4=1. It can be understood that the weighting coefficients can be dynamically adjusted according to the actual situation. For example, when prioritizing economic costs, λ1=0.4; when prioritizing customer experience, λ3=0.4. This invention does not impose any restrictions.

[0087] Next, sort the wi values ​​of all tasks in AffectSet in descending order to generate a weighted sorting table. Extract the top k tasks from the sorting table as "high-weight tasks" and record their task numbers, original weight values, and parameter details.

[0088] Optionally, in one embodiment, the value of k is dynamically determined based on the expected size of the local optimization domain, for example,

[0089] If the AffectSet contains ≤10 tasks, k is 50% of the total number of tasks (rounded up).

[0090] If AffectSet contains more than 10 tasks, k can take a fixed value, preferably, for example, k is any value between 5 and 8.

[0091] Step S5: Centered on the event source node, extract the local optimization domain of the dependency graph based on multi-dimensional thresholds, and freeze the allocation of tasks and personnel outside the optimization domain. The multi-dimensional thresholds include graph distance threshold, travel time threshold, and time window overlap threshold.

[0092] In some embodiments, this step is used to accurately delineate the local scope to be optimized from the global dependency graph, control the size of the optimization domain through multi-dimensional thresholds, and freeze off-domain allocations to reduce disturbances.

[0093] Specifically, three types of threshold parameters are preset: graph distance threshold, travel time threshold, and time window overlap threshold, which can be dynamically adjusted according to the characteristics of elevator maintenance scenarios.

[0094] For the graph distance threshold d_max, it is defined, for example, as the maximum number of edges in the shortest path between nodes in the dependent graph (default value 3), to limit the association level of delay propagation (e.g., the number of edges that need to be traversed from the event source node to a certain task node ≤ 3).

[0095] For the travel time threshold t_travel, it is defined, for example, as the maximum travel time (default 30 minutes) between the task location and the location associated with the event source node (e.g., the original planned location of the personnel being transferred), calculated based on historical travel data (average speed of driving / subway).

[0096] The time window overlap threshold o_min is defined as the minimum overlap ratio between the task time window and the task time window in the AffectSet (default 30%), and the calculation formula is "overlap duration / task baseline duration".

[0097] In one embodiment, based on three preset threshold parameters, candidate elements are filtered according to the following rules, centered on the event source node (the node of the temporarily transferred personnel):

[0098] Task node selection: simultaneously satisfy the following conditions: graph distance to the event source node ≤ d_max; travel time between the task location and the associated location of the event source ≤ t_travel; and time window overlap with the time window of at least one task in the AffectSet ≥ o_min.

[0099] Personnel node filtering: There is a direct connection edge with the filtered task node (such as the skill matching assignment relationship), and the travel time from the current location of the personnel to any candidate task location is ≤ t_travel.

[0100] Edge filtering: retain the temporal edges, collaboration edges, resource edges, and supervision edges between candidate task nodes and personnel nodes.

[0101] The above screening results constitute the preliminary local domain Ω1. At the same time, the "top k tasks with the highest weights" determined in step S4 are included in the local domain, even if some of their indicators exceed the preset threshold (for example, the graph distance of a high-weight task is 4, it is still included in the optimization domain), forming the final local optimization domain Ω.

[0102] In addition, if the personnel or resources associated with a high-weight task are not included in Ω1, then their associated nodes will be expanded to include them simultaneously (for example, if task t001 is one of the top k tasks and its collaborator P005 is not in Ω1, then P005 will be included in Ω).

[0103] Therefore, the mandatory inclusion of high-weight tasks is to ensure that the rescheduling scheme is targeted and effective, and can prioritize the resolution of key delay risks within the framework of local optimization, balancing optimization efficiency with actual scheduling needs.

[0104] In one embodiment, a freeze operation is performed on task nodes, personnel nodes, and edges that are not included in the dependency graph. For example, for a task node, its originally planned executor, time window, and priority are locked, and it is prohibited from being reassigned by other tasks.

[0105] For personnel nodes, for example, their available time window is frozen (except for the time period occupied by tasks within Ω), and they are prohibited from being reassigned by tasks outside Ω;

[0106] For edge attributes, such as temporal relationships and collaborations between nodes outside the fixed domain, they are not included in the calculation as optimization variables.

[0107] Step S6: Input the relevant information of the nodes in the optimization domain into the large model to generate candidate strategies for human resource allocation, wherein the relevant information of the nodes includes at least task information, personnel information and travel time matrix summary.

[0108] In some embodiments, this step is used to generate multiple feasible human resource allocation candidate strategies based on node information within the local optimization domain using a large model.

[0109] Preferably, such as Figure 3 As shown, the large model is a GPT-based model, including an input parsing layer and a policy generation layer. The input parsing layer is used to parse the input information, convert it into semantic features, and extract key constraints and optimization objectives. The policy generation layer generates multiple candidate policies based on exchange operators, insertion operators, translation operators, and collaborative task splitting. The exchange operator exchanges tasks based on skill matching and time window compatibility. The insertion operator inserts high-weight tasks based on available time windows of personnel. The translation operator shifts the time windows of low-weight tasks. The collaborative task splitting divides multi-person collaborative tasks into serial sub-stages.

[0110] Specifically, node-related information is extracted and organized from the local optimization domain Ω determined in step S5 to form a standardized input dataset, including:

[0111] For task information, such as the unique identifier of each task node (e.g., t001), skill requirements (e.g., "trapped person rescue + electrical inspection"), time window [start, end], base duration, priority (e.g., the impact weight wi calculated in step S4), geographical location (latitude and longitude), and the currently assigned personnel identifier (if any).

[0112] For personnel information, such as the unique identifier of each personnel node (e.g., EMP001), skill set (e.g., {“trapped person rescue”, “daily inspection”}), available time window [avail_start, avail_end] (excluding frozen periods), current location, and historical task execution efficiency (e.g., the ratio of average completion time to baseline time).

[0113] For the travel time matrix summary, for example, based on the geographical location of tasks and personnel, the travel time between key nodes is calculated and summarized, including: the average commuting time between task locations (e.g., 15 minutes from t001 to t002) and the commuting time from the current location of personnel to each task location (e.g., 10 minutes from EMP001 to t001), presented in matrix form (only the time values ​​between nodes within Ω are retained).

[0114] In addition, preferably, it also includes high-weight task conflict relationships, such as the conflict type (e.g., time window overlap, shared resource competition, skill requirement conflict) and conflict degree (e.g., overlap rate 60%) between the top k high-weight tasks determined in step S4.

[0115] Optionally, all information is converted to JSON format, with the time field uniformly set to timestamp type and the geographic location converted to UTM coordinates for easier parsing of large models.

[0116] Next, the standardized input dataset is fed into the GPT-based model for the generation strategy. The model contains the following layers:

[0117] 1. Input parsing layer, for example, guides the model to understand the constraints and objectives of the input data through Prompt (prompt word), such as: "Based on the following elevator maintenance tasks and personnel information, generate resource allocation strategy, which should prioritize ensuring that tasks with wi>0.8 do not default, and meet constraints such as skill matching, time window compatibility, and sufficient travel time."

[0118] This layer transforms structured data into semantic features, extracting key constraints (e.g., "t001 must be performed by personnel with entrapment rescue skills") and optimization objectives (e.g., "minimize the delay time of high-weight tasks").

[0119] 2. Policy Generation Layer: In one embodiment, the policy generation layer has four built-in operator logics to generate candidate policies based on input features. Specifically:

[0120] For the swap operator, for example, it can traverse the task-person matching pairs within Ω, filter the combinations that match skills and have compatible time windows, and generate a task swap scheme; for example, if P01 originally planned to execute t002 (skill A) and P02 executed t003 (skill A), and the time windows of the two can be swapped, then the strategy of "P01 and P02 swap t002 and t003" is generated.

[0121] For the insertion operator, for example, the scanner can use the gaps in the time window to calculate the execution feasibility (including travel time) of high-weight tasks (e.g., t005) and generate a task insertion plan; for example, if P03 is idle from 14:00 to 15:00, and the location of t005 is only 10 minutes away from its current task location, then a strategy of "P03 executes t005 from 14:10 to 14:50" is generated.

[0122] For the shift operator, for example, the time window of low-weight tasks (wi<0.3) can be fine-tuned by ±30 minutes to ensure that high-weight tasks are not affected and the time window limit is not exceeded, thus generating a time adjustment plan; for example, t008 (wi=0.2) was originally scheduled to be executed from 10:00 to 11:00, but can be shifted to 11:30 to 12:30, freeing up execution time for P01 for t001 (wi=0.9);

[0123] For collaborative task splitting, for example, a multi-person collaborative task (e.g., t007 requires 2 people to cooperate) can be split into serial sub-stages (e.g., t007-1: inspection, t007-2: maintenance), and the personnel allocation and handover time of the sub-stages can be adjusted to generate a splitting scheme; for example, the original t007 (9:00-11:00, requiring P04 and P05 to be present at the same time) can be split into t007-1 (9:00-10:00, P04 to perform alone) and t007-2 (10:10-11:10, P05 to perform alone) to avoid time conflicts between the two people.

[0124] For example, the model parameters are set as follows: 5-8 generated strategies, temperature coefficient 0.7 (balancing innovation and feasibility), and maximum number of tokens 2048.

[0125] Here, it can be understood that the prompt is a user-input instruction or contextual description used to guide the model to generate output that meets the requirements; the temperature coefficient controls the randomness and creativity of the model's output, and its value is usually between 0 and 1. When it is close to 0, the model tends to choose the output with the highest probability, and the result is more certain and conservative; when it is close to 1, the model increases the weight of low-probability options, and the output is more diverse but may deviate from the topic; the maximum number of tokens, 2048, is used to limit the total length of the model's output ("tokens" can be understood as words or sub-word units), and its function is to control the length of the generated content.

[0126] Step S7: Select the optimal solution from the candidate strategies based on the constraints and objective function.

[0127] In some embodiments, this step is used to select the optimal solution from the candidate strategies generated in step S6, and to ensure that the final solution has both feasibility and optimization effect through constraint condition verification and objective function quantification evaluation.

[0128] Preferably, the optimal solution is selected from the candidate strategies based on constraints and objective functions, including: traversing all the candidate strategies, and selecting strategies that meet the constraints as the effective candidate set; calculating the objective function for each strategy in the effective candidate set, and selecting the strategy with the smallest function value as the optimal solution; wherein the constraints include skill matching constraints, time window constraints, resource conflict constraints, and travel time constraints.

[0129] Specifically, four types of constraints are set as admission criteria for candidate strategies, including:

[0130] Skill matching constraint: The skill requirements of the task are contained within the skill set of the personnel performing the task (e.g., the task of "inverter repair" requires personnel to have the skill of "electrical debugging"). For each task-person assignment pair in the strategy, the skill tag matching algorithm (e.g., set inclusion relationship judgment, which can be implemented by existing methods and will not be elaborated here) is used to verify the pair. If there is no match, the pair is marked as invalid.

[0131] Time window constraint: The actual execution time interval of the task [exec_start, exec_end] falls within its allowed time window [start, end], and exec_end - exec_start ≥ the task's baseline duration. This is verified by calculating the overlap of time intervals (the intersection of the actual execution interval and the time window equals the actual execution interval).

[0132] Resource conflict constraint: The same person or shared resource cannot be assigned to multiple tasks at the same time. For personnel nodes, check whether there is any overlap in the time intervals of all their assigned tasks; for shared resources, verify that there are no conflicts through the resource occupancy time period matrix.

[0133] Travel time constraint: Between two consecutively executed tasks, the commuting time from the former location to the latter location must be less than or equal to the time interval between the two tasks (i.e., the start time of the subsequent task - the end time of the preceding task ≥ travel time). The difference between the time interval and the commuting time is calculated based on the travel time matrix; if the difference is ≥ 0, the constraint is satisfied.

[0134] Next, all candidate strategies are traversed, and the above constraints are verified one by one. Strategies that satisfy all constraints are retained as the valid candidate set S_valid.

[0135] Subsequently, the strategies in the valid candidate set S_valid are evaluated using a quantitative objective function, which is defined as follows:

[0136]

[0137] Wherein, DelayCost is the sum of the products of the delay impact weights of all tasks and the actual delay duration, i.e. ,in The weights calculated in step S4, Let be the difference between the actual start time and the originally planned start time of task i. ;

[0138] Disturbance (Scale): The amount of change the strategy makes to the original plan, including the weighted sum of the following indicators: "Number of tasks adjusted / Total number of tasks within Ω", "Number of personnel replacements / Total number of matches within Ω", and "Total duration of time adjustment / Total baseline duration of tasks within Ω".

[0139] , For the preset coefficients, where, The specific value of the coefficient can be set according to the actual situation, and this invention does not impose any restrictions.

[0140] Finally, calculate the F-value for each policy in S_valid. The smaller the F-value, the better the policy.

[0141] Optionally, if there exists a unique strategy with the smallest F value in S_valid, then it is directly selected as the optimal solution;

[0142] If multiple strategies have the same F value, further screening is performed using secondary indicators. For example, the strategy with the smallest total delay time of the top k high-weight tasks is selected first. If they are still the same, the strategy with the fewest "personnel replacement matching pairs" in the disturbance scale is selected, until a unique solution is determined.

[0143] Figure 4 A human resource allocation device 400 for elevator maintenance is shown. This device embodiment is similar to... Figure 1 Corresponding to the illustrated method embodiments, this device can be specifically applied to various electronic devices. Specifically, it includes:

[0144] The temporary personnel reassignment event detection module 401 is used to record the event trigger time and the identifier of the affected personnel when a temporary personnel reassignment event is detected.

[0145] The dependency graph construction and update module 402 is used to construct a task-person dependency graph, which contains multiple nodes and multiple edges and their corresponding attributes. The nodes include task nodes and personnel nodes, and the edges include time-series edges, collaboration edges, resource edges and supervision edges. The module updates the available time windows and related edge attributes of affected personnel based on temporary transfer events.

[0146] The affected task set determination module 403 is used to calculate and obtain the affected task set by propagating the delay along the dependency graph starting from the event source node, wherein the event source node is the node of the temporarily transferred personnel;

[0147] The impact weight calculation module 404 is used to evaluate the impact weight of the affected tasks based on the impact parameters, and obtain the top k tasks with the highest weights, where k>0. The impact parameters include the urgency of the task, the cost of breach of contract, the criticality of the customer, and the sensitivity of the location.

[0148] The optimization domain determination module 405 is used to extract the local optimization domain of the dependency graph based on multi-dimensional thresholds with the event source node as the center, and freeze the allocation of tasks and personnel outside the optimization domain. The multi-dimensional thresholds include graph distance threshold, travel time threshold, and time window overlap threshold.

[0149] The candidate strategy generation module 406 is used to input the node-related information in the optimization domain into the large model to generate candidate strategies for human resource allocation, wherein the node-related information includes at least task information, personnel information and travel time matrix summary.

[0150] The optimal solution selection module 407 is used to select the optimal solution from the candidate strategies based on the constraints and the objective function.

[0151] Based on the same inventive concept, this application also provides an electronic device. The method corresponding to the electronic device can be the method in the foregoing embodiments, and its problem-solving principle is similar to that method. The electronic device provided in this application includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the methods and / or technical solutions of the foregoing embodiments of this application.

[0152] The electronic device can be a user device, or a device formed by integrating user devices and network devices through a network, or it can be an application running on the aforementioned devices. The user device includes, but is not limited to, various terminal devices such as computers, mobile phones, tablets, smartwatches, and smart bands. The network device includes, but is not limited to, network hosts, single network servers, multiple network server sets, or cloud computing-based computer sets, and can be used to implement some processing functions when setting an alarm clock. Here, the cloud consists of a large number of hosts or network servers based on cloud computing. Cloud computing is a type of distributed computing, consisting of a virtual computer composed of a group of loosely coupled computer sets.

[0153] Figure 5 The diagram illustrates the structure of an apparatus suitable for implementing the methods and / or technical solutions in the embodiments of this application. The apparatus 500 includes a central processing unit (CPU) 501, which can perform various appropriate actions and processes based on a program stored in a read-only memory (ROM) 502 or a program loaded from a storage portion 508 into a random access memory (RAM) 503. The RAM 503 also stores various programs and data required for system operation. The CPU 501, ROM 502, and RAM 503 are interconnected via a bus 504. An input / output (I / O) interface 505 is also connected to the bus 504.

[0154] The following components are connected to I / O interface 505: input section 506 including keyboard, mouse, touch screen, microphone, infrared sensor, etc.; output section 507 including cathode ray tube (CRT), liquid crystal display (LCD), LED display, OLED display, etc., and speakers, etc.; storage section 508 including one or more computer-readable media such as hard disk, optical disk, magnetic disk, semiconductor memory, etc.; and communication section 509 including network interface card such as LAN (local area network) card, modem, etc. Communication section 509 performs communication processing via a network such as the Internet.

[0155] In particular, the methods and / or embodiments in this application can be implemented as computer software programs. For example, the embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowchart. When the computer program is executed by the central processing unit (CPU) 501, it performs the functions defined in the methods of this application.

[0156] Another embodiment of this application provides a computer-readable storage medium having computer program instructions stored thereon, which can be executed by a processor to implement the methods and / or technical solutions of any one or more embodiments of this application described above.

[0157] Specifically, this embodiment may employ any combination of one or more computer-readable media. A computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media (a non-exhaustive list) include: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this document, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

[0158] Computer-readable signal media may include data signals propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, capable of sending, propagating, or transmitting programs for use by or in connection with an instruction execution system, apparatus, or device.

[0159] Program code contained on a computer-readable medium may be transmitted using any suitable medium, including but not limited to wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0160] The flowcharts or block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of devices, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-specific system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0161] Furthermore, it is clear that the word "comprising" does not exclude other units or steps, and the singular does not exclude the plural. Multiple units or devices recited in a device claim may also be implemented by a single unit or device through software or hardware. The terms "first," "second," etc., are used to indicate names and do not indicate any specific order.

Claims

1. A method for allocating human resources for elevator maintenance, characterized in that, Includes the following steps: Step S1: When a temporary personnel reassignment event is detected, record the event trigger time and the identifier of the affected personnel; Step S2: Construct a task-person dependency graph. The dependency graph contains multiple nodes and multiple edges and their corresponding attributes. The nodes include task nodes and personnel nodes. The edges include temporal edges, collaboration edges, resource edges, and supervisory edges. Based on temporary transfer events, the available time windows and related edge attributes of affected personnel are updated. The task nodes also include task node attributes, such as skill requirements, time windows, baseline duration, and service level agreement costs. The personnel nodes also include personnel node attributes, such as skill sets, available time windows, and locations. The temporal edges represent the time dependency of consecutive tasks for the same person. The collaboration edges represent the participation relationship of multiple people in a shared task. The resource edges represent the association between a task and shared resources. The supervisory edges represent the supervisory relationship between a task and a supervisory person. Step S3: Starting from the event source node, propagate the delay along the dependency graph and calculate the set of affected tasks, wherein the event source node is the node of the temporarily transferred personnel; Step S4: Evaluate the impact weight of the affected tasks based on the impact parameters, and obtain the top k tasks with the highest weights, where k>0. The impact parameters include the urgency of the task, the cost of breach of contract, the criticality of the customer, and the sensitivity of the location. Step S5: Centered on the event source node, extract the local optimization domain of the dependency graph based on multi-dimensional thresholds, and freeze the allocation of tasks and personnel outside the optimization domain. The multi-dimensional thresholds include graph distance threshold, travel time threshold, and time window overlap threshold. Step S6: Input the node-related information within the optimization domain into the large model to generate candidate strategies for human resource allocation. The node-related information includes at least task information, personnel information, and a travel time matrix summary. The large model is a GPT-based model, including an input parsing layer and a strategy generation layer. The input parsing layer is used to parse the input information, convert it into semantic features, and extract key constraints and optimization objectives. The policy generation layer includes generating multiple candidate policies based on exchange operators, insertion operators, translation operators, and collaborative task splitting. The exchange operator exchanges tasks based on skill matching and time window compatibility. The insertion operator inserts high-weight tasks based on available time windows of personnel. The translation operator shifts the time windows of low-weight tasks. The collaborative task splitting divides multi-person collaborative tasks into serial sub-stages. Step S7: Select the optimal solution from the candidate strategies based on the constraints and objective function; specifically including: Iterate through all the candidate strategies, and the strategies that meet the constraints are taken as the valid candidate set; For each strategy in the valid candidate set, calculate the objective function, and the one with the smallest function value is the optimal solution; The constraints include skill matching constraints, time window constraints, resource conflict constraints, and travel time constraints. The objective function is F = w1× DelayCost + w2× Disturbance, where DelayCost is the sum of the products of the delay impact weights of all tasks and the actual delay duration, Disturbance is an indicator that measures the amount of change of the original plan by the strategies in the candidate set, and w1 and w2 are preset weight coefficients.

2. The method for allocating human resources for elevator maintenance according to claim 1, characterized in that, The calculation to obtain the set of affected tasks includes: Set initialization involves adding the initial task node associated with the event source node to the set; Starting from the initial task node, traverse the associated nodes along different types of edges in the dependency graph, and determine whether the associated node is unable to execute the task as originally planned due to the delay of the preceding task. If the condition is met, the task is included in the set. Propagation stops when all associated nodes have been traversed and no new task meets the addition criteria.

3. The method for allocating human resources for elevator maintenance according to claim 1, characterized in that, The local optimization domain based on multi-dimensional threshold extraction dependency graph includes: Based on the graph distance threshold, travel time threshold, and time window overlap threshold, a set of candidate tasks, a set of candidate personnel, and associated edges that meet the conditions are selected from global tasks and personnel to form a preliminary local domain. The top k tasks with the highest weights are included in the local domain to form the local optimization domain.

4. A human resource allocation device for elevator maintenance, characterized in that, include: The temporary personnel reassignment event detection module is used to record the event trigger time and the identifier of the affected personnel when a temporary personnel reassignment event is detected. The dependency graph construction and update module is used to construct a task-person dependency graph. The dependency graph contains multiple nodes and edges with corresponding attributes. The nodes include task nodes and personnel nodes, and the edges include temporal edges, collaboration edges, resource edges, and supervisory edges. It updates the available time windows and related edge attributes of affected personnel based on temporary transfer events. The task nodes also include task node attributes, such as skill requirements, time windows, baseline duration, and service level agreement costs. The personnel nodes also include personnel node attributes, such as skill sets, available time windows, and location. Temporal edges represent the time dependency of consecutive tasks for the same person; collaboration edges represent the participation relationship of multiple people in a shared task; resource edges represent the association between a task and shared resources; and supervisory edges represent the supervisory relationship between a task and a supervisor. The affected task set determination module is used to calculate and obtain the affected task set by propagating the delay along the dependency graph starting from the event source node, wherein the event source node is the node of the temporarily transferred personnel; The impact weight calculation module is used to evaluate the impact weight of the affected tasks based on the impact parameters, and obtain the top k tasks with the highest weights, where k>0. The impact parameters include the urgency of the task, the cost of breach of contract, the criticality of the customer, and the sensitivity of the location. The optimization domain determination module is used to extract local optimization domains of the dependency graph centered on the event source node based on multi-dimensional thresholds, and freeze the allocation of tasks and personnel outside the optimization domain. The multi-dimensional thresholds include graph distance threshold, travel time threshold, and time window overlap threshold. The candidate strategy generation module is used to input node-related information within the optimization domain into the large model to generate candidate strategies for human resource allocation. The node-related information includes at least task information, personnel information, and a travel time matrix summary. The large model is a GPT-based model, comprising an input parsing layer and a strategy generation layer. The input parsing layer is used to parse the input information, convert it into semantic features, and extract key constraints and optimization objectives. The policy generation layer includes generating multiple candidate policies based on exchange operators, insertion operators, translation operators, and collaborative task splitting. The exchange operator exchanges tasks based on skill matching and time window compatibility. The insertion operator inserts high-weight tasks based on available time windows of personnel. The translation operator shifts the time windows of low-weight tasks. The collaborative task splitting divides multi-person collaborative tasks into serial sub-stages. The optimal solution selection module is used to select the optimal solution from the candidate strategies based on constraints and an objective function; specifically, it includes: Iterate through all the candidate strategies, and the strategies that meet the constraints are taken as the valid candidate set; For each strategy in the valid candidate set, calculate the objective function, and the one with the smallest function value is the optimal solution; The constraints include skill matching constraints, time window constraints, resource conflict constraints, and travel time constraints. The objective function is F = w1× DelayCost + w2× Disturbance, where DelayCost is the sum of the products of the delay impact weights of all tasks and the actual delay duration, Disturbance is an indicator that measures the amount of change of the original plan by the strategies in the candidate set, and w1 and w2 are preset weight coefficients.

5. An electronic device, characterized in that, include: At least one processor; and a memory communicatively connected to the processor; wherein, The memory stores instructions that can be executed by the processor to enable the processor to perform the method of any one of claims 1-3.

6. A computer-readable medium having computer program instructions stored thereon, characterized in that, The computer program instructions can be executed by a processor to implement the method as described in any one of claims 1-3.

7. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method as described in any one of claims 1-3.

Images