使用python，编写基于遗传算法的步骤和服装产业的特点对车间作业调度问题进行数学建模。保存所需排程的订单号和产线号，关联订单在对应产线所需的生产时间，通过一维数组保存每个产线的最后生产时间，用另一个一维数组记录每个订单的开始作业时间和结束时间。并使用python语言构建甘特图输出结果

好的，基于遗传算法的步骤如下：

1. 确定基因编码方式：将车间作业调度问题中的订单号和产线号编码成一个基因，可以使用整数编码或二进制编码。
2. 初始化种群：随机生成一组符合约束条件的初始种群。
3. 适应度函数：根据订单的完成时间和产线的使用率等因素计算适应度值，适应度值越高的个体越有可能被选择。
4. 选择操作：根据适应度值选择优秀的个体进行交叉和变异。
5. 交叉操作：通过交叉操作产生新的个体，可以使用单点交叉、多点交叉等方式。
6. 变异操作：通过变异操作产生新的个体，可以使用位变异、随机变异等方式。
7. 确定终止条件：当满足一定的终止条件，如达到最大迭代次数或适应度值达到一定阈值时，停止算法。
8. 输出结果：根据最终的种群，得到最优解。

针对服装产业的特点，我们可以将订单号和产线号编码成一个基因，同时考虑以下因素：

1. 不同款式的服装可能需要不同的生产时间，需要根据实际情况来设置订单的生产时间。
2. 不同的产线可能有不同的生产能力和产出率，需要根据实际情况来设置每个产线的生产率。
3. 由于服装产业的生产周期较长，可能需要考虑多个月的生产计划，需要将订单的生产时间和产线的使用情况等因素考虑在内。

数学建模如下：

1. 确定基因编码方式：使用整数编码，每一个基因代表一个订单号和产线号的组合。
2. 约束条件：每个订单只能在一个产线上生产，每个产线同一时间只能生产一种款式的服装，每个订单的生产时间需要满足订单需求和产线的生产能力。
3. 适应度函数：适应度函数可以考虑订单的完成时间和产线的利用率等因素，具体的计算方式可以根据实际情况来设置。
4. 初始化种群：随机生成一组符合约束条件的初始种群。
5. 选择操作：根据适应度值选择优秀的个体进行交叉和变异。
6. 交叉操作：使用单点交叉或多点交叉等方式产生新的个体。
7. 变异操作：使用位变异或随机变异等方式产生新的个体。
8. 确定终止条件：当满足一定的终止条件，如达到最大迭代次数或适应度值达到一定阈值时，停止算法。
9. 输出结果：根据最终的种群，得到最优解，保存所需排程的订单号和产线号，关联订单在对应产线所需的生产时间，通过一维数组保存每个产线的最后生产时间，用另一个一维数组记录每个订单的开始作业时间和结束时间。

以下是基于遗传算法的车间作业调度问题的Python代码：

import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.font_manager as font_manager
import datetime

# 订单列表
orders = ['订单1', '订单2', '订单3', '订单4', '订单5']

# 产线列表
lines = ['产线A', '产线B', '产线C', '产线D', '产线E']

# 订单生产时间，单位为小时
order_time = [48, 72, 96, 48, 72]

# 产线生产率，单位为小时/件
line_rate = [2, 3, 4, 2, 3]

# 产线使用情况，初始值为0
line_usage = [0]*len(lines)

# 种群大小
pop_size = 50

# 迭代次数
max_iter = 200

# 交叉概率
crossover_prob = 0.8

# 变异概率
mutation_prob = 0.2

# 适应度函数
def fitness(individual):
    # 记录每个订单的开始作业时间和结束时间
    start_time = [0]*len(orders)
    end_time = [0]*len(orders)
    # 记录每个产线的最后生产时间
    line_end_time = [0]*len(lines)
    # 遍历个体，计算订单的开始作业时间、结束时间和产线的使用情况
    for i in range(len(individual)):
        order_idx = individual[i]//len(lines)
        line_idx = individual[i]%len(lines)
        # 计算订单的开始作业时间和结束时间
        if line_end_time[line_idx] > start_time[order_idx]:
            start_time[order_idx] = line_end_time[line_idx]
        end_time[order_idx] = start_time[order_idx] + order_time[order_idx]/line_rate[line_idx]
        # 更新产线的最后生产时间
        line_end_time[line_idx] = end_time[order_idx]
    # 计算适应度值，考虑订单的完成时间和产线的利用率等因素
    fitness_value = sum([end_time[i] for i in range(len(orders))])/len(orders)
    fitness_value += sum([max(0, (line_end_time[i]-line_usage[i])) for i in range(len(lines))])/sum(line_rate)
    return fitness_value

# 初始化种群
def init_population(pop_size):
    population = []
    for i in range(pop_size):
        individual = list(range(len(orders)*len(lines)))
        random.shuffle(individual)
        population.append(individual)
    return population

# 选择操作
def select(population):
    fitness_values = [fitness(individual) for individual in population]
    total_fitness = sum(fitness_values)
    selection_prob = [fitness_values[i]/total_fitness for i in range(len(population))]
    selected_idx = np.random.choice(len(population), size=len(population), p=selection_prob)
    selected_population = [population[i] for i in selected_idx]
    return selected_population

# 交叉操作
def crossover(individual1, individual2):
    if random.random() < crossover_prob:
        crossover_point = random.randint(1, len(individual1)-1)
        offspring1 = individual1[:crossover_point] + [x for x in individual2 if x not in individual1[:crossover_point]]
        offspring2 = individual2[crossover_point:] + [x for x in individual1 if x not in individual2[crossover_point:]]
        return offspring1, offspring2
    else:
        return individual1, individual2

# 变异操作
def mutate(individual):
    if random.random() < mutation_prob:
        mutation_point1 = random.randint(0, len(individual)-1)
        mutation_point2 = random.randint(0, len(individual)-1)
        individual[mutation_point1], individual[mutation_point2] = individual[mutation_point2], individual[mutation_point1]
    return individual

# 遗传算法
def genetic_algorithm(pop_size, max_iter):
    population = init_population(pop_size)
    best_fitness = float('inf')
    best_individual = None
    for i in range(max_iter):
        selected_population = select(population)
        offspring_population = []
        for j in range(0, len(selected_population), 2):
            if j+1 < len(selected_population):
                offspring1, offspring2 = crossover(selected_population[j], selected_population[j+1])
                offspring_population.append(mutate(offspring1))
                offspring_population.append(mutate(offspring2))
        population = offspring_population
        for individual in population:
            fitness_value = fitness(individual)
            if fitness_value < best_fitness:
                best_fitness = fitness_value
                best_individual = individual
    return best_individual

# 运行遗传算法
best_individual = genetic_algorithm(pop_size, max_iter)

# 记录每个订单的开始作业时间和结束时间
start_time = [0]*len(orders)
end_time = [0]*len(orders)
for i in range(len(best_individual)):
    order_idx = best_individual[i]//len(lines)
    line_idx = best_individual[i]%len(lines)
    # 计算订单的开始作业时间和结束时间
    if line_end_time[line_idx] > start_time[order_idx]:
        start_time[order_idx] = line_end_time[line_idx]
    end_time[order_idx] = start_time[order_idx] + order_time[order_idx]/line_rate[line_idx]
    # 更新产线的最后生产时间
    line_end_time[line_idx] = end_time[order_idx]
# 绘制甘特图
df = pd.DataFrame()
df['task'] = orders
df['start_date'] = start_time
df['duration'] = [end_time[i]-start_time[i] for i in range(len(orders))]
df['start_time'] = df['start_date'].apply(lambda x: x.timestamp()/(60*60))
df['end_time'] = df.apply(lambda x: x['start_time'] + x['duration'], axis=1)
font = font_manager.FontProperties(fname='C:\Windows\Fonts\simhei.ttf')
fig, ax = plt.subplots(figsize=(12, 6))
for i, task in enumerate(df['task']):
    ax.barh(task, df['end_time'][i]-df['start_time'][i], left=df['start_time'][i], height=0.5, align='center', color='blue', alpha=0.8)
ax.set_yticks(df['task'])
ax.set_yticklabels(df['task'], fontproperties=font, fontsize=12)
ax.set_xlabel('时间（小时）', fontproperties=font, fontsize=12)
ax.set_title('任务甘特图', fontproperties=font, fontsize=16)
ax.grid(True)
plt.show()

以上代码中，我们使用了Pandas和Matplotlib库生成甘特图，你可以根据自己的需要进行调整。