【问题标题】:Determine allocation of values - Python确定值的分配 - Python
【发布时间】:2019-04-10 03:09:38
【问题描述】:

我正在尝试创建一个最佳的轮班时间表,将员工分配到轮班时间。输出的目标应该是花费最少的钱。棘手的部分是我需要考虑特定的约束。这些是:

1) At any given time period, you must meet the minimum staffing requirements
2) A person has a minimum and maximum amount of hours they can do
3) An employee can only be scheduled to work within their available hours
4) A person can only work one shift per day

staff_availability df 包含可以从['Person'] 中选择的员工、他们可以工作的最小-最大小时数['MinHours']-['MaxHours']、他们获得多少报酬['HourlyWage'],以及可用性,以小时数表示@ 987654327@ 和 15 分钟段 ['Availability_15min_Seg']

注意:如果不需要,不必为可用员工分配轮班。他们只是可以这样做。

staffing_requirements df 包含一天中的时间['Time'] 以及这些时间段内所需的员工['People']

脚本返回一个df'availability_per_member',显示每个时间点有多少员工可用。所以1 表示可以调度,0 表示不可用。然后,它旨在分配班次时间,同时使用pulp 考虑约束。

我得到了输出,但轮班时间没有连续应用于员工。

我没有满足第四个限制条件,即员工每天只能工作一班

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as dates
import pulp

staffing_requirements = pd.DataFrame({
    'Time' : ['0/1/1900 8:00:00','0/1/1900 9:59:00','0/1/1900 10:00:00','0/1/1900 12:29:00','0/1/1900 12:30:00','0/1/1900 13:00:00','0/1/1900 13:02:00','0/1/1900 13:15:00','0/1/1900 13:20:00','0/1/1900 18:10:00','0/1/1900 18:15:00','0/1/1900 18:20:00','0/1/1900 18:25:00','0/1/1900 18:45:00','0/1/1900 18:50:00','0/1/1900 19:05:00','0/1/1900 19:07:00','0/1/1900 21:57:00','0/1/1900 22:00:00','0/1/1900 22:30:00','0/1/1900 22:35:00','1/1/1900 3:00:00','1/1/1900 3:05:00','1/1/1900 3:20:00','1/1/1900 3:25:00'],                 
    'People' : [1,1,2,2,3,3,2,2,3,3,4,4,3,3,2,2,3,3,4,4,3,3,2,2,1],                      
     })

staff_availability = pd.DataFrame({
    'Person' : ['C1','C2','C3','C4','C5','C6','C7','C8','C9','C10','C11'],                 
    'MinHours' : [3,3,3,3,3,3,3,3,3,3,3],    
    'MaxHours' : [10,10,10,10,10,10,10,10,10,10,10],                 
    'HourlyWage' : [26,26,26,26,26,26,26,26,26,26,26],  
    'Availability_Hr' : ['8-18','8-18','8-18','9-18','9-18','9-18','12-1','12-1','17-3','17-3','17-3'],                              
    'Availability_15min_Seg' : ['1-41','1-41','1-41','5-41','5-41','5-41','17-69','17-79','37-79','37-79','37-79'],                              
    })

staffing_requirements['Time'] = ['/'.join([str(int(x.split('/')[0])+1)] + x.split('/')[1:]) for x in staffing_requirements['Time']]
staffing_requirements['Time'] = pd.to_datetime(staffing_requirements['Time'], format='%d/%m/%Y %H:%M:%S')
formatter = dates.DateFormatter('%Y-%m-%d %H:%M:%S') 

# 15 Min
staffing_requirements = staffing_requirements.groupby(pd.Grouper(freq='15T',key='Time'))['People'].max().ffill()
staffing_requirements = staffing_requirements.reset_index(level=['Time'])

staffing_requirements.index = range(1, len(staffing_requirements) + 1) 

staff_availability.set_index('Person')

staff_costs = staff_availability.set_index('Person')[['MinHours', 'MaxHours', 'HourlyWage']]
availability = staff_availability.set_index('Person')[['Availability_15min_Seg']]
availability[['first_15min', 'last_15min']] =  availability['Availability_15min_Seg'].str.split('-', expand=True).astype(int)

