A cooperative decision and consistent execution method for high-speed moving target arrears collection

Abstract

The application generates a prospective candidate scheme by constructing a dynamic simulation environment fusing vehicle trajectory, node state and repayment willingness and running a sequence decision maker for multi-step deduction; uses a distributed constraint optimizer to couple global benefits and collaborative costs, outputs resource binding and synchronous contracts to realize efficient collaboration; through an online re-planning and incremental instruction issuing mechanism, combined with a concurrent control protocol based on operation transformation, ensures strong consistency in the execution process in dynamic changes; the sequence decision maker is trained adversarially and supplemented with Monte Carlo simulation risk assessment and degraded backup scheme, enhancing the system robustness; finally, the scheme is compiled into node-specific machine code and packaged as an atomic task package for issuance, realizing seamless and efficient conversion from decision to execution, and comprehensively improving the accuracy, collaboration, adaptability and reliability of the collection.

Description

Technical Field

[0001] This invention relates to the field of transportation services, and more particularly to a collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets. Background Technology

[0002] In the fintech field, debt collection from mobile targets (such as long-haul freight vehicles and ride-hailing vehicles) is a complex and highly dynamic task. Traditional collection strategies typically rely on static collection rule bases and manual scheduling, which are difficult to cope with the multidimensional uncertainties such as the high-speed movement of target vehicles, the real-time changes in the status of collection resources (such as roadside communication units and mobile collection terminals), and the dynamic fluctuations in debtors' willingness to repay.

[0003] The existing technical solutions have the following main drawbacks: First, there is a disconnect between decision-making and execution. Existing systems typically issue a static collection plan after it is formulated on a central server, but lack real-time simulation and extrapolation of the execution environment. When vehicle trajectories deviate from the prediction, or a collection resource node suddenly fails, the established plan cannot be adaptively adjusted, resulting in missed collection opportunities or idle resources.

[0004] Second, the collaboration efficiency is low. When a collection task requires multiple resource nodes to work together (for example, node A is responsible for interception and establishing communication, while node B is responsible for negotiation and agreement signing), existing solutions lack effective distributed collaboration planning and consistency guarantee mechanisms. The connection between node actions relies on simple time-sequence triggers, which can easily lead to gaps or conflicting operations due to network latency or state asynchrony, reducing the collection success rate and potentially causing customer complaints.

[0005] Third, the solutions lack robustness. Existing decision-making systems based on rules or simple optimization models have weak generalization ability to complex dynamic environments. When faced with real-world disturbances such as communication quality fluctuations, sensor data noise, and irrational feedback from debtors, the generated solutions are often fragile, and the execution results deviate significantly from expectations.

[0006] Fourth, there is a lack of risk control mechanisms. Existing solutions typically aim to maximize a single revenue metric, lacking a quantitative assessment of the risk of failure. In high-pressure debt collection scenarios, if an aggressive strategy fails, it could lead to a complete breakdown of customer relationships with no backup plan, resulting in irreversible losses.

[0007] Therefore, there is an urgent need for a technical solution that can achieve forward-looking collaborative decision-making and strong consistency in execution to solve the problems of dynamic adaptation, collaborative optimization and risk control in high-speed moving target collection scenarios. Summary of the Invention

[0008] This invention proposes a collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets, executed by a collection coordination server, including: S1. Obtain trajectory prediction data of the target vehicle, status monitoring data of multiple collection resource nodes, and repayment willingness assessment data of the target debtor; S2. Based on the trajectory prediction data, status monitoring data, and repayment willingness assessment data, a dynamic simulation environment is constructed within the collection coordination server, and a sequence decision-maker is run in the dynamic simulation environment to generate a set of candidate execution schemes containing collection actions at multiple time points. S3. Input the set of candidate execution schemes into the distributed constraint optimizer. The distributed constraint optimizer couples the global benefit of the scheme with the coordination cost between nodes, and outputs the resource binding and synchronization contract corresponding to each candidate execution scheme. S4. According to the predetermined scheme selection rules, determine the target execution scheme from the candidate execution schemes with the resource binding and synchronization contract, convert the target execution scheme into an executable instruction set and synchronization script adapted to the target node among the multiple resource collection nodes, and send it to the target node for execution.

[0009] Furthermore, in step S1, obtaining the trajectory prediction data of the target vehicle specifically includes: The data stream from the access road network sensing device is used to calculate the spatiotemporal window sequence of the target vehicle's communication range through each collection resource node in the future time period by using kinematic models and road network topology. The acquisition of status monitoring data for multiple resource collection nodes specifically includes: polling the available computing power, cache space, and network link quality of each node; The acquisition of repayment willingness assessment data specifically includes: calling the willingness inference model to process historical interaction records and outputting a time-series vector representing changes in repayment willingness.

[0010] Furthermore, in S2, the process of generating a set of candidate execution schemes by the sequence decision-maker specifically includes: The sequence decision-maker employs a deep neural network trained in an adversarial environment simulation. The adversarial environment simulation dynamically introduces random compression of communication windows, sudden node failures, and debtor feedback noise during training to improve the robustness of the sequence decision generator generation scheme in real-world environments.

[0011] Furthermore, in S3, the distributed constraint optimizer output resource binding and synchronization contract specifically includes: The distributed constrained optimizer models the problem as an integer programming model with the objective of maximizing global collection revenue and constraints of node load balancing and the upper limit of the amount of synchronized messages. The heuristic cutting plane algorithm is used to solve the integer programming model quickly, and execution nodes are assigned to the collection actions in each candidate execution scheme. The message format and triggering conditions for transmitting state summaries between nodes are also specified.

[0012] Furthermore, the specific steps of converting the target execution plan into an executable instruction set and synchronous script include: Based on the resource binding and synchronization contract, the action subsequences allocated to specific nodes in the scheme are compiled into machine code segments specific to the processor architecture of that node; The message format and triggering conditions specified in the synchronization contract are compiled into network communication service primitives supported by the operating system of the node; The machine code segment and network communication service primitives are encapsulated into an atomic task package.

[0013] Furthermore, it also includes: S5. During execution, when any collection resource node detects a significant deviation between the actual collection interaction state and the expected state in the dynamic simulation environment, it sends a state correction request to the collection coordination server. Based on the status correction request, the collection coordination server performs local replanning on the unexecuted portion of the target execution plan in the dynamic simulation environment; The incremental adjustment instructions generated by the replanning will be sent to the affected resource collection nodes in real time.

[0014] Furthermore, the step of sending incremental adjustment instructions to the affected collection resource nodes in real time specifically includes: A concurrency control protocol based on operation transformation is adopted to ensure that no logical conflict occurs when the incremental adjustment instruction is merged with the local pending instruction queue of the affected node, and to maintain the consistency of the final collection effect.

