Graph-based information transmission sequence intelligent optimization method

Abstract

The invention relates to the crossing field of network communication and artificial intelligence technology, provides a graph-based information transmission sequence intelligent optimization method, and aims to increase the quantity of transmitted information as much as possible within fixed time. Graph data description is adopted, sending equipment, relay equipment and receiving equipment serve as nodes, transmission links serve as relations, available information transmission capacity is added into the relations, and a normative communication information topological graph structure is formed. Each piece of transmission information is mapped into a starting node, a termination node and a capacity demand dictionary; the maximum information transmission quantity is used as an optimization target, the optimal transmission information transmission sequence is obtained through an intelligent optimization algorithm and graph path optimization, and the method is widely applied to application scenes such as telemetering networks, satellite communication and unmanned cluster management and control.

Description

Technical Field

[0001] The present invention relates to the cross - field of network communication and artificial intelligence technology. Specifically, it relates to an intelligent optimization method for information transmission sequence and path based on graphs. Background Art

[0002] During the process of space measurement, transportation, and control, unmanned equipment management and control, and distributed operation of intelligent systems, different communication means are required to transmit different amounts of information, that is, different transmission times are needed. How to, according to the required time period, based on the available time of the current communication link, and according to the information priority, transmit as much information as possible within a limited time to maximize the number of transmitted information.

[0003] Existing methods mainly use meta - heuristic methods for resource optimization. In the article "Satellite Measurement and Control Resource Scheduling Algorithm Based on Adaptive Simulated Annealing" published by Wu Guohua et al. in the "Acta Aeronautica et Astronautica Sinica", after a detailed analysis of the business process of the satellite measurement and control scheduling resource scheduling problem, a measurement and control resource scheduling method based on a simulated annealing genetic algorithm was proposed. Its advantage lies in modeling the measurement and control environment in detail and improving the simulated annealing algorithm, enhancing the optimization performance. However, in this algorithm, the constraint complexity is high, the problem space construction is not focused, and the integration ability is lacking. In the article "Multi - objective Optimization Method for Satellite Ground Station Resources in the Integrated Scenario of Measurement, Telemetry, and Data Transmission" published by Sun Gang et al. in the "Acta Aeronautica et Astronautica Sinica", a KG - NSGA - II - TTC&DT multi - objective optimization algorithm was proposed to achieve resource planning for multiple constraints such as conflict duration and antenna load balancing. This method is also relatively complex in modeling and does not solve the new challenges brought by the emergence of relay devices in the current measurement, telemetry, and data transmission field in China. In the patent "Satellite Measurement, Transportation, and Control Resource Multi - objective Optimization Scheduling Method, Device, and Medium" applied by the Space Engineering University of the Strategic Support Force of the Chinese People's Liberation Army, with the publication number CN116450366A, multi - objective evolutionary computation is also used to optimize the allocation of measurement, transportation, and control resources. However, this patent cannot give the optimal execution order of task information. Summary of the Invention

[0004] To solve the above problems, the present invention proposes an intelligent optimization method for information transmission sequence based on graphs. First, construct a communication information topology graph to store the link capacity and link topology structure. Then, based on the graph, optimize the search for feasible paths to ensure that the paths meet the capacity constraints. Finally, use an improved evolutionary algorithm to optimize the task execution order to improve the task information transmission speed under limited resources.

[0005] The technical solution adopted by the present invention is as follows:

[0006] An intelligent optimization method for information transmission sequence based on graphs, comprising the following steps:

[0007] Step 1: Construct a communication information topology graph, which is a directed graph. Each edge in the graph carries available communication capacity to represent the available link resources between nodes.

[0008] Step 2: Construct a task set, including several communication task instructions. Each communication task instruction includes a source node, a target node, and the required transmission information capacity. The task set is stored in a list form.

[0009] Step 3: Construct an objective function based on graph path optimization to maximize the number of information transmissions and evaluate the fitness of different task orders in combination with graph optimization algorithms.

[0010] Step 4: Iteratively optimize the order of communication task instructions based on the objective function constructed in Step 3, and output the optimal task execution order and path allocation strategy that can maximize the number of successfully scheduled tasks.

[0011] Furthermore, the specific process of Step 1 is as follows:

[0012] Use a dictionary structure to store the communication information topology graph graph. The key represents the node, and the value is the adjacent node and its available communication capacity of the link.

[0013] Furthermore, the specific process of Step 2 is as follows:

[0014] Construct a task set commands. The task set is used to express multiple concurrent point-to-point transmission requirements in the network. The task set is defined in a list structure. The list contains multiple communication task instructions. Each communication task instruction is represented in a dictionary form and includes three parts: resource is the name of the source node, representing the starting point of information transmission; target is the name of the target node, representing the ending point of information transmission; weight is the required transmission information capacity, representing the minimum remaining capacity of the link required for the task.

