< Return to Video

MLM CAP06 2025 VA03 IMPLEMENTACAO DO METODO A PRIORI

  • 0:08 - 0:11
    Como nós construímos
    regras de associação?
  • 0:11 - 0:14
    Existem diversas formas de você
    encontrar uma associação
  • 0:14 - 0:16
    entre um produto e outro.
  • 0:16 - 0:18
    Aqui nosso objetivo é olhar
    para produtos, de fato.
  • 0:18 - 0:21
    Nós não estamos interessados
    no perfil dos usuários.
  • 0:21 - 0:23
    Não me interessa saber quem está
    comprando o quê.
  • 0:23 - 0:27
    Eu quero saber qual produto
    está relacionado com quais outros.
  • 0:27 - 0:29
    Basicamente, nós vamos minerar regras.
  • 0:29 - 0:31
    É aqui que aparece o tal do Data Mining.
  • 0:31 - 0:34
    Data Mining fica muito evidente
    nesse tipo de algoritmo,
  • 0:34 - 0:37
    quando estamos tentando encontrar
    relações de produtos
  • 0:37 - 0:41
    e vamos verificar se essa relação
    procede ou não procede.
  • 0:41 - 0:43
    Portanto, a nossa base de dados
    deve ser sempre uma transação,
  • 0:43 - 0:46
    um histórico de transações de vendas,
    por exemplo.
  • 0:46 - 0:48
    Eu posso pensar o seguinte.
  • 0:48 - 0:51
    Em um supermercado,
    quais são os produtos
  • 0:51 - 0:53
    comprados em conjunto
    ao longo do tempo?
  • 0:53 - 0:59
    Eu quero minerar regras de compras
    similares entre esse histórico.
  • 0:59 - 1:00
    Para essa simulação,
  • 1:00 - 1:02
    vou utilizar uma base de dados
    disponível no Kaggle
  • 1:02 - 1:07
    que está imitando um histórico
    de compras no supermercado.
  • 1:07 - 1:09
    Então,
    aqui já estou na mente do Colab
  • 1:09 - 1:11
    com uma instância inicializada.
  • 1:11 - 1:15
    Eu já subi a base também aqui
    no nosso ambiente
  • 1:15 - 1:17
    e vou começar a executar os códigos.
  • 1:17 - 1:21
    O primeiro passo é rodar
    essa célula que está instalando
  • 1:21 - 1:24
    a biblioteca "apyori",
    que é uma brincadeira
  • 1:24 - 1:28
    com o nome de Python
    e o método em si.
  • 1:28 - 1:30
    Pronto,
    já está instalado aqui nesse ambiente.
  • 1:30 - 1:33
    Agora eu posso fazer alguns imports
    necessários,
  • 1:33 - 1:35
    que é Pandas, NumPy
    para limpeza de dados também.
  • 1:35 - 1:39
    E, de fato, o algoritmo da biblioteca
    é Apriori.
  • 1:39 - 1:42
    Aqui vou ler essa base
    que está salva como um CSV, tá?
  • 1:42 - 1:45
    E nesse caso específico,
    ela não tem nenhum cabeçalho.
  • 1:45 - 1:48
    Não é um CSV tradicional,
    digamos assim.
  • 1:48 - 1:53
    Tanto que na execução já mostra
    como se fosse um DataFrame
  • 1:53 - 1:54
    com as linhas lidas.
  • 1:54 - 1:57
    O que me interessa é linha a linha,
    o que foi adquirido.
  • 1:57 - 2:00
    Então, nós temos aqui
    colunas sem nome,
  • 2:00 - 2:02
    porque a coluna "0",
    por exemplo,
  • 2:02 - 2:06
    contém o primeiro
    produto que passou nessa compra.
  • 2:06 - 2:08
    A coluna "1",
    contém o segundo produto,
  • 2:08 - 2:10
    a "2" o terceiro
    e por aí vai.
  • 2:10 - 2:13
    Então, pode ser que eu compro
    apenas um produto
  • 2:13 - 2:16
    ou uma sequência
    de produtos também.
  • 2:16 - 2:19
    Esses "NaN" indicam
    que esse produto não foi comprado.
  • 2:19 - 2:22
    Ou seja, nem vi o produto em si,
  • 2:22 - 2:26
    mas essa cesta de compras
    teve apenas três produtos,
  • 2:26 - 2:28
    dois e por aí vai.
  • 2:28 - 2:32
    É normal ter uma matriz bem esparsa
    nesse tipo de dado.
  • 2:32 - 2:35
    Portanto, temos que prepará-la
    para implementar o método.
  • 2:35 - 2:36
    Nessa preparação,
  • 2:36 - 2:38
    nós temos que eliminar
    esse tanto de "NaN".
  • 2:38 - 2:41
    Basicamente, nós queremos
    criar uma lista de lista, ou seja,
  • 2:41 - 2:45
    para cada compra,
    cada transação de fato, cada cesta,
  • 2:45 - 2:49
    eu quero criar uma lista
    onde apenas produtos comprados
  • 2:49 - 2:51
    estejam de fato presentes nessa lista.
  • 2:51 - 2:54
    Quem está com valor "NaN"
    eu possa ignorá-lo.
  • 2:54 - 2:56
    Vou fazer isso
    com Python puro mesmo
  • 2:56 - 2:58
    a partir do código da próxima célula.
  • 2:58 - 3:01
    Então, aqui embaixo,
    nós temos um código
  • 3:01 - 3:03
    que está fazendo o seguinte.
  • 3:03 - 3:04
    Basicamente,
    nós temos aqui
  • 3:04 - 3:07
    uma lista de transações,
    uma lista vazia
  • 3:07 - 3:12
    e eu vou adicionar nessa lista
    uma outra lista.
  • 3:12 - 3:13
    Ficando uma lista de listas.
  • 3:13 - 3:16
    Onde cada lista
    que compõe a lista externa,
  • 3:16 - 3:20
    está analisando os produtos
    que foram adquiridos
  • 3:20 - 3:22
    e se ele for "NaN" estou ignorando.
  • 3:22 - 3:24
    Eu só vou por dentro da lista mesmo
  • 3:24 - 3:27
    a palavra que representa
    o nome daquele produto.
  • 3:27 - 3:32
    Então eu estou percorrendo
    o dado da primeira linha até a última,
  • 3:32 - 3:35
    criando essa nova representação,
    esse novo dado.
  • 3:35 - 3:38
    Aqui temos um exemplo
    de como ficou.
  • 3:38 - 3:41
    Então, cada lista dessa
    é uma cesta de compras.
  • 3:41 - 3:43
    Ela pode ser menor,
    maior e por aí vai.
  • 3:43 - 3:47
    Notem que o que me interessa saber
    é a relação de um produto com o outro.
  • 3:47 - 3:49
    A quantidade não é relevante no caso.
  • 3:49 - 3:52
    Então, saber que existe uma relação,
    por exemplo,
  • 3:52 - 3:56
    entre frango e ovo
    já é relevante para mim.
  • 3:56 - 3:59
    Não me interessa saber quantos ovos
    são associados à compra
  • 3:59 - 4:01
    de quantos quilos de frango,
    por exemplo,
  • 4:01 - 4:01
    ou vice-versa.
  • 4:01 - 4:03
    Então,
    como a sessão aqui é grande,
  • 4:03 - 4:08
    vou lá para baixo para começar
    a construir a regra de associação.
  • 4:08 - 4:11
    O uso do método A priori
    é muito direto.
  • 4:11 - 4:15
    Basicamente,
    ele espera esses "records",
  • 4:15 - 4:16
    que são aquela lista de listas,
  • 4:16 - 4:19
    a lista dos produtos comprados de fato
  • 4:19 - 4:21
    e aqui alguns fatores
    de parametrização.
  • 4:21 - 4:24
    Essa parametrização depende muito
    do que a gente quer
  • 4:24 - 4:25
    como objetivo de negócio.
  • 4:25 - 4:28
    Aqui nós estamos fazendo
    da parametrização do método baseado
  • 4:28 - 4:32
    em algumas métricas de avaliação
    da recomendação, ou seja,
  • 4:32 - 4:34
    quero avaliar o poder,
    digamos assim,
  • 4:34 - 4:37
    daquela associação
    de um produto com outro.
  • 4:37 - 4:40
    Esse poder está ligado
    às métricas de avaliação
  • 4:40 - 4:43
    da relação entre um produto e outro.
  • 4:43 - 4:45
    Eu posso adicionar métricas
    como confiança,
  • 4:45 - 4:48
    alavancagem,
    entre tantas outras.
  • 4:48 - 4:51
    Eu posso limitar, inclusive,
    o tamanho da regra a ser criada.
  • 4:51 - 4:53
    Eu posso limitar,
    por exemplo,
  • 4:53 - 4:57
    que as regras envolvam
    pelo menos dois produtos,
  • 4:57 - 4:59
    mas eu posso criar regras
    que envolvem pelo menos três,
  • 4:59 - 5:01
    quatro, cinco produtos também.
  • 5:01 - 5:03
    No método Apriori
    não tem certo ou errado,
  • 5:03 - 5:06
    nós vamos fazer combinações
    de produtos a produtos
  • 5:06 - 5:09
    e verificar se existem dados,
    evidências reais,
  • 5:09 - 5:11
    que comprovem a eficácia,
    eficiência,
  • 5:11 - 5:13
    o poder de fato daquela associação.
  • 5:13 - 5:17
    Por exemplo,
    um lift é uma métrica interessante
  • 5:17 - 5:19
    que mostra alavancagem.
  • 5:19 - 5:22
    Quando eu tenho um produto A
    que leva a compra do B,
  • 5:22 - 5:26
    o quanto que o produto A
    está alavancando a venda do B?
  • 5:26 - 5:28
    Por exemplo,
    a métrica do suporte.
  • 5:28 - 5:31
    Imagine que quero verificar
    uma associação entre maçã e banana.
  • 5:31 - 5:35
    Então, o suporte dessa regra
    indica quantas vezes
  • 5:35 - 5:38
    maçãs e bananas
    foram compradas em conjunto,
  • 5:38 - 5:42
    em todo o histórico de transações
    que estou analisando.
  • 5:42 - 5:44
    E eu posso especificar
    o suporte mínimo,
  • 5:44 - 5:46
    assim como eu posso
    especificar um lift,
  • 5:46 - 5:47
    uma alavancagem mínima.
  • 5:47 - 5:48
    O que isso quer dizer?
  • 5:48 - 5:53
    Eu estou minerando regras e gerando
    combinações entre produtos.
  • 5:53 - 5:57
    Eu quero ter uma regra
    que tenha no mínimo
  • 5:57 - 5:59
    uma alavancagem de três,
    por exemplo.
  • 5:59 - 6:02
    Ou seja,
    esse produto A,
  • 6:02 - 6:06
    a compra dele alavanca a compra
    do B em pelo menos 3 vezes.
  • 6:06 - 6:09
    Ou então,
    supondo nessa associação
  • 6:09 - 6:12
    entre produção de maçãs e bananas,
  • 6:12 - 6:15
    eu quero ter um suporte mínimo,
    ou seja,
  • 6:15 - 6:19
    eu quero regras que indicam,
    que apareçam no histórico
  • 6:19 - 6:21
    pelo menos um número mínimo
    de vezes.
  • 6:21 - 6:22
    Portanto,
    uma vez configurado
  • 6:22 - 6:25
    o que a gente quer do ponto de vista
    de regras mínimas,
  • 6:25 - 6:29
    nós podemos rodar aqui
    o Apriori para fazer essa mineração
  • 6:29 - 6:31
    sobre o conjunto de dados
    já pré-preparado.
  • 6:31 - 6:34
    Então,
    vou rodar aqui o algoritmo
  • 6:34 - 6:36
    e vejam que ele rodou muito rápido,
  • 6:36 - 6:39
    porque é uma base de dados
    pequena de fato.
  • 6:39 - 6:41
    E aqui estou criando uma lista,
    estou forçando a criação de uma lista
  • 6:41 - 6:44
    da associação
    e verificando o seu tamanho.
  • 6:44 - 6:46
    Foram geradas 24 regras.
  • 6:46 - 6:49
    Claro que se eu tivesse
    um histórico de dados maior,
  • 6:49 - 6:50
    com mais produtos,
  • 6:50 - 6:53
    teriam sido muito mais métricas
    a serem geradas.
  • 6:53 - 6:56
    Ou caso tivesse relaxado
    essas métricas,
  • 6:56 - 6:59
    eu poderia ter regras
    um pouco mais fracas,
  • 6:59 - 7:00
    mas mais abundantes.
  • 7:00 - 7:03
    Vamos entender
    como que o Apriori funciona
  • 7:03 - 7:06
    para como que ele gera
    essas regras aqui.
  • 7:06 - 7:09
    Eu posso puxar a primeira regra
    gerada por meio do seguinte comando:
  • 7:09 - 7:11
    "association_rules[0]".
  • 7:11 - 7:16
    Olhando a lista de regras,
    quero pegar a primeira.
  • 7:16 - 7:19
    E aqui está mostrando os itens de fato.
  • 7:19 - 7:23
    Então,
    é um creme com frango, tá?
  • 7:23 - 7:25
    Qual é o item a ser colocado.
  • 7:25 - 7:28
    Qual é o item que gerou a compra
    posteriormente.
  • 7:28 - 7:32
    Essa regra tem qual é o lift mínimo.
  • 7:32 - 7:38
    Qual é a confiança apoiada
    dessa regra também.
  • 7:38 - 7:42
    Eu posso pegar o segundo item
    dessa composição,
  • 7:42 - 7:43
    dessa regra,
    que é de fato,
  • 7:43 - 7:45
    a lista de recomendações.
  • 7:45 - 7:48
    Então, estou pegando a lista
    "association_rules",
  • 7:48 - 7:50
    o primeiro item, "0"
  • 7:50 - 7:52
    e vou pegar agora
    a lista de recomendação em si.
  • 7:52 - 7:54
    Então, o segundo item.
  • 7:54 - 7:58
    Eu posso pegar aqui
    como uma lista de fato.
  • 7:58 - 8:01
    Se eu quiser pegar qual é o produto
    a ser analisado,
  • 8:01 - 8:03
    eu vou fazer uma outra indexação
  • 8:03 - 8:09
    baseado aqui na posição "0",
    na "2" e na "0" novamente.
  • 8:09 - 8:13
    Então, aqui eu tenho exatamente
    os produtos configurados.
  • 8:13 - 8:18
    Note que a saída
    da regra anterior dessa é a mesma,
  • 8:18 - 8:20
    porque essa regra aqui é bem simples
    e tem dois produtos apenas.
  • 8:20 - 8:23
    Ou seja, nesse ponto,
    a regra já está melhorada.
  • 8:23 - 8:24
    O que eu tenho que fazer
    é simplesmente
  • 8:24 - 8:27
    passar para essas regras
    explorando que regras são essas.
  • 8:27 - 8:30
    Construindo aquele motor,
    digamos assim.
  • 8:30 - 8:32
    Quem compra a compra A,
    compra a parte B.
  • 8:32 - 8:34
    A gente pode fazer isso
    com um laço
  • 8:34 - 8:36
    que está iterando
    por essas regras também
  • 8:36 - 8:39
    e mostrando na tela
    as principais métricas
  • 8:39 - 8:40
    e quais regras foram geradas.
  • 8:40 - 8:41
    Vamos ver.
  • 8:41 - 8:45
    A próxima tela faz exatamente isso, tá?
  • 8:45 - 8:47
    Criando aqui até mesmo
    um numerador da regra.
  • 8:47 - 8:50
    Aí número um, dois, três
    e está separando
  • 8:50 - 8:55
    uma impressão da outra
    por uma sequência de 15 iguais,
  • 8:55 - 8:57
    digamos assim,
    impressas na tela.
  • 8:57 - 9:00
    Então,
    vendo aqui no início.
  • 9:03 - 9:07
    A primeira regra tem aqui na sexta,
  • 9:07 - 9:09
    um creme também
    e um frango.
  • 9:09 - 9:14
    A segunda regra temos aqui escalope,
    uma carne também,
  • 9:14 - 9:17
    com o molho de cogumelo.
  • 9:17 - 9:21
    A terceira regra está colocando
    a carne também e massa.
  • 9:21 - 9:22
    E por aí vai.
  • 9:22 - 9:24
    Então nós podemos verificar
    quais são os produtos
  • 9:24 - 9:29
    que foram comprados em conjunto,
    às vezes com umas regras pequenas,
  • 9:29 - 9:30
    com o tamanho de dois.
  • 9:30 - 9:34
    Como nós configuramos
    o tamanho mínimo da regra para dois,
  • 9:34 - 9:35
    o valor de dois produtos,
  • 9:35 - 9:40
    nós temos várias regras que foram
    criadas com apenas dois produtos.
  • 9:40 - 9:41
    Mas,
    olhando um pouco mais,
  • 9:41 - 9:44
    quais dessas regras foram
    impressas nessas 24 criadas,
  • 9:44 - 9:46
    isso em regras um pouco maiores,
  • 9:46 - 9:48
    com três,
    com quatro produtos também.
  • 9:48 - 9:53
    No entanto, elas são menos
    comuns do que regras menores.
  • 9:53 - 9:55
    Então, aqui embaixo,
    nós temos também
  • 9:55 - 9:57
    um exemplo com três produtos
  • 9:57 - 10:00
    ou com outros três
    produtos diferentes, tá?
  • 10:00 - 10:02
    Com outros três produtos também,
  • 10:02 - 10:05
    que pode ser simplesmente
    uma combinação entre eles.
  • 10:05 - 10:09
    Eu posso tirar um produto
    e ir colocando outro no lugar,
  • 10:09 - 10:13
    mas essa base nos permitiu
    gerar esse conjunto de regras.
  • 10:13 - 10:15
    E a pergunta que fica é:
  • 10:15 - 10:17
    como nós vamos entregar
    essas regras?
  • 10:17 - 10:19
    Se for, por exemplo,
    uma loja física,
  • 10:19 - 10:21
    nós podemos pegar produtos
    que tem uma relação
  • 10:21 - 10:23
    e colocar próximo um dos outros.
  • 10:23 - 10:26
    É claro que isso
    pode não ser viável.
  • 10:26 - 10:28
    Por exemplo,
    eu vou colocar um enlatado
  • 10:28 - 10:32
    próximo de uma carne
    que está no açougue.
  • 10:32 - 10:35
    Talvez levar uma prateleira
    do enlatado para próximo do açougue,
  • 10:35 - 10:36
    faz sentido.
  • 10:36 - 10:40
    Ao levar a carne para um outro lugar,
    pode não ser viável.
  • 10:40 - 10:42
    Agora, no cenário digital,
  • 10:42 - 10:44
    quando por exemplo,
    uma compra em um e-commerce
  • 10:44 - 10:45
    é desse mercado,
  • 10:45 - 10:49
    ou até mesmo no aplicativo
    de relacionamento com os usuários,
  • 10:49 - 10:52
    com os clientes dessa loja,
    nós podemos verificar
  • 10:52 - 10:54
    baseado em qual produto
    a pessoa está interagindo
  • 10:54 - 10:56
    e colocou na compra,
    pode ter algum card que indica:
  • 10:56 - 10:58
    "por que você não compra
    também tal produto?"
  • 10:58 - 11:01
    E esse outro aqui com algum desconto,
    alguma coisa do gênero.
  • 11:01 - 11:05
    Assim, o objetivo principal da regra
    de associação é achar a associação
  • 11:05 - 11:08
    uma relação de produtos
    que devem ser combinados.
  • 11:08 - 11:11
    A forma como nós vamos entregar
    essa inteligência
  • 11:11 - 11:14
    que a máquina gerou para a gente,
    depende muito do negócio
  • 11:14 - 11:18
    a ser impactado e como ele
    quer implementar essa regra,
  • 11:18 - 11:19
    de fato,
    no mundo real.
Title:
MLM CAP06 2025 VA03 IMPLEMENTACAO DO METODO A PRIORI
Video Language:
Portuguese, Brazilian
Duration:
11:23

Portuguese, Brazilian subtitles

Incomplete

Revisions Compare revisions