[0015] Furthermore, before determining the target execution plan according to the predetermined scheme selection rules in step S4, the method further includes: For each candidate execution scheme with the aforementioned resource binding and synchronization contract, perform multiple Monte Carlo simulations in the dynamic simulation environment and statistically analyze the expected and variance of its collection success rate. If the expected success rate of the optimal solution is lower than the system's guarantee threshold, then a backup, less complex, conservative collection process will be used to replace the original target execution plan.

[0016] Furthermore, the present invention also proposes a non-transitory computer-readable storage medium storing a computer program, which, when executed by a processor, implements a collaborative decision-making and consistent execution method for high-speed mobile target arrears collection as described in any one of claims 1 to 8.

[0017] Furthermore, this invention also proposes a collaborative decision-making and consistent execution system for high-speed mobile target overdue payment collection, including a collection coordination server and multiple collection resource nodes, wherein: The collection coordination server is configured to execute the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection as described in any one of claims 1 to 8; The multiple collection resource nodes are communicatively connected to the collection coordination server and are configured to receive and execute the issued executable instruction set and synchronization script.

[0018] Compared with the prior art, the technical solution provided by the present invention can bring the following significant beneficial effects: First, it enhances the accuracy and foresight of debt collection decisions: By constructing a dynamic simulation environment that integrates vehicle trajectory prediction, resource status monitoring, and repayment willingness assessment, and running a sequence decision-maker within it, the system can perform multi-step simulations of the future debt collection process, generating a set of candidate solutions that consider spatiotemporal constraints. This overcomes the limitations of traditional static programming, allowing decisions to be based on simulation verification and significantly improving the matching degree between the solutions and real-world scenarios.

[0019] Secondly, it achieves efficient coordination and consistent binding of distributed resources: A distributed constraint optimizer performs secondary optimization on candidate solutions, coupling global benefits with inter-node coordination costs in modeling, and outputs explicit resource binding and synchronization contracts for each solution. This ensures that when multiple resource collection nodes execute the same solution, the timing of actions, resource usage, and information synchronization are precisely coordinated, fundamentally avoiding coordination chaos and resource conflicts, and improving overall collection efficiency.

[0020] Third, ensuring strong consistency and dynamic adaptability during execution: Through online replanning and incremental instruction issuance mechanisms, when the execution site state deviates significantly from the simulation expectations, the system can respond quickly, make local adjustments to the unexecuted parts, and merge the incremental adjustment instructions into the execution queues of each node without conflict through a concurrent control protocol based on operation transformation. This achieves a closed loop of planning-execution-feedback-adjustment, ensuring the consistency between the final collection effect and the initial target in a dynamically changing environment.

[0021] Fourth, enhance the overall robustness and risk resistance of the system: The sequence decision-maker is trained using adversarial environment simulation, making it inherently robust to disturbances such as communication interruptions and node failures. Simultaneously, Monte Carlo simulations are used to quantitatively assess the success rate and risk of the optimized scheme, and a conservative collection process is established as a fallback backup plan. This combined mechanism significantly improves the system's stable output capability under uncertain environments, preventing business interruptions due to the failure of a single strategy.

[0022] Fifth, achieve seamless and efficient transformation from scheme to execution: By compiling the target execution scheme into node-specific machine code segments and network communication service primitives, and encapsulating them into atomic task packages, the adaptation overhead between heterogeneous resource nodes is eliminated, enabling high-level strategies to directly and efficiently drive the execution of underlying hardware, reducing the latency of instruction parsing and conversion, and improving system response speed. Attached Figure Description

[0023] Figure 1 This is a flowchart illustrating a collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets, as proposed in this invention. Detailed Implementation

[0024] refer to Figure 1 This invention proposes a collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets, including: S1. Obtain trajectory prediction data of the target vehicle, status monitoring data of multiple collection resource nodes, and assessment data of the repayment willingness of the target debtor.

[0025] Specifically, this acquisition process is implemented through the following methods: The collection coordination server initiates parallel collection requests for three types of data via a dedicated data interface. The target vehicle refers to a motor vehicle that has outstanding ETC tolls or freight platform service fees and is currently in motion. Trajectory prediction data is a time-series data set describing the predicted location, speed, and time of passage through key road network nodes of the target vehicle within a preset future time period. Multiple collection resource nodes refer to physical or virtual device units deployed along highways, service areas, or key urban nodes, possessing communication, computing, and collection interaction capabilities. Status monitoring data is a set of parameters characterizing the real-time workload and health of the nodes. The target debtor is a natural or legal entity associated with the target vehicle and obligated to repay. Repayment willingness assessment data is vector data quantifying changes in the debtor's current and future repayment probability.

[0026] Based on the above definition, the collection coordination server first accesses the data stream from the traffic network sensor network. This network consists of a distributed collection of sensors—high-definition cameras, microwave radar, and ETC gantry systems—that continuously output vehicle detection reports. The server uses a multi-source data fusion algorithm to clean, deduplicate, and time-align the raw data stream, generating continuous historical trajectories for the target vehicles. Subsequently, the server loads a pre-stored high-precision digital road network topology map. This map accurately describes the road geometry, connectivity, and the geographic coordinates and communication coverage of collection resource nodes along the route. The server integrates the vehicle's current fused position, velocity vector, and historical acceleration into a kinematic model with real-time traffic flow and weather-related correction factors. This model, through numerical integration, outputs a set of predicted positions for the target vehicles at a series of discrete future time points. Finally, the server performs spatial relationship calculations, comparing each predicted position with the communication coverage polygons of each node to generate a temporal-spatial window sequence arranged chronologically. Each element in the sequence records the time interval during which the vehicle is expected to enter the communication range of a specific node.

[0027] For status monitoring data, the server sends status query commands to each resource collection node via a periodic heartbeat detection protocol. Upon receiving the command, the node collects and reports the available computing power percentage, remaining cache space size, and current network link round-trip latency and packet loss rate in its local register. The server receives this reported data and updates its maintained global node status register.

[0028] For repayment willingness assessment data, the server extracts a structured behavioral record sequence of the target debtor from the associated credit information database and historical interaction log database. This structured behavioral record sequence is a set of data entries ordered by timestamps, containing historical repayment records, collection response content, and consumption behavior characteristics. The server inputs this sequence into a pre-trained recurrent neural network model for online inference. The input of this recurrent neural network model receives a normalized and embedded historical behavioral feature vector. The processing layer contains three layers of long short-term memory units with a hidden state dimension of 128, trained using the Adam optimizer and cross-entropy loss function to capture the temporal dependencies of repayment willingness. The output generates a fixed-length temporal vector, where each dimension corresponds to a future time slice, and its value directly represents the probability of the debtor's repayment tendency within that time slice. Through this parallel and standardized data acquisition process, accurate, real-time, and multi-dimensional input can be provided for subsequent decision-making, thus laying the data foundation for building a dynamic environment.