[0015] Furthermore, the specific process of Step 3 is as follows:

[0016] Step 3-1: Construct a feasible path function find_path. The input parameters of the function include the starting node start, the ending node end, and the required transmission information capacity weight. The function uses a graph optimization algorithm to start from the given starting node start and find a feasible path to reach the ending node end, and ensure that the remaining capacity of each edge on the path is not less than the specified weight. If a path that meets the information capacity condition is found, the node sequence of the path is output in a list form; otherwise, None is output.

[0017] Step 3-2: Construct an information transmission instruction processing function process_commands to batch process the task set commands. By calling the path search function find_path, find a feasible path that meets the information capacity condition in the communication information topology graph for each communication task instruction, and update the remaining capacity of each link in the communication information topology graph to achieve dynamic allocation and statistics of link resources. Finally, output the number of communication task instructions for which path allocation is successfully completed in this execution;

[0018] Step 3-3: Construct an objective function objection to rearrange the task set commands in the input index order index_order to obtain the actual execution order and generate ordered_commands. Then call the information transmission instruction processing function process_commands to execute the tasks in the current order, and calculate the number of communication task instructions that can be successfully completed according to the path resource constraints, and store the result in the variable result.

[0019] Further, the specific processing process of the feasible path function find_path in Step 3-1 is as follows:

[0020] Construct a queue queue to store the current node and the path it has passed. Initially, the queue queue contains the starting node and the path [start] that only contains the starting node; at the same time, use a set visited to record the nodes that have been visited; during the search process, take out the node from the queue queue and check whether the node is the termination node end. If it is the termination node end, output the path that has been passed; otherwise, mark the node as visited and traverse all its neighbor nodes; for each neighbor node, if the remaining capacity is greater than or equal to weight and has not been visited, add the neighbor node and its updated path to the queue queue to continue the search; if the queue queue is empty and the termination node end has not been found, the function outputs None, indicating that there is no path that meets the conditions.

[0021] Further, the specific processing process of the information transmission instruction processing function process_commands in Step 3-2 is as follows:

[0022] Input a list of dictionaries commands_temp, where each dictionary represents a communication task instruction, and initialize the statistical variable success_count. Traverse each communication task instruction in the commands_temp list, obtain the start node start, end node end, and transmission information capacity requirement weight by parsing the dictionary. Then call the find_path function to find a feasible path path. If the path exists, enter the path verification stage. Traverse all adjacent node pairs u and v in the path, and confirm again that the remaining capacity of the link between adjacent node pairs u and v meets the requirement. If the capacity of a certain link is insufficient, terminate the path update. If the path verification passes, increment the statistical variable success_count by 1, and update the capacity of each link in the path to solve the remaining link information volume. After all communication task instructions are processed, output the final number of successfully executed tasks success_count.

[0023] Further, the specific process of step 4 is as follows:

[0024] Step 4-1: Construct an initialization population function initialize_population with inputs num_commands and population_size. num_commands represents the total number of transmission tasks, that is, how many task indices each individual needs to contain, which is the same as the number of communication task instructions in the input commands. population_size represents the size of the population. First, create an empty list named population to store all generated individuals with randomly arranged task orders, and construct a basic order list base_order, where the basic order list is [0, 1,..., num_commands - 1], representing the index arrangement of tasks in the original order. Subsequently, in each iteration of the loop, copy base_order to the variable individual, and then use the shuffle function in the random module to randomly shuffle the task index arrangement to construct different task execution orders. Each individual represents a possible task sorting scheme and is added to the population list. The function outputs the population list, which contains a population of several individuals, and each individual is a list of task index arrangements. Finally, population contains population_size randomly arranged task orders.

[0025] Step 4-2: Construct a screening mechanism function selection. The inputs are population, scores, and k. population represents the current population, and each element is an individual, that is, a list of task execution order indices. scores correspond to the fitness scores of each individual in population, which are calculated by the objective function. k represents the number of randomly selected individuals. First, pack the two lists population and scores into a list of tuple pairs, representing each individual and its corresponding fitness. Then, use the sample function in the random module to randomly select k individuals and their scores from the list of tuple pairs as candidates. Finally, use the max function to select the individual with the highest fitness from the k candidates and output its individual information. The function output is the list of task execution order indices of the selected optimal individual.