availability_per_member =  [pd.DataFrame(1, columns=[idx], index=range(row['first_15min'], row['last_15min']+1))
 for idx, row in availability.iterrows()]

availability_per_member = pd.concat(availability_per_member, axis='columns').fillna(0).astype(int).stack()
availability_per_member.index.names = ['Timeslot', 'Person']
availability_per_member = (availability_per_member.to_frame()
                        .join(staff_costs[['HourlyWage']])
                        .rename(columns={0: 'Available'}))


''' Generate shift times based off availability  '''

prob = pulp.LpProblem('CreateStaffing', pulp.LpMinimize) # Minimize costs

timeslots = staffing_requirements.index
persons = availability_per_member.index.levels[1]

# A member is either staffed or is not at a certain timeslot
staffed = pulp.LpVariable.dicts("staffed",
                                   ((timeslot, staffmember) for timeslot, staffmember 
                                    in availability_per_member.index),
                                     lowBound=0,
                                     cat='Binary')

# Objective = cost (= sum of hourly wages)                              
prob += pulp.lpSum(
    [staffed[timeslot, staffmember] * availability_per_member.loc[(timeslot, staffmember), 'HourlyWage'] 
    for timeslot, staffmember in availability_per_member.index]
)

# Staff the right number of people
for timeslot in timeslots:
    prob += (sum([staffed[(timeslot, person)] for person in persons]) 
    == staffing_requirements.loc[timeslot, 'People'])

# Do not staff unavailable persons
for timeslot in timeslots:
    for person in persons:
        if availability_per_member.loc[(timeslot, person), 'Available'] == 0:
            prob += staffed[timeslot, person] == 0

# Do not underemploy people
for person in persons:
    prob += (sum([staffed[(timeslot, person)] for timeslot in timeslots])
    >= staff_costs.loc[person, 'MinHours']*4) # timeslot is 15 minutes => 4 timeslots = hour

# Do not overemploy people
for person in persons:
    prob += (sum([staffed[(timeslot, person)] for timeslot in timeslots])
    <= staff_costs.loc[person, 'MaxHours']*4) # timeslot is 15 minutes => 4 timeslots = hour


prob.solve()
print(pulp.LpStatus[prob.status])

output = []
for timeslot, staffmember in staffed:
    var_output = {
        'Timeslot': timeslot,
        'Staffmember': staffmember,
        'Staffed': staffed[(timeslot, staffmember)].varValue,
    }
    output.append(var_output)
output_df = pd.DataFrame.from_records(output)#.sort_values(['timeslot', 'staffmember'])
output_df.set_index(['Timeslot', 'Staffmember'], inplace=True)
if pulp.LpStatus[prob.status] == 'Optimal':
    print(output_df)

以下是前两个小时的输出(8 个 15 分钟时隙)。问题是这些转变不是连续的。安排在第一个8 时间段的员工主要是不同的。我会在前 2 小时内有 5 人开始。员工每天只能工作一班。

   Timeslot   C
0         1  C2
1         2  C2
2         3  C1
3         4  C3
4         5  C6
5         6  C1
6         7  C5
7         8  C2

【问题讨论】:

  • 如果您有一个软约束(例如 MinHours 应该是 5,但并非必须如此),我建议您关联一个成本并将其添加到您的目标函数中。
  • 谢谢@ThomasBoeck。因此,我是否应该在 objective 中包含所有约束?
  • 非常酷的问题,我在类似的领域工作,但更多的是预测时间和填补技能空白。我想这是给联络中心的?你有 github 吗?希望看到更多你的代码。
  • 不是联络中心。这是在热情好客。不幸的是,我没有 GitHub。在与其他用户共享之前,我已尝试确定一个可行的选项。
  • 我还没有。分配合适的人数是一个简单的解决方法。但是将轮班时间连续应用于员工让我感到悲痛。我没有有效地满足我的第四个约束。

标签: python pandas linear-programming pulp integer-programming


【解决方案1】:

注意:这是对早期版本问题的回答。


我认为求解器返回的解是正确的;每个人正在工作他们的MinHours,他们只是不连续。我跑了你的代码,然后说

for person in persons:
    print("{}: {}".format(person, sum([staffed[(timeslot, person)].value() for timeslot in timeslots])))