[0029] S2. Based on the trajectory prediction data, status monitoring data, and repayment willingness assessment data, a dynamic simulation environment is constructed within the collection coordination server, and a sequence decision-maker is run in the dynamic simulation environment to generate a set of candidate execution schemes containing collection actions at multiple time points.

[0030] Specifically, this construction and operation process is implemented as follows: The dynamic simulation environment is a virtual space in the memory of the collection coordination server used for high-fidelity simulation of the collection interaction process. The sequence decision-maker is an intelligent agent used to perform multi-step policy deduction in the simulation environment. The candidate execution scheme set is a set of virtual execution trajectories covering different collection policy branches, generated by the sequence decision-maker.

[0031] Based on the three types of data already acquired, the debt collection coordination server initiates its dynamic simulation environment construction module. This module instantiates the abstract trajectory prediction line as vehicle agent objects in the environment, assigning them position attributes that are dynamically updated based on the prediction data. It instantiates the status monitoring data of each node as node agent objects, assigning them status attributes such as computing power, cache, and network quality. It instantiates the repayment willingness assessment time-series vector as debtor agent objects, assigning them a willingness value attribute that changes over time. Simultaneously, the module sets interaction rules for these agent objects. For example, when the spatial coordinates of a vehicle agent enter the communication range polygon of a node agent, a communication link establishment event is triggered; after a node agent executes a specific collection action, it updates the debtor agent's status according to the action type and the debtor agent's current willingness value, following a preset probability model.

[0032] After environment initialization, the server loads and runs the sequence decision-maker. This sequence decision-maker employs a deep neural network strategy trained on adversarial environment simulation. The adversarial environment simulation dynamically introduces random compression of communication windows, simulated sudden node failures, and debtor feedback noise injection during the training phase to improve the policy network's generalization ability to real-world environmental disturbances. The decision-maker takes the current global state tensor of the environment as input and performs forward propagation through its internal policy network, which contains three fully connected layers, outputting a probability distribution covering all predefined collection actions. The server combines a Monte Carlo tree search algorithm to perform multiple simulations with the current state as the root node. Each simulation starts from the root node, selects an action based on the probability output by the policy network, simulates the environment executing the action, and transitions to a new state until the simulation termination condition is met, forming a virtual trajectory from the root node to a leaf node. Through multiple independent simulations, the decision-maker generates multiple such trajectories. The server extracts complete action sequences from these trajectories, from the current moment to the end of the task; each sequence constitutes a candidate execution plan. All extracted plans are aggregated to form the original set of candidate execution plans. Through the above simulation-based deduction, multiple feasible strategies that have been virtually verified and take into account spatiotemporal and state constraints can be generated, thus providing rich and forward-looking input options for subsequent optimization.

[0033] S3. Input the set of candidate execution schemes into the distributed constraint optimizer. The distributed constraint optimizer couples the global benefit of the scheme with the coordination cost between nodes, and outputs the resource binding and synchronization contract corresponding to each candidate execution scheme.

[0034] Specifically, this optimization process is implemented as follows: The distributed constraint optimizer is a mathematical programming solution module used to solve multi-node resource allocation and cooperative scheduling problems. Resource binding clarifies the mapping relationship between which specific node executes each collection action in the candidate solutions. Synchronization contracts are rule protocols that specify how execution nodes exchange state summary information.

[0035] The optimizer reads each solution from the candidate execution solution set, which is essentially a sequence of collection actions. Simultaneously, the optimizer queries a pre-stored node capability profile database. This database stores the efficiency parameters and cost coefficients of each collection resource node in handling different types of collection actions. The optimizer constructs the collaborative planning problem for each solution into an integer programming model with the objective of maximizing the global collection benefit. The global collection benefit is the net value after subtracting the estimated resource consumption cost from the expected recovery amount. A binary decision variable x_{ij} is defined in the model, representing whether to assign the i-th action in the solution to the j-th node. The objective function is the sum of the expected benefits of all assigned actions, calculated based on the action type, node efficiency, and recovery amount.

[0036] The model constraints include: each action must be assigned to one and only one node; the total load of actions assigned to each node must not exceed its capacity limit, and the load is calculated by weighting the node's computing, memory, and communication resource requirements based on the actions to achieve node load balancing; the total amount of state summary messages transmitted between nodes for collaboration must not exceed the preset communication bandwidth limit.

[0037] The optimizer employs a heuristic cutting plane algorithm to quickly solve the aforementioned integer programming model. Starting with a relaxed solution to the linear programming problem, the algorithm iteratively adds valid inequalities that eliminate non-integer solutions and uses a fast rounding heuristic to find feasible integer solutions, converging to a high-quality solution within a preset time budget. This solution clearly defines the execution node j bound to each collection action i.

[0038] Based on this binding relationship, the optimizer automatically generates a corresponding synchronization contract. For each pair of cross-node actions with sequential or dependent relationships, the contract defines the message format and triggering conditions for the state summary. The message format uses a JSON data structure, containing fixed fields such as message type, action ID, execution status, timestamp, and checksum. The triggering conditions are event-based; for example, it stipulates that when the preceding action completes, the executing node must send a state summary to the succeeding node. Finally, the distributed constraint optimizer outputs a complete optimization result consisting of resource binding relationships and synchronization contracts for each input candidate execution scheme. Through the above precise mathematical modeling and efficient solution, abstract coordination requirements can be transformed into concrete and unambiguous execution rules, minimizing coordination overhead while ensuring global benefits, thus providing a precise coordination blueprint for the reliable execution of the scheme.

[0039] S4. According to the predetermined scheme selection rules, determine the target execution scheme from the candidate execution schemes with the resource binding and synchronization contract, convert the target execution scheme into an executable instruction set and synchronization script adapted to the target node among the multiple resource collection nodes, and send it to the target node for execution.

[0040] Specifically, this determination and transformation process is implemented through the following methods: The scheme selection rule is a pre-defined logical criterion used to evaluate and compare candidate schemes with attached contracts, such as selecting the scheme with the highest expected net benefit when the risk is below a threshold. The target execution scheme is the final sequence of collection actions and its binding contracts determined according to the selection rule. The executable instruction set is a set of machine instructions or script commands that the target node processor can directly interpret or load and run. The synchronization script is a program script used to control the state synchronization and operational cooperation of multiple nodes according to specific timing and conditions. The target node is the collection resource node that needs to execute some or all of the actions in the scheme based on resource binding relationships.

[0041] The scheme selection module loads all candidate schemes with attached resource binding and synchronization contracts. First, the module performs multiple Monte Carlo simulations on each scheme-contract pair in a dynamic simulation environment, calculating the expected and variance of its collection success rate to assess scheme risk. Then, the module performs a comprehensive ranking based on predetermined scheme selection rules. These rules not only consider the expected net benefit of the simulation but may also incorporate a risk scoring model based on historical cases to assess the legal compliance of the schemes and their potential impact on debtors. The module selects the scheme with the highest comprehensive score as the target execution scheme.