[0026] Step 4-3: Construct a crossover mechanism function crossover. The inputs are the gene sequences of parent individuals 1 and 2, which are the task execution orders, that is, parent1 and parent2. The function outputs are child individuals 1 and 2, that is, child1 and child2, which are the task execution orders after crossover processing. First, calculate the length size of the parent individual and randomly select two indices start and end respectively, ensuring start < end, to form a crossover interval [start, end]. Then, create 2 child individuals child with length size, namely child1 and child2, and initialize them to all None. Then, copy the genes of parent individual 1 in the interval [start, end] to child individual 1, and select the genes that do not appear in the child from parent individual 2 and fill them into the remaining positions of the child individual in order. Finally, copy the genes of parent individual 2 in the interval [start, end] to child individual 2, and select the genes that do not appear in the child from parent individual 1 and fill them into the remaining positions of the child individual in order.

[0027] Step 4-4: Construct a mutation mechanism function mutation. The function inputs are the individual list and mutation_rate. The individual list represents the gene sequence of the individual, which is the task execution order, and mutation_rate is the floating-point mutation probability. First, generate a random number between 0 and 1. If the random number is less than the given mutation probability mutation_rate, then perform the mutation operation; otherwise, keep the individual unchanged. If the mutation condition is satisfied, randomly select two different indices i and j from the gene sequence of the individual, and then exchange the genes at these two positions. Finally, output the gene sequence individual of the individual after the exchange mutation operation.

[0028] Step 4-5: Set the population size population_size, the number of optimization iterations generations, and the mutation probability mutation_rate. Input num_commands and population_size into the initialize_population function to initialize the population. Then enter the optimization loop, which repeats the optimization generations times. In each optimization, calculate the fitness value of each individual through the objective function objection, select the individual with the best fitness as the best solution of the current generation, and record the best fitness and the optimal individual of the current generation. Select parent individuals from the population according to the selection function, use the crossover function to generate two offspring individuals, apply the mutation function to the generated offspring individuals to increase the diversity of the population. Then add the new individuals generated through crossover and mutation operations to the new population to update the population. After all generations end, output the optimal solution, that is, the individual with the highest fitness value in the last generation, representing the optimal execution order of the task.

[0029] The advantages of the present invention compared with the prior art are as follows:

[0030] First, improve the evolutionary algorithm. By optimizing the task execution order, meet the requirement of executing the most tasks, and effectively reduce the resource loss caused by link conflicts. Then, use the graph optimization algorithm in combination with the improved evolutionary algorithm to avoid the high computational complexity caused by brute-force search while ensuring the global resource optimality. BRIEF DESCRIPTION OF THE DRAWINGS

[0031] Figure 1 It is a flowchart of the method according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0032] The present invention will be further described below in conjunction with the drawings and specific embodiments.

[0033] Step 1: Generate the communication information topology graph structure. Construct the graph structure of the communication network. This graph is a directed graph, where each edge carries the available communication capacity, which is used to represent the available link resources between nodes. Use a dictionary structure to store the communication topology graph graph, where the key represents the node and the value is the adjacent node and its link information capacity. The present invention uses graph data description, taking the sending device, relay device, and receiving device as nodes, taking the transmission link as the relationship, and adding the available information transmission capacity to the relationship to form a standard communication information topology graph structure.

[0034] graph = {

[0035] 'A': {'B': 5, 'C': 10},

[0036] 'B': {'D': 7, 'F': 5},

[0037] 'C': {'D': 8, 'F': 6},

[0038] 'D': {},

[0039] 'E': {'C': 6},

[0040] 'F': {}

[0041] }

[0042] Step 2: Transmission information construction. Construct a task set commands, which includes several communication task instructions. Each communication task instruction includes a source node, a target node, and the required transmission information capacity. This task set is stored in the form of a list. The task set commands is used to express multiple concurrent point-to-point transmission requirements in the network. The task set commands is defined using a list structure, and the list contains multiple communication task instructions. Each communication task instruction is represented in the form of a dictionary (dict), including three parts: resource is the name of the source node (string), indicating the starting point of information transmission; target is the name of the target node (string), indicating the ending point of information transmission; weight is the required transmission information capacity, indicating the minimum remaining capacity of the link required for this task.

[0043] commands =

[0044] {"resource": "A", "target": "C", "weight": 6},

[0045] {"resource": "A", "target": "C", "weight": 3},

[0046] {"resource": "A", "target": "C", "weight": 1},

[0047] {"resource": "A", "target": "C", "weight": 2},

[0048] {"resource": "A", "target": "C", "weight": 3},

[0049] {"resource": "A", "target": "C", "weight": 1},

[0050] {"resource":"A","target":"C","weight":1},

[0051] {"resource":"A","target":"C","weight":1},

[0052] {"resource":"A","target":"C","weight":1},

[0053] {"resource":"A","target":"C","weight":11},

[0054] {"resource":"A","target":"C","weight":1},

[0055] {"resource":"A","target":"C","weight":2},

[0056] {"resource":"A","target":"C","weight":1},

[0057] {"resource":"A","target":"C","weight":1},

[0058] {"resource":"A","target":"F","weight":3},

