wave-planning-optimization

波次计划优化

你是仓库波次计划和订单释放优化方面的专家。你的目标是帮助设计和优化拣货波次，以最大限度提高拣货员的生产效率、平衡工作量、满足截单时间，并提升整体履约效率。

初步评估

优化波次计划之前，请先了解：

1. 运营特点

   • 每日订单量（订单行数和件数）是多少？
   • 订单类型有哪些（单件拣选、整箱拣选、整托盘拣选）？
   • 仓库有哪些区域和拣货方式？
   • 班次如何安排？可用人力有多少？
   • 当前波次频率和规模如何？

2. 业务需求

   • 发货截单时间是什么时候？
   • 优先订单类型有哪些（当日达、次日达）？
   • 客户 SLA 和承诺是什么？
   • 承运商的揽收计划如何？
   • 订单构成如何（单行订单还是多行订单）？

3. 约束条件

   • 设备产能如何（输送机、分拣机）？
   • 包装工位的产能如何？
   • 有哪些可用的发货月台门？
   • 各班次的人力供应情况如何？
   • WMS 的功能和限制有哪些？

4. 绩效指标

   • 当前每小时拣货量是多少？
   • 订单周期时间（订单 → 发货）是多少？
   • 人力利用率如何？
   • 准时发货表现如何？
   • 波次完成率如何？

---

波次计划框架

波次设计原则

1. 波次规模

• 小波次（50-200 个订单）

  • 优点：灵活、完成速度快、易于重新组波
  • 缺点：释放频率更高，管理开销更大
  • 适用场景：需求变化大、截单时间频繁

• 中等波次（200-500 个订单）

  • 优点：工作量均衡，设备利用率高
  • 缺点：波次之间可能出现一些空闲时间
  • 适用场景：标准运营、中等订单量

• 大波次（500-1000+ 个订单）

  • 优点：效率最高，释放次数更少
  • 缺点：灵活性较差，周期时间更长
  • 适用场景：订单量大、需求稳定

2. 波次频率

• 连续波次：前一波次完成后立即释放新波次
• 固定计划：每隔 2-4 小时（例如，8am、12pm、4pm）
• 动态计划：根据订单累积量阈值触发
• 准时制：与承运商揽收时间相匹配

3. 波次构成

• 按区域划分：包含所有发往某个仓库区域的订单
• 按订单类型划分：分别处理优先、标准和大宗订单
• 按客户划分：按客户或收货地区分组
• 按承运商划分：按发货承运商分组
• 混合方式：结合上述方式

波次优化目标

Primary Goals:
1. Maximize picker productivity (picks/hour)
2. Balance workload across zones/pickers
3. Meet shipping cutoff times
4. Minimize labor cost
5. Maximize equipment utilization

Trade-offs:
- Large waves → Higher efficiency BUT Longer cycle time
- Small waves → Faster cycle time BUT Lower efficiency
- Balanced waves → Even workload BUT May miss optimal picking

---

数学建模

波次计划优化模型

决策变量：

• x[o,w] = 如果订单 o 分配到波次 w，则为 1；否则为 0
• y[w] = 如果使用波次 w，则为 1；否则为 0
• t[w] = 波次 w 的开始时间
• z[w,z] = 波次 w 中区域 z 的工作量（订单行数）

参数：

• L[o] = 订单 o 的拣货行数
• Z[o,z] = 订单 o 在区域 z 的行数
• D[o] = 订单 o 的截止时间
• P = 拣货员生产率（行/小时）
• W_min, W_max = 每个波次的最小/最大行数
• N_pickers[z] = 区域 z 的拣货员人数

目标函数：

Minimize:
  α × (Number of waves)              # Minimize wave releases
  + β × (Total completion time)      # Minimize cycle time
  + γ × (Workload imbalance)         # Balance zones
  + δ × (Late orders penalty)        # Meet deadlines

Formally:
  α × Σ y[w]
  + β × Σ (t[w] + duration[w])
  + γ × Σ (max_workload[w] - min_workload[w])
  + δ × Σ max(0, completion[o] - D[o])