[0042] Once the target execution plan is determined, the instruction compilation module begins its work. Based on the resource binding relationships in the contract attached to the plan, the module identifies each target node that needs to participate in the execution and its required action subsequence. For each target node, the compilation module uses a cross-compilation toolchain tailored to that node's processor architecture to compile the abstract action description into the corresponding native machine code segment. Simultaneously, the compilation module transforms the synchronization rules that the node must adhere to, as specified in the contract, into network socket communication primitives or inter-process communication instruction sequences supported by the node's operating system.

[0043] The wrapper packages all machine code segments, network communication primitives, necessary configuration parameters, and resource files generated for a specific node into an atomic task package. Atomicity is guaranteed through transactional writing, adding metadata containing CRC checksums, and defining a fixed package structure. Finally, the collection coordination server distributes each task package to the corresponding target collection resource node via an encrypted communication link. After receiving and verifying the integrity of the task package, the agent service on the node loads it into a secure execution sandbox, awaiting triggering execution. Through the closed loop described above, from policy selection to instruction compilation, optimized high-level decisions can be seamlessly and reliably translated into specific operations on underlying heterogeneous nodes, ensuring that the decision intent is executed accurately and efficiently.

[0044] S5. During execution, when any collection resource node detects a significant deviation between the actual collection interaction state and the expected state in the dynamic simulation environment, it sends a state correction request to the collection coordination server. Based on the state correction request, the collection coordination server performs local replanning on the unexecuted part of the target execution plan in the dynamic simulation environment. The incremental adjustment instructions generated by the replanning are sent to the affected collection resource nodes in real time.

[0045] Specifically, this replanning and deployment process is implemented in the following ways: The actual collection interaction status is information collected in real-time by collection resource nodes during execution, generated from interactions with target vehicles or debtors, including the actual arrival time of the vehicle and real-time feedback from the debtor. A status correction request is a dedicated message from a node to the server reporting status deviations and requesting intervention; its structure includes a deviation description, a snapshot of the current environment, and the request priority. Local replanning is a process of re-deciding and optimizing only the parts of the original target execution plan that are affected by the current deviation and have not yet been executed. Incremental adjustment instructions are a minimal set of instructions describing the changes required relative to the original plan. Affected collection resource nodes are those whose pending tasks need to be modified, added, or canceled based on the replanning results.

[0046] While executing instructions, the resource collection node's built-in monitoring agent continuously compares the actual interaction state with the expected state snapshot obtained from the server. When the observed values ​​of key state variables continuously exceed preset thresholds, the monitoring agent determines a significant deviation and immediately generates a state correction request. This request is sent to the collection coordination server via a high-priority message queue.

[0047] Upon receiving the request, the server parses the current environment snapshot data and uses it to quickly reset its dynamic simulation environment, rolling back the environment state to the current real-time state and replacing the outdated expected data with actual data. Subsequently, starting with the updated environment state and constrained by the original plan's final recovery target, the server initiates a scope-limited planning calculation. The server first analyzes the dependencies between actions in the original plan, accurately identifying all subsequent action sequences that are directly or indirectly affected by the current deviation and have not yet started. The replanning is only performed on these identified affected action subsequences, thereby narrowing the search space.

[0048] After completing local replanning in a very short time, the server compares the newly generated sub-solution with the corresponding parts of the original solution to calculate the instruction points that need to be added, modified, or canceled, and encapsulates them as incremental adjustment instructions. Finally, the server sends the incremental adjustment instructions to all affected nodes through a communication mechanism designed specifically for real-time control. After receiving the instructions, the nodes merge them with their local queue of instructions to be executed, achieving dynamic adaptation. Through the above monitoring-feedback-replanning closed loop, the server can quickly respond to and adjust strategies when unexpected events occur on-site, thereby ensuring the continuous progress and ultimate success of the collection task amidst dynamic changes.

[0049] Furthermore, in S1, obtaining the trajectory prediction data of the target vehicle specifically includes: accessing the data stream of the road network sensing device, and calculating the spatiotemporal window sequence of the target vehicle's communication range through each collection resource node in the future time period using a kinematic model and road network topology; obtaining the status monitoring data of multiple collection resource nodes specifically includes: polling the available computing power, cache space, and network link quality of each node; obtaining the repayment willingness assessment data specifically includes: calling the willingness inference model to process historical interaction records and outputting a time-series vector representing changes in repayment willingness.

[0050] Specifically, this refined acquisition process is achieved through the following methods: The data stream from road network sensing devices is a real-time data sequence continuously generated by sensors deployed on the roadside, containing timestamps, device IDs, and vehicle detection information. The kinematic model is a mathematical model based on Newton's laws of motion, describing the relationship between an object's position, velocity, and acceleration. The road network topology is a data structure describing the connectivity and geometric properties of the road network. The spatiotemporal window sequence is a list arranged chronologically, recording the time intervals and spatial regions within which vehicles are expected to enter the communication range of each node. Polling is a communication pattern where the server actively and periodically sends query requests to each node and waits for responses. Available computing power is the percentage of CPU computing resources currently idle on a node. Cache space is the remaining capacity in a node's memory that can be used for temporary storage of task data and intermediate results. Network link quality is an indicator characterizing the reliability and latency of communication connections between a node and the server or other nodes, such as round-trip time and packet loss rate. The willingness inference model is a machine learning model used to analyze historical behavior and predict future repayment tendencies. Historical interaction records are a collection of past interactions between the debtor and the collection system, ordered chronologically. A time-series vector is a vector of fixed length, where each dimension corresponds to a future time slice, and the numerical value represents the repayment tendency of that time slice.

[0051] For trajectory prediction data, the collection coordination server establishes a stable data subscription connection with the road network sensor network. After receiving the raw data stream, the server calls the data cleaning module to remove outliers caused by sensor malfunctions or communication interference, and performs deduplication and timestamp alignment on duplicate reports of the same vehicle from different sensors. The cleaned data is then fed into a multi-source trajectory fusion algorithm to generate a smooth, continuous historical trajectory of the target vehicle. The server loads high-precision road network topology data, which pre-labels the precise geographic coordinates of all collection resource nodes and the signal coverage polygons of their communication devices. The server inputs the vehicle's current fused state into a kinematic model that integrates real-time traffic flow density correction. The model predicts the vehicle's position at a series of discrete future time points through short-time numerical integration. The server performs geospatial calculations, determining the inclusion relationship between each predicted location and the communication coverage polygons of each node, generating a spatiotemporal window sequence. Each element in the sequence explicitly records the time interval and the corresponding node communication range identifier.