得到:

C1: 12.0
C2: 12.0
C3: 12.0
C4: 20.0
C5: 23.0
C6: 18.0
C7: 22.0
C8: 29.0
C9: 22.0
C10: 27.0
C11: 32.0

所以每个人至少轮班工作 12 个班次,即 3 小时。

如果您希望轮班是连续的(即,一个人不能在第 1 时段工作,然后在第 3 时段工作),那么处理这种情况的典型方法是使用一个决策变量来说明每个员工开始轮班的时间,而不是指定它们工作的每个时间段的变量。然后,引入类似a[j][t] 的参数,如果在槽j 开始轮班的员工正在槽t 工作,则该参数等于1。从那里,您可以计算出谁在哪个时段工作。

当您将MinHours 设置为 5 时,问题不可行的原因是它迫使太多人在某些时间工作。例如,6 人必须在 41 时隙之前完成轮班。这意味着 6 x 4 x 5 = 120 人时隙需要在 41 时隙之前工作。但在时隙 1 和 41 之间只需要 97 人时隙。

如果人员配备系统允许,则可以通过将“配备合适人数的人员”约束更改为 &gt;= 而不是 == 来解决此问题。 (如果不是,那么您手头上只有一个不可行的实例。)

(顺便说一句——您可能对Operations Research and Analytics 上提议的新 Stack Exchange 站点感兴趣。我们将在那边解决类似这样的问题。:-))

【讨论】:

  • 谢谢@grendelsdad。这很有帮助。我去看看那个网站
  • 很好,很高兴它有帮助。如果您认为我的回答足够,请不要忘记接受它。 :)
  • 不用担心。我先看看我怎么走。这是非常有帮助的,但是。我也会在那里发帖。谢谢你
  • 我知道已经有一段时间了,这应该是一个单独的问题,但我有一个关于“配备合适人数的人员”的问题。我不要求为每个员工分配轮班。可用性 df 被确定为涵盖所有情况。我希望员工人数最少。例如,如果需要一个人,只需配备一个人。我不要求每个人都换班。这有意义吗?
【解决方案2】:

这是您修改后问题的答案,即如何添加要求每个员工连续工作时间段的约束。

我建议你添加以下约束(这里用代数写):

x[t+1,p] <= x[t,p] + (1 - (1/T) * sum_{s=1}^{t-1} x[s,p])    for all p, for all t < T

其中x 是您的staffed 变量(此处写为x 是为了简洁),t 是时间索引,T 是时间段数,p 是员工索引.

约束的逻辑是:如果x[t,p] = 0(员工在t期间没有工作)和x[s,p] = 1对于任何s &lt; t(员工在任何以前的期间),那么x[t+1,p]必须= 0(员工不能在t+1期间工作。因此,一旦员工停止工作,他们就无法重新开始。注意如果x[t,p] = 1 x[s,p] = 0 对应每个 s &lt; t,然后 x[t+1,p] 可以等于 1

这是我在pulp 中对这个约束的实现:

# If an employee works and then stops, they can't start again
num_slots = max(timeslots)
for timeslot in timeslots:
    if timeslot < num_slots:
        for person in persons:
            prob += staffed[timeslot+1, person] <= staffed[timeslot, person] + \
                (1 - (1./num_slots) *
                 sum([staffed[(s, person)] for s in timeslots if s < timeslot]))

我运行模型并得到:

Optimal
                      Staffed
Timeslot Staffmember         
1        C2               1.0
2        C2               1.0
3        C2               1.0
4        C2               1.0
5        C2               1.0
6        C2               1.0
7        C2               1.0
8        C2               1.0
9        C2               1.0
         C6               1.0
10       C2               1.0
         C6               1.0
11       C2               1.0
         C6               1.0
12       C2               1.0
         C6               1.0
13       C3               1.0
         C6               1.0
14       C3               1.0
         C6               1.0

等等。因此,员工在连续的时间段内工作。

请注意,新的约束会稍微减慢模型的速度。它仍然可以在

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2023-03-20
    • 1970-01-01
    • 1970-01-01
    • 2020-04-17
    • 2017-06-06
    • 2018-09-07
    • 1970-01-01
    相关资源
    最近更新 更多