约束条件：

# 1. Each order in exactly one wave
for o in orders:
    Σ x[o,w] = 1  for all w

# 2. Wave size limits
for w in waves:
    W_min × y[w] ≤ Σ (L[o] × x[o,w]) ≤ W_max × y[w]  for all o

# 3. Meet deadlines
for o in orders:
    for w in waves:
        if x[o,w] = 1:
            t[w] + processing_time[w] ≤ D[o]

# 4. Zone workload calculation
for w in waves:
    for z in zones:
        z[w,z] = Σ (Z[o,z] × x[o,w])  for all o

# 5. Workload feasibility (can complete in shift)
for w in waves:
    for z in zones:
        z[w,z] / (N_pickers[z] × P) ≤ shift_duration

# 6. Wave sequencing
for w in 1..W-1:
    t[w] + duration[w] ≤ t[w+1]

---

波次计划算法

贪心波次构建

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def greedy_wave_planning(orders, max_wave_size=500, max_waves=10):
    """
    Build waves using greedy heuristic

    Sort orders by priority/deadline, then fill waves

    Parameters:
    -----------
    orders : DataFrame
        Columns: order_id, lines, deadline, priority, zone
    max_wave_size : int
        Maximum lines per wave
    max_waves : int
        Maximum number of waves

    Returns:
    --------
    Wave assignments
    """

    # Sort orders: priority first, then deadline
    orders_sorted = orders.sort_values(
        ['priority', 'deadline', 'lines'],
        ascending=[False, True, False]
    )

    waves = []
    current_wave = {
        'wave_id': 1,
        'orders': [],
        'total_lines': 0,
        'zones': {}
    }

    for idx, order in orders_sorted.iterrows():
        order_lines = order['lines']
        order_zone = order.get('zone', 'default')

        # Check if adding order exceeds wave size
        if current_wave['total_lines'] + order_lines <= max_wave_size:
            # Add to current wave
            current_wave['orders'].append(order['order_id'])
            current_wave['total_lines'] += order_lines

            # Track zone distribution
            if order_zone not in current_wave['zones']:
                current_wave['zones'][order_zone] = 0
            current_wave['zones'][order_zone] += order_lines

        else:
            # Start new wave
            waves.append(current_wave)

            if len(waves) >= max_waves:
                break

            current_wave = {
                'wave_id': len(waves) + 1,
                'orders': [order['order_id']],
                'total_lines': order_lines,
                'zones': {order_zone: order_lines}
            }

    # Add final wave
    if current_wave['orders'] and len(waves) < max_waves:
        waves.append(current_wave)

    return pd.DataFrame(waves)


# Example usage
orders = pd.DataFrame({
    'order_id': [f'ORD{i:04d}' for i in range(1, 101)],
    'lines': np.random.randint(1, 50, 100),
    'deadline': pd.date_range('2024-01-01 16:00', periods=100, freq='H'),
    'priority': np.random.choice([1, 2, 3], 100),
    'zone': np.random.choice(['A', 'B', 'C'], 100)
})

waves = greedy_wave_planning(orders, max_wave_size=400, max_waves=8)

print("Wave Planning Results:")
print(f"Total Waves: {len(waves)}")
print("\nWave Summary:")
for _, wave in waves.iterrows():
    print(f"Wave {wave['wave_id']}: {len(wave['orders'])} orders, "
          f"{wave['total_lines']} lines, Zones: {wave['zones']}")

均衡波次计划

def balanced_wave_planning(orders, num_waves, zones):
    """
    Create balanced waves across zones to even workload

    Parameters:
    -----------
    orders : DataFrame
        Order data with zone distribution
    num_waves : int
        Number of waves to create
    zones : list
        Zone identifiers

    Returns:
    --------
    Balanced wave assignments
    """

    # Calculate zone distribution for each order
    order_zone_lines = {}
    for idx, order in orders.iterrows():
        order_id = order['order_id']
        # Assume we have zone breakdown (simplified: random here)
        zone_dist = {z: np.random.randint(0, order['lines'] // len(zones) + 1)
                    for z in zones}
        order_zone_lines[order_id] = zone_dist

    # Initialize waves
    waves = [{
        'wave_id': w + 1,
        'orders': [],
        'zone_lines': {z: 0 for z in zones},
        'total_lines': 0
    } for w in range(num_waves)]

    # Sort orders by total lines (largest first for better packing)
    orders_sorted = orders.sort_values('lines', ascending=False)

    # Assign each order to wave with minimum workload imbalance
    for idx, order in orders_sorted.iterrows():
        order_id = order['order_id']
        zone_dist = order_zone_lines[order_id]

        # Find wave that minimizes maximum zone workload
        best_wave_idx = None
        best_balance_score = float('inf')

        for w_idx, wave in enumerate(waves):
            # Calculate new zone workloads if order added
            new_zone_loads = {}
            for z in zones:
                new_zone_loads[z] = wave['zone_lines'][z] + zone_dist[z]

            # Balance score: range of zone workloads
            max_load = max(new_zone_loads.values())
            min_load = min(new_zone_loads.values())
            balance_score = max_load - min_load

            if balance_score < best_balance_score:
                best_balance_score = balance_score
                best_wave_idx = w_idx

        # Assign order to best wave
        waves[best_wave_idx]['orders'].append(order_id)
        waves[best_wave_idx]['total_lines'] += order['lines']
        for z in zones:
            waves[best_wave_idx]['zone_lines'][z] += zone_dist[order_id][z]

    return pd.DataFrame(waves)


# Example
zones = ['Zone_A', 'Zone_B', 'Zone_C']
balanced_waves = balanced_wave_planning(orders, num_waves=5, zones=zones)

print("\nBalanced Wave Planning:")
for _, wave in balanced_waves.iterrows():
    print(f"Wave {wave['wave_id']}: {len(wave['orders'])} orders")
    print(f"  Zone distribution: {wave['zone_lines']}")
    max_zone = max(wave['zone_lines'].values())
    min_zone = min(wave['zone_lines'].values())
    print(f"  Balance: {max_zone - min_zone} lines difference\n")

基于 MIP 的波次优化

from pulp import *

def optimize_wave_planning(orders_df, num_waves, zone_productivity,
                           shift_hours=8, min_wave_size=100):
    """
    Optimize wave planning using Mixed-Integer Programming

    Parameters:
    -----------
    orders_df : DataFrame
        Order data: order_id, lines, deadline, zone_breakdown
    num_waves : int
        Number of waves to plan
    zone_productivity : dict
        {zone: lines_per_hour_per_picker}
    shift_hours : float
        Hours available per shift
    min_wave_size : int
        Minimum lines per wave

    Returns:
    --------
    Optimal wave assignments
    """

    orders = orders_df['order_id'].tolist()
    waves = list(range(num_waves))
    zones = list(zone_productivity.keys())

    # Create problem
    prob = LpProblem("Wave_Planning", LpMinimize)

    # Decision variables
    # x[o,w] = 1 if order o in wave w
    x = LpVariable.dicts("assign",
                        [(o, w) for o in orders for w in waves],
                        cat='Binary')

    # y[w] = 1 if wave w is used
    y = LpVariable.dicts("use_wave",
                        waves,
                        cat='Binary')

    # Workload variables
    workload = LpVariable.dicts("workload",
                               [(w, z) for w in waves for z in zones],
                               lowBound=0,
                               cat='Continuous')

    # Max workload per wave (for balancing)
    max_workload = LpVariable.dicts("max_load",
                                   waves,
                                   lowBound=0,
                                   cat='Continuous')

    # Objective: Minimize number of waves + balance workload
    prob += (
        100 * lpSum([y[w] for w in waves]) +  # Minimize waves
        lpSum([max_workload[w] for w in waves])  # Balance workload
    ), "Objective"

    # Constraints

    # 1. Each order in exactly one wave
    for o in orders:
        prob += lpSum([x[o, w] for w in waves]) == 1, f"Order_{o}"

    # 2. Calculate workload per wave per zone
    for w in waves:
        for z in zones:
            # Simplified: assume equal zone distribution
            # In practice, would have actual zone breakdown per order
            prob += workload[w, z] == lpSum([
                orders_df.loc[orders_df['order_id'] == o, 'lines'].values[0] / len(zones) * x[o, w]
                for o in orders
            ]), f"Workload_{w}_{z}"

    # 3. Track maximum workload per wave
    for w in waves:
        for z in zones:
            prob += max_workload[w] >= workload[w, z], f"MaxLoad_{w}_{z}"

    # 4. Wave size constraints
    for w in waves:
        total_lines = lpSum([
            orders_df.loc[orders_df['order_id'] == o, 'lines'].values[0] * x[o, w]
            for o in orders
        ])

        # Minimum wave size
        prob += total_lines >= min_wave_size * y[w], f"MinSize_{w}"

        # Maximum wave size (implicit from shift capacity)
        # Total lines must be completable in shift
        prob += total_lines <= shift_hours * sum(zone_productivity.values()) * y[w], \
                f"MaxSize_{w}"

    # 5. Link order assignment to wave usage
    for w in waves:
        for o in orders:
            prob += x[o, w] <= y[w], f"Link_{o}_{w}"

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract solution
    wave_assignments = []
    for w in waves:
        if y[w].varValue > 0.5:
            wave_orders = [o for o in orders if x[o, w].varValue > 0.5]
            total_lines = sum(
                orders_df.loc[orders_df['order_id'] == o, 'lines'].values[0]
                for o in wave_orders
            )

            wave_workloads = {
                z: workload[w, z].varValue for z in zones
            }

            wave_assignments.append({
                'wave_id': w + 1,
                'orders': wave_orders,
                'num_orders': len(wave_orders),
                'total_lines': total_lines,
                'zone_workloads': wave_workloads,
                'max_zone_workload': max_workload[w].varValue
            })

    return {
        'status': LpStatus[prob.status],
        'objective': value(prob.objective),
        'waves': pd.DataFrame(wave_assignments)
    }


# Example
zone_productivity = {'Zone_A': 100, 'Zone_B': 120, 'Zone_C': 110}  # lines/hour

result = optimize_wave_planning(
    orders.head(50),  # Use subset for faster solving
    num_waves=6,
    zone_productivity=zone_productivity,
    shift_hours=8,
    min_wave_size=80
)

print(f"\nOptimization Status: {result['status']}")
print(f"Objective Value: {result['objective']:.2f}")
print("\nOptimal Waves:")
print(result['waves'][['wave_id', 'num_orders', 'total_lines', 'max_zone_workload']])

---

高级波次计划技术

动态波次释放策略

class DynamicWaveManager:
    """
    Manage dynamic wave releases based on order accumulation
    """

    def __init__(self, target_wave_size=400, min_wave_size=200,
                 release_threshold=0.9):
        self.target_wave_size = target_wave_size
        self.min_wave_size = min_wave_size
        self.release_threshold = release_threshold
        self.pending_orders = []
        self.released_waves = []

    def add_order(self, order):
        """Add new order to pending queue"""
        self.pending_orders.append(order)

    def should_release_wave(self):
        """
        Determine if wave should be released

        Release criteria:
        1. Accumulated lines >= target size
        2. Oldest order waiting > max_wait_time
        3. Cutoff time approaching
        """

        total_lines = sum(o['lines'] for o in self.pending_orders)

        # Criterion 1: Size threshold
        if total_lines >= self.target_wave_size * self.release_threshold:
            return True, "Size threshold reached"

        # Criterion 2: Max wait time (simplified)
        if len(self.pending_orders) > 0:
            oldest_order_time = min(o['received_time'] for o in self.pending_orders)
            wait_minutes = (datetime.now() - oldest_order_time).total_seconds() / 60

            if wait_minutes > 120:  # 2 hours max wait
                return True, "Max wait time exceeded"

        # Criterion 3: Minimum size and approaching cutoff
        if total_lines >= self.min_wave_size:
            # Check if cutoff approaching (simplified)
            return True, "Minimum size reached, release to avoid rush"

        return False, "Not ready"

    def release_wave(self):
        """Release wave from pending orders"""

        if len(self.pending_orders) == 0:
            return None

        # Take up to target_wave_size
        wave_orders = []
        total_lines = 0

        # Sort by priority and deadline
        sorted_orders = sorted(
            self.pending_orders,
            key=lambda x: (x.get('priority', 0), x.get('deadline', datetime.max)),
            reverse=True
        )

        for order in sorted_orders:
            if total_lines + order['lines'] <= self.target_wave_size:
                wave_orders.append(order)
                total_lines += order['lines']

        # Remove released orders from pending
        for order in wave_orders:
            self.pending_orders.remove(order)

        wave = {
            'wave_id': len(self.released_waves) + 1,
            'orders': wave_orders,
            'total_lines': total_lines,
            'release_time': datetime.now()
        }

        self.released_waves.append(wave)

        return wave

    def get_pending_summary(self):
        """Get summary of pending orders"""
        return {
            'num_orders': len(self.pending_orders),
            'total_lines': sum(o['lines'] for o in self.pending_orders),
            'oldest_order': min((o['received_time'] for o in self.pending_orders),
                              default=None)
        }


# Example usage
manager = DynamicWaveManager(target_wave_size=500, min_wave_size=200)

# Simulate order arrivals
for i in range(30):
    order = {
        'order_id': f'ORD{i:04d}',
        'lines': np.random.randint(10, 50),
        'priority': np.random.choice([1, 2, 3]),
        'deadline': datetime.now() + timedelta(hours=4),
        'received_time': datetime.now() - timedelta(minutes=np.random.randint(0, 180))
    }
    manager.add_order(order)

# Check if should release
should_release, reason = manager.should_release_wave()
print(f"Should release wave: {should_release} ({reason})")

if should_release:
    wave = manager.release_wave()
    print(f"\nReleased Wave {wave['wave_id']}:")
    print(f"  Orders: {len(wave['orders'])}")
    print(f"  Lines: {wave['total_lines']}")

pending = manager.get_pending_summary()
print(f"\nPending Orders: {pending['num_orders']} orders, {pending['total_lines']} lines")

多班次波次计划

def plan_multi_shift_waves(orders, shifts, pickers_per_shift,
                           productivity=100):
    """
    Plan waves across multiple shifts

    Parameters:
    -----------
    orders : DataFrame
        All orders to fulfill
    shifts : list of dict
        [{shift_id, start_time, end_time, hours}, ...]
    pickers_per_shift : dict
        {shift_id: num_pickers}
    productivity : float
        Lines per hour per picker

    Returns:
    --------
    Wave plan with shift assignments
    """

    # Calculate capacity per shift
    shift_capacity = {}
    for shift in shifts:
        shift_id = shift['shift_id']
        capacity = (pickers_per_shift[shift_id] *
                   shift['hours'] *
                   productivity)
        shift_capacity[shift_id] = capacity

    # Sort orders by deadline
    orders_sorted = orders.sort_values('deadline')

    shift_assignments = {shift['shift_id']: [] for shift in shifts}
    shift_loads = {shift['shift_id']: 0 for shift in shifts}

    # Assign orders to shifts
    for idx, order in orders_sorted.iterrows():
        order_lines = order['lines']
        deadline = order['deadline']

        # Find earliest shift that can handle this order and meet deadline
        assigned = False
        for shift in shifts:
            shift_id = shift['shift_id']

            # Check if shift can complete before deadline
            if shift['end_time'] <= deadline:
                # Check if capacity available
                if shift_loads[shift_id] + order_lines <= shift_capacity[shift_id]:
                    shift_assignments[shift_id].append(order['order_id'])
                    shift_loads[shift_id] += order_lines
                    assigned = True
                    break

        if not assigned:
            print(f"Warning: Could not assign order {order['order_id']}")

    # Create waves within each shift
    all_waves = []
    wave_counter = 1

    for shift in shifts:
        shift_id = shift['shift_id']
        shift_orders = shift_assignments[shift_id]

        if not shift_orders:
            continue

        # Split shift into waves (e.g., 2 waves per 8-hour shift)
        num_waves_per_shift = max(1, int(shift['hours'] / 4))
        orders_per_wave = len(shift_orders) // num_waves_per_shift

        for w in range(num_waves_per_shift):
            start_idx = w * orders_per_wave
            end_idx = start_idx + orders_per_wave if w < num_waves_per_shift - 1 else len(shift_orders)

            wave_orders = shift_orders[start_idx:end_idx]
            wave_lines = sum(
                orders.loc[orders['order_id'] == o, 'lines'].values[0]
                for o in wave_orders
            )

            all_waves.append({
                'wave_id': wave_counter,
                'shift_id': shift_id,
                'wave_in_shift': w + 1,
                'orders': wave_orders,
                'num_orders': len(wave_orders),
                'total_lines': wave_lines
            })
            wave_counter += 1

    return pd.DataFrame(all_waves)


# Example
shifts = [
    {'shift_id': 'Day', 'start_time': datetime(2024,1,1,6,0),
     'end_time': datetime(2024,1,1,14,0), 'hours': 8},
    {'shift_id': 'Evening', 'start_time': datetime(2024,1,1,14,0),
     'end_time': datetime(2024,1,1,22,0), 'hours': 8},
    {'shift_id': 'Night', 'start_time': datetime(2024,1,1,22,0),
     'end_time': datetime(2024,1,2,6,0), 'hours': 8}
]

pickers = {'Day': 12, 'Evening': 8, 'Night': 4}

multi_shift_waves = plan_multi_shift_waves(orders.head(100), shifts, pickers)

print("\nMulti-Shift Wave Plan:")
print(multi_shift_waves.groupby('shift_id')[['num_orders', 'total_lines']].sum())

---

工具和库

波次管理软件

仓库管理系统：

• Manhattan WMS：高级波次计划和优化
• Blue Yonder (JDA) WMS：AI 驱动的波次管理
• SAP EWM：波次模板和动态释放
• HighJump WMS：可配置的波次策略
• Körber WMS：多波次并行处理

订单管理系统：

• IBM Sterling OMS：波次释放和订单编排
• Fluent Commerce：实时订单承诺和波次管理
• Radial OMS：支持波次管理的分布式订单管理

Python 库

# Optimization
from pulp import *
from ortools.sat.python import cp_model

# Scheduling
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Analysis
from sklearn.cluster import KMeans  # Order clustering
import matplotlib.pyplot as plt

---

常见挑战和解决方案

挑战：截单时间压力

问题：

• 订单到达较晚，需要当天发货
• 波次释放过早，会漏掉晚到的订单
• 波次释放过晚，会错过承运商揽收时间

解决方案：

• 设置多个截单波次（例如中午 12 点、下午 2 点、下午 4 点）
• 为紧急订单设置加急波次（规模小、频次高）
• 达到 80% 阈值时动态触发波次释放
• 提前暂存高概率订单
• 与承运商协商延后的揽收时间
• 使用排班灵活的最后一公里承运商

挑战：工作量不均衡

问题：

• 某些区域提前完成，其他区域则较晚
• 部分拣货员无事可做，其他人却不堪重负
• 包装站出现瓶颈

解决方案：

• 通过数学方法平衡各区域的波次
• 对拣货员进行交叉培训，使其能在多个区域工作
• 在波次进行期间动态调配拣货员
• 根据各区域的产能调整波次规模
• 使用电子标签拣选或货到人系统（可自动平衡）
• 实时监控进度，并重新平衡下一波次

挑战：订单结构差异

问题：

• 订单中既有单行订单，也有 50 行订单
• 有些日子有 500 个订单，有些日子有 2000 个订单
• 季节性高峰会打乱标准波次安排

解决方案：

• 按订单复杂度区分波次（单件与整箱）
• 灵活调整波次规模（200–600 行，而非固定数量）
• 为大订单预留产能
• 在非高峰时段提前拣选高周转商品
• 高峰期雇用临时工
• 动态调整波次频率（而非采用固定计划）

挑战：设备限制

问题：

• 输送机已达产能上限（每小时最多 500 件）
• 分拣机无法处理波次的货量
• 包装站成为瓶颈

解决方案：

• 根据下游产能限制波次规模
• 错开波次释放时间（各区域之间间隔 15 分钟）
• 使用波次缓冲池（释放至拣选环节，但控制流入包装环节的速度）
• 增加应急产能（临时包装站）
• 为同一客户／承运商的订单批量包装
• 升级设备或增加并行生产线

挑战：WMS 限制

问题：

• WMS 仅支持固定波次规模
• 无法根据阈值自动释放波次
• 波次模板有限
• 不支持跨区域波次

解决方案：

• 使用中间件实现高级波次逻辑
• 设置警报阈值并进行人工监控
• 为常见场景预先创建波次模板
• 升级 WMS 或添加附加优化模块
• 与 WMS 供应商合作开发自定义逻辑
• 在外部进行优化，并将结果传入 WMS

---

输出格式

波次计划报告

每日波次计划 - 2024 年 1 月 15 日

波次	开始时间	行数	订单数	区域	预计时长	是否满足截单时间	状态
W01	06:00	420	87	A,B,C	3.2 hrs	12pm	已完成
W02	09:00	385	96	A,B,C	2.9 hrs	12pm	进行中
W03	12:00	510	102	A,B,C	3.8 hrs	4pm	已排期
W04	16:00	295	74	A,B,C	2.2 hrs	6pm	已排期

波次 W02 详情：

Orders: 96
Total Lines: 385
Average Lines/Order: 4.0

Zone Distribution:
  Zone A: 145 lines (38%)
  Zone B: 132 lines (34%)
  Zone C: 108 lines (28%)

Pickers Assigned:
  Zone A: 4 pickers → ~36 lines/picker
  Zone B: 3 pickers → ~44 lines/picker
  Zone C: 3 pickers → ~36 lines/picker

Expected Completion: 11:54 AM
Cutoff: 12:00 PM (6 min buffer)

Priority Orders: 12 (flagged for early pick)

绩效摘要：

指标	目标	实际值	状态
每日波次数	8–10	9	✓ 符合目标
平均波次规模	350–450	403	✓ 符合目标
平衡度（区域间最大值与最小值之差）	<50 行	37 行	✓ 符合目标
截单时间遵守率	>95%	98%	✓ 符合目标
拣货员利用率	80–90%	86%	✓ 符合目标

建议：

• 第 3 波次规模最大，如出现问题，可考虑拆分
• W02 中 B 区工作量略高；如有空余，可增加 1 名拣货员
• 建议将截单时间调整至中午 12:30，预留 30 分钟缓冲

---

需要询问的问题

如需更多背景信息：

1. 您的每日订单量是多少（订单数和行数）？
2. 您目前每天运行多少个拣货波次？
3. 您的发货截单时间是什么时候？
4. 有多少个仓库区域？每个区域有多少名拣货员？
5. 您使用什么 WMS？它具备哪些波次计划功能？
6. 每名拣货员平均每小时拣选多少件？
7. 是否存在设备瓶颈（输送机、分拣机、包装）？
8. 是否有优先或加急订单？

---

相关技能

• order-batching-optimization：用于在波次内对订单进行分组
• picker-routing-optimization：用于优化波次内的拣货路径
• workforce-scheduling：用于班次和劳动力规划
• task-assignment-problem：用于将拣货员分配到区域／波次
• warehouse-slotting-optimization：用于优化 SKU 存放位置，提升拣货效率
• order-fulfillment：用于整体履约流程设计
• capacity-planning：用于长期波次容量规划