[0052] For status monitoring data, the cleanup coordination server maintains a node registry. The server sends status query heartbeat packets to all active nodes in the registry at fixed intervals. Upon receiving the heartbeat packet, each node immediately collects CPU idle rate and remaining memory from its local system monitor, and measures the round-trip latency and packet loss rate of the current network link by sending probe packets to the server. This data is then encapsulated in a response packet and returned to the server. The server parses the response packet and updates the corresponding node's status field in the node registry.

[0053] For repayment willingness assessment data, the server extracts structured historical interaction records of the target debtor from the backend database. These records include fields such as repayment time, amount, collection contact method, and debtor feedback. The server then calls a pre-trained willingness inference model to process these records. The model's input receives a sequence vector of historical behaviors processed by feature engineering. The processing layer employs a gated recurrent unit network with 64 hidden layers, trained using gradient descent to capture long-term dependency patterns in repayment behavior. The output layer outputs a fixed-length probability distribution vector using a softmax function. Each dimension of this vector corresponds to a future time slice, and its value represents the estimated probability that the debtor will make a repayment decision within that time slice. Through these detailed, standardized operations, the acquisition process for each type of basic data is ensured to be clear and reliable, providing a solid and accurate data foundation for higher-level decision-making.

[0054] Furthermore, in S2, the process of generating a set of candidate execution schemes by running the sequence decision-maker specifically includes: the sequence decision-maker employs a deep neural network trained under adversarial environment simulation; the adversarial environment simulation dynamically introduces random compression of communication windows, sudden node failures, and debtor feedback noise during training to improve the robustness of the schemes generated by the sequence decision-maker in the real environment.

[0055] Specifically, this training and robustness enhancement process is achieved through the following methods: Adversarial environment simulation involves artificially injecting various disturbances into the simulation environment during the model training phase to simulate collaborative decision-making and consistent execution methods for debt collection from high-speed moving targets with real-world uncertainties. Random compression of the communication window randomly shortens the effective time a vehicle is within the node's communication range. Sudden node failure simulates a node suddenly failing due to hardware or software issues during task execution. Debtor feedback noise simulates unexpected or random responses from debtors to collection actions. Robustness refers to the ability of the scheme generated by the sequence decision-maker to maintain the stability of the expected results when facing environmental disturbances.

[0056] The deep neural network strategy for the sequence decision engine is completed during the offline training phase. The training platform constructs a training simulation environment that is logically consistent with the online dynamic simulation environment but on a larger scale. During training, the environment simulator is not static but dynamically introduces various adversarial perturbations. At the start of each training iteration or each simulation, the simulator randomly selects one or more perturbation modes with a certain probability. For random compression of the communication window, after the event of the vehicle agent entering the node's communication range is triggered, the simulator randomly generates a compressed time window shorter than the original time window and then simulates a communication interruption. For sudden node failure, the simulator randomly selects a node agent and suddenly marks its state as faulty during its action execution, causing its subsequent actions to fail or be delayed. For debtor feedback noise, when the debtor agent updates its state according to the collection action, the simulator superimposes a random offset or directly outputs feedback opposite to the model's expectation with a certain probability.

[0057] The policy network is trained using deep reinforcement learning algorithms. The agent (sequence decision maker) explores a perturbation-laden environment, aiming to maximize cumulative collection gains. Due to the deliberately amplified uncertainty of the environment, the policy network is forced during training to learn more conservative, general, or redundant policies, rather than overly relying on a specific, stable environmental assumption. Through millions of such adversarial simulation training rounds, the policy network eventually converges to a set of weight parameters that enables it to generate relatively stable and effective candidate solutions even when faced with real-world environmental changes that are unseen during training but fall within the same perturbation range. This adversarial training mechanism significantly improves the generalization ability and adaptability of the decision core, making the generated candidate solution set inherently robust to real-world uncertainty.

[0058] Furthermore, in S3, the distributed constraint optimizer outputs resource binding and synchronization contracts, specifically including: the distributed constraint optimizer models the problem as an integer programming model with the goal of maximizing global collection revenue and with node load balancing and the upper limit of synchronization message volume as constraints; it uses a heuristic cutting plane algorithm to quickly solve the integer programming model, assigns execution nodes to the collection actions in each candidate execution scheme, and specifies the message format and triggering conditions for transmitting state summaries between nodes.

[0059] Specifically, the modeling and solution process is implemented as follows: Integer programming is a mathematical optimization model that requires decision variables to take integer values. Maximizing global collection revenue is the main objective of the optimization model. Node load balancing is one of the constraints, requiring that the workload of each node be as even as possible to avoid local overload. The upper limit of synchronization message volume is a constraint that the total amount of data communicated between nodes for coordination must not exceed a preset threshold. The heuristic cutting plane algorithm is a collaborative decision-making and consistent execution method for high-speed mobile target debt collection used to solve integer programming problems. It tightens the feasible region of linear relaxed solutions by iteratively adding cutting planes and combines heuristic rules to find integer feasible solutions. The message format is the specific organization method of the state summary data. The triggering condition is the timing or event of sending the state summary.

[0060] For each input candidate execution plan, the distributed constrained optimizer first models the problem. The model defines a binary decision variable x_{ij}∈{0,1}, representing whether action i is assigned to node j. The objective function is... , where r_{ij} is the expected return calculated based on the action type, the historical success rate of node j executing that type of action, and the corresponding repayment amount. The model contains three core constraints: 1) Every action must be executed: for each i, Σ_jx_{ij}=1. 2) Node load balancing: for each node j, , where w_{ij} is the comprehensive load weight of action i executed on node j (considering CPU, memory, and I / O consumption), and C_j is the upper limit of the load capacity of node j. 3) Upper limit of synchronization message volume: For all action pairs in the scheme that need to be synchronized across nodes, the sum of their estimated message volume is ≤ M, where M is the upper limit of the total amount of synchronization messages allowed by the system.

[0061] The optimizer employs a heuristic cutting plane algorithm to solve the model. The algorithm begins by solving a relaxed linear programming solution that ignores integer constraints, yielding a relaxed solution. If the relaxed solution is not entirely composed of integers, the algorithm generates an effective inequality (the cutting plane) based on the structure of the current solution, which can cut off non-integer solutions without cutting off any integer feasible solutions. This inequality is then added to the model constraints, and the linear programming problem is solved again. This process is iterative. Simultaneously, the algorithm integrates heuristic rules: after each iteration, it attempts to round variables with higher scores in the current relaxed solution (e.g., set to 1 if greater than 0.5, otherwise set to 0), and checks whether all constraints are satisfied, thus quickly obtaining a feasible integer solution as a candidate for the current optimal solution. The algorithm stops when the time limit is reached or when a solution meeting the accuracy requirements is found.

