Six Sigma — DMAIC and Process Improvement

Six Sigma is a disciplined, data-driven methodology for eliminating defects and reducing process variation to achieve near-perfect quality outcomes. Originating at Motorola in the 1980s under engineer Bill Smith, Six Sigma has evolved into a comprehensive management philosophy grounded in statistical thinking and rigorous process improvement. The methodology targets a maximum of 3.4 defects per million opportunities (DPMO), corresponding to a process that operates at 6 sigma levels of quality where sigma represents the standard deviation from the mean.

Theoretical Foundation

Process Capability Indices

Process capability indices quantify how well a process can meet specification limits relative to its natural variation.

DMAIC Methodology

DMAIC is the core improvement cycle in Six Sigma, consisting of five structured phases. Each phase employs specific statistical tools and methodologies.

Define Phase Tools

The Define phase establishes project charter, Voice of the Customer (VOC) translation, and SIPOC mapping:

• CTQ Tree: Decomposes critical-to-quality characteristics from high-level needs to measurable specifications
• SIPOC Diagram: Maps Suppliers, Inputs, Process, Outputs, and Customers to define process boundaries
• Project Charter: Documents business case, problem statement, goal statement, and team roles

Measure Phase Tools

The Measure phase quantifies current performance and validates the measurement system:

• Gage R&R Study: Assesses measurement system variation through analysis of variance:

• Process Capability Analysis: Computes , , , from collected data
• Data Collection Plan: Defines sampling strategy, sample size, and measurement procedures

Analyze Phase Tools

Statistical analysis identifies root causes and quantifies their impact:

• Hypothesis Testing: Tests significance of potential factors using t-tests, ANOVA, chi-square tests
• Regression Analysis: Models relationships between inputs (X's) and outputs (Y):

• Multi-Vari Studies: Decomposes variation into positional, cyclical, and temporal components
• Failure Mode and Effects Analysis (FMEA): Prioritizes risks using Risk Priority Numbers:

Improve Phase Tools

Solutions are developed and validated through designed experiments:

• Design of Experiments (DOE): Systematic variation of factors to optimize responses
• Mistake-Proofing (Poka-Yoke): Engineering controls that prevent defects
• Pilot Testing: Small-scale validation before full implementation

Control Phase Tools

Gains are sustained through monitoring and standardization:

• Statistical Process Control (SPC): Control charts monitor process stability:

• Control Plan: Documents monitoring procedures, response plans, and responsible parties
• Standard Operating Procedures (SOPs): Formalized work instructions

Python Implementation

import numpy as np
import pandas as pd
from scipy import stats
import matplotlib.pyplot as plt
from matplotlib.patches import FancyBboxPatch

# Process Capability Analysis
def calculate_capability(data, usl, lsl, target=None):
    """Calculate process capability indices."""
    n = len(data)
    x_bar = np.mean(data)
    s = np.std(data, ddof=1)
    
    # Within-subgroup estimate (using ranges or s)
    sigma_within = s  # Simplified; in practice use pooled estimate
    
    # Capability indices
    cp = (usl - lsl) / (6 * sigma_within)
    cpu = (usl - x_bar) / (3 * sigma_within)
    cpl = (x_bar - lsl) / (3 * sigma_within)
    cpk = min(cpu, cpl)
    
    # Process performance (overall)
    sigma_overall = np.std(data, ddof=0)
    pp = (usl - lsl) / (6 * sigma_overall)
    ppk = min((usl - x_bar) / (3 * sigma_overall),
              (x_bar - lsl) / (3 * sigma_overall))
    
    # DPMO calculation
    z_upper = (usl - x_bar) / sigma_overall
    z_lower = (x_bar - lsl) / sigma_overall
    z_min = min(z_upper, z_lower)
    ppm = (1 - stats.norm.cdf(z_min)) * 1e6 * 2  # Two-sided
    
    return {
        'Cp': cp, 'Cpu': cpu, 'Cpl': cpl, 'Cpk': cpk,
        'Pp': pp, 'Ppk': ppk, 'Sigma_Level': z_min,
        'DPMO': ppm, 'Mean': x_bar, 'Std': sigma_overall
    }

# Generate example process data (shifted process)
np.random.seed(42)
process_data = np.random.normal(loc=10.05, scale=0.12, size=200)

# Calculate capability
results = calculate_capability(process_data, usl=10.5, lsl=9.5)
print("Process Capability Analysis:")
for key, value in results.items():
    print(f"  {key}: {value:.4f}")

# DPMO to Sigma Level conversion table
def dpmo_to_sigma(dpmo):
    """Convert DPMO to sigma level with 1.5 sigma shift."""
    p = dpmo / 1e6
    z = stats.norm.ppf(1 - p/2) + 1.5
    return z

# Control Chart for Phase Monitoring
def xbar_r_chart(data, subgroup_size=5):
    """Generate X-bar and R control charts."""
    n_subgroups = len(data) // subgroup_size
    subgroups = data[:n_subgroups * subgroup_size].reshape(n_subgroups, subgroup_size)
    
    x_bar = np.mean(subgroups, axis=1)
    r = np.ptp(subgroups, axis=1)
    
    x_bar_mean = np.mean(x_bar)
    r_mean = np.mean(r)
    
    # Control limits (from standard constants)
    A2 = 0.577  # For n=5
    D3 = 0
    D4 = 2.114
    
    ucl_x = x_bar_mean + A2 * r_mean
    lcl_x = x_bar_mean - A2 * r_mean
    ucl_r = D4 * r_mean
    lcl_r = D3 * r_mean
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
    
    # X-bar chart
    ax1.plot(x_bar, 'o-', markersize=4)
    ax1.axhline(x_bar_mean, color='green', linestyle='-', label='Center Line')
    ax1.axhline(ucl_x, color='red', linestyle='--', label='UCL')
    ax1.axhline(lcl_x, color='red', linestyle='--', label='LCL')
    ax1.set_ylabel('X-bar')
    ax1.set_title('X-bar Control Chart')
    ax1.legend()
    
    # R chart
    ax2.plot(r, 'o-', markersize=4)
    ax2.axhline(r_mean, color='green', linestyle='-', label='Center Line')
    ax2.axhline(ucl_r, color='red', linestyle='--', label='UCL')
    ax2.axhline(lcl_r, color='red', linestyle='--', label='LCL')
    ax2.set_ylabel('Range')
    ax2.set_title('R Control Chart')
    ax2.legend()
    
    plt.tight_layout()
    plt.savefig('control_charts.png', dpi=150)
    plt.show()

# DMAIC Project Metrics
def dmaic_dashboard():
    """Simulate DMAIC project tracking metrics."""
    phases = ['Define', 'Measure', 'Analyze', 'Improve', 'Control']
    metrics = {
        'Baseline_DPMO': [12000, 12000, 12000, 12000, 12000],
        'Current_DPMO': [12000, 9500, 6200, 2800, 1800],
        'Sigma_Level': [3.5, 3.7, 4.0, 4.5, 4.8]
    }
    
    fig, ax1 = plt.subplots(figsize=(10, 6))
    
    x = np.arange(len(phases))
    width = 0.35
    
    bars1 = ax1.bar(x - width/2, metrics['Baseline_DPMO'], width, 
                    label='Baseline DPMO', alpha=0.7, color='red')
    bars2 = ax1.bar(x + width/2, metrics['Current_DPMO'], width, 
                    label='Current DPMO', alpha=0.7, color='green')
    
    ax1.set_xlabel('DMAIC Phase')
    ax1.set_ylabel('DPMO')
    ax1.set_title('DMAIC Improvement Trajectory')
    ax1.set_xticks(x)
    ax1.set_xticklabels(phases)
    ax1.legend()
    
    # Annotate sigma levels
    for i, sigma in enumerate(metrics['Sigma_Level']):
        ax1.annotate(f'σ={sigma}', xy=(i, metrics['Current_DPMO'][i]),
                    ha='center', va='bottom', fontsize=9)
    
    plt.tight_layout()
    plt.savefig('dmaic_dashboard.png', dpi=150)
    plt.show()

Six Sigma Toolset Summary