Association Rules

1 Bootstrap para Algoritmos de Associação

1.1 Introdução

A Mineração de Regras de Associação (também chamada de Aprendizado de Regras de Associação) é uma técnica comum usada para identificar a interdependência desconhecida dos dados e descobrir as regras entre esses itens.

Um bom algoritmo de mineração de padrões em dados são aqueles que capturam regras de associação entre itens ou variáveis. Essas regras são como “if-then”, onde “se X, então Y”, representando as interdependências buscadas por esses algoritmos. A mais comum e utilizada nas tarefas atuais é o Algoritmo Apriori, foco de estudo deste documento.

1.2 Algoritmo Apriori

Antes de seguirmos, veja o seguinte banco de dados:

Compra	Leite	Pão	Cerveja	Refrigerante
1	0	1	1	0
2	1	1	0	0
3	0	0	1	1
4	1	0	0	1

O objetivo de um algoritmo de associação é encontrar regras de alta frequência em bancos de dados como o nosso, por exemplo:

• “Quem compra leite compra pão”
• “Quem compra cerveja compra refrigerante”

Essas regras ajudam a definir inúmeras estratégias de comércio e até marketing, descobrindo regras escondidas e prováveis do comportamento do consumidor, entre outras possibilidades, além de serem de fácil interpretação

Para isso, dispomos de dados onde as entradas (linhas) são as compras, usuários, dias, etc., e as colunas representam as covariáveis de interesse, cujos valores serão binários: 1 para sim e 0 para não

Com isso, podemos identificar associações de alta probabilidade, que chamamos de Confiança, onde \(P(B|A)\) ou “Probabilidade de A dado que B ocorreu”. Mas no nosso contexto, chamamos de A a nossa consequência e B o nosso antecedente

1.3 Como validar e definir boas regras?

Dada a grande quantidade de dados de uma base e sua característica esparsa, costuma-se restringir o número de regras cujos subconjuntos de itens \(S\) das \(d\) variáveis (por exemplo, \(S = {2, 4, 10}\)) tenham frequência ou probabilidade (chamado de suporte) maior que um limiar \(t\). Isso limita a quantidade de regras a serem analisadas

A partir disso, o algoritmo Apriori identifica os conjuntos de itens mais frequentes e, com base neles, gera as regras de associação. Ele inicia com um conjunto simples, verifica a frequência dos itens e, caso sejam de alta frequência (ou seja, cuja frequência mínima foi definida em \(t\)), usa os itens mais frequentes para formar novos conjuntos cada vez maiores, até que não haja mais conjuntos possíveis ou que novos conjuntos tenham uma frequência menor que o limiar definido

Também é possível definir um número mínimo e máximo de itens nos subconjuntos \(S\). Aumentá-lo ajuda a descobrir regras de maior frequência, principalmente em datasets mais extensos, cujos conjuntos menores terão, quase sempre, uma frequência bem pequena

1.4 Levantamento ou Lift

Há um outro output importante em regras de associação que denominamos de “Lift” ou “Levantamento”, que indica quanto o aumento de A irá aumentar as chances de B. Ou seja, indica um efeito de substituição, se menor que 1, e complementar, se maior que 1. A estimativa criada segue algo como \(P(B|A) / P(B)\).

Caso seu Lift seja 1, isso indica que os itens são independentes entre si.

1.5 Sobre o projeto

No meu exemplo, vamos usar dados já produzidos e tratados do dataset Groceries do pacote arules do R. Vamos explorar como montar nosso Algoritmo Apriori e, posteriormente, aplicar um bootstrap no algoritmo para gerar robustez ao processo.

A função apriori básica é dada por:

regras <- apriori(data, 
          parameter = list(supp = 0.005, conf = 0.5, maxlen = 3))

arules::inspect(regras[1:5]) #mostrando apenas as primeiras 5 linhas

Onde "supp" é o suporte, ou limiar \(t\), "conf" representa a nossa probabilidade mínima buscada, e "maxlen" define o tamanho máximo do suporte.

Para inspecionarmos, usamos a função arules::inspect(modelo[]).

1.5.1 Por que Bootstrap?

Bootstrap é uma técnica de reamostragemcom reposição de uma amostra. Esse processo gera robustez nos resultados e cria uma maior confiabilidade de que essas regras se manterão para novos datasets. Portanto, o Bootstrap é um dos métodos mais eficientes e poderosos no campo estatístico para mitigar possíveis erros e regressões à média. No entanto, lembre-se de que, para aplicá-lo corretamente, sua amostra deve ser bem representativa e relativamente grande.

#Carregando nossos dados
data("Groceries")

class(Groceries)

[1] "transactions"
attr(,"package")
[1] "arules"

#criando nosso algoritmo do pacote Arules (apriori)
regras <- apriori(Groceries, parameter = list(supp = 0.005, conf = 0.5,
                                              maxlen = 3), 
                  control = list(verbose = FALSE))

arules::inspect(regras[1:5])

1.6 Output do Inspect - Tabela de Associação

O output gerado pela função inspect() do pacote arules mostra as regras de associação extraídas, com as seguintes colunas:

• lhs: Representa os antecedentes da regra, ou seja, o conjunto de itens que devem ser consumidos antes para que a consequência ocorra.
• rhs: Refere-se às consequências da regra, ou seja, os itens que tendem a ser consumidos quando os itens no lhs são consumidos.
• support: Indica a frequência com que a associação entre o conjunto de lhs e rhs ocorre nas transações. É a proporção de transações que contêm tanto o lhs quanto o rhs.
• confidence: Reflete a probabilidade de que o rhs seja consumido quando o lhs já foi consumido. Em outras palavras, a confidence é a probabilidade condicional de observar rhs dado lhs.
• lift: Mede a força da associação entre os itens, considerando a probabilidade de ocorrência dos itens em relação à sua ocorrência isolada. Um lift maior que 1 indica que os itens no lhs e rhs são complementares, ou seja, um aumento na frequência de consumo de um item aumenta a probabilidade de consumir o outro. Um lift menor que 1 indica que os itens são substitutivos, ou seja, o aumento no consumo de um item diminui a probabilidade de consumir o outro.

Conseguimos, por exemplo, notar que quase 1% das compras pessoas que compram fermento em pó acabam comprando leite com 52% de probabilidade e são produtos complementares

Podemos organizar a tabela de resultados do algoritmo com o parâmetro "by" e também aumentar o número de linhas exibidas.

regras <- sort(regras, by = "confidence", decreasing = TRUE)

arules:: inspect(regras[1:8])

Também é possível escolher mostrar apenas regras com algum antecedente específico utilizando o parâmetro "lhs", ou com consequência específica através do parâmetro "rhs". No nosso caso, vamos mostrar todos os resultados com Cerveja como consequência

regras <- apriori(data = Groceries,
                  parameter = list(supp = 0.001, conf = 0.08),
                  appearance = list(default = "lhs", 
                                    rhs = "bottled beer"),
                  control = list(verbose = FALSE))

regras <- sort(regras, by = "confidence", decreasing = TRUE)
arules:: inspect(regras[1:5])

tabela_regras <- as(regras[1:5], "data.frame")


# Criar tabela estilizada com ajustes
gt_table <- tabela_regras %>%
  dplyr::select(rules, support, confidence, lift) %>%
  mutate(
    support = round(support * 100, 4), # Transformar em % e arredondar para 4 casas
    confidence = round(confidence * 100, 2), # Transformar em % e arredondar para 2 casas
    lift = round(lift, 2) # Arredondar lift para 2 casas
  ) %>%
  rename(
    "Regras" = rules,
    "Suporte (%)" = support,
    "Confiança (%)" = confidence,
    "Lift" = lift
  ) %>%
  gt() %>%
  tab_header(
    title = "Regras de Associação com Cerveja como Consequência",
    subtitle = "Base de Dados: Groceries"
  ) %>%
  tab_style(
    style = cell_borders(
      sides = "bottom",
      color = "tomato",
      weight = px(3)
    ), # Adicionar borda inferior para simular sublinhado
    locations = cells_body(rows = 1) # Aplicar apenas à primeira linha
  ) %>%
  tab_style(
    style = cell_text(weight = "bold"), # Negrito nos nomes das colunas
    locations = cells_column_labels()
  )

# Exibir tabela
gt_table

Regras de Associação com Cerveja como Consequência
Base de Dados: Groceries
Regras	Suporte (%)	Confiança (%)	Lift
{liquor,red/blush wine} => {bottled beer}	0.1932	90.48	11.24
{soda,liquor} => {bottled beer}	0.1220	57.14	7.10
{liquor} => {bottled beer}	0.4677	42.20	5.24
{herbs,bottled water} => {bottled beer}	0.1220	40.00	4.97
{whole milk,soups} => {bottled beer}	0.1118	37.93	4.71

NA

1.7 Bootstrap

Vamos criar uma função para implementar o algoritmo utilizando dados amostrados. Em seguida, reescreveremos essa função utilizando um laço for, capturando os resultados e calculando os intervalosdeconfiança para cada métrica de interesse

set.seed(15)

library(tidyr)
library(Hmisc)

boot_apriori <- function(data, rhs, confidence, minlen, maxlen, supp){
  # Criando a amostra bootstrap
  bootstrap_sample <- function(data) {
    sampled_ids <- sample(seq_along(data), replace = TRUE) 
    sampled_transactions <- data[sampled_ids] 
    return(sampled_transactions)
  }
  
  
  boot_data <- bootstrap_sample(data = data)

  #Ajuste de parâmetros
  boot_rules_eh <- apriori(boot_data,
                      parameter = list(confidence = confidence, minlen=minlen,
                                       maxlen = maxlen, supp = supp),
                      appearance = list(default = "lhs", 
                                    rhs = rhs),
                      control = list(verbose = FALSE))
  
  ## Encontrando regras redundantes e excluindo elas
  boot_rules_eh.sorted <- sort(boot_rules_eh, by = "confidence")
  boot_subset.matrix<-is.subset(boot_rules_eh.sorted,boot_rules_eh.sorted) 
  boot_subset.matrix[lower.tri(boot_subset.matrix,diag=T)]<-F
  if(length(boot_subset.matrix) > 0){
    boot_redundant<-colSums(boot_subset.matrix)>=1
    boot_rules_eh.pruned<-boot_rules_eh.sorted[!boot_redundant]
  } else {
    boot_rules_eh.pruned <- boot_rules_eh
  }
  return(boot_rules_eh.pruned)
}


n_iterations <- 100

# Lista para armazenar os resultados de cada iteração
results_list <- vector("list", n_iterations)

#Laço for - lembrandoq 
for (i in 1:n_iterations) {
  rules <- boot_apriori(Groceries,"bottled beer",0.08, 1, 4, 0.001)
  # Transformar as regras em data frame e armazenar métricas de interesse
  rules_df <- as(rules, "data.frame")
  rules_df$lhs <- labels(lhs(rules))
  rules_df$rhs <- labels(rhs(rules))
  results_list[[i]] <- rules_df
}

# Combinar resultados em um único data frame
results_final <- bind_rows(results_list)



# Calcular estatísticas com IC para cada regra usando a biblioteca Hmisc
results_summary <- results_final %>%
  group_by(lhs, rhs) %>%
  summarise(
    N = n(),
    confidence_ci = list(smean.cl.normal(confidence)),
    support_ci = list(smean.cl.normal(support)),
    lift_ci = list(smean.cl.normal(lift))
  ) %>%
  unnest_wider(confidence_ci, names_sep = "_") %>%
  unnest_wider(support_ci, names_sep = "_") %>%
  unnest_wider(lift_ci, names_sep = "_")

# Exibir resultados
results_summary[1:10] #exibingo as 10 primeiras linhas

NA

1.8 Adicional : Forma Gráfica de Visualizar os resultados

Podemos visualizar essas associações, sim, de forma gráfica com

plot(resultado, method = "graph",...)

conseguimos ver quais itens ou set-itens mais se relacionam com o item de consequeência

rules <- boot_apriori(Groceries, "bottled beer", 0.08, 1, 4, 0.001)

top_5_rules <- rules[1:5]

plot(regras[1:5], method = "graph", engine = "igraph", 
      main = "Gráfico de Rede das Top 5 Regras")

1.9 Referências

Izbicki, R., & dos Santos, T. M. (2021). *Aprendizado de Máquina: Uma Abordagem Estatística*. Parte III, Capítulo 12.

University of Virginia Library. (n.d.). *Bootstrapped Association Rule Mining in R*. Disponível em: https://library.virginia.edu/data/articles/bootstrapped-association-rule-mining-r

CIRP Conference. (2021). Association rules mining in R for product performance management in Industry 4.0 products for an assembly oriented product family identification. *11th CIRP Conference on Industrial Product-Service Systems*. Disponível em: ScienceDirect.