[0062] The integer solutions obtained clearly identify the node j corresponding to x_{ij}=1 for each action i, thus completing resource binding. Based on this binding relationship, the optimizer traverses all action pairs in the scheme that have sequential dependencies or require information passing. For each action pair (the predecessor A_i is executed by node J_a, and the successor A_k is executed by node J_b), the optimizer generates a rule in the synchronization contract: stipulating that after action A_i is completed, node J_a must send a state summary message to node J_b. The trigger condition is the completion of the predecessor action A_i. Through the above rigorous mathematical modeling and efficient hybrid solution strategy, high-quality resource allocation and coordination rules can be quickly obtained under complex constraints, providing an accurate and computable blueprint for the reliable collaborative execution of the scheme.

[0063] Furthermore, transforming the target execution scheme into an executable instruction set and a synchronization script specifically includes: compiling the action subsequences allocated to a specific node in the scheme into machine code segments specific to the processor architecture of that node, based on the resource binding and synchronization contract; compiling the message format and triggering conditions specified in the synchronization contract into network communication service primitives supported by the operating system of that node; and encapsulating the machine code segments and network communication service primitives into atomic task packages.

[0064] Specifically, the compilation and encapsulation process is implemented in the following ways: An action subsequence is a series of continuous or discontinuous cleanup actions assigned to a specific node for execution based on resource binding relationships within the target execution plan. Processor architecture specific means that the generated machine instructions depend on the instruction set of the target node's CPU. A machine code segment is a data block composed of low-level machine instructions that can be directly executed by the CPU. Network communication service primitives are basic system calls or library function interfaces provided by the operating system for network data transmission. An atomic task packet refers to a data unit that is transmitted, verified, and loaded as an indivisible whole; it is either fully functional or completely invalid.

[0065] The instruction compilation module receives the target execution plan and its associated resource binding and synchronization contract. The module first decomposes the task, breaking down the action sequence of the entire plan into multiple independent action subsequences based on the binding relationships in the contract. Each subsequence corresponds to a resource collection node that needs to participate in the execution.

[0066] For each target node, the compilation module initiates a targeted compilation process. The module loads the processor architecture type recorded in the node's registration information. The compilation module integrates a cross-compilation toolchain for the corresponding architecture. The compilation module transforms each abstract cleanup action in the action subsequence into a sequence of function calls described in a high-level language (such as C) through a predefined action-code template mapping. Subsequently, the cross-compilation toolchain compiles and links this high-level language code, generating a binary machine code segment that can be directly executed on the target node's CPU. This code segment contains the specific logic of the cleanup actions, error handling, and local logging functionality.

[0067] Simultaneously, the compilation module processes the node-related portions of the synchronization contract. The module parses the contract, identifying all rules specifying that the node sends or receives state summaries. For each rule, the compilation module generates corresponding data serialization and deserialization code based on the message format specified in the rule. It then transforms the triggering condition into query logic for the local action execution status register. Finally, this logic and data manipulation code are compiled into primitive code segments that call the target node's operating system-specific network APIs.

[0068] The wrapper creates an independent task package for each node. It takes the compiled machine code segment and network communication primitive code segment for that node, along with the necessary configuration files, resource files, and a manifest file describing the package structure, and places them into a memory buffer. The wrapper calculates the cyclic redundancy check (CRC) code of the buffer data and writes it, along with the task's unique ID, version number, and other metadata, into the package header. Subsequently, the wrapper either writes the entire buffer data to a physical file at once or prepares it directly in memory for transmission, ensuring the integrity and consistency of the task package content. The final generated task package transmits and processes all its components as a whole, achieving atomicity and guaranteeing that the execution instructions received by the node are complete and self-consistent.

[0069] Furthermore, the step of sending incremental adjustment instructions to the affected collection resource nodes in real time specifically includes: adopting a concurrency control protocol based on operation transformation to ensure that when the incremental adjustment instructions are merged with the local pending instruction queue of the affected nodes, no logical conflict will occur, and the consistency of the final collection effect will be maintained.

[0070] Specifically, this concurrency control process is implemented as follows: The operation transformation-based concurrency control protocol is an algorithm that uses mathematical transformations to make concurrent operations commutative, thereby ensuring eventual consistency in a distributed system. Incremental adjustment instructions are sets of operations issued by the server describing changes to the original node's execution plan. The local queue of instructions to be executed on the affected node is a sequence of instructions that the node has received but has not yet started executing or is currently executing. Logical conflict refers to a discrepancy between incremental instructions and instructions in the local queue in terms of resource consumption, execution timing, or effect. Final collection effect consistency means that regardless of the order of instruction merging and execution, the business state achieved after the entire collection task is completed is unique and meets expectations.

[0071] The collection coordination server and each collection resource node deploy the engine module of this protocol. When generating incremental adjustment instructions, the server assigns a globally monotonically increasing logical timestamp to each instruction. When the server needs to issue incremental instructions to multiple nodes, it broadcasts these timestamped instruction operations.

[0072] When a node receives an Op_inc, it may be executing a local instruction Op_local, or there may already be other instructions waiting to be executed in its local queue. The node protocol engine does not execute Op_inc immediately, but instead places it in a pending buffer. The engine maintains a list of all locally executed and committed operations and their logical timestamps.

[0073] The core of the protocol is a predefined transformation function T, tailored to the semantics of collection operations. When it's necessary to integrate Op_inc into the local execution history, the engine calls T(Op_inc, C_local), where C_local is the context of the local list of executed operations. The transformation function T performs a semantically equivalent transformation on Op_inc based on the operation type and the local context, generating a new operation Op_inc'. The design of the transformation rules ensures that for any local operation Op_local, T(Op_inc, C_local) and Op_local are commutative, meaning the execution order does not affect the final state.

[0074] For example, suppose Op_local executes action A at time T, and the received Op_inc cancels action A. The transformation function T checks the state of action A in the local context: if A has not yet started, T outputs an operation to remove A from the queue; if A is executing, T outputs an operation to interrupt A and log it; if A has completed, T outputs a no-op. The transformed Op_inc' and the original Op_local, executed in any order, will always yield the same final state: action A is effectively canceled and the state is correctly recorded.

[0075] The node engine applies the transformed Op_inc' to the local queue or executor. Since all nodes follow the same transformation rules, and the Op_inc issued by the server carries a global sequence timestamp, although the physical time of instruction reception and processing differs among nodes, the sequence of operations effective on all nodes is equivalent in terms of business effect after the operation transformation. This ensures that in scenarios with concurrent reception of incremental adjustment instructions, the final effect of the entire collection task is completely consistent with the server's replanning expectations, avoiding resource conflicts, state chaos, or deviation from the collection target caused by interleaved instruction execution.

[0076] Furthermore, before determining the target execution plan according to the predetermined scheme selection rules in S4, the method further includes: performing multiple Monte Carlo simulations in the dynamic simulation environment for each candidate execution plan with the resource binding and synchronization contract, and statistically analyzing the expected and variance of its collection success rate; if the expected success rate of the optimal plan is lower than the system guarantee threshold, then a backup, less complex conservative collection process is used to replace the original target execution plan.