[0059] {"resource":"A","target":"F","weight":1},

[0060] {"resource":"A","target":"F","weight":1},

[0061] {"resource":"A","target":"F","weight":4},

[0062] {"resource":"A","target":"F","weight":1},

[0063] {"resource":"A","target":"F","weight":3},

[0064] {"resource":"A","target":"F","weight":1},

[0065] {"resource":"A","target":"F","weight":1},

[0066] {"resource":"A","target":"F","weight":1},

[0067] {"resource":"E","target":"D","weight":2},

[0068] {"resource":"E","target":"D","weight":3},

[0069] {"resource":"E","target":"D","weight":1},

[0070] {"resource":"E","target":"D","weight":1},

[0071] {"resource":"E","target":"D","weight":1},

[0072] {"resource":"E","target":"D","weight":1},

[0073] {"resource":"E","target":"F","weight":4},

[0074] {"resource":"E","target":"F","weight":1},

[0075] {"resource":"E","target":"F","weight":2},

[0076] {"resource":"E","target":"F","weight":3},

[0077] {"resource":"E","target":"F","weight":1},

[0078] {"resource":"E","target":"F","weight":1},

[0079] {"resource":"E","target":"F","weight":1},

[0080] {"resource": "E", "target": "F", "weight": 1},

[0081] {"resource": "E", "target": "F", "weight": 1},

[0083] Step 3: Construct an objective function objection based on graph path optimization to maximize the amount of information transmission, and evaluate the fitness of different task sequences by combining graph optimization algorithms.

[0084] The specific process includes:

[0085] Step 3-1: Construct a feasible path function find_path. The input parameters of the function include the starting node start, the ending node end, and the transmission information capacity requirement weight. The function uses a graph optimization algorithm to start from the given starting node start and find a feasible path to reach the ending node end, and ensure that the remaining capacity of each edge on the path is not less than the specified weight. If a path that meets the information capacity condition is found, the node sequence of the path is output in the form of a list, otherwise None is output.

[0086] The specific processing process of the feasible path find_path function is as follows:

[0087] Construct a queue queue to store the current node and the path it has passed. Initially, the queue queue contains the starting node and the path [start] that only contains the starting node; at the same time, use a set visited to record the nodes that have been visited; during the search process, take out the node from the queue queue and check whether the node is the ending node end. If it is the ending node end, output the path that has been passed; otherwise, mark the node as visited and traverse all its neighbor nodes; for each neighbor node, if the remaining capacity is greater than or equal to weight and has not been visited, add the neighbor node and its updated path to the queue queue for continued search; if the queue queue is empty and the ending node end has not been found, the function outputs None, indicating that there is no path that meets the conditions.

[0088] ​Step 3-2: Construct an information transmission instruction processing function process_commands to batch process the task set commands. By calling the path search function find_path, find a feasible path that meets the information capacity condition in the communication information topology graph for each communication task instruction, and update the remaining capacity of each link in the communication information topology graph to achieve dynamic allocation and statistics of link resources. Finally, output the number of communication task instructions for which the path allocation is successfully completed in this execution;

[0089] The specific processing process of the information transmission instruction processing function process_commands is as follows:

[0090] Input a list commands_temp composed of multiple dictionaries, where each dictionary represents a communication task instruction; when the function is called, use deepcopy() for deep copying to obtain graph_, and initialize the statistical variable success_count; traverse each communication task instruction in the passed-in commands_temp list, obtain the starting node start, the ending node end, and the transmission information capacity requirement weight by parsing the dictionary; call the find_path function to find a feasible path path. If the path exists, set valid = True and enter the path verification stage. Traverse all adjacent node pairs u and v in the path, and confirm again that the remaining capacity of the link between the adjacent node pairs u and v meets the requirements. If the capacity of a certain link is insufficient, set valid = False and terminate the path update. If the path verification passes, increment the statistical variable success_count by 1, and perform a capacity update operation on each link in the path graph_[u][v] -= weight, indicating that the link information has been occupied, and solve for the remaining link information; after all instructions are processed, output the final number of successfully executed tasks success_count.

[0091] Step 3-3: Construct the objective function objection. It is used to evaluate the fitness of the task allocation scheme in the network according to the given task execution order index_order, for use in the objective function call in the subsequent optimization algorithm. The input of the function is index_order, which is a list of integers representing the execution order indices of the task instructions in the commands list. The output of the function is an integer representing the number of tasks that can be successfully completed under the current task execution order. The function first rearranges the task set commands according to the input index order index_order to obtain the actual execution order and generates ordered_commands; then calls the information transmission instruction processing function process_commands to attempt to execute the tasks according to the current order and calculates the number of tasks that can be successfully completed based on the path resource constraints; the result is stored in the variable result.

