Controle Estatístico de Processos: Amostragem de Aceitação Lote a Lote para Atributos

Mapa do Capítulo 15

Agenda

• O problema da amostragem de aceitação: motivação, vantagens e desvantagens
• Tipos de planos: única, dupla, múltipla e sequencial
• Curva Característica de Operação (CO): tipos A e B, efeitos de \(n\) e \(c\)
• Amostragem dupla: curvas primária e secundárias (Exemplo prático)
• Amostragem sequencial: o Teste Sequencial da Razão de Probabilidade (TSRP) de Wald
• Inspeção de retificação: Qualidade de Saída Média (QSM), LQSM e ITM
• MIL STD 105E (ANSI/ASQC Z1.4, ISO 2859): esquema orientado por NQA
• Planos de Dodge-Romig: PADL e LQSM

Configuração do Ambiente em R

library(ggplot2)
library(patchwork)

pal <- c(azul   = "#7ecff7",
         verde  = "#4f9d6e",
         ambar  = "#f7c87e",
         roxo   = "#c87ef7",
         coral  = "#f07050",
         neutro = "#aab4c8")

tema_cep <- function(base_size = 13) {
  theme_minimal(base_size = base_size) +
    theme(plot.title = element_text(face = "bold"),
          panel.grid.minor = element_blank())
}

O Problema da Amostragem de Aceitação

• Amostragem é a técnica estatística usada para estimar características de uma população a partir da observação de uma fração dela — a amostra
• Uma indústria recebe um carregamento (lote) de um fornecedor; seleciona-se uma amostra e inspeciona-se uma característica da qualidade
• Com base nessa informação, toma-se uma decisão: aceitar ou rejeitar o lote — o chamado sentenciamento do lote
• Lotes aceitos seguem para processamento; lotes rejeitados são retrabalhados ou sucateados

Diferentes Abordagens de Inspeção

• Aceitar sem inspeção: útil quando o processo é muito bom (capacidade \(C_p \ge 3\) ou \(4\)) ou quando há necessidade de conter despesas
• Inspeção 100%: remove todas as unidades defeituosas; usada quando é crítico impedir a passagem de itens defeituosos, ou quando a capacidade do processo é duvidosa
• Amostragem de aceitação: apropriada quando o teste é destrutivo, quando a inspeção 100% é cara, quando há muitos itens, ou quando há bom histórico de qualidade do fornecedor

Amostragem de Aceitação vs. Inspeção 100%

Tipos de Planos de Amostragem

• Amostragem Única: seleciona-se \(n\) itens; conta-se os defeitos \(d\); aceita-se se \(d \le c\)
• Amostragem Dupla: a decisão pode exigir uma segunda amostra antes do sentenciamento
• Amostragem Múltipla: extensão da dupla para mais de duas amostras
• Amostragem Sequencial: unidades são retiradas uma a uma; a cada unidade decide-se aceitar, rejeitar ou continuar amostrando

Formação dos Lotes

A forma como o lote é constituído afeta diretamente a eficiência do plano de amostragem:

• Os lotes devem ser homogêneos
• Lotes maiores são preferíveis a lotes menores, por razões econômicas
• Deve haver fácil acesso ao lote para a escolha aleatória dos itens
• As unidades devem ser escolhidas aleatoriamente e ser representativas de todo o lote

Planos de Amostragem Única para Atributos

• Definido por dois parâmetros: o tamanho amostral \(n\) e o número de aceitação \(c\)
• Exemplo: lote de tamanho \(N = 10.000\). O plano \(n = 89\), \(c = 2\) significa: inspecionar \(89\) unidades aleatórias e contar o número \(d\) de itens não conformes
• Se \(d \le 2\), o lote é aceito; se \(d > 2\), o lote é rejeitado

Fundamento Probabilístico

• A característica de qualidade é dicotômica (conforme/não conforme)
• A distribuição do número de defeitos \(d\) em uma amostra de \(n\) itens é:
  • Binomial, quando \(N \to \infty\) (ou \(N \gg n\))
  • Hipergeométrica, quando \(N\) é finito
• Em ambos os casos, \(p\) representa a fração de itens defeituosos no lote

A Curva Característica de Operação (CO) — Tipo B

A CO plota a probabilidade de aceitação do lote versus a fração de defeituosos, revelando o poder discriminatório do plano:

\[P_a = P(d \le c) = \sum_{d=0}^{c} \binom{n}{d} p^d (1-p)^{n-d}\]

onde \(d \sim \text{Binomial}(n, p)\).

Exemplo: Cálculo Manual da Curva CO

n_ex <- 89
c_ex <- 2
p_ex <- 0.01

Pa_manual <- pbinom(c_ex, n_ex, p_ex)
cat(sprintf("Pa = %.4f\n", Pa_manual))

Pa = 0.9397

\(P_a \approx 0{,}9397\) — cerca de 94% dos lotes com 1% de defeituosos serão aceitos por este plano.

Construindo a Curva CO Completa no R

p_seq <- seq(0.005, 0.09, by = 0.001)
Pa_seq <- pbinom(c_ex, n_ex, p_seq)
df_co <- data.frame(p = p_seq, Pa = Pa_seq)

ggplot(df_co, aes(p, Pa)) +
  geom_line(color = pal["azul"], linewidth = 1.1) +
  labs(title = "Curva CO Tipo B para n = 89 e c = 2",
       x = "Fracao de defeituosos do lote (p)",
       y = "Probabilidade de aceitacao (Pa)") +
  tema_cep()

Efeitos de \(n\) e \(c\) sobre as Curvas CO

• A curva CO ideal discriminaria perfeitamente entre lotes bons e ruins — só é alcançável (na teoria) com inspeção 100% livre de erro
• Aumentar o tamanho amostral \(n\), mantendo \(c\) proporcional a \(n\), aproxima a forma da curva real da ideal
• Planos com menores valores de \(c\) discriminam melhor em níveis baixos de \(p\) do que planos com \(c\) maior

Elaborando um Plano com Curva CO Especificada

Uma curva CO fica completamente definida por dois pontos — e é assim que, na prática, \(n\) e \(c\) são escolhidos (não o contrário):

• \((p_1, 1-\alpha)\): a qualidade que se quer aceitar com alta probabilidade — \(p_1\) é o NQA, e \(\alpha\) é o risco do produtor
• \((p_2, \beta)\): a qualidade ruim que se quer rejeitar com alta probabilidade — \(p_2\) é o PADL, e \(\beta\) é o risco do consumidor

\[1-\alpha = \sum_{d=0}^{c}\binom{n}{d}p_1^d(1-p_1)^{n-d}, \qquad \beta = \sum_{d=0}^{c}\binom{n}{d}p_2^d(1-p_2)^{n-d}\]

• Duas equações não lineares, duas incógnitas (\(n\) inteiro, \(c\) inteiro) — sem solução fechada
• Historicamente resolvido com um nomograma binomial (Duncan, 1986); hoje, resolve-se numericamente
• Como \(n\) e \(c\) devem ser inteiros, raramente existe uma solução que passe exatamente pelos dois pontos — busca-se o plano cuja curva CO passe o mais próximo possível de ambos

Resolvendo o Sistema no R

p1_dp <- 0.01; alpha_dp <- 0.05; p2_dp <- 0.06; beta_dp <- 0.10
n_max_dp <- 200

n1_de_c <- function(c) {
  ns <- (c + 1):n_max_dp
  ok <- ns[pbinom(c, ns, p1_dp) >= (1 - alpha_dp)]
  if (length(ok) == 0) return(NA)
  max(ok)
}
n2_de_c <- function(c) {
  ns <- (c + 1):n_max_dp
  ok <- ns[pbinom(c, ns, p2_dp) <= beta_dp]
  if (length(ok) == 0) return(NA)
  min(ok)
}

candidatos <- data.frame(c = 0:6)
candidatos$n1 <- sapply(candidatos$c, n1_de_c)
candidatos$n2 <- sapply(candidatos$c, n2_de_c)
candidatos$gap <- abs(candidatos$n1 - candidatos$n2)
print(candidatos)

  c  n1  n2 gap
1 0   5  38  33
2 1  35  64  29
3 2  82  88   6
4 3 137 110  27
5 4 198 132  66
6 5 200 153  47
7 6 200 174  26

melhor <- candidatos[which.min(candidatos$gap), ]
n_final <- round((melhor$n1 + melhor$n2) / 2)

cat(sprintf("\nMelhor c = %d (n1=%d, n2=%d)\n", melhor$c, melhor$n1, melhor$n2))

Melhor c = 2 (n1=82, n2=88)

cat(sprintf("n escolhido = %d\n", n_final))

n escolhido = 85

cat(sprintf("Pa(p1) = %.4f (meta >= %.2f)\n", pbinom(melhor$c, n_final, p1_dp), 1 - alpha_dp))

Pa(p1) = 0.9460 (meta >= 0.95)

cat(sprintf("Pa(p2) = %.4f (meta <= %.2f)\n", pbinom(melhor$c, n_final, p2_dp), beta_dp))

Pa(p2) = 0.1090 (meta <= 0.10)

n1(c) é o maior \(n\) que ainda garante \(P_a(p_1) \ge 1-\alpha\); n2(c) é o menor \(n\) que já garante \(P_a(p_2) \le \beta\). O \(c\) ideal é aquele em que essas duas fronteiras ficam mais próximas — aqui, \(c=2\), com \(n\) bem próximo do \(n=89\) usado ao longo do capítulo.

Comparando Curvas CO: Efeito de \(n\)

planos_n <- list(c(n = 50, c = 1), c(n = 100, c = 2), c(n = 200, c = 4))
p_seq2 <- seq(0.001, 0.08, by = 0.001)

df_n <- do.call(rbind, lapply(planos_n, function(pl) {
  data.frame(p = p_seq2, Pa = pbinom(pl["c"], pl["n"], p_seq2),
             plano = sprintf("n=%d, c=%d", pl["n"], pl["c"]))
}))

ggplot(df_n, aes(p, Pa, color = plano)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["azul"]), unname(pal["verde"]), unname(pal["coral"]))) +
  labs(title = "Efeito do tamanho amostral sobre a curva CO",
       x = "Fracao de defeituosos (p)", y = "Probabilidade de aceitacao",
       color = "Plano") +
  tema_cep()

Comparando Curvas CO: Efeito de \(c\) (mesmo \(n\))

planos_c <- list(c(n = 89, c = 0), c(n = 89, c = 1), c(n = 89, c = 2))
df_c <- do.call(rbind, lapply(planos_c, function(pl) {
  data.frame(p = p_seq2, Pa = pbinom(pl["c"], pl["n"], p_seq2),
             plano = sprintf("n=%d, c=%d", pl["n"], pl["c"]))
}))

ggplot(df_c, aes(p, Pa, color = plano)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["roxo"]), unname(pal["ambar"]), unname(pal["azul"]))) +
  labs(title = "Efeito do numero de aceitacao c sobre a curva CO",
       x = "Fracao de defeituosos (p)", y = "Probabilidade de aceitacao",
       color = "Plano") +
  tema_cep()

A Curva CO Tipo A

• Utilizada para calcular probabilidades de aceitação em lotes de tamanho finito — a distribuição correta é a Hipergeométrica
• Quando \(N\) é grande em relação a \(n\), a curva Tipo A é bem aproximada pela curva Tipo B (Binomial)
• A diferença entre as duas curvas cresce à medida que \(N\) diminui (relativamente a \(n\))

Comparando Curvas CO Tipo A e Tipo B no R

n_ab <- 50; c_ab <- 1; N_ab <- 500
p_seq3 <- seq(0.005, 0.09, by = 0.002)

Pa_tipoB <- pbinom(c_ab, n_ab, p_seq3)
Pa_tipoA <- sapply(p_seq3, function(p) {
  D <- round(p * N_ab)
  phyper(c_ab, D, N_ab - D, n_ab)
})

df_ab <- rbind(data.frame(p = p_seq3, Pa = Pa_tipoB, tipo = "Tipo B (Binomial)"),
               data.frame(p = p_seq3, Pa = Pa_tipoA, tipo = "Tipo A (Hipergeometrica, N=500)"))

ggplot(df_ab, aes(p, Pa, color = tipo)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["coral"]), unname(pal["azul"]))) +
  labs(title = "Curvas CO Tipo A vs Tipo B (n=50, c=1)",
       x = "Fracao de defeituosos (p)", y = "Probabilidade de aceitacao", color = NULL) +
  tema_cep()

Exercício — Curvas CO Tipo A e B

N_exercicio <- 1000
p_seq4 <- seq(0.01, 0.15, by = 0.005)
Pa_B <- pbinom(1, 50, p_seq4)
Pa_A <- sapply(p_seq4, function(p) {
  D <- round(p * N_exercicio)
  phyper(1, D, N_exercicio - D, 50)
})
comparacao <- data.frame(p = p_seq4, Tipo_B = round(Pa_B, 4), Tipo_A = round(Pa_A, 4))
head(comparacao, 8)

      p Tipo_B Tipo_A
1 0.010 0.9106 0.9147
2 0.015 0.8273 0.8299
3 0.020 0.7358 0.7360
4 0.025 0.6435 0.6415
5 0.030 0.5553 0.5512
6 0.035 0.4738 0.4681
7 0.040 0.4005 0.3937
8 0.045 0.3357 0.3283

Para \(N\) moderado (aqui, 1.000), as curvas já são bastante próximas — a Binomial é uma excelente aproximação prática.

Plano de Amostragem Dupla

Definido por quatro parâmetros:

• \(n_1\): tamanho da primeira amostra
• \(c_1\): número de aceitação da primeira amostra
• \(n_2\): tamanho da segunda amostra
• \(c_2\): número de aceitação (combinado) da segunda amostra

Vantagem principal: pode reduzir a quantidade total de inspeção exigida em relação à amostragem única.

Fluxograma da Amostragem Dupla

Curva CO da Amostragem Dupla

Um plano de amostragem dupla é caracterizado por três curvas CO:

• Primária: probabilidade de aceitação considerando as amostras combinadas
• Secundária (aceitação na 1ª amostra): idêntica à curva de uma amostragem única com \(n_1\), \(c_1\)
• Secundária (rejeição na 1ª amostra): probabilidade de já rejeitar o lote na primeira amostra

\[P_a = P_a^{I} + P_a^{II}, \qquad P_a^{I} = P(d_1 \le c_1)\]

\[P_a^{II} = \sum_{d_1 = c_1+1}^{c_2} P(d_1) \cdot P(d_2 \le c_2 - d_1)\]

Exemplo: Amostragem Dupla no R

n1 <- 50; c1 <- 1; n2 <- 100; c2 <- 3; p_dup <- 0.05

PaI <- pbinom(c1, n1, p_dup)

PaII <- 0
for (d1 in (c1 + 1):c2) {
  PaII <- PaII + dbinom(d1, n1, p_dup) * pbinom(c2 - d1, n2, p_dup)
}

Pa_total <- PaI + PaII
cat(sprintf("Pa_I = %.4f | Pa_II = %.4f | Pa total = %.4f\n", PaI, PaII, Pa_total))

Pa_I = 0.2794 | Pa_II = 0.0110 | Pa total = 0.2904

Cerca de 29% dos lotes com 5% de defeituosos serão aceitos — a maior parte dessa probabilidade (quase toda) vem já da primeira amostra.

Curvas CO da Amostragem Dupla — Visualização

p_seq5 <- seq(0.005, 0.12, by = 0.002)

Pa_I_curve <- pbinom(c1, n1, p_seq5)
Pa_R_curve <- 1 - pbinom(c2, n1, p_seq5)

Pa_total_curve <- sapply(p_seq5, function(p) {
  PaI_p <- pbinom(c1, n1, p)
  PaII_p <- 0
  for (d1 in (c1 + 1):c2) {
    PaII_p <- PaII_p + dbinom(d1, n1, p) * pbinom(c2 - d1, n2, p)
  }
  PaI_p + PaII_p
})

df_dupla <- rbind(
  data.frame(p = p_seq5, Pa = Pa_total_curve, curva = "Primaria (combinada)"),
  data.frame(p = p_seq5, Pa = Pa_I_curve, curva = "Aceitacao na 1a amostra"),
  data.frame(p = p_seq5, Pa = Pa_R_curve, curva = "Rejeicao na 1a amostra")
)

ggplot(df_dupla, aes(p, Pa, color = curva)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["azul"]), unname(pal["verde"]), unname(pal["coral"]))) +
  labs(title = "Curvas CO da amostragem dupla (n1=50,c1=1,n2=100,c2=3)",
       x = "Fracao de defeituosos (p)", y = "Probabilidade", color = NULL) +
  tema_cep()

Exercício — Amostragem Dupla

n1_ex <- 40; c1_ex <- 2; n2_ex <- 90; c2_ex <- 5; p_exd <- 0.04

PaI_ex <- pbinom(c1_ex, n1_ex, p_exd)
PaR_ex <- 1 - pbinom(c2_ex, n1_ex, p_exd)

PaII_ex <- 0
for (d1 in (c1_ex + 1):c2_ex) {
  PaII_ex <- PaII_ex + dbinom(d1, n1_ex, p_exd) * pbinom(c2_ex - d1, n2_ex, p_exd)
}
Pa_final_ex <- PaI_ex + PaII_ex

cat(sprintf("P(aceitacao na 1a amostra) = %.4f\n", PaI_ex))

P(aceitacao na 1a amostra) = 0.7855

cat(sprintf("P(aceitacao final) = %.4f\n", Pa_final_ex))

P(aceitacao final) = 0.8339

cat(sprintf("P(rejeicao na 1a amostra) = %.4f\n", PaR_ex))

P(rejeicao na 1a amostra) = 0.0049

Planos de Amostragem Múltipla

• Extensão da amostragem dupla: mais de duas amostras podem ser necessárias para sentenciar o lote
• O aspecto negativo é a dificuldade de implantação — mais regras, mais treinamento operacional
• Duncan (1986) apresenta uma discussão detalhada dessa técnica
• Na prática, o MIL STD 105E (mais adiante) fornece tabelas prontas para amostragem múltipla

Planos de Amostragem Sequencial

• Unidades do lote são selecionadas uma a uma; a cada unidade toma-se uma decisão: aceitar, rejeitar, ou inspecionar outra unidade
• Baseado no Teste Sequencial da Razão de Probabilidade (TSRP), desenvolvido por Wald (1947)
• Em teoria, minimiza o número esperado de itens inspecionados para um dado nível de proteção

Operação do Plano Sequencial

• Considera-se o número acumulado de defeituosos \(d\) a cada nova unidade
• Constrói-se um gráfico: eixo horizontal = número total de itens selecionados (\(n\)); eixo vertical = número total de defeituosos (\(d\))
• Enquanto os pontos permanecem entre as retas de aceitação e rejeição, continua-se amostrando
• Se o ponto atinge ou ultrapassa a reta superior, rejeita-se; se atinge ou fica abaixo da reta inferior, aceita-se

Equações das Retas Limite

Para valores especificados de \((p_1, 1-\alpha)\) e \((p_2, \beta)\):

\[X_A = -h_1 + sn \quad \text{(reta de aceitação)}\]

\[X_R = h_2 + sn \quad \text{(reta de rejeição)}\]

onde:

\[h_1 = \frac{\log\left[\frac{1-\alpha}{\beta}\right]}{k}, \quad h_2 = \frac{\log\left[\frac{1-\beta}{\alpha}\right]}{k}, \quad s = \frac{\log\left[\frac{1-p_1}{1-p_2}\right]}{k}\]

\[k = \log\left[\frac{p_2(1-p_1)}{p_1(1-p_2)}\right]\]

Exemplo: Construindo as Retas no R

p1_seq <- 0.01; alpha_seq <- 0.05; p2_seq <- 0.06; beta_seq <- 0.10

k_seq <- log((p2_seq * (1 - p1_seq)) / (p1_seq * (1 - p2_seq)))
h1_seq <- log((1 - alpha_seq) / beta_seq) / k_seq
h2_seq <- log((1 - beta_seq) / alpha_seq) / k_seq
s_seq <- log((1 - p1_seq) / (1 - p2_seq)) / k_seq

cat(sprintf("k = %.4f\n", k_seq))

k = 1.8436

cat(sprintf("h1 = %.3f | h2 = %.3f | s = %.4f\n", h1_seq, h2_seq, s_seq))

h1 = 1.221 | h2 = 1.568 | s = 0.0281

cat(sprintf("Reta de aceitacao: XA = %.3f + %.4f n\n", -h1_seq, s_seq))

Reta de aceitacao: XA = -1.221 + 0.0281 n

cat(sprintf("Reta de rejeicao:  XR = %.3f + %.4f n\n", h2_seq, s_seq))

Reta de rejeicao:  XR = 1.568 + 0.0281 n

Arredondamento para Valores Inteiros

• \(X_A\) e \(X_R\) precisam ser inteiros: \(X_A\) é o inteiro mais próximo menor ou igual; \(X_R\) é o inteiro mais próximo maior ou igual
• Para \(n = 45\):

n_teste <- 45
XA_45 <- -h1_seq + s_seq * n_teste
XR_45 <- h2_seq + s_seq * n_teste

cat(sprintf("XA(45) = %.3f -> arredonda para %d\n", XA_45, floor(XA_45)))

XA(45) = 0.044 -> arredonda para 0

cat(sprintf("XR(45) = %.3f -> arredonda para %d\n", XR_45, ceiling(XR_45)))

XR(45) = 2.833 -> arredonda para 3

Como \(X_A(45) < 0\), o lote não pode ser aceito antes de, no mínimo, \(n=44\) unidades inspecionadas.

Visualizando o Plano Sequencial no R

n_grid <- 0:60
df_seq <- data.frame(
  n = n_grid,
  XA = -h1_seq + s_seq * n_grid,
  XR = h2_seq + s_seq * n_grid
)

ggplot(df_seq, aes(x = n)) +
  geom_line(aes(y = XA), color = pal["verde"], linewidth = 1.05) +
  geom_line(aes(y = XR), color = pal["coral"], linewidth = 1.05) +
  annotate("text", x = 50, y = max(df_seq$XR) - 1, label = "Rejeitar", color = pal["coral"]) +
  annotate("text", x = 50, y = min(df_seq$XA) + 1, label = "Aceitar", color = pal["verde"]) +
  labs(title = "Plano de amostragem sequencial: retas de decisao",
       x = "Numero de itens inspecionados (n)", y = "Numero acumulado de defeituosos (d)") +
  tema_cep()

Exercício — Amostragem Sequencial

p1_ex2 <- 0.02; alpha_ex2 <- 0.05; p2_ex2 <- 0.10; beta_ex2 <- 0.10

k_ex2 <- log((p2_ex2 * (1 - p1_ex2)) / (p1_ex2 * (1 - p2_ex2)))
h1_ex2 <- log((1 - alpha_ex2) / beta_ex2) / k_ex2
h2_ex2 <- log((1 - beta_ex2) / alpha_ex2) / k_ex2
s_ex2 <- log((1 - p1_ex2) / (1 - p2_ex2)) / k_ex2

n_min_aceitar <- uniroot(function(n) -h1_ex2 + s_ex2 * n, c(0, 100))$root
cat(sprintf("h1 = %.3f | h2 = %.3f | s = %.4f\n", h1_ex2, h2_ex2, s_ex2))

h1 = 1.329 | h2 = 1.706 | s = 0.0503

cat(sprintf("XA = 0 quando n = %.1f -> minimo de %d unidades para aceitar\n",
            n_min_aceitar, ceiling(n_min_aceitar)))

XA = 0 quando n = 26.4 -> minimo de 27 unidades para aceitar

Inspeção de Retificação

• Usada quando o fabricante quer saber o nível médio de qualidade que resultará de um estágio de manufatura
• Lotes rejeitados sofrem inspeção 100%, com os itens defeituosos substituídos por itens bons (ou removidos)
• Duas métricas centrais: a Qualidade de Saída Média (QSM) e a Inspeção Total Média (ITM)

Qualidade de Saída Média (QSM)

A QSM é o nível médio de defeituosos que resulta de um programa de retificação, ao longo de uma longa sequência de lotes:

\[QSM = \frac{P_a \cdot p \cdot (N-n)}{N}\]

• Quando a qualidade de entrada é muito boa ou muito ruim, a QSM tende a ser boa (lotes ruins são rejeitados e retificados)
• Entre esses extremos, a curva QSM sobe, passa por um máximo, e desce

Exemplo: Cálculo da QSM no R

N_qsm <- 10000; n_qsm <- 89; c_qsm <- 2; p_qsm <- 0.01

Pa_qsm <- pbinom(c_qsm, n_qsm, p_qsm)
QSM <- (Pa_qsm * p_qsm * (N_qsm - n_qsm)) / N_qsm

cat(sprintf("Pa = %.4f\n", Pa_qsm))

Pa = 0.9397

cat(sprintf("QSM = %.5f (%.2f%% de defeituosos)\n", QSM, QSM * 100))

QSM = 0.00931 (0.93% de defeituosos)

O Limite da Qualidade de Saída Média (LQSM)

p_seq_qsm <- seq(0.001, 0.09, by = 0.001)
Pa_curve_qsm <- pbinom(c_qsm, n_qsm, p_seq_qsm)
QSM_curve <- (Pa_curve_qsm * p_seq_qsm * (N_qsm - n_qsm)) / N_qsm

df_qsm <- data.frame(p = p_seq_qsm, QSM = QSM_curve)
LQSM_valor <- max(df_qsm$QSM)
p_no_LQSM <- df_qsm$p[which.max(df_qsm$QSM)]

ggplot(df_qsm, aes(p, QSM)) +
  geom_line(color = pal["roxo"], linewidth = 1.1) +
  geom_hline(yintercept = LQSM_valor, linetype = "dashed", color = pal["coral"]) +
  labs(title = "Curva da Qualidade de Saida Media (QSM) para n=89, c=2",
       x = "Fracao de defeituosos de entrada (p)", y = "QSM") +
  tema_cep()

cat(sprintf("LQSM (maximo da curva) = %.4f, atingido proximo de p = %.3f\n",
            LQSM_valor, p_no_LQSM))

LQSM (maximo da curva) = 0.0152, atingido proximo de p = 0.025

Mesmo que a fração de defeituosos de entrada seja péssima, os lotes que saem nunca terão, em média, qualidade pior que o LQSM.

Inspeção Total Média (ITM)

Quantidade média de itens inspecionados por lote, sob retificação:

\[ITM = n + (1 - P_a)(N - n)\]

• Se \(p=0\): nenhum lote é rejeitado, e a inspeção por lote é apenas \(n\)
• Se \(p=1\): todo lote sofre inspeção 100%, e a inspeção por lote é \(N\)
• No meio termo, a ITM varia suavemente entre esses extremos

Exemplo: Cálculo da ITM no R

ITM <- n_qsm + (1 - Pa_qsm) * (N_qsm - n_qsm)
cat(sprintf("ITM = %.1f unidades inspecionadas, em media, por lote\n", ITM))

ITM = 686.7 unidades inspecionadas, em media, por lote

Curvas de ITM para Diferentes Tamanhos de Lote

tamanhos_lote <- c(1000, 5000, 10000)
p_seq_itm <- seq(0.001, 0.09, by = 0.001)

df_itm <- do.call(rbind, lapply(tamanhos_lote, function(N) {
  Pa_i <- pbinom(c_qsm, n_qsm, p_seq_itm)
  data.frame(p = p_seq_itm, ITM = n_qsm + (1 - Pa_i) * (N - n_qsm),
             N_lote = factor(N))
}))

ggplot(df_itm, aes(p, ITM, color = N_lote)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["azul"]), unname(pal["verde"]), unname(pal["coral"]))) +
  labs(title = "Inspecao Total Media para n=89, c=2",
       x = "Fracao de defeituosos (p)", y = "ITM (unidades)", color = "Tamanho do lote") +
  tema_cep()

MIL STD 105E — Introdução

• Sistema de amostragem de aceitação para atributos mais amplamente usado no mundo; origem na Segunda Guerra Mundial (MIL STD 105A, 1950); versão atual: 105E (1989)
• É um esquema de amostragem: uma coleção de planos organizados em torno do Nível de Qualidade Aceitável (NQA)
• Fornece três tipos de plano: única, dupla e múltipla, cada um sob inspeção normal, intensificada ou reduzida
• Padrão civil equivalente: ANSI/ASQC Z1.4 (ISO 2859)

Regras de Mudança entre Inspeções

Exemplo Completo: MIL STD 105E

lote_mil <- 2000
nqa_mil <- 0.0065
codigo_mil <- "K"

plano_normal <- c(n = 125, c = 2)
plano_intensificado <- c(n = 125, c = 1)
plano_reduzido <- c(n = 50, c = 1, r = 3)

cat(sprintf("Codigo alfabetico do tamanho amostral: %s\n", codigo_mil))

Codigo alfabetico do tamanho amostral: K

cat(sprintf("Normal:        n=%d, c=%d\n", plano_normal["n"], plano_normal["c"]))

Normal:        n=125, c=2

cat(sprintf("Intensificado: n=%d, c=%d\n", plano_intensificado["n"], plano_intensificado["c"]))

Intensificado: n=125, c=1

cat(sprintf("Reduzido:      n=%d, c=%d, r=%d\n",
            plano_reduzido["n"], plano_reduzido["c"], plano_reduzido["r"]))

Reduzido:      n=50, c=1, r=3

Note o padrão: ao intensificar, o tamanho amostral \(n\) permanece igual, mas o número de aceitação \(c\) diminui — regra geral do MIL STD 105E.

Comparando os Planos MIL STD 105E no R

p_seq_mil <- seq(0.001, 0.05, by = 0.0005)

df_mil <- rbind(
  data.frame(p = p_seq_mil, Pa = pbinom(2, 125, p_seq_mil), plano = "Normal (n=125,c=2)"),
  data.frame(p = p_seq_mil, Pa = pbinom(1, 125, p_seq_mil), plano = "Intensificado (n=125,c=1)"),
  data.frame(p = p_seq_mil, Pa = pbinom(1, 50, p_seq_mil), plano = "Reduzido (n=50,c=1)")
)

ggplot(df_mil, aes(p, Pa, color = plano)) +
  geom_line(linewidth = 1.05) +
  geom_vline(xintercept = nqa_mil, linetype = "dashed", color = pal["neutro"]) +
  scale_color_manual(values = c(unname(pal["verde"]), unname(pal["coral"]), unname(pal["azul"]))) +
  labs(title = "Curvas CO dos planos MIL STD 105E (codigo K, NQA=0,65%)",
       x = "Fracao de defeituosos (p)", y = "Probabilidade de aceitacao", color = NULL) +
  tema_cep()

Discussão sobre o MIL STD 105E

• Os tamanhos amostrais são padronizados: \(2, 3, 5, 8, 13, 20, 32, 50, 80, 125, 200, 315, 500, 800, 1250, 2000\)
• O tamanho amostral cresce com o tamanho do lote, mas a razão \(n/N\) decresce — economia de escala na inspeção
• Crítica comum: as regras de mudança entre inspeções geram trocas “erradas” mesmo quando a qualidade real não mudou
• Abuso frequente: usar o MIL STD 105E sem as regras de mudança — aumenta seriamente o risco do consumidor

Os Planos de Amostragem Dodge-Romig

• Desenvolvidos por H. F. Dodge e H. G. Romig, com foco na proteção do lote individual, não apenas em médias de longo prazo
• Dois tipos de plano:
  • PADL — Percentual Aceitável de Defeituosos no Lote (protege lotes individuais)
  • LQSM — Limite da Qualidade de Saída Média (protege a média de longo prazo)
• Aplicam-se somente sob inspeção de retificação (lotes rejeitados sofrem inspeção 100%)
• Exigem o conhecimento da média do processo do fornecedor

Por Que NQA Pequeno Ainda Pode Ser Ruim?

nqa_componente <- 0.005
n_componentes <- 100

p_placa_ok <- (1 - nqa_componente) ^ n_componentes
cat(sprintf("P(placa funcionar) = (1 - %.3f)^%d = %.4f\n",
            nqa_componente, n_componentes, p_placa_ok))

P(placa funcionar) = (1 - 0.005)^100 = 0.6058

Mesmo com NQAs individualmente pequenos, produtos complexos (muitos componentes) podem ter taxas de falha combinadas alarmantes — daí a importância dos planos PADL de Dodge-Romig para peças críticas.

Planos LQSM de Dodge-Romig

• Elaborados para que a Inspeção Total Média seja mínima, para um dado LQSM e uma dada média do processo \(p\)
• Exemplo: elementos de memória LSI, lotes de \(N=5.000\), média do processo \(=1\%\). Deseja-se plano de amostragem única com LQSM \(=3\%\)

N_dr <- 5000
n_dr <- 65
c_dr <- 3
p_processo_dr <- 0.01
PADL_dr <- 0.103

Pa_dr <- pbinom(c_dr, n_dr, p_processo_dr)
ITM_dr <- n_dr + (1 - Pa_dr) * (N_dr - n_dr)

cat(sprintf("Plano: n=%d, c=%d | PADL = %.1f%%\n", n_dr, c_dr, PADL_dr * 100))

Plano: n=65, c=3 | PADL = 10.3%

cat(sprintf("Pa no nivel da media do processo = %.4f\n", Pa_dr))

Pa no nivel da media do processo = 0.9958

cat(sprintf("ITM = %.2f unidades\n", ITM_dr))

ITM = 85.58 unidades

O plano garante que 90% dos lotes tão ruins quanto 10,3% de defeituosos serão rejeitados (esse é o PADL), com uma inspeção média de aproximadamente 86 unidades por lote.

Planos PADL de Dodge-Romig

• Elaborados de modo que a probabilidade de aceitação no nível PADL seja exatamente \(0{,}10\)
• Exemplo: mesmos elementos de memória, \(N=5.000\), média do processo \(=0{,}25\%\), PADL desejado \(=1\%\)

n_padl <- 770
c_padl <- 4
LQSM_resultante <- 0.0028

cat(sprintf("Plano PADL: n=%d, c=%d\n", n_padl, c_padl))

Plano PADL: n=770, c=4

cat(sprintf("LQSM resultante (aproximado) = %.2f%%\n", LQSM_resultante * 100))

LQSM resultante (aproximado) = 0.28%

Planos PADL de Dodge-Romig tendem a exigir amostras bem maiores que os planos LQSM equivalentes — o preço da proteção individual de cada lote, não apenas da média de longo prazo.

MIL STD 105E vs. Dodge-Romig

Resumo de Fórmulas — Capítulo 15

Glossário Rápido de Siglas

Exercício 1 — Curvas CO Tipo A e B

N_ex1 <- 800
p_seq_e1 <- seq(0.005, 0.12, by = 0.003)

Pa_B_e1 <- pbinom(1, 50, p_seq_e1)
Pa_A_e1 <- sapply(p_seq_e1, function(p) {
  D <- round(p * N_ex1)
  phyper(1, D, N_ex1 - D, 50)
})

df_e1 <- rbind(data.frame(p = p_seq_e1, Pa = Pa_B_e1, tipo = "Tipo B"),
               data.frame(p = p_seq_e1, Pa = Pa_A_e1, tipo = "Tipo A (N=800)"))

ggplot(df_e1, aes(p, Pa, color = tipo)) +
  geom_line(linewidth = 1.05) +
  scale_color_manual(values = c(unname(pal["azul"]), unname(pal["coral"]))) +
  labs(title = "Exercicio: Curvas CO tipo A e B (n=50, c=1)",
       x = "Fracao de defeituosos (p)", y = "Probabilidade de aceitacao", color = NULL) +
  tema_cep()

Exercício 2 — Amostragem Dupla

n1_e2 <- 50; c1_e2 <- 2; n2_e2 <- 100; c2_e2 <- 6; p_e2 <- 0.05

PaI_e2 <- pbinom(c1_e2, n1_e2, p_e2)
PaR_e2 <- 1 - pbinom(c2_e2, n1_e2, p_e2)

PaII_e2 <- 0
for (d1 in (c1_e2 + 1):c2_e2) {
  PaII_e2 <- PaII_e2 + dbinom(d1, n1_e2, p_e2) * pbinom(c2_e2 - d1, n2_e2, p_e2)
}
Pa_final_e2 <- PaI_e2 + PaII_e2

cat(sprintf("P(aceitacao na 1a amostra) = %.4f\n", PaI_e2))

P(aceitacao na 1a amostra) = 0.5405

cat(sprintf("P(aceitacao final) = %.4f\n", Pa_final_e2))

P(aceitacao final) = 0.6159

cat(sprintf("P(rejeicao na 1a amostra) = %.4f\n", PaR_e2))

P(rejeicao na 1a amostra) = 0.0118

Exercício 3 — Amostragem Sequencial

p1_e3 <- 0.02; alpha_e3 <- 0.05; p2_e3 <- 0.10; beta_e3 <- 0.10

k_e3 <- log((p2_e3 * (1 - p1_e3)) / (p1_e3 * (1 - p2_e3)))
h1_e3 <- log((1 - alpha_e3) / beta_e3) / k_e3
h2_e3 <- log((1 - beta_e3) / alpha_e3) / k_e3
s_e3 <- log((1 - p1_e3) / (1 - p2_e3)) / k_e3

# Numero minimo de itens para aceitar: menor n tal que XA(n) >= 0
n_min_aceitar_e3 <- uniroot(function(n) -h1_e3 + s_e3 * n, c(0, 200))$root

# Numero minimo de itens para rejeitar: menor n tal que n >= teto(XR(n)),
# ja que o numero de defeituosos d nao pode exceder o numero de itens
# inspecionados n. Busca simples, robusta a qualquer combinacao de parametros.
XR_e3 <- function(n) h2_e3 + s_e3 * n
n_min_rejeitar_e3 <- min(which(sapply(1:200, function(n) n >= ceiling(XR_e3(n)))))

cat(sprintf("h1 = %.3f | h2 = %.3f | s = %.4f\n", h1_e3, h2_e3, s_e3))

h1 = 1.329 | h2 = 1.706 | s = 0.0503

cat(sprintf("Reta de aceitacao: XA = %.3f + %.4f n\n", -h1_e3, s_e3))

Reta de aceitacao: XA = -1.329 + 0.0503 n

cat(sprintf("Reta de rejeicao:  XR = %.3f + %.4f n\n", h2_e3, s_e3))

Reta de rejeicao:  XR = 1.706 + 0.0503 n

cat(sprintf("Minimo de unidades para aceitar: %d\n", ceiling(n_min_aceitar_e3)))

Minimo de unidades para aceitar: 27

cat(sprintf("Minimo de unidades para rejeitar: %d (com todas defeituosas)\n", n_min_rejeitar_e3))

Minimo de unidades para rejeitar: 2 (com todas defeituosas)