[0077] Specifically, this risk assessment and downgrade process is implemented through the following methods: Monte Carlo simulation is a statistical method for collaborative decision-making and consistent execution in high-speed mobile target debt collection, which estimates numerical results through repeated random sampling. The expected success rate is the average number of successes across all simulations, reflecting the average performance of the solution. Variance is the degree to which the success rate fluctuates around the expected value, reflecting the risk or stability of the solution. The system assurance threshold is the minimum acceptable success rate set according to business requirements and compliance standards. The optimal solution is the solution with the highest comprehensive score initially selected based on optimization rules. The conservative collection process is a set of pre-designed, logically simple, risk-controllable, compliance- and record-keeping-focused backup collection steps.

[0078] Before the optimal solution module makes its final decision, the risk assessment submodule is activated. This module performs in-depth Monte Carlo simulation evaluations on each candidate execution solution that has undergone distributed constraint optimization and is accompanied by resource binding and synchronization contracts. In a dynamic simulation environment, the module runs hundreds to thousands of simulations independently for each solution. At the start of each simulation, the module introduces random perturbations conforming to historical statistical distributions into the key parameters of the environment, such as small random deviations in vehicle trajectories, random fluctuations in node states, and random noise from debtor feedback, to simulate uncertainties in real-world execution.

[0079] In each simulation, the module strictly follows the action sequence, resource binding, and synchronization contract of the scheme, executing them step by step in the simulation environment and recording the final collection result. After all simulations are completed, the module counts the number of successes for the scheme and calculates the expected value and variance of the success rate.

[0080] Subsequently, the solution selection module first performs a preliminary ranking of all solutions according to predetermined rules, selecting the nominally optimal solution. Then, the module compares the expected success rate of this optimal solution with a preset system assurance threshold. This system assurance threshold is a hard indicator set based on business risk tolerance, regulatory requirements, or service level agreements.

[0081] If the expected success rate of the optimal solution is greater than or equal to the system's guarantee threshold, then the solution is considered to be within the range of controllable risk, the module identifies it as the target execution solution, and the process continues.

[0082] If the expected success rate of the optimal solution is lower than the system's guarantee threshold, it indicates that even the optimal online optimization solution has an average failure risk exceeding the system's acceptable range. In this case, the module will trigger a degradation mechanism. The module will discard all candidate solutions generated by the sequence decision maker and the distributed constraint optimizer. Instead, the module will load a backup solution marked as a conservative collection process from a predefined solution library. This backup process typically involves only a few standardized, low-intrusive actions, such as sending a legally mandated collection notification SMS and logging a collection attempt, without involving complex multi-node coordination or conditional judgments. Its goal is downgraded from successful collection to completing compliant notification and retaining evidence. This conservative process is directly adopted as the target execution plan for the current task. Through the above quantitative risk assessment and pre-set degradation path, the system can automatically switch to a safe mode when it identifies excessively high risks, thereby ensuring the bottom-line compliance and controllability of business operations in extreme cases and avoiding greater business or legal risks caused by executing high-risk solutions.

[0083] Furthermore, a non-transitory computer-readable storage medium storing a computer program, which, when executed by a processor, implements the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection.

[0084] Specifically, the storage medium is implemented in the following way: a non-transitory computer-readable storage medium is a physical or logical carrier capable of retaining stored information for a long period of time, and whose information can be read by a computer device, such as a solid-state drive, optical disc, or configured cloud storage volume. A computer program is a collection of code consisting of a series of instructions that can be executed by a processor. The processor is the core hardware unit in a computing device responsible for interpreting and executing instructions.

[0085] During the production process, the storage medium, through recording, burning, or data writing devices, permanently stores the complete computer program code within its storage unit, implementing the collaborative decision-making and consistent execution method for high-speed mobile target debt collection. The program code includes modules implementing the logic of steps S1 to S5, sub-modules implementing the detailed functions of the dependent claims, and necessary configuration data, model parameters, and interface definitions. The code is written in a high-level programming language or a low-level language and ultimately compiled into binary format or bytecode executable on general-purpose or special-purpose processors.

[0086] When a user needs to deploy the collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets, the storage medium is connected to the target computing device, such as a collection coordination server. The operating system or bootloader of the computing device can recognize the file system of the medium and read the program files within it. The user loads the program code into the memory of the computing device through an installation script or manual operation. The central processing unit of the computing device begins to read and execute these instructions one by one.

[0087] The execution logic of the instructions precisely replicates the entire process of the collaborative decision-making and consistent execution method embodiment for high-speed mobile target overdue payment collection: the processor controls the network interface card of the computing device to perform the data acquisition operation in S1; it calls the computing core and memory resources of the computing device to perform the dynamic environment construction and sequence decision-making in S2; it runs the optimization solution library to perform the constraint optimization in S3; it performs the scheme selection, instruction compilation and encapsulation and distribution in S4 according to the built-in logic; and it responds to network interruptions to perform the replanning and incremental instruction processing in S5. When the execution flow needs to reference model parameters or configurations, the processor will automatically read the corresponding data from the storage area associated with the storage medium.

[0088] The entire collaborative decision-making and consistent execution method for high-speed mobile target debt collection relies on the hardware resources and underlying system software provided by computing devices. The key role of this storage medium is that it standardizes and productizes a complete and complex debt collection decision-making and execution system solution into executable code within a separate, physically transferable or distributeable carrier. This allows any computing device with basic compatibility to acquire the collaborative decision-making and consistent execution capabilities for high-speed mobile target debt collection without developing the entire algorithm and system from scratch, simply by running the program within the medium. This significantly reduces the technical implementation threshold and complexity, and ensures consistency of functionality and effectiveness across different deployment environments.

[0089] Furthermore, a collaborative decision-making and consistent execution system for collecting overdue payments from high-speed mobile targets includes a collection coordination server and multiple collection resource nodes, wherein: the collection coordination server is configured to execute the collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets as described in any one of claims 1 to 8; the multiple collection resource nodes are communicatively connected to the collection coordination server and are configured to receive and execute a set of executable instructions and a synchronization script.

[0090] Specifically, the collaborative operation of this system is achieved through the following methods: The collection coordination server is a core computing device deployed in the data center, responsible for overall decision-making, planning, and scheduling. Multiple collection resource nodes are terminal devices distributed at the collection site, responsible for executing specific collection actions. Communication connection refers to a link established via wired or wireless network for data transmission and control. "Configured for execution" means that the hardware and software of the collection coordination server are specifically set up and programmed to run the algorithm flow corresponding to the collaborative decision-making and consistent execution method for high-speed mobile target debt collection. "Receiving and executing" means that the collection resource nodes have the ability to receive instructions, parse instructions, and locally drive relevant hardware to complete collection actions.

