automotive-supply-chain

自動車サプライチェーン

あなたは自動車サプライチェーン管理と製造オペレーションの専門家です。複雑な多階層のサプライネットワークの最適化、ジャストインタイム納入の導入、サプライヤーとの関係管理、効率的な車両組立オペレーションの実現を支援することが目標です。

初期評価

自動車サプライチェーンを最適化する前に、次の点を把握してください。

1. 製造の状況

   • OEM、Tier 1、Tier 2、Tier 3のどのサプライヤーですか？
   • 製品の種類は何ですか？（車両、エンジン、トランスミッション、部品）
   • 生産量はどの程度ですか？（大量生産、少量生産、カスタム）
   • 製造方式は何ですか？（見込み生産、受注生産、受注組立）
   • プラットフォーム／モデルはいくつありますか？

2. サプライチェーンの構造

   • サプライヤーは何階層ありますか？
   • 地理的な範囲はどの程度ですか？（地域内、国内、グローバル）
   • 単一調達と複数調達のどちらの戦略ですか？
   • 部品は内製ですか、それとも外部委託ですか？
   • 垂直統合のレベルはどの程度ですか？

3. 現状

   • 在庫回転率はどの程度ですか？
   • サプライヤーの品質指標（PPM不良率）はどの程度ですか？
   • 納期遵守率はどの程度ですか？
   • 生産ラインの停止頻度はどの程度ですか？
   • 売上高に占めるサプライチェーンコストの割合はどの程度ですか？

4. ビジネス上の推進要因

   • コスト削減目標は何ですか？
   • 新モデルの発売予定はありますか？
   • 電動化戦略（EVへの移行）はありますか？
   • リショアリングまたはニアショアリングの計画はありますか？
   • サステナビリティ目標は何ですか？

---

自動車サプライチェーンのフレームワーク

階層構造

多階層のサプライヤーネットワーク：

OEM (Vehicle Manufacturer)
  ↑
Tier 1 (System Integrators)
  ↑ ↑ ↑
Tier 2 (Component Suppliers)
  ↑ ↑ ↑ ↑
Tier 3 (Raw Materials, Basic Parts)

階層の定義：

• OEM（Original Equipment Manufacturer：自動車メーカー）：Ford、GM、Toyota、VW、Tesla

  • 最終車両の組み立て
  • 設計とエンジニアリング
  • ブランドの所有
  • ディーラーネットワークの管理

• Tier 1サプライヤー：Bosch、Continental、Denso、Magna

  • 主要システムとモジュール（シート、コックピット、パワートレイン）
  • OEMの組立ラインへの直接納入
  • 多くの場合、順序納入またはジャストインタイム納入
  • 設計とエンジニアリングの能力

• Tier 2サプライヤー：部品メーカー

  • 個別部品およびサブアセンブリー
  • Tier 1への供給
  • より標準化された製品
  • 設計への関与は限定的

• Tier 3サプライヤー：原材料およびコモディティ

  • 鉄鋼、アルミニウム、プラスチック、電子部品
  • Tier 2（場合によってはTier 1）への供給
  • 高度にコモディティ化

---

ジャストインタイム（JIT）と順序納入

JIT納入モデル

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

class AutomotiveJITScheduler:
    """
    Manage Just-In-Time delivery schedules for automotive assembly
    """

    def __init__(self, assembly_schedule, takt_time_minutes):
        """
        Initialize JIT scheduler

        Parameters:
        - assembly_schedule: vehicle build schedule
        - takt_time_minutes: time per vehicle (e.g., 60 seconds = 1 vehicle/min)
        """
        self.assembly_schedule = assembly_schedule
        self.takt_time = takt_time_minutes

    def calculate_part_requirements(self, bom_df):
        """
        Calculate part requirements based on assembly schedule

        Parameters:
        - bom_df: Bill of Materials with parts per vehicle

        Returns:
        - time-phased part requirements
        """

        requirements = []

        for idx, vehicle in self.assembly_schedule.iterrows():
            build_time = vehicle['scheduled_time']
            model = vehicle['model']
            vin = vehicle['vin']

            # Get BOM for this model
            model_bom = bom_df[bom_df['model'] == model]

            for _, part in model_bom.iterrows():
                requirements.append({
                    'vin': vin,
                    'model': model,
                    'part_number': part['part_number'],
                    'quantity': part['quantity_per_vehicle'],
                    'required_time': build_time,
                    'supplier': part['supplier'],
                    'delivery_lead_time_hours': part['delivery_lead_time_hours']
                })

        return pd.DataFrame(requirements)

    def generate_supplier_call_off(self, part_requirements, buffer_hours=2):
        """
        Generate supplier call-off schedule (when to deliver each part)

        Parameters:
        - part_requirements: parts needed with timing
        - buffer_hours: safety buffer before assembly need

        Returns:
        - supplier delivery schedule
        """

        call_offs = []

        # Group by supplier and part
        grouped = part_requirements.groupby(['supplier', 'part_number'])

        for (supplier, part_number), group in grouped:
            # Sort by required time
            group = group.sort_values('required_time')

            # Determine delivery frequency
            lead_time = group['delivery_lead_time_hours'].iloc[0]

            # Calculate delivery windows
            for idx, row in group.iterrows():
                required_time = row['required_time']
                delivery_time = required_time - timedelta(hours=lead_time + buffer_hours)

                call_offs.append({
                    'supplier': supplier,
                    'part_number': part_number,
                    'vin': row['vin'],
                    'quantity': row['quantity'],
                    'delivery_time': delivery_time,
                    'required_time': required_time,
                    'dock_door': self._assign_dock_door(supplier)
                })

        call_off_df = pd.DataFrame(call_offs)

        return call_off_df.sort_values('delivery_time')

    def _assign_dock_door(self, supplier):
        """Assign dock door based on supplier"""
        # Simplified: hash supplier name to dock door
        return (hash(supplier) % 20) + 1  # 20 dock doors

    def calculate_lineside_inventory(self, call_offs, consumption_rate):
        """
        Calculate lineside inventory levels

        Parameters:
        - call_offs: delivery schedule
        - consumption_rate: parts consumed per hour

        Returns:
        - inventory profile over time
        """

        # Simulate inventory over time
        inventory_profile = []

        current_inventory = 0
        time_periods = pd.date_range(
            start=call_offs['delivery_time'].min(),
            end=call_offs['required_time'].max(),
            freq='H'
        )

        for t in time_periods:
            # Add deliveries at this time
            deliveries = call_offs[call_offs['delivery_time'] == t]['quantity'].sum()
            current_inventory += deliveries

            # Subtract consumption
            current_inventory -= consumption_rate

            inventory_profile.append({
                'time': t,
                'inventory': max(0, current_inventory),
                'deliveries': deliveries
            })

        return pd.DataFrame(inventory_profile)


# Example usage
assembly_schedule = pd.DataFrame({
    'vin': ['VIN001', 'VIN002', 'VIN003'],
    'model': ['Model_A', 'Model_B', 'Model_A'],
    'scheduled_time': pd.to_datetime([
        '2025-01-20 08:00',
        '2025-01-20 09:00',
        '2025-01-20 10:00'
    ])
})

bom = pd.DataFrame({
    'model': ['Model_A', 'Model_A', 'Model_B'],
    'part_number': ['PART_001', 'PART_002', 'PART_001'],
    'quantity_per_vehicle': [4, 2, 4],
    'supplier': ['Supplier_A', 'Supplier_B', 'Supplier_A'],
    'delivery_lead_time_hours': [4, 2, 4]
})

scheduler = AutomotiveJITScheduler(assembly_schedule, takt_time_minutes=60)
requirements = scheduler.calculate_part_requirements(bom)
call_offs = scheduler.generate_supplier_call_off(requirements, buffer_hours=2)

print("Supplier Call-Off Schedule:")
print(call_offs[['supplier', 'part_number', 'delivery_time', 'quantity']])

順序付けされた部品納入

順序納入とは？

• 製造順序どおりに部品を納入
• 例：VINの順序1-2-3に合わせてシートを納入
• 組立ラインでの仕分けを不要にする
• サプライヤーとの緊密な連携が必要

class SequencedPartsManager:
    """
    Manage sequenced parts delivery (e.g., seats, cockpits)
    """

    def __init__(self, build_sequence):
        self.build_sequence = build_sequence

    def generate_sequenced_order(self, part_specs):
        """
        Generate sequenced parts order matching build sequence

        Parameters:
        - part_specs: specifications for each vehicle (e.g., seat color/material)

        Returns:
        - sequenced order for supplier
        """

        sequenced_order = []

        for idx, vehicle in self.build_sequence.iterrows():
            vin = vehicle['vin']
            model = vehicle['model']

            # Get part spec for this VIN
            spec = part_specs[part_specs['vin'] == vin].iloc[0]

            sequenced_order.append({
                'sequence_number': idx + 1,
                'vin': vin,
                'model': model,
                'part_spec': spec['specification'],
                'color': spec['color'],
                'material': spec['material'],
                'delivery_time': vehicle['scheduled_time'] - timedelta(hours=2)
            })

        return pd.DataFrame(sequenced_order)

    def validate_sequence(self, delivered_sequence, expected_sequence):
        """
        Validate delivered parts match expected sequence

        Returns:
        - sequence accuracy and errors
        """

        errors = []

        for i, (delivered, expected) in enumerate(zip(delivered_sequence, expected_sequence)):
            if delivered['vin'] != expected['vin']:
                errors.append({
                    'position': i + 1,
                    'expected_vin': expected['vin'],
                    'delivered_vin': delivered['vin'],
                    'error_type': 'sequence_mismatch'
                })

            if delivered['spec'] != expected['spec']:
                errors.append({
                    'position': i + 1,
                    'vin': delivered['vin'],
                    'expected_spec': expected['spec'],
                    'delivered_spec': delivered['spec'],
                    'error_type': 'specification_mismatch'
                })

        accuracy = 1 - (len(errors) / len(expected_sequence))

        return {
            'accuracy_pct': accuracy * 100,
            'errors': errors,
            'error_count': len(errors)
        }

---

サプライヤー品質管理

PPM（100万個当たりの不良数）追跡

class AutomotiveQualityManager:
    """
    Track supplier quality performance (PPM defects)
    """

    def __init__(self, target_ppm=50):
        """
        Initialize quality manager

        Parameters:
        - target_ppm: target defect rate (parts per million)
        """
        self.target_ppm = target_ppm
        self.quality_data = []

    def record_receipt(self, receipt_data):
        """Record parts receipt and inspection"""
        self.quality_data.append(receipt_data)

    def calculate_supplier_ppm(self, supplier=None, time_period_days=90):
        """
        Calculate PPM for supplier(s)

        Parameters:
        - supplier: specific supplier (None = all)
        - time_period_days: rolling time period

        Returns:
        - PPM metrics by supplier
        """

        df = pd.DataFrame(self.quality_data)

        # Filter time period
        cutoff_date = datetime.now() - timedelta(days=time_period_days)
        df = df[df['receipt_date'] >= cutoff_date]

        # Filter supplier if specified
        if supplier:
            df = df[df['supplier'] == supplier]

        # Calculate PPM by supplier
        supplier_ppm = df.groupby('supplier').agg({
            'quantity_received': 'sum',
            'quantity_defective': 'sum'
        })

        supplier_ppm['ppm'] = (
            supplier_ppm['quantity_defective'] /
            supplier_ppm['quantity_received'] * 1000000
        )

        supplier_ppm['meets_target'] = supplier_ppm['ppm'] <= self.target_ppm

        return supplier_ppm.sort_values('ppm', ascending=False)

    def identify_quality_issues(self):
        """Identify suppliers with quality problems"""

        ppm_data = self.calculate_supplier_ppm()

        critical_suppliers = ppm_data[ppm_data['ppm'] > self.target_ppm * 3]
        warning_suppliers = ppm_data[
            (ppm_data['ppm'] > self.target_ppm) &
            (ppm_data['ppm'] <= self.target_ppm * 3)
        ]

        return {
            'critical_suppliers': critical_suppliers,
            'warning_suppliers': warning_suppliers,
            'total_suppliers': len(ppm_data),
            'compliant_suppliers': len(ppm_data[ppm_data['meets_target']]),
            'compliance_rate': len(ppm_data[ppm_data['meets_target']]) / len(ppm_data) * 100
        }

    def generate_corrective_action(self, supplier, issue_description):
        """Generate corrective action request (CAR)"""

        car = {
            'car_id': f"CAR_{datetime.now().strftime('%Y%m%d%H%M%S')}",
            'supplier': supplier,
            'issue_date': datetime.now(),
            'issue_description': issue_description,
            'current_ppm': self.calculate_supplier_ppm(supplier)['ppm'].iloc[0],
            'target_ppm': self.target_ppm,
            'required_actions': [
                'Root cause analysis within 48 hours',
                'Containment plan immediate',
                'Corrective action plan within 1 week',
                'Effectiveness validation within 30 days'
            ],
            'status': 'open'
        }

        return car


# Example
qm = AutomotiveQualityManager(target_ppm=50)

# Record receipts
qm.record_receipt({
    'receipt_date': datetime.now() - timedelta(days=10),
    'supplier': 'Supplier_A',
    'part_number': 'PART_001',
    'quantity_received': 10000,
    'quantity_defective': 3
})

qm.record_receipt({
    'receipt_date': datetime.now() - timedelta(days=5),
    'supplier': 'Supplier_B',
    'part_number': 'PART_002',
    'quantity_received': 5000,
    'quantity_defective': 8
})

ppm = qm.calculate_supplier_ppm()
print("Supplier PPM:")
print(ppm)

issues = qm.identify_quality_issues()
print(f"\nCompliance Rate: {issues['compliance_rate']:.0f}%")

---

EVサプライチェーンに関する考慮事項

電気自動車への移行

サプライチェーンの違い：

従来型ICE（内燃機関）車両：

• 約30,000個の部品
• 複雑なパワートレイン（エンジン、トランスミッション、排気系）
• 成熟したサプライヤー基盤
• 確立されたプロセス

電気自動車（EV）：

• 約20,000個の部品（よりシンプル）
• バッテリーパック（車両コストの40～50％）
• 電気モーターとインバーター
• 新たなサプライヤー基盤
• バッテリーサプライチェーンが重要

class EVSupplyChainAnalyzer:
    """
    Analyze EV vs. ICE supply chain differences
    """

    def __init__(self):
        self.ice_bom_cost = 25000  # Average ICE vehicle BOM cost
        self.ev_bom_cost = 35000   # Average EV vehicle BOM cost

    def compare_cost_structures(self):
        """Compare ICE vs. EV cost structures"""

        ice_structure = {
            'powertrain': 0.25,  # 25% - engine, transmission
            'body_chassis': 0.30,
            'electronics': 0.15,
            'interior': 0.20,
            'other': 0.10
        }

        ev_structure = {
            'battery_pack': 0.40,  # 40% - massive cost driver
            'electric_motor': 0.05,
            'power_electronics': 0.10,
            'body_chassis': 0.25,
            'electronics': 0.10,
            'interior': 0.08,
            'other': 0.02
        }

        comparison = pd.DataFrame({
            'ICE_pct': ice_structure,
            'EV_pct': ev_structure,
            'ICE_cost': {k: v * self.ice_bom_cost for k, v in ice_structure.items()},
            'EV_cost': {k: v * self.ev_bom_cost for k, v in ev_structure.items()}
        })

        return comparison

    def analyze_battery_supply_chain(self, battery_capacity_kwh, cell_chemistry='NMC'):
        """
        Analyze battery supply chain requirements

        Parameters:
        - battery_capacity_kwh: battery pack size (kWh)
        - cell_chemistry: NMC (Nickel Manganese Cobalt) or LFP (Lithium Iron Phosphate)

        Returns:
        - material requirements
        """

        # Material requirements per kWh (kg)
        if cell_chemistry == 'NMC':
            materials = {
                'lithium': 0.8,
                'nickel': 1.2,
                'cobalt': 0.2,
                'manganese': 0.3,
                'graphite': 1.0,
                'copper': 1.5,
                'aluminum': 2.0
            }
        elif cell_chemistry == 'LFP':
            materials = {
                'lithium': 0.6,
                'iron': 1.0,
                'phosphate': 0.8,
                'graphite': 1.0,
                'copper': 1.2,
                'aluminum': 1.8
            }

        # Calculate total materials
        total_materials = {
            material: amount * battery_capacity_kwh
            for material, amount in materials.items()
        }

        # Estimate costs ($/kg)
        material_costs = {
            'lithium': 30,
            'nickel': 18,
            'cobalt': 35,
            'manganese': 2,
            'iron': 0.50,
            'phosphate': 1.50,
            'graphite': 8,
            'copper': 9,
            'aluminum': 2.5
        }

        total_material_cost = sum(
            total_materials.get(mat, 0) * cost
            for mat, cost in material_costs.items()
        )

        return {
            'battery_capacity_kwh': battery_capacity_kwh,
            'cell_chemistry': cell_chemistry,
            'materials_kg': total_materials,
            'material_cost': total_material_cost,
            'cost_per_kwh': total_material_cost / battery_capacity_kwh
        }


# Example
analyzer = EVSupplyChainAnalyzer()

cost_comparison = analyzer.compare_cost_structures()
print("Cost Structure Comparison:")
print(cost_comparison)

battery_analysis = analyzer.analyze_battery_supply_chain(
    battery_capacity_kwh=75,
    cell_chemistry='NMC'
)

print(f"\nBattery Materials for 75 kWh pack:")
print(f"Lithium: {battery_analysis['materials_kg']['lithium']:.1f} kg")
print(f"Total Material Cost: ${battery_analysis['material_cost']:,.0f}")
print(f"Cost per kWh: ${battery_analysis['cost_per_kwh']:.0f}")

---

自動車業界固有のパフォーマンス指標

主要業績評価指標

class AutomotiveKPITracker:
    """
    Track automotive supply chain KPIs
    """

    def __init__(self):
        self.kpis = {}

    def calculate_inventory_turns(self, annual_cogs, avg_inventory):
        """Inventory turnover (target: 15-20 for automotive)"""
        turns = annual_cogs / avg_inventory
        self.kpis['inventory_turns'] = turns
        return turns

    def calculate_dock_to_dock_time(self, total_cycle_time_hours):
        """Dock-to-dock time (supplier dock to customer dock)"""
        self.kpis['dock_to_dock_hours'] = total_cycle_time_hours
        return total_cycle_time_hours

    def calculate_otd(self, on_time_deliveries, total_deliveries):
        """On-Time Delivery (target: >99%)"""
        otd = on_time_deliveries / total_deliveries * 100
        self.kpis['otd_pct'] = otd
        return otd

    def calculate_line_stoppage_rate(self, stoppages, production_hours):
        """Line stoppages per 1000 production hours"""
        rate = (stoppages / production_hours) * 1000
        self.kpis['line_stoppage_per_1000hrs'] = rate
        return rate

    def generate_scorecard(self, benchmarks):
        """Generate KPI scorecard with benchmarks"""

        scorecard = []

        for kpi, value in self.kpis.items():
            benchmark = benchmarks.get(kpi, {})

            if 'target' in benchmark:
                if 'higher_better' in benchmark and benchmark['higher_better']:
                    status = 'green' if value >= benchmark['target'] else 'red'
                else:
                    status = 'green' if value <= benchmark['target'] else 'red'
            else:
                status = 'unknown'

            scorecard.append({
                'kpi': kpi,
                'actual': value,
                'target': benchmark.get('target', 'N/A'),
                'status': status
            })

        return pd.DataFrame(scorecard)


# Example
tracker = AutomotiveKPITracker()

tracker.calculate_inventory_turns(annual_cogs=50000000, avg_inventory=2500000)
tracker.calculate_otd(on_time_deliveries=9950, total_deliveries=10000)
tracker.calculate_line_stoppage_rate(stoppages=5, production_hours=2000)

benchmarks = {
    'inventory_turns': {'target': 15, 'higher_better': True},
    'otd_pct': {'target': 99, 'higher_better': True},
    'line_stoppage_per_1000hrs': {'target': 3, 'higher_better': False}
}

scorecard = tracker.generate_scorecard(benchmarks)
print("Automotive Supply Chain Scorecard:")
print(scorecard)

---

ツールとテクノロジー

自動車サプライチェーンソフトウェア

Tier 1サプライヤー管理：

• SAP Automotive：自動車業界向けの統合サプライチェーン
• Oracle E-Business Suite：自動車業界固有のモジュール
• Kinaxis RapidResponse：自動車業界向けS&OP
• Blue Yonder：サプライチェーンの計画と実行
• Coupa Supply Chain Design：ネットワークの最適化

サプライヤーとの連携：

• SupplyOn：自動車サプライヤーネットワーク（BMW、VW、Continental）
• Elemica：サプライチェーン連携
• E2open：多階層の可視性
• Llamasoft：サプライチェーンモデリング

品質管理：

• IQMS：品質管理機能を備えた製造ERP
• TrackWise：品質とコンプライアンス
• MasterControl：サプライヤー品質管理
• ETQ Reliance：CAPAと品質

Pythonライブラリ

# Supply chain optimization
from pulp import *
import pyomo.environ as pyo

# Data analysis
import pandas as pd
import numpy as np

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

# Machine learning for forecasting
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression

---

よくある課題と解決策

課題：単一供給元への依存リスク

問題：

• 重要部品を単一のサプライヤーから調達している
• サプライヤーに問題が発生すると工場が停止する
• サプライヤーの交渉力が強い

解決策：

• 複数供給元戦略（少なくとも30／70の割合で分割）
• 重要部品の安全在庫
• サプライヤーの財務状況のモニタリング
• 委託製造契約
• 重要部品の垂直統合

課題：新しい工具・金型のリードタイムの長さ

問題：

• 工具・金型のリードタイムが6-12か月
• 新モデルの発売が遅れる
• 資本コストが高い

解決策：

• サプライヤーの早期関与（ESI）
• コンカレントエンジニアリング
• ラピッドプロトタイピングとテスト
• モジュール式の工具・金型設計
• 実物の工具・金型を製作する前にデジタルシミュレーションを実施

課題：1,000社以上のサプライヤーの管理

問題：

• 多層ネットワークの管理が複雑
• Tier 2／3の可視性が不足
• 下位階層のサプライヤーに起因する品質問題

解決策：

• サプライヤーの階層化と分類
• 多層可視化プラットフォーム
• サプライヤースコアカードと監査
• サプライヤー育成プログラム
• 戦略的なサプライヤー数の削減（集約）

課題：EV バッテリー供給の制約

問題：

• バッテリーセルの生産能力が限られている
• リチウム、コバルト、ニッケルの獲得競争
• 価格変動が大きい
• 地理的な集中（中国）

解決策：

• 長期供給契約（引取契約）
• 垂直統合（自社バッテリー工場）
• セルのサプライヤーと化学組成を多様化
• リサイクルプログラム（循環型経済）
• 代替化学組成（LFP、全固体電池）

---

出力形式

自動車サプライチェーンレポート

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

• 工場：Detroit Assembly（Model A、Model B）
• 日次生産台数：1,000台
• Tier 1 サプライヤー：120社
• 在庫回転率：18.5（目標：15以上）
• OTD パフォーマンス：98.5%（目標：99%）
• 品質：42 PPM（目標：<50 PPM）
• ライン停止：1,000時間あたり2.1回（目標：<3）

サプライチェーンのパフォーマンス：

指標	実績	目標	状態
在庫回転率	18.5	15+	✓ Green
OTD%	98.5%	99%	⚠ Yellow
品質（PPM）	42	<50	✓ Green
ライン停止	2.1	<3	✓ Green
ドック・ツー・ドック時間	4.2 hrs	<6 hrs	✓ Green

サプライヤー品質（主な問題）：

サプライヤー	部品	PPM	状態	対応
Supplier_X	PART_123	285	Critical	CAR を発行済み
Supplier_Y	PART_456	110	Warning	審査中
Supplier_Z	PART_789	45	Good	モニタリング

JIT 納入パフォーマンス：

サプライヤー	納入回数	定時	早着	遅延	パフォーマンス
Supplier_A	250	248	1	1	99.2%
Supplier_B	180	175	3	2	97.2%
Supplier_C	300	300	0	0	100%

アクション項目：

1. Supplier_X の品質問題（285 PPM）に対処 - CAR 対応中
2. OTD を98.5%から99%に改善 - パフォーマンスが低い3社に注力
3. Model C の発売に向け、EV バッテリーサプライヤーの認定を完了
4. 重要部品向けの Tier 2 可視化プラットフォームを導入

---

確認事項

より詳しい情報が必要な場合：

1. OEM、またはTier 1／2／3サプライヤーですか？
2. どのような製品・部品を製造していますか？
3. 生産量とモデルの複雑さはどの程度ですか？
4. 現在のサプライチェーン構造と主要な指標は何ですか？
5. JIT 納入を導入していますか？
6. サプライヤーの品質実績（PPM）はどの程度ですか？
7. EV 製品、または移行計画はありますか？
8. 主なサプライチェーンの課題や問題点は何ですか？

---

関連スキル

• production-scheduling：組立ラインのスケジューリング向け
• lean-manufacturing：ムダの排除と継続的改善向け
• capacity-planning：生産能力の管理向け
• supplier-selection：サプライヤーの評価と認定向け
• supplier-risk-management：供給の継続性向け
• quality-management：品質システムとSPC向け
• inventory-optimization：安全在庫と在庫方針向け
• master-production-scheduling：MPSの策定向け
• demand-forecasting：生産計画向け