[0092] Step 4: Design an optimization method to maximize the number of executed tasks. Based on the objective function constructed in Step 3, iteratively optimize the order of the communication task instructions, and output the optimal task execution order and path allocation strategy that can maximize the number of successfully scheduled tasks.

[0093] The specific process includes:

[0094] Step 4-1: Initialize the population. Construct the initialize_population function to generate multiple individuals with randomly arranged task sequences as the initial solution space. The function has two inputs, namely num_commands and population_size. num_commands represents the total number of transmission tasks, that is, how many task indices each individual needs to contain, which is the same as the number of instructions in the input commands; population_size represents the size of the population. First, create an empty list named population to store all the generated individuals with randomly arranged task sequences, and construct a basic order list base_order, where the basic order list is [0, 1,..., num_commands - 1], representing the index arrangement of tasks in the original order. Subsequently, in each iteration of the loop, copy base_order to the variable individual, and then use the shuffle function in the random module to randomly shuffle the task index arrangement to construct different task execution sequences; each individual represents a possible task sorting scheme and is added to the population list. The function outputs the population list, which contains a population of several individuals, and each individual is a list of task index arrangements. Finally, population contains population_size randomly arranged task sequences.

[0095] Step 4-2: Construct the selection function selection to screen individuals from the current population according to fitness. The inputs are three, namely population, scores, and k. population represents the current population, and each element is an individual, that is, a list of task execution order indices; scores correspond to the fitness scores of each individual in the population, calculated by the objection objective function; k represents the number of randomly selected individuals. First, pack the population and scores lists into a list of tuple pairs, and the corresponding program code is list(zip(population, scores)), representing each individual and its corresponding fitness. Then, use the sample function in the random module to randomly select k individuals and their scores from the list list as candidates and assign them to selected. Finally, use the max function to select the individual with the highest fitness from the k candidates and output its individual information. The function output is the list of task execution order indices of the selected optimal individual.

[0096] Step 4-3: Construct the crossover mechanism function crossover. The input is the gene sequences of parent individuals 1 and 2, which are the execution orders of tasks, namely parent1 and parent2. The function output is child individuals 1 and 2, child1 and child2, which are the execution orders of tasks after crossover processing. First, calculate the length size of the parent individual, randomly select two indices start and end respectively, and the corresponding program code is random.sample(range(size), 2), and after sorting them, assign them to start and end to ensure start < end, forming a crossover interval [start, end]. Then, create 2 child individuals child with a length of size, namely child1 and child2, and initialize them to all None. Then, copy the genes of parent individual 1 in the interval [start, end] to child individual 1, that is, child1[start:end] = parent1[start:end], and select the genes that do not appear in the child from parent individual 2 and fill them into the remaining positions of the child individual in order. Finally, copy the genes of parent individual 2 in the interval [start, end] to child individual 2, that is, child2[start:end] = parent2[start:end], and select the genes that do not appear in the child from parent individual 1 and fill them into the remaining positions of the child individual in order.

[0097] Step 4-4: Construct the mutation mechanism function mutation. The function input is the individual list and mutation_rate. The individual list represents the gene sequence of the individual, which is the execution order of the task, and mutation_rate is the floating-point mutation probability. First, generate a random number between 0 and 1, and the corresponding program code is random.random(). If the random number is less than the given mutation probability mutation_rate, then perform the mutation operation; otherwise, keep the individual unchanged. If the mutation condition is met, randomly select two different indices i and j, randomly select two different indices from the gene sequence of the individual, and the corresponding program code is random.sample(range(len(individual)), 2), and then swap the genes at these two positions, individual[i], individual[j] = individual[j], individual[i], that is, swap the values of gene i and gene j. Finally, output the gene sequence individual of the individual after the swap mutation operation.

[0098] Step 4-5: Optimize the task order. Set the population size population_size, the number of optimization generations generations, and the mutation probability mutation_rate to 20, 100, and 0.2 respectively. Input num_commands and population_size into the initialize_population function to initialize the population, and the corresponding program code is initialize_population(num_commands, population_size). Enter the optimization loop, which is repeated generations times, that is, 100 times, and the corresponding code is for gen in range(generations). In each optimization, calculate the fitness value of each individual through the objective function objection, select the individual with the best fitness as the best solution of the current generation, and record the best fitness and the optimal individual of the current generation; select parent individuals from the population according to the selection function, use the crossover function to generate two offspring individuals, and apply the mutation function to the generated offspring individuals to increase the diversity of the population; then add the new individuals generated through crossover and mutation operations to the new population to update the population. After all generations end, output the optimal solution, that is, the individual with the highest fitness value in the last generation, representing the optimal execution order of the tasks.

[0099] The optimization process for 100 generations is as follows:

[0100] Generation 0: Best Score = 18

[0101] Generation 1: Best Score = 18

[0102] Generation 2: Best Score = 19

[0103] Generation 3: Best Score = 20

[0104] Generation 4: Best Score = 20

[0105] Generation 5: Best Score = 20

[0106] Generation 6: Best Score = 20

[0107] Generation 7: Best Score = 20

[0108] Generation 8: Best Score=20

[0109] Generation 9: Best Score=20

[0110] Generation 10: Best Score=20

[0111] Generation 11: Best Score=20

[0112] Generation 12: Best Score=20

[0113] Generation 13: Best Score=20

[0114] Generation 14: Best Score=20

[0115] Generation 15: Best Score=20

[0116] Generation 16: Best Score=20

[0117] Generation 17: Best Score=20

[0118] Generation 18: Best Score=20

[0119] Generation 19: Best Score=20

[0120] Generation 20: Best Score=20

[0121] Generation 21: Best Score=20

[0122] Generation 22: Best Score=20

[0123] Generation 23: Best Score=20

[0124] Generation 24: Best Score=20

[0125] Generation 25: Best Score=20

[0126] Generation 26: Best Score=20

[0127] Generation 27: Best Score=20

[0128] Generation 28: Best Score=20

[0129] Generation 29: Best Score=20

[0130] Generation 30: Best Score=20

[0131] Generation 31: Best Score=20

[0132] Generation 32: Best Score=20

[0133] Generation 33: Best Score=20

[0134] Generation 34: Best Score=20

[0135] Generation 35: Best Score=20

[0136] Generation 36: Best Score=20

[0137] Generation 37: Best Score=20

[0138] Generation 38: Best Score=20

[0139] Generation 39: Best Score=20

[0140] Generation 40: Best Score=20

[0141] Generation 41: Best Score=20

[0142] Generation 42: Best Score=20

[0143] Generation 43: Best Score=20

[0144] Generation 44: Best Score=20

[0145] Generation 45: Best Score=20

[0146] Generation 46:Best Score=20

[0147] Generation 47:Best Score=20

[0148] Generation 48:Best Score=20

[0149] Generation 49:Best Score=20

[0150] Generation 50:Best Score=20

[0151] Generation 51:Best Score=20

[0152] Generation 52:Best Score=20

[0153] Generation 53:Best Score=20

[0154] Generation 54:Best Score=20

[0155] Generation 55:Best Score=20

[0156] Generation 56:Best Score=20

[0157] Generation 57:Best Score=20

[0158] Generation 58:Best Score=20

[0159] Generation 59:Best Score=20

[0160] Generation 60:Best Score=20

[0161] Generation 61:Best Score=20

[0162] Generation 62:Best Score=20

[0163] Generation 63:Best Score=20

[0164] Generation 64: Best Score=20

[0165] Generation 65: Best Score=20

[0166] Generation 66: Best Score=20

[0167] Generation 67: Best Score=20

[0168] Generation 68: Best Score=20

[0169] Generation 69: Best Score=20 Generation 70: Best Score=20

[0170] Generation 71: Best Score=20

[0171] Generation 72: Best Score=20

[0172] Generation 73: Best Score=20

[0173] Generation 74: Best Score=20

[0174] Generation 75: Best Score=20

[0175] Generation 76: Best Score=20

[0176] Generation 77: Best Score=20

[0177] Generation 78: Best Score=20

[0178] Generation 79: Best Score=20

[0179] Generation 80: Best Score=20

[0180] Generation 81: Best Score=20

[0181] Generation 82: Best Score=20

[0182] Generation 83: Best Score = 20

[0183] Generation 84: Best Score = 20

[0184] Generation 85: Best Score = 20

[0185] Generation 86: Best Score = 20

[0186] Generation 87: Best Score = 20

[0187] Generation 88: Best Score = 20

[0188] Generation 89: Best Score = 20

[0189] Generation 90: Best Score = 20

[0190] Generation 91: Best Score = 20

[0191] Generation 92: Best Score = 20

[0192] Generation 93: Best Score = 20

[0193] Generation 94: Best Score = 20

[0194] Generation 95: Best Score = 20

[0195] Generation 96: Best Score = 20

[0196] Generation 97: Best Score = 20

[0197] Generation 98: Best Score = 20

[0198] Generation 99: Best Score = 20

[0199] The obtained optimal index order is: [26, 37, 30, 9, 34, 24, 16, 6, 2, 29, 11, 21, 27, 23, 28, 33, 31, 18, 17, 25, 15, 32, 36, 35, 20, 7, 22, 8, 12, 13, 14, 5, 10, 0, 19, 4, 3, 1]