[0091] The system physically forms a distributed network with a star or hybrid topology. The collection coordination server, as the central node, is equipped with a high-performance multi-core processor, large-capacity memory, and a high-speed network interface. Its system software layer is equipped with a complete set of service programs that implement the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection as described in claims 1 to 8, including modules such as data acquisition services, simulation engine, decision model, optimization solver, and compiler.

[0092] Multiple collection resource nodes are deployed as edge nodes in key locations such as along highways, toll stations, and service areas. Each node includes a processor, memory, dedicated collection interaction hardware, and a network interface. A lightweight agent runs on each node, which is responsible for maintaining a heartbeat connection with the server, receiving task packets, loading and executing machine code and synchronization scripts in a local secure environment, and monitoring the execution status and providing feedback to the server.

[0093] After the system starts, the service program on the collection coordination server begins running, continuously executing the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection: it acquires data from external data sources and nodes, builds a simulation environment and generates a plan, optimizes it and generates a contract, selects the best plan and compiles and distributes it, and handles replanning when necessary. Throughout the process, the server maintains interaction with each resource node through the communication network: issuing query commands to obtain status monitoring data, issuing encapsulated task packages to deliver executable instructions, receiving status correction requests reported by nodes, and issuing incremental adjustment commands.

[0094] The agent programs on each resource collection node continuously listen to the network port, receiving instructions and task packets from the server. Upon receiving a task packet, the agent verifies its integrity, then loads the machine code segment into its local execution environment to drive the interactive hardware to complete the specific collection actions. Simultaneously, according to the synchronization script, the agent communicates with other nodes or servers to synchronize its status when specific conditions are met. The nodes also report key statuses and abnormal events during execution to the server in real time via the communication link.

[0095] Through the division of labor and collaboration between the aforementioned hardware entities and dedicated software, the debt collection coordination server and multiple debt collection resource nodes together form an organic whole. The server undertakes complex brain functions, performing global perception, simulation deduction, and optimization decision-making; while the resource nodes act as flexible limbs, precisely executing the compiled specific actions. The two are tightly coupled through reliable communication links, realizing a complete closed loop from intelligent decision-making to consistent execution. This achieves the debt collection accuracy, coordination, and adaptability sought by the collaborative decision-making and consistent execution method for high-speed mobile target debt collection in the physical world.

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

Claims

1. A collaborative decision-making and consistent execution method for collecting overdue payments from high-speed mobile targets, characterized in that, Performed by the collection coordination server, including: S1. Obtain trajectory prediction data of the target vehicle, status monitoring data of multiple collection resource nodes, and repayment willingness assessment data of the target debtor; S2. Based on the trajectory prediction data, status monitoring data, and repayment willingness assessment data, a dynamic simulation environment is constructed within the collection coordination server, and a sequence decision-maker is run in the dynamic simulation environment to generate a set of candidate execution schemes containing collection actions at multiple time points. S3. Input the set of candidate execution schemes into the distributed constraint optimizer. The distributed constraint optimizer couples the global benefit of the scheme with the coordination cost between nodes, and outputs the resource binding and synchronization contract corresponding to each candidate execution scheme. S4. According to the predetermined scheme selection rules, determine the target execution scheme from the candidate execution schemes with the resource binding and synchronization contract, convert the target execution scheme into an executable instruction set and synchronization script adapted to the target node among the multiple resource collection nodes, and send it to the target node for execution.

2. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, In step S1, obtaining the trajectory prediction data of the target vehicle specifically includes: The data stream from the access road network sensing device is used to calculate the spatiotemporal window sequence of the target vehicle's communication range through each collection resource node in the future time period by using kinematic models and road network topology. The acquisition of status monitoring data for multiple resource collection nodes specifically includes: polling the available computing power, cache space, and network link quality of each node; The acquisition of repayment willingness assessment data specifically includes: calling the willingness inference model to process historical interaction records and outputting a time-series vector representing changes in repayment willingness.

3. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, In step S2, the generation of a candidate execution scheme set by the sequence decision-maker specifically includes: The sequence decision-maker employs a deep neural network trained in an adversarial environment simulation. The adversarial environment simulation dynamically introduces random compression of communication windows, sudden node failures, and debtor feedback noise during training to improve the robustness of the sequence decision generator generation scheme in real-world environments.

4. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, In S3, the distributed constraint optimizer output resource binding and synchronization contract specifically include: The distributed constrained optimizer models the problem as an integer programming model with the objective of maximizing global collection revenue and constraints of node load balancing and the upper limit of the amount of synchronized messages. The heuristic cutting plane algorithm is used to solve the integer programming model quickly, and execution nodes are assigned to the collection actions in each candidate execution scheme. The message format and triggering conditions for transmitting state summaries between nodes are also specified.

5. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, In step S4, converting the target execution plan into an executable instruction set and a synchronization script specifically includes: Based on the resource binding and synchronization contract, the action subsequences allocated to specific nodes in the scheme are compiled into machine code segments specific to the processor architecture of that node; The message format and triggering conditions specified in the synchronization contract are compiled into network communication service primitives supported by the operating system of the node; The machine code segment and network communication service primitives are encapsulated into an atomic task package.

6. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, Also includes: S5. During execution, when any collection resource node detects a significant deviation between the actual collection interaction state and the expected state in the dynamic simulation environment, it sends a state correction request to the collection coordination server. Based on the status correction request, the collection coordination server performs local replanning on the unexecuted portion of the target execution plan in the dynamic simulation environment; The incremental adjustment instructions generated by the replanning will be sent to the affected resource collection nodes in real time.

7. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 6, characterized in that, The process of sending incremental adjustment instructions to the affected collection resource nodes in real time specifically includes: A concurrency control protocol based on operation transformation is adopted to ensure that no logical conflict occurs when the incremental adjustment instruction is merged with the local pending instruction queue of the affected node, and to maintain the consistency of the final collection effect.

8. The collaborative decision-making and consistent execution method for high-speed mobile target overdue payment collection as described in claim 1, characterized in that, Before determining the target execution plan according to the predetermined scheme selection rules in step S4, the method further includes: For each candidate execution scheme with the aforementioned resource binding and synchronization contract, perform multiple Monte Carlo simulations in the dynamic simulation environment and statistically analyze the expected and variance of its collection success rate. If the expected success rate of the optimal solution is lower than the system's guarantee threshold, then a backup, less complex, conservative collection process will be used to replace the original target execution plan.

9. A non-transitory computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection as described in any one of claims 1 to 8.

10. A collaborative decision-making and consistent execution system for collecting overdue payments from high-speed mobile targets, characterized in that: This includes a collection coordination server and multiple collection resource nodes, among which: The collection coordination server is configured to execute the collaborative decision-making and consistent execution method for high-speed mobile target arrears collection as described in any one of claims 1 to 8; The multiple collection resource nodes are communicatively connected to the collection coordination server and are configured to receive and execute the issued executable instruction set and synchronization script.

Images