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（原始设备制造商）：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（百万分率）缺陷跟踪

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、固态电池）

---

输出格式

汽车供应链报告

执行摘要：

• 工厂：底特律装配厂（Model A、Model B）
• 日产量：1,000 辆汽车
• Tier 1 供应商：120 家
• 库存周转次数：18.5（目标：15+）
• OTD 表现：98.5%（目标：99%）
• 质量：42 PPM（目标：<50 PPM）
• 生产线停工：每 1000 小时 2.1 次（目标：<3）

供应链表现：

指标	实际值	目标值	状态
库存周转次数	18.5	15+	✓ 绿色
OTD%	98.5%	99%	⚠ 黄色
质量（PPM）	42	<50	✓ 绿色
生产线停工	2.1	<3	✓ 绿色
从收货到发货时间	4.2 小时	<6 小时	✓ 绿色

供应商质量（主要问题）：

供应商	零部件	PPM	状态	措施
Supplier_X	PART_123	285	严重	已发出 CAR
Supplier_Y	PART_456	110	警告	审查中
Supplier_Z	PART_789	45	良好	监控

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：用于生产计划