warehouse-slotting-optimization

倉庫スロッティングの最適化

あなたは、倉庫スロッティングの最適化と保管場所の割り当てに精通しています。目標は、SKUを倉庫内の場所に最適に配置し、移動距離を最小限に抑え、ピッキング効率を高め、スペース利用率を最大化し、人件費を削減することです。

初期評価

スロッティングを最適化する前に、次の点を把握してください。

1. 倉庫の特性

   • 倉庫のレイアウトはどのようになっていますか？（ゾーン、通路、階層）
   • 保管場所の総数と収容能力はどれくらいですか？
   • ピッキングゾーンはありますか？（フォワードピック、予備、バルク）
   • どのような設備を使用していますか？（フォークリフト、ピッカー、自動化システム）
   • 現在のスロッティング方法は何ですか？（手動、ABC分析、ランダム）

2. 製品プロファイル

   • SKU数はいくつですか？
   • 製品の寸法と重量はどれくらいですか？
   • 出庫頻度はどれくらいですか？（1日／1週間あたりのピッキング数）
   • 季節性や需要パターンはありますか？
   • キューブ移動量はどれくらいですか？（立方フィート × ピッキング数）

3. 運用上の制約

   • FIFO／FEFOの要件はありますか？
   • 危険物や相性に関する制限はありますか？
   • 温度帯の区分はありますか？
   • 場所／階層ごとの最大重量はどれくらいですか？
   • 補充頻度はどれくらいですか？

4. ビジネス目標

   • 主な目標は何ですか？（移動の最小化、作業負荷の平準化、スループットの最大化）
   • 現在のピッキング効率の指標は何ですか？
   • 想定される注文プロファイルの変化はありますか？
   • スロッティングの更新頻度はどれくらいですか？

---

スロッティング最適化フレームワーク

スロッティングの原則

1. ゴールデンゾーンの原則

• 出庫頻度の高い商品を、最もアクセスしやすい場所に配置します
• 目の高さ（腰から肩の高さ）が最適です
• かがんだり、手を伸ばしたりする動作を最小限に抑えます
• ピッカーの疲労を軽減します

2. 立方体積当たり注文指数（COI）

• 式：COI = 立方体積 / 期間あたりの注文数
• COIが低いほど、立方フィート当たりのピッキング数が多く、候補として適しています
• ピッキング頻度が高く、容積が小さい商品をフォワードピックで優先します

3. ABC出庫頻度分析

• A商品：SKUの上位20％、ピッキング数の80％ → 最優先の場所
• B商品：次のSKUの30％、ピッキング数の15％ → 二次的な場所
• C商品：下位50％のSKU、ピッキング数の5％ → 予備保管場所

4. 相関ピッキング

• 頻繁に一緒に注文される商品は、近くに配置します
• ピッキング間の移動を減らします
• 注文履歴に対してクラスター分析を行います

5. 商品の親和性

• 類似した商品をまとめます（サイズ、カテゴリー、取扱方法）
• 補充効率を高めます
• クロストレーニングを容易にします

---

数理モデル

二次割り当て問題（QAP）

スロッティングの最適化は、基本的に二次割り当て問題です。

決定変数：

• x[i,j] = SKU i が場所 j に割り当てられる場合は1、それ以外は0

目的関数： ピッキング頻度で重み付けした総移動距離を最小化します

minimize: Σ Σ Σ Σ (f[i,k] × d[j,l] × x[i,j] × x[k,l])
          i k j l

where:
- f[i,k] = frequency SKU i and k are picked together
- d[j,l] = distance between location j and l
- x[i,j] = 1 if SKU i assigned to location j

制約条件：

# 1. Each SKU assigned to exactly one location
for i in SKUs:
    Σ x[i,j] = 1  for all j in Locations

# 2. Each location holds at most one SKU (can be relaxed)
for j in Locations:
    Σ x[i,j] ≤ 1  for all i in SKUs

# 3. Capacity constraints
for j in Locations:
    Σ (size[i] × x[i,j]) ≤ capacity[j]  for all i

# 4. Compatibility constraints (hazmat, temperature, etc.)
for i in SKUs:
    for j in Locations:
        if not compatible(i, j):
            x[i,j] = 0

---

スロッティングアルゴリズム

ABCスロッティング（基本）

import pandas as pd
import numpy as np

def abc_slotting_analysis(sku_data):
    """
    Perform ABC analysis for warehouse slotting

    Parameters:
    -----------
    sku_data : DataFrame with columns
        - sku_id: Product identifier
        - picks_per_month: Number of picks
        - cube_per_unit: Cubic feet per unit
        - units_per_pick: Average units per pick

    Returns:
    --------
    DataFrame with ABC classification and slotting recommendations
    """

    df = sku_data.copy()

    # Calculate total cube moved
    df['cube_moved'] = (df['picks_per_month'] *
                        df['units_per_pick'] *
                        df['cube_per_unit'])

    # Calculate Cube-per-Order Index (COI)
    df['coi'] = df['cube_per_unit'] / (df['picks_per_month'] + 1)

    # Sort by picks (velocity)
    df = df.sort_values('picks_per_month', ascending=False)

    # Calculate cumulative percentage of picks
    df['cumulative_picks'] = df['picks_per_month'].cumsum()
    total_picks = df['picks_per_month'].sum()
    df['pick_percentage'] = (df['cumulative_picks'] / total_picks) * 100

    # ABC Classification
    df['abc_class'] = pd.cut(
        df['pick_percentage'],
        bins=[0, 80, 95, 100],
        labels=['A', 'B', 'C']
    )

    # Slotting recommendations
    def get_zone_recommendation(row):
        if row['abc_class'] == 'A':
            if row['coi'] < 0.1:
                return 'Forward Pick - Golden Zone'
            else:
                return 'Forward Pick - Lower Priority'
        elif row['abc_class'] == 'B':
            return 'Forward Pick - Edge Locations'
        else:
            return 'Reserve Storage'

    df['recommended_zone'] = df.apply(get_zone_recommendation, axis=1)

    # Priority score (lower is better)
    df['priority_score'] = (
        df['pick_percentage'].rank() * 0.5 +
        df['coi'].rank(ascending=False) * 0.3 +
        df['cube_moved'].rank(ascending=False) * 0.2
    )

    return df.sort_values('priority_score')


# Example usage
sku_data = pd.DataFrame({
    'sku_id': [f'SKU{i:04d}' for i in range(1, 101)],
    'picks_per_month': np.random.randint(1, 1000, 100),
    'cube_per_unit': np.random.uniform(0.5, 10, 100),
    'units_per_pick': np.random.randint(1, 5, 100)
})

slotting_analysis = abc_slotting_analysis(sku_data)

print("Top 10 SKUs for Golden Zone:")
print(slotting_analysis.head(10)[['sku_id', 'picks_per_month',
                                    'coi', 'abc_class', 'recommended_zone']])

print(f"\nABC Distribution:")
print(slotting_analysis['abc_class'].value_counts())

相関ピッキング分析

from sklearn.cluster import KMeans
from scipy.spatial.distance import pdist, squareform

def analyze_pick_correlation(order_lines_data):
    """
    Analyze which SKUs are frequently picked together

    Parameters:
    -----------
    order_lines_data : DataFrame with columns
        - order_id: Order identifier
        - sku_id: Product identifier
        - quantity: Units picked

    Returns:
    --------
    Correlation matrix and clustered SKU groups
    """

    # Create SKU co-occurrence matrix
    pivot = order_lines_data.pivot_table(
        index='order_id',
        columns='sku_id',
        values='quantity',
        fill_value=0,
        aggfunc='sum'
    )

    # Binary: SKU was in order or not
    binary_matrix = (pivot > 0).astype(int)

    # Calculate correlation between SKUs
    correlation_matrix = binary_matrix.corr()

    # Calculate pick affinity score
    # How often SKU i and j appear together / total orders
    n_orders = len(pivot)
    co_occurrence = binary_matrix.T.dot(binary_matrix)
    affinity_matrix = co_occurrence / n_orders

    # Cluster SKUs based on pick patterns
    n_clusters = min(10, len(pivot.columns) // 5)

    if len(pivot.columns) > 1:
        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
        clusters = kmeans.fit_predict(binary_matrix.T)

        sku_clusters = pd.DataFrame({
            'sku_id': pivot.columns,
            'cluster': clusters
        })

        # Add cluster size
        cluster_sizes = sku_clusters['cluster'].value_counts()
        sku_clusters['cluster_size'] = sku_clusters['cluster'].map(cluster_sizes)

    else:
        sku_clusters = pd.DataFrame({
            'sku_id': pivot.columns,
            'cluster': 0,
            'cluster_size': len(pivot.columns)
        })

    return {
        'correlation_matrix': correlation_matrix,
        'affinity_matrix': affinity_matrix,
        'sku_clusters': sku_clusters,
        'binary_matrix': binary_matrix
    }


def get_top_correlations(correlation_matrix, top_n=20):
    """Get top N SKU pairs with highest correlation"""

    # Get upper triangle (avoid duplicates)
    mask = np.triu(np.ones_like(correlation_matrix), k=1).astype(bool)
    upper_tri = correlation_matrix.where(mask)

    # Stack and sort
    correlations = upper_tri.stack().sort_values(ascending=False)

    return correlations.head(top_n)


# Example usage
order_lines = pd.DataFrame({
    'order_id': [1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5],
    'sku_id': ['A', 'B', 'C', 'A', 'B', 'A', 'D', 'E', 'B', 'C', 'A', 'B', 'C', 'F'],
    'quantity': [1, 2, 1, 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 2]
})

correlation_analysis = analyze_pick_correlation(order_lines)
print("SKU Clusters (items to slot near each other):")
print(correlation_analysis['sku_clusters'].sort_values('cluster'))

top_corr = get_top_correlations(correlation_analysis['correlation_matrix'])
print("\nTop Correlated SKU Pairs:")
print(top_corr)

最適化モデル：スロッティング割り当て

from pulp import *
import numpy as np

def optimize_slotting(skus, locations, pick_frequencies, distances,
                      sku_sizes, location_capacities, constraints=None):
    """
    Optimize warehouse slotting using Mixed-Integer Programming

    Parameters:
    -----------
    skus : list
        SKU identifiers
    locations : list
        Location identifiers
    pick_frequencies : dict
        {sku: picks_per_period}
    distances : dict
        {location: distance_from_depot} or distance matrix
    sku_sizes : dict
        {sku: cubic_feet}
    location_capacities : dict
        {location: max_cubic_feet}
    constraints : dict, optional
        Additional constraints (compatibility, etc.)

    Returns:
    --------
    Optimal slotting assignment
    """

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

    # Decision variables: x[i,j] = 1 if SKU i assigned to location j
    x = LpVariable.dicts("assign",
                         [(i, j) for i in skus for j in locations],
                         cat='Binary')

    # Objective: Minimize total travel distance weighted by pick frequency
    # Assuming distance is from central depot/staging area to location
    prob += lpSum([
        pick_frequencies.get(i, 0) * distances.get(j, 0) * x[i, j]
        for i in skus for j in locations
    ]), "Total_Weighted_Distance"

    # Constraints

    # 1. Each SKU must be assigned to exactly one location
    for i in skus:
        prob += lpSum([x[i, j] for j in locations]) == 1, f"SKU_{i}_Assignment"

    # 2. Each location can hold at most one SKU (can be relaxed)
    for j in locations:
        prob += lpSum([x[i, j] for i in skus]) <= 1, f"Location_{j}_Capacity_Count"

    # 3. Physical capacity constraints
    for j in locations:
        prob += lpSum([
            sku_sizes.get(i, 0) * x[i, j] for i in skus
        ]) <= location_capacities.get(j, float('inf')), f"Location_{j}_Volume"

    # 4. Additional constraints (if provided)
    if constraints and 'incompatible' in constraints:
        for (sku, loc) in constraints['incompatible']:
            if sku in skus and loc in locations:
                prob += x[sku, loc] == 0, f"Incompatible_{sku}_{loc}"

    if constraints and 'required' in constraints:
        for (sku, loc) in constraints['required']:
            if sku in skus and loc in locations:
                prob += x[sku, loc] == 1, f"Required_{sku}_{loc}"

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

    # Extract solution
    assignments = {}
    for i in skus:
        for j in locations:
            if x[i, j].varValue > 0.5:
                assignments[i] = j
                break

    # Calculate metrics
    total_distance = sum(
        pick_frequencies.get(sku, 0) * distances.get(loc, 0)
        for sku, loc in assignments.items()
    )

    utilization = {}
    for j in locations:
        used = sum(
            sku_sizes.get(i, 0)
            for i, assigned_loc in assignments.items()
            if assigned_loc == j
        )
        capacity = location_capacities.get(j, 1)
        utilization[j] = (used / capacity * 100) if capacity > 0 else 0

    return {
        'status': LpStatus[prob.status],
        'assignments': assignments,
        'total_weighted_distance': total_distance,
        'location_utilization': utilization,
        'objective_value': value(prob.objective)
    }


# Example usage
skus = [f'SKU{i}' for i in range(1, 21)]
locations = [f'A{i:02d}' for i in range(1, 26)]  # 25 locations for 20 SKUs

# Generate sample data
np.random.seed(42)
pick_frequencies = {sku: np.random.randint(10, 1000) for sku in skus}
distances = {loc: np.random.uniform(10, 100) for loc in locations}
sku_sizes = {sku: np.random.uniform(1, 5) for sku in skus}
location_capacities = {loc: 10.0 for loc in locations}

# Add some constraints
constraints = {
    'incompatible': [('SKU1', 'A01'), ('SKU5', 'A25')],  # Example incompatibilities
}

result = optimize_slotting(
    skus, locations, pick_frequencies, distances,
    sku_sizes, location_capacities, constraints
)

print(f"Optimization Status: {result['status']}")
print(f"Total Weighted Distance: {result['total_weighted_distance']:,.2f}")
print(f"\nTop 10 Assignments (by pick frequency):")

# Sort by pick frequency
sorted_skus = sorted(skus, key=lambda s: pick_frequencies[s], reverse=True)[:10]
for sku in sorted_skus:
    loc = result['assignments'][sku]
    print(f"  {sku} → {loc} (picks: {pick_frequencies[sku]}, distance: {distances[loc]:.1f})")

単純な割り当てに対するハンガリー法

from scipy.optimize import linear_sum_assignment
import numpy as np

def hungarian_slotting(skus, locations, cost_matrix):
    """
    Use Hungarian algorithm for simple one-to-one slotting

    Parameters:
    -----------
    skus : list
        SKU identifiers
    locations : list
        Location identifiers
    cost_matrix : 2D array
        Cost[i,j] = cost of assigning sku i to location j

    Returns:
    --------
    Optimal assignment (when # SKUs = # locations)
    """

    # Ensure square matrix (pad if needed)
    n_skus = len(skus)
    n_locs = len(locations)

    if n_skus != n_locs:
        # Pad with dummy SKUs or locations
        max_dim = max(n_skus, n_locs)
        padded_cost = np.full((max_dim, max_dim), np.max(cost_matrix) * 10)
        padded_cost[:n_skus, :n_locs] = cost_matrix
        cost_matrix = padded_cost

    # Solve using Hungarian algorithm
    row_ind, col_ind = linear_sum_assignment(cost_matrix)

    # Extract valid assignments (not dummy)
    assignments = {}
    total_cost = 0

    for i, j in zip(row_ind, col_ind):
        if i < n_skus and j < n_locs:
            assignments[skus[i]] = locations[j]
            total_cost += cost_matrix[i, j]

    return {
        'assignments': assignments,
        'total_cost': total_cost,
        'row_indices': row_ind[:n_skus],
        'col_indices': col_ind[:n_skus]
    }


# Example: Assign 10 SKUs to 10 best locations
skus = [f'SKU{i}' for i in range(1, 11)]
locations = [f'LOC{i}' for i in range(1, 11)]

# Cost = Pick frequency × Distance
# Lower cost = better assignment
np.random.seed(42)
pick_freq = np.random.randint(50, 500, 10)
distances = np.random.uniform(5, 50, 10)

# Cost matrix: each row is a SKU, each column is a location
cost_matrix = np.outer(pick_freq, distances)

result = hungarian_slotting(skus, locations, cost_matrix)

print("Hungarian Algorithm Assignment:")
print(f"Total Cost: {result['total_cost']:,.2f}")
print("\nAssignments:")
for sku, loc in result['assignments'].items():
    i = skus.index(sku)
    j = locations.index(loc)
    print(f"  {sku} → {loc} (cost: {cost_matrix[i,j]:,.2f})")

---

高度なスロッティング手法

動的スロッティング

import pandas as pd
from datetime import datetime, timedelta

class DynamicSlottingOptimizer:
    """
    Dynamic slotting that adapts to changing demand patterns
    """

    def __init__(self, warehouse_layout, refresh_frequency='weekly'):
        self.warehouse_layout = warehouse_layout
        self.refresh_frequency = refresh_frequency
        self.slotting_history = []
        self.current_slotting = {}

    def calculate_velocity_trend(self, historical_picks, window_days=30):
        """
        Calculate velocity trends for each SKU

        Returns trending up, stable, or trending down
        """

        df = historical_picks.copy()
        df['date'] = pd.to_datetime(df['date'])

        # Calculate rolling average
        recent_end = df['date'].max()
        recent_start = recent_end - timedelta(days=window_days)
        older_start = recent_start - timedelta(days=window_days)

        recent_picks = df[df['date'] >= recent_start].groupby('sku_id')['picks'].sum()
        older_picks = df[
            (df['date'] >= older_start) & (df['date'] < recent_start)
        ].groupby('sku_id')['picks'].sum()

        velocity_change = (recent_picks - older_picks) / (older_picks + 1)

        trends = {}
        for sku in velocity_change.index:
            change = velocity_change[sku]
            if change > 0.2:
                trends[sku] = 'trending_up'
            elif change < -0.2:
                trends[sku] = 'trending_down'
            else:
                trends[sku] = 'stable'

        return trends

    def seasonal_adjustment(self, sku_id, current_month):
        """
        Apply seasonal factors to velocity
        """

        # Example seasonal factors (would be learned from historical data)
        seasonal_factors = {
            'toy_sku': {11: 2.5, 12: 3.0, 1: 0.5},  # Holiday season
            'apparel_sku': {3: 1.5, 4: 1.3, 9: 1.4, 10: 1.2},  # Spring/Fall
        }

        # Default factor
        return seasonal_factors.get(sku_id, {}).get(current_month, 1.0)

    def recommend_reslotting(self, current_slotting, velocity_trends,
                            threshold_change=0.3):
        """
        Recommend which SKUs should be reslotted
        """

        reslot_candidates = []

        for sku, current_zone in current_slotting.items():
            trend = velocity_trends.get(sku, 'stable')

            # High priority: trending up items in poor locations
            if trend == 'trending_up' and current_zone in ['Reserve', 'C_Zone']:
                reslot_candidates.append({
                    'sku': sku,
                    'reason': 'Trending up, needs better location',
                    'priority': 'High',
                    'current_zone': current_zone,
                    'recommended_zone': 'Forward Pick'
                })

            # Low priority: trending down items in prime locations
            elif trend == 'trending_down' and current_zone == 'Golden Zone':
                reslot_candidates.append({
                    'sku': sku,
                    'reason': 'Trending down, free up prime space',
                    'priority': 'Medium',
                    'current_zone': current_zone,
                    'recommended_zone': 'B_Zone or Reserve'
                })

        return pd.DataFrame(reslot_candidates)

    def minimize_disruption(self, old_slotting, new_slotting, max_moves=50):
        """
        Minimize number of moves when implementing new slotting

        Use cycle counting approach: only move most impactful SKUs
        """

        moves_needed = []

        for sku in new_slotting:
            old_loc = old_slotting.get(sku)
            new_loc = new_slotting.get(sku)

            if old_loc != new_loc:
                # Calculate impact of this move
                impact = self.calculate_move_impact(sku, old_loc, new_loc)
                moves_needed.append({
                    'sku': sku,
                    'from': old_loc,
                    'to': new_loc,
                    'impact': impact
                })

        # Sort by impact, take top N moves
        moves_df = pd.DataFrame(moves_needed)
        if len(moves_df) > 0:
            moves_df = moves_df.sort_values('impact', ascending=False)
            return moves_df.head(max_moves)

        return moves_df

    def calculate_move_impact(self, sku, old_loc, new_loc):
        """
        Estimate benefit of moving SKU from old to new location
        """
        # Simplified: would use actual distances and pick frequencies
        # Higher impact = more important to move
        return np.random.uniform(0, 100)  # Placeholder


# Example usage
optimizer = DynamicSlottingOptimizer(warehouse_layout={})

# Simulate historical picks
historical_data = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=90),
    'sku_id': np.random.choice(['SKU1', 'SKU2', 'SKU3', 'SKU4', 'SKU5'], 90),
    'picks': np.random.randint(10, 200, 90)
})

velocity_trends = optimizer.calculate_velocity_trend(historical_data)
print("Velocity Trends:")
print(velocity_trends)

current_slotting = {
    'SKU1': 'Golden Zone',
    'SKU2': 'Forward Pick',
    'SKU3': 'Reserve',
    'SKU4': 'C_Zone',
    'SKU5': 'Forward Pick'
}

recommendations = optimizer.recommend_reslotting(current_slotting, velocity_trends)
print("\nReslotting Recommendations:")
print(recommendations)

フォワードピック場所のサイズ設定

def calculate_forward_pick_size(sku_data, replenishment_frequency='daily'):
    """
    Determine optimal forward pick location size for each SKU

    Balance between:
    - Minimizing forward pick space (expensive)
    - Minimizing replenishment trips (labor cost)

    Parameters:
    -----------
    sku_data : DataFrame with columns
        - sku_id
        - daily_picks (average)
        - units_per_pick
        - cube_per_unit
        - replenishment_cost ($ per trip)

    Returns:
    --------
    Recommended forward pick capacity for each SKU
    """

    df = sku_data.copy()

    # Calculate daily cube picked
    df['daily_cube_picked'] = (df['daily_picks'] *
                                df['units_per_pick'] *
                                df['cube_per_unit'])

    # Determine replenishment period
    replen_days = {
        'daily': 1,
        'every_2_days': 2,
        'weekly': 7
    }
    days = replen_days.get(replenishment_frequency, 1)

    # Forward pick size = days of inventory
    df['forward_pick_cube'] = df['daily_cube_picked'] * days * 1.2  # 20% buffer

    # Round up to standard bin sizes
    standard_sizes = [1, 2, 4, 8, 16, 32]  # cubic feet

    def round_to_standard(size):
        for std_size in standard_sizes:
            if size <= std_size:
                return std_size
        return standard_sizes[-1]

    df['recommended_bin_size'] = df['forward_pick_cube'].apply(round_to_standard)

    # Calculate annual replenishment trips
    df['annual_replen_trips'] = (365 / days) * (df['recommended_bin_size'] > 0)
    df['annual_replen_cost'] = df['annual_replen_trips'] * df['replenishment_cost']

    # Calculate space cost (assuming $10/sq ft/year, 8 ft ceiling)
    space_cost_per_cuft = 10 / 8
    df['annual_space_cost'] = df['recommended_bin_size'] * space_cost_per_cuft

    df['total_annual_cost'] = df['annual_replen_cost'] + df['annual_space_cost']

    return df[[
        'sku_id', 'daily_picks', 'daily_cube_picked',
        'forward_pick_cube', 'recommended_bin_size',
        'annual_replen_trips', 'total_annual_cost'
    ]]


# Example
sku_data = pd.DataFrame({
    'sku_id': [f'SKU{i}' for i in range(1, 11)],
    'daily_picks': np.random.randint(5, 100, 10),
    'units_per_pick': np.random.uniform(1, 3, 10),
    'cube_per_unit': np.random.uniform(0.1, 2, 10),
    'replenishment_cost': np.full(10, 5.0)  # $5 per replenishment
})

forward_pick_sizing = calculate_forward_pick_size(sku_data, 'every_2_days')
print("Forward Pick Location Sizing:")
print(forward_pick_sizing)

---

ツールとライブラリ

スロッティングソフトウェア

商用ソリューション：

• Manhattan WMS：高度なスロッティングモジュール
• Blue Yonder (JDA) WMS：AIを活用したスロッティング
• SAP EWM：拡張倉庫管理のスロッティング
• HighJump WMS：タスクベースのスロッティング最適化
• Körber Supply Chain：動的スロッティング
• Infor WMS：出庫頻度ベースのスロッティング

専門スロッティングツール：

• EasySlot：単体型スロッティング最適化ツール
• SlotSmart：クラウドベースのスロッティング
• Warehousing Efficiency Solutions：スロッティングのコンサルティングとソフトウェア

Pythonライブラリ

# Optimization
from pulp import *  # Linear programming
from scipy.optimize import linear_sum_assignment  # Hungarian algorithm
from ortools.linear_solver import pywraplp  # Google OR-Tools

# Data Analysis
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans  # Clustering for product affinity
from scipy.spatial.distance import cdist  # Distance calculations

# Visualization
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px  # Interactive warehouse heatmaps

---

よくある課題と解決策

課題：季節的な需要の変化

問題：

• 夏物と冬物では出庫頻度が異なります
• ホリデーシーズンにはピッキングパターンが大きく変化します
• 新学期前に需要が急増します

解決策：

• 季節別のスロッティングプロファイルを年に3～4回導入します
• 分類には直近30日間の出庫頻度を使用します
• 季節商品用に柔軟に使えるゾーンを確保します
• シーズン開始前に事前スロッティングを行います（先行対応）
• フォワードピックのあふれ分を保管するエリアを使用します
• 移行期間中は出庫頻度を毎週確認します

課題：製品の増加

問題：

• 前方ピッキング用の棚スペースに対して、SKU が多すぎます
• 新しい SKU が常に追加されます
• 動きの遅い商品のロングテールがあります

解決策：

• ABC 分類の基準を厳しくします（前方ピッキングには上位 15～20％のみ配置）
• C 品目は予備在庫からバラ単位でピッキングします
• 類似する SKU を統合します
• 動きの遅い商品を段階的に廃止します
• 動的な棚割りを使用します（継続的に再最適化します）
• 小型商品は 1 つのロケーションに複数の SKU を配置します

課題：物理的な制約

問題：

• 上段の棚に重量制限があります
• 互換性のない商品があります（危険物、温度条件）
• 大型商品は標準の棚スペースに収まりません

解決策：

• 最適化モデルに重量制約を追加します
• 商品タイプごとにゾーンを事前に割り当てます
• バルクピッキング専用エリアを設けます
• 重量物や大型商品の床置き積載を行います
• 機器専用ゾーンを使用します
• 予備在庫用に複列パレットラックを使用します

課題：補充による混乱

問題：

• ピッキングのウェーブ中に補充が混雑します
• フォークリフトの通行がピッカーの妨げになります
• 前方ピッキング用の在庫がなくなります

解決策：

• ピッキングのウェーブ間に補充をスケジュールします
• 補充専用の通路を使用します
• 最小在庫量／最大在庫量に基づく補充トリガーを導入します
• 前方ピッキング用ロケーションのサイズを適正化します
• 前方ピッキングを 2 か所に分けます（A／B の位置）
• 自動補充を導入します（AS/RS、シャトル）

課題：変化への抵抗

問題：

• ピッカーが新しい棚割りに抵抗します
• 身体で覚えた動作が乱れます
• 短期的に生産性が低下します

解決策：

• 段階的に導入します（ゾーンごとに実施）
• メリットを明確に伝えます
• 最新のピッキング面マップを提供します
• 2 週間の習熟期間を設けます
• 音声／RF による誘導ピッキングを使用します（ロケーションを案内します）
• 改善状況を追跡し、成果を称えます
• 経験豊富なピッカーを設計に参加させます

課題：データ品質

問題：

• ピッキング履歴が不正確です
• 商品寸法が不足しています
• 新商品の商品回転率が不明です

解決策：

• 過去のデータを整理します（外れ値、返品を除外）
• 商品寸法を実地監査します
• 入荷時に容積をスキャンします
• 類似商品の回転率を代理値として使用します
• 新しい SKU にはカテゴリー平均を使用します
• 保守的な棚割りから始め、30 日後に調整します

---

出力形式

スロッティング最適化レポート

エグゼクティブサマリー：

• 現在のピッキング効率：120 明細／時間
• 改善予測：145 明細／時間（+21%）
• 分析対象のSKU総数：2,450
• 移動が必要なSKU：347（14%）
• 実施予定期間：3週間
• 投資回収期間：6か月

ABC分析の結果：

カテゴリ	SKU数	SKUの割合	ピッキングの割合	月平均ピッキング数	ゾーンの割り当て
A	245	10%	75%	850	ゴールデンゾーン
B	612	25%	20%	180	フォワードピック
C	1,593	65%	5%	12	予備保管

上位25 SKU ― ゴールデンゾーンへの配置：

SKU	説明	月間ピッキング数	COI	現在のロケーション	最適なロケーション	移動距離の削減量
SKU1234	ウィジェットA	1,245	0.05	C-15-3	A-01-2	3,850 ft/月
SKU2345	ガジェットB	1,123	0.08	B-08-1	A-01-3	3,200 ft/月
...	...	...	...	...	...	...

商品親和性クラスター：

Cluster 1 (Office Supplies): 45 SKUs
  - Frequently ordered together
  - Recommend: Aisle A1-A2

Cluster 2 (Electronics): 32 SKUs
  - High correlation in order patterns
  - Recommend: Aisle B1-B2

...

実施計画：

フェーズ1 ― 第1週： ゴールデンゾーン（A品目）

• 上位50 SKUを最適なロケーションに移動
• 期待効果：全体の効果の50%
• 混乱を最小限に抑制

フェーズ2 ― 第2週： フォワードピック（B品目）

• 200 SKUのロケーションを最適化
• 期待効果：さらに30%の効果

フェーズ3 ― 第3週： 予備保管（C品目）

• 集約して整理
• 期待効果：さらに20%の効果

期待されるメリット：

指標	現在	最適化後	改善
平均ピッキング移動距離（ft）	2,850	2,100	-26%
1時間あたりのピッキング数	120	145	+21%
1日の作業時間	180	150	-17%
年間人件費	$540K	$450K	-$90K
フォワードピックの使用率	68%	89%	+21ポイント

保守計画：

• 毎週、出荷速度を監視
• 毎月、ABC分類を見直し
• 四半期ごとにスロッティングを全面的に見直し
• 季節ごとにプロファイルを変更（年4回）
• 継続的な改善（週1%の移動）

---

質問事項

さらに詳しい情報が必要な場合：

1. SKUと保管ロケーションはいくつありますか？
2. 現在のピッキング効率（明細／時間）はどのくらいですか？
3. フォワードピックゾーンと予備保管ゾーンがありますか？
4. 現在、どのくらいの頻度でスロッティングを見直していますか？
5. どのWMSまたはスロッティングソフトウェアを使用していますか？
6. 季節的な需要パターンはありますか？
7. 重量、温度、危険物など、物理的な制約はありますか？
8. 現在、補充はどのようにスケジュールされていますか？

---

関連スキル

• picker-routing-optimization：スロッティングを前提にピッキング経路を最適化します
• warehouse-design：全体的なレイアウトとゾーン設計を行います
• order-batching-optimization：まとめてピッキングする注文をバッチ化します
• wave-planning-optimization：ピッキングウェーブを計画します
• task-assignment-problem：ピッカーをゾーンに割り当てます
• inventory-optimization：フォワードピックの在庫水準を最適化します
• demand-forecasting：今後の出荷速度の変化を予測します
• abc-analysis：商品を分類します