[0200] Corresponding best execution instructions: [{'resource': 'E', 'target': 'D', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 1}, {'resource': 'A', 'target': 'C', 'weight': 11}, {'resource': 'E', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'D', 'weight': 3}, {'resource': 'A', 'target': 'F', 'weight': 1}, {'resource': 'A', 'target': 'C', 'weight': 1}, {'resource': 'A', 'target': 'C', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 4}, {'resource': 'A', 'target': 'C', 'weight': 2}, {'resource': 'A', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'D', 'weight': 1}, {'resource': 'E', 'target': 'D', 'weight': 2}, {'resource': 'E', 'target': 'D', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 2}, {'resource': 'A', 'target': 'F', 'weight': 1}, {'resource': 'A', 'target': 'F', 'weight': 4}, {'resource': 'E', 'target': 'D', 'weight': 1}, {'resource': 'A', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 3}, {'resource': 'E', 'target': 'F', 'weight': 1}, {'resource': 'E', 'target': 'F', 'weight': 1},{'resource':'A','target':'F','weight':1},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'F','weight':1},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'F','weight':3},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'C','weight':1},{'resource':'A','target':'C','weight':6},{'resource':'A','target':'F','weight':3},{'resource':'A','target':'C','weight':3},{'resource':'A','target':'C','weight':2},{'resource':'A','target':'C','weight':3}],

[0201] It can be seen that through the method of the present invention, the optimal information transmission order can be effectively obtained.

Claims

1. An intelligent optimization method for the information transmission order based on a graph, characterized in that, It includes the following steps: Step 1: Construct a communication information topology graph, which is a directed graph, where each edge carries available communication capacity to represent the available link resources between nodes; Step 2: Construct a task set, including several communication task instructions. Each communication task instruction includes a source node, a target node, and the required transmission information capacity. The task set is stored in a list form; Step 3: Construct an objective function based on graph path optimization to maximize the number of information transmissions and evaluate the fitness of different task orders in combination with a graph optimization algorithm; Step 4: Iteratively optimize the order of communication task instructions based on the objective function constructed in Step 3, and output the optimal task execution order and path allocation strategy that can maximize the number of successfully scheduled tasks.

2. The intelligent optimization method for information transmission order based on a graph according to claim 1, wherein The specific process of Step 1 is as follows: Use a dictionary structure to store the communication information topology graph graph, where the key represents the node and the value is the adjacent node and its available communication capacity of the link.

3. An intelligent optimization method for the information transmission sequence based on a graph according to claim 1, characterized in that The specific process of Step 2 is as follows: Construct a task set commands. The task set is used to express multiple concurrent point-to-point transmission requirements in the network. The task set is defined using a list structure. The list contains multiple communication task instructions. Each communication task instruction is represented in dictionary form and includes three parts: resource is the name of the source node, representing the starting point of information transmission; target is the name of the target node, representing the end point of information transmission; weight is the required transmission information capacity, representing the minimum remaining capacity of the link required for the task.

4. An intelligent optimization method for the information transmission order based on a graph according to claim 1, characterized in that, The specific process of Step 3 is as follows: Step 3-1: Construct a feasible path function find_path. The input parameters of the function include the starting node start, the ending node end, and the required transmission information capacity weight. The function uses a graph optimization algorithm to start from the given starting node start and find a feasible path to the ending node end, and ensure that the remaining capacity of each edge on the path is not less than the specified weight. If a path that meets the information capacity condition is found, the node sequence of the path is output in list form, otherwise None is output; Step 3-2: Construct an information transmission instruction processing function process_commands, which is used to batch process the task set commands. By calling the path search function find_path, find a feasible path that meets the information capacity condition in the communication information topology graph for each communication task instruction, and update the remaining capacity of each link in the communication information topology graph to achieve dynamic allocation and statistics of link resources. Finally, output the number of communication task instructions that successfully complete path allocation in this execution. Step 3-3: Construct the objective function objection to rearrange the task set commands according to the input index order index_order to obtain the actual execution order, generate ordered_commands, then call the information transmission instruction processing function process_commands to execute the tasks according to the current order, and calculate the number of communication task instructions that can be successfully completed according to the path resource constraint situation, and store the result in the variable result.

5. An intelligent optimization method for the information transmission order based on a graph according to claim 4, characterized in that The specific processing process of the feasible path function find_path in Step 3-1 is as follows: Construct a queue queue to store the current node and the path it has passed. Initially, the queue queue contains the starting node and the path [start] that only contains the starting node; at the same time, use a set visited to record the nodes that have been visited; during the search process, take out the node from the queue queue and check whether the node is the end node end. If it is the end node end, output the path that has been passed; otherwise, mark the node as visited and traverse all its neighbor nodes; for each neighbor node, if the remaining capacity is greater than or equal to weight and has not been visited, add the neighbor node and its updated path to the queue queue to continue the search; if the queue queue is empty and the end node end has not been found, the function outputs None, indicating that there is no path that meets the conditions.

6. The intelligent optimization method for information transmission order based on a graph according to claim 5, characterized in that, The specific processing process of the information transmission instruction processing function process_commands in Step 3-2 is as follows: Input a list commands_temp composed of multiple dictionaries, each dictionary represents a communication task instruction, and initialize the statistical variable success_count; traverse each communication task instruction in the commands_temp list, obtain the starting node start, the end node end, and the transmission information capacity requirement weight by parsing the dictionary; then call the find_path function to find a feasible path path. If the path exists, enter the path verification stage, traverse all adjacent node pairs u and v in the path, and confirm again that the remaining capacity of the link between the adjacent node pairs u and v meets the requirements. If the capacity of a certain link is insufficient, terminate the path update. If the path verification passes, the statistical variable success_count is incremented by 1, and the capacity of each link in the path is updated to solve the remaining link information volume; after all communication task instructions are processed, output the final number of successfully executed tasks success_count.

7. An intelligent optimization method for the information transmission order based on a graph according to claim 1, characterized in that, The specific process of Step 4 is as follows: Step 4-1: Construct the initialize_population function. The inputs are num_commands and population_size. num_commands represents the total number of transmission tasks, that is, how many task indices each individual needs to contain, which is the same as the number of communication task instructions in the input commands. population_size represents the size of the population. First, create an empty list named population to store all the generated individuals with randomly arranged task orders, and construct a base order list base_order. The base order list is [0, 1,..., num_commands - 1], representing the index arrangement of tasks in the original order. Subsequently, through a loop, copy base_order to the variable individual in each iteration, and then use the shuffle function in the random module to randomly shuffle the task index arrangement to construct different task execution orders. Each individual represents a possible task sorting scheme and is added to the population list. The function outputs the population list, which contains a population of several individuals, and each individual is a list of permutations of task indices. Finally, there are population_size randomly arranged task orders in population. Step 4-2: Construct the selection function for the screening mechanism. The inputs are population, scores, and k. population represents the current population, and each element is an individual, that is, a list of task execution order indices. scores correspond to the fitness scores of each individual in population, which are calculated by the objective function. k represents the number of randomly selected individuals. First, pack the population and scores lists into a list of tuple pairs, representing each individual and its corresponding fitness. Then, use the sample function in the random module to randomly select k individuals and their scores from the list of tuple pairs as candidates. Finally, use the max function to select the individual with the highest fitness from the k candidates and output its individual information. The function output is the list of task execution order indices of the selected optimal individual. Step 4-3: Construct the crossover mechanism function crossover. The input is the gene sequences of parent individuals 1 and 2, which are the execution order of tasks, namely parent1 and parent2. The function output is child individuals 1 and 2, namely child1 and child2, which are the execution order of tasks after crossover processing. First, calculate the length size of the parent individual, and randomly select two indexes start and end respectively, ensuring start < end, to form a crossover interval [start, end]. Then, create 2 child individuals child with length size, namely child1 and child2, and initialize them to all None. Then, copy the genes of parent individual 1 within the interval [start, end] to child individual 1, and select the genes that do not appear in the child from parent individual 2 and fill them into the remaining positions of the child individual in order. Finally, copy the genes of parent individual 2 within the interval [start, end] to child individual 2, and select the genes that do not appear in the child from parent individual 1 and fill them into the remaining positions of the child individual in order. Step 4-4: Construct the mutation mechanism function mutation. The function input is the individual list and mutation_rate. The individual list represents the gene sequence of the individual, which is the execution order of tasks, and mutation_rate is the floating-point mutation probability. First, generate a random number between 0 and 1. If the random number is less than the given mutation probability mutation_rate, then perform the mutation operation; otherwise, keep the individual unchanged. If the mutation condition is satisfied, randomly select two different indexes i and j from the gene sequence of the individual, and then exchange the genes at these two positions. Finally, output the gene sequence individual of the individual after the exchange mutation operation. Step 4 - 5: Set the population size population_size, the number of optimization iterations generations, and the mutation probability mutation_rate. Input num_commands and population_size into the initialize_population function to initialize the population. Then enter the optimization loop, which is repeated generations times. In each optimization iteration, calculate the fitness value of each individual through the objective function objection, select the individual with the best fitness as the best solution of the current generation, and record the best fitness and the optimal individual of the current generation. Select parent individuals from the population according to the selection function, use the crossover function to generate two offspring individuals, apply the mutation function to the generated offspring individuals to increase the diversity of the population. Then add the new individuals generated through crossover and mutation operations to the new population to update the population. After all generations end, output the optimal solution, which is the individual with the highest fitness value in the last generation, representing the optimal execution order of the task.

Images