當前位置：首頁 > 运维知识 > windows >内容正文

windows

【调度算法】并行机调度问题遗传算法

發布時間：2023/11/16 windows 63 coder

生活随笔收集整理的這篇文章主要介紹了【调度算法】并行机调度问题遗传算法小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

問題描述

m臺相同的機器，n個工件，每個工件有1道工序，可按照任意的工序為每個工件分配一臺機器進行加工

工件	A	B	C	D	E	F	G	H	I
工件編號	0	1	2	3	4	5	6	7	8
加工時間	4	7	6	5	8	3	5	5	10
到達時間	3	2	4	5	3	2	1	8	6
交貨期	10	15	30	24	14	13	20	18	10

設備數目：3

目標函數

最小化交貨期總延時時間

編碼說明

記機器數為m，從0開始編號為0,1,...,m-1，記工件數為n，同樣從0開始編號。

定義兩個變量job_id和job，前者表示工件的加工順序（不是嚴格意義上的先加工A再加工B這種順序，這里的每個工件都是獨立的，整一個id只是為了再分配完機器之后自然就能選出一種加工順序），后者表示每個工件用哪臺機器加工。

例如，job_id=[4, 0, 5, 8, 1, 6, 2, 7, 3]，job=[0, 1, 2, 2, 1, 0, 2, 1, 0]表示“編號為4的工件被分配給了編號為0的機器”，“編號為0的工件被分配給了編號為1的機器”，編號為0的機器上工件加工的先后順序為4,6,3，其余類推。

注意，并行機調度問題里邊對于染色體的編碼一般分為機器選擇部分和工件排序部分，機器選擇部分，就是正常這里應該是先給工件分配機器，再對每臺工件上分配的機器進行排序，但是我這個代碼里就是先直接對工件進行亂序然后再選擇機器，乍一聽好像最后的效果差不多，但是看代碼就會知道，我代碼里是對job_id進行亂序之后，直接就一種群為單位進行選擇交叉變異了。即，一個job_id值對應一個種群（而非一個個體，但是理論上應該是每個個體對對飲過一個不同的順序），就可能會導致處理大規模問題的時候時間復雜度太高（這里確實是偷懶了但是我這兩天看代碼真的看麻了5555，菜是原罪），有能力的好兄弟改好了可以踢我一下。

具體思路可以看這篇：https://blog.csdn.net/qq_38361726/article/details/120669250

運算結果

最佳加工順序： [4, 0, 5, 8, 1, 6, 2, 7, 3]
最佳調度分配： [0, 1, 2, 2, 1, 0, 2, 1, 0]
最小交貨期延時時間： 7

python代碼

import random
import numpy as np
import matplotlib.pyplot as plt
import copy


# 定義遺傳算法參數
POP_SIZE = 100  # 種群大小
MAX_GEN = 100  # 最大迭代次數
CROSSOVER_RATE = 0.7  # 交叉概率
MUTATION_RATE = 0.2  # 變異概率


def sort_by_id(id, sequence):
    # 根據id對sequence進行排序
    new_sequence = sequence[:]
    for i in range(len(id)):
        sequence[i] = new_sequence[id[i]]


# 隨機生成初始種群，這里的每個個體表示第i個工件選擇在第choose[i]臺機器進行加工，工件和機器編碼都是從0開始
def get_init_pop(pop_size):
    pop = []
    for _ in range(pop_size):
        choose = []
        for _ in range(len(job_id)):
            choose.append(random.randint(0, machine_num - 1))
        pop.append(list(choose))
    return pop


# 計算染色體的適應度（makespan） 以最小化交貨期延時為目標函數，這里計算的是交貨期總延時時間
def fitness(job):
    delay_times = [[] for _ in range(machine_num)]  # 每個工件超過交貨期的延時時間
    finish_times = [[] for _ in range(machine_num)]  # 每個工件完成加工的時間點
    for i in range(len(job)):
        if finish_times[job[i]]:
            finish_times[job[i]].append(
                pro_times[job_id[i]] + max(finish_times[job[i]][-1], arr_times[job_id[i]]))
        else:
            finish_times[job[i]].append(pro_times[job_id[i]] + arr_times[job_id[i]])
        delay_times[job[i]].append(max(finish_times[job[i]][-1] - deadlines[job_id[i]], 0))

    return sum(element for sublist in delay_times for element in sublist)


# 選擇父代，這里選擇POP_SIZE/2個作為父代
def selection(pop):
    fitness_values = [1 / fitness(job) for job in pop]  # 以最小化交貨期總延時為目標函數，這里把最小化問題轉變為最大化問題
    total_fitness = sum(fitness_values)
    prob = [fitness_value / total_fitness for fitness_value in fitness_values]  # 輪盤賭，這里是每個適應度值被選中的概率
    # 按概率分布prob從區間[0,len(pop))中隨機抽取size個元素，不允許重復抽取，即輪盤賭選擇
    selected_indices = np.random.choice(len(pop), size=POP_SIZE // 2, p=prob, replace=False)
    return [pop[i] for i in selected_indices]


# 交叉操作 這里是單點交叉
def crossover(job_p1, job_p2):
    cross_point = random.randint(1, len(job_p1) - 1)
    job_c1 = job_p1[:cross_point] + job_p2[cross_point:]
    job_c2 = job_p2[:cross_point] + job_p1[cross_point:]
    return job_c1, job_c2


# 變異操作
def mutation(job):
    index = random.randint(0, len(job) - 1)
    job[index] = random.randint(0, machine_num - 1)  # 這樣的話變異概率可以設置得大一點，因為實際的變異概率是MUTATION_RATE*(machine_num-1)/machine_num
    return job


# 主遺傳算法循環
# 以最小化延遲交貨時間為目標函數
# TODO: 沒有考慮各機器的負載均衡
def GA(is_shuffle):  # 工件加工順序是否為無序
    best_id = job_id  # 初始化job_id
    best_job = [0, 0, 0, 0, 0, 0, 0, 0, 0]  # 獲得最佳個體
    # "makespan" 是指完成整個生產作業或生產訂單所需的總時間，通常以單位時間（例如小時或分鐘）來衡量。
    best_makespan = fitness(best_job)  # 獲得最佳個體的適應度值
    # 創建一個空列表來存儲每代的適應度值
    fitness_history = [best_makespan]

    pop = get_init_pop(POP_SIZE)
    for _ in range(1, MAX_GEN + 1):
        if is_shuffle:
            random.shuffle(job_id)
        pop = selection(pop)  # 選擇
        new_population = []

        while len(new_population) < POP_SIZE:
            parent1, parent2 = random.sample(pop, 2)  # 不重復抽樣2個
            if random.random() < CROSSOVER_RATE:
                child1, child2 = crossover(parent1, parent2)  # 交叉
                new_population.extend([child1, child2])
            else:
                new_population.extend([parent1, parent2])

        pop = [mutation(job) if random.random() < MUTATION_RATE else job for job in new_population]
        best_gen_job = min(pop, key=lambda x: fitness(x))
        best_gen_makespan = fitness(best_gen_job)  # 每一次迭代獲得最佳個體的適應度值

        if best_gen_makespan < best_makespan:  # 更新最小fitness值
            best_makespan = best_gen_makespan
            best_job = copy.deepcopy(best_gen_job)  # TODO: 不用deepcopy的話不會迭代，但是這里應該有更好的方法
            best_id = copy.deepcopy(job_id)
        fitness_history.append(best_makespan)  # 把本次迭代結果保存到fitness_history中（用于繪迭代曲線）

    # 繪制迭代曲線圖
    plt.plot(range(MAX_GEN + 1), fitness_history)
    plt.xlabel('Generation')
    plt.ylabel('Fitness Value')
    plt.title('Genetic Algorithm Convergence')
    plt.show()

    return best_id, best_job, best_makespan


def plot_gantt(job_id, job):
    # 準備一系列顏色
    colors = ['blue', 'yellow', 'orange', 'green', 'palegoldenrod', 'purple', 'pink', 'Thistle', 'Magenta', 'SlateBlue',
              'RoyalBlue', 'Cyan', 'Aqua', 'floralwhite', 'ghostwhite', 'goldenrod', 'mediumslateblue', 'navajowhite',
              'moccasin', 'white', 'navy', 'sandybrown', 'moccasin']
    job_colors = random.sample(colors, len(job))
    # 計算每個工件的開始時間和結束時間
    start_time = [[] for _ in range(machine_num)]
    end_time = [[] for _ in range(machine_num)]
    id = [[] for _ in range(machine_num)]
    job_color = [[] for _ in range(machine_num)]

    for i in range(len(job)):
        if start_time[job[i]]:
            start_time[job[i]].append(max(end_time[job[i]][-1], arr_times[job_id[i]]))
            end_time[job[i]].append(start_time[job[i]][-1] + pro_times[job_id[i]])
        else:
            start_time[job[i]].append(arr_times[job_id[i]])
            end_time[job[i]].append(start_time[job[i]][-1] + pro_times[job_id[i]])
        id[job[i]].append(job_id[i])
        job_color[job[i]].append(job_colors[job_id[i]])

    # 創建圖表和子圖
    plt.figure(figsize=(12, 6))

    # 繪制工序的甘特圖
    for i in range(len(start_time)):
        for j in range(len(start_time[i])):
            plt.barh(i, end_time[i][j] - start_time[i][j], height=0.5, left=start_time[i][j], color=job_color[i][j],
                     edgecolor='black')
            plt.text(x=(start_time[i][j] + end_time[i][j]) / 2, y=i, s=id[i][j], fontsize=14)

    # 設置縱坐標軸刻度為機器編號
    machines = [f'Machine {i}' for i in range(len(start_time))]
    plt.yticks(range(len(machines)), machines)

    # 設置橫坐標軸刻度為時間
    # start = min([min(row) for row in start_time])
    start = 0
    end = max([max(row) for row in end_time])
    plt.xticks(range(start, end + 1))
    plt.xlabel('Time')

    # 圖表樣式設置
    plt.ylabel('Machines')
    plt.title('Gantt Chart')
    # plt.grid(axis='x')

    # 自動調整圖表布局
    plt.tight_layout()

    # 顯示圖表
    plt.show()


if __name__ == '__main__':
    # 定義多機調度問題的工件和加工時間
    job_id =    [0, 1, 2, 3, 4, 5, 6, 7, 8]  # 工件編號
    pro_times = [4, 7, 6, 5, 8, 3, 5, 5, 10]  # 加工時間
    arr_times = [3, 2, 4, 5, 3, 2, 1, 8, 6]  # 到達時間
    deadlines = [10, 15, 30, 24, 14, 13, 20, 18, 10]  # 交貨期
    machine_num = 3  # 3臺完全相同的并行機，編號為0,1,2

    job_id, best_job, best_makespan = GA(True)

    print("最佳加工順序：", job_id)
    print("最佳調度分配：", best_job)
    print("最小交貨期延時時間：", best_makespan)
    plot_gantt(job_id, best_job)

總結

以上是生活随笔為你收集整理的【调度算法】并行机调度问题遗传算法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

算法