Aqui está uma implementação simples do MATLAB do algoritmo de associação FP-Tree para mineração de dados. Este código encontra conjuntos de itens frequentes e regras de associação de um determinado conjunto de dados de transação.

```
% Crie o banco de dados de transações original como uma matriz de células
transações ={ ...
{'Pão', 'Leite', 'Manteiga'}, ...
{'Pão', 'Fraldas', 'Cerveja', 'Ovos'}, ...
{'Leite', 'Fraldas', 'Cerveja', 'Coca'}, ...
{'Pão', 'Leite', 'Fraldas', 'Coca'}, ...
{'Pão', 'Ovos', 'Cerveja'} ...
};

% Converter transações em uma matriz binária
binaryTransactions =zeros(size(transactions, 1), size(unique([transactions{:}]), 2));
para i =1:tamanho(transações, 1)
para j =1:tamanho(transações{i}, 2)
binaryTransactions(i, strcmp(transações{i}{j}, único([transações{:}]))) =1;
fim
fim

% Crie uma árvore de padrões frequentes a partir da matriz de transação binária
fpTree =fptree(transações binárias);

% Encontre todos os conjuntos de itens frequentes com suporte mínimo de 2
FrequentItemsets =find_frequent_itemsets(fpTree, 2);

% Gera regras de associação a partir dos conjuntos de itens frequentes
AssociationRules =generate_association_rules(frequentItemsets);

% Exibir os conjuntos de itens frequentes e regras de associação
disp('Conjuntos de itens frequentes:');
disp('------------------');
para i =1:comprimento (conjuntos de itens frequentes)
fprintf('%s\n', strjoin(frequentItemsets{i}, ', '));
fim

disp('Regras de Associação:');
disp('------------------');
para i =1:comprimento (regras de associação)
lhs =strjoin(associationRules{i}.lhs, ', ');
rhs =strjoin(associationRules{i}.rhs, ', ');
confiança =associaçãoRules{i}.confiança * 100;
suporte =associaçãoRules{i}.suporte * 100;
fprintf('Se %s, então %s. Confiança =%f%%, Suporte =%f%%\n', lhs, rhs, confiança, suporte);
fim

% Função para criar uma árvore de padrões frequentes a partir de uma matriz de transação binária
função fpTree =fptree(transações)
headerTable =create_header_table(transações);
raiz =add_node(-1, headerTable.id);
fpTree =struct('root', root, 'headerTable', headerTable);

para i =1:tamanho(transações, 1)
add_transaction(transações(i, :), root, headerTable);
fim
fim

% Função para criar uma tabela de cabeçalho a partir das transações
função headerTable =create_header_table(transações)
headerTable =struct();
itens únicos =único([transações{:}]);
para i =1:tamanho(itens exclusivos, 2)
headerTable(uniqueItems{i}).id =i;
headerTable(uniqueItems{i}).count =sum(sum(transactions ==uniqueItems{i}));
headerTable(uniqueItems{i}).link =[];
fim
fim

% Função para adicionar uma transação à FP-Tree
função add_transaction(transação, nó, headerTable)
se estiver vazio (transação)
retornar;
fim

% Encontre o item com maior frequência na transação
maxFrequência =0;
maxItem ='';
para i =1:comprimento (transação)
if headerTable(transaction{i}).count> maxFrequency
maxFrequency =headerTable(transaction{i}).count;
maxItem =transação{i};
fim
fim

% Se o nó não tiver um filho para maxItem, crie um
se estiver vazio (node.children)
node.children(maxItem).id =headerTable(maxItem).id;
node.children(maxItem).count =1;
node.children(maxItem).link =headerTable(maxItem).link;
node.children(maxItem).parent =node;
outro
if isfield(node.children, maxItem)
node.children(maxItem).count =node.children(maxItem).count + 1;
outro
node.children(maxItem).id =headerTable(maxItem).id;
node.children(maxItem).count =1;
node.children(maxItem).link =headerTable(maxItem).link;
node.children(maxItem).parent =node;
fim
fim

% Atualizar a tabela de cabeçalho
headerTable(maxItem).link =nó;

% Adiciona recursivamente os itens restantes à árvore
para i =1:comprimento (transação)
if ~(strcmp(maxItem, transação{i}))
add_transaction(transaction(2:end), node.children(maxItem), headerTable);
fim
fim
fim

% Função para encontrar todos os conjuntos de itens frequentes da FP-Tree
função freqüenteItemsets =find_frequent_itemsets(fpTree, minSupport)
FrequentItemsets ={};

% Encontre recursivamente conjuntos de itens frequentes de cada ramo da FP-Tree
para ramificação em fpTree.root.children.keys
branchFrequency =fpTree.headerTable(branch).count;

% Se a frequência da filial for menor que o suporte mínimo, continue para a próxima filial
se branchFrequency continuar;
fim

% Adicione o item da ramificação como um conjunto de itens frequente
FrequentItemsets{end + 1} ={branch};

% Encontra recursivamente conjuntos de itens frequentes para todas as subárvores do ramo atual
subFrequentItemsets =find_frequent_itemsets(subtrees(fpTree.root, branch), minSupport);

% Adiciona o item da ramificação a todos os conjuntos de itens frequentes da subárvore
para i =1:comprimento (subFrequentItemsets)
subFrequentItemsets{i}{1} =[ramo, subFrequentItemsets{i}{1}];
FrequentItemsets{end + 1} =subFrequentItemsets{i};
fim
fim
fim

% Função para gerar regras de associação a partir dos conjuntos de itens frequentes
função associaçãoRules =generate_association_rules(frequentItemsets)
regras de associação ={};

% Para cada conjunto de itens frequentes, gere todas as regras de associação possíveis
para conjunto de itens =conjuntos de itens frequentes
para i =1:comprimento (conjunto de itens)

% Cria o antecedente e o consequente da regra
antecedente =conjunto de itens(1:i-1);
consequente =conjunto de itens(i+1:fim);

% Calcule o suporte, a confiança e a suspensão da regra
suporte =100 * (find_support(união(antecedente, consequente)) / find_support(antecedente));
confiança =100 * (find_support(union(antecedente, consequente)) / find_support(antecedente));
lift =confiança / (100 * find_support(consequente) / find_support(antecedente));

% Adiciona a regra de associação à lista
AssociationRules{end + 1} =struct('lhs', antecedente, 'rhs', consequente, 'confiança', confiança, 'suporte', suporte);
fim
fim
fim

% Função para encontrar o suporte de um conjunto de itens
suporte de função =find_support(itemset)
suporte =0;

% Iterar todas as transações e verificar se elas contêm o conjunto de itens
para i =1:tamanho (transações binárias, 1)
if all(binaryTransactions(i, ismember(unique([binaryTransactions{:}]), conjunto de itens)))
suporte =suporte + 1;
fim
fim
fim
```