Existe-t-il un code Matlab pour la technique d'exploration de données d'algorithme d'association d'arbres de modèles fréquents ?

```

% Créer la base de données de transactions d'origine sous forme de tableau de cellules

transactions ={ ...

{'Pain', 'Lait', 'Beurre'}, ...

{'Pain', 'Couches', 'Bière', 'Œufs'}, ...

{'Lait', 'Couches', 'Bière', 'Coke'}, ...

{'Pain', 'Lait', 'Couches', 'Coke'}, ...

{'Pain', 'Œufs', 'Bière'}...

} ;

% Convertir les transactions en une matrice binaire

binaireTransactions =zéros(size(transactions, 1), size(unique([transactions{:}]), 2));

pour i =1:taille(transactions, 1)

pour j =1:taille(transactions{i}, 2)

binaireTransactions(i, strcmp(transactions{i}{j}, unique([transactions{:}]))) =1;

fin

fin

% Créer un arbre de modèles fréquents à partir de la matrice de transactions binaires

fpTree =fptree(binaryTransactions);

% Trouver tous les ensembles d'éléments fréquents avec un support minimum de 2

fréquentItemsets =find_frequent_itemsets(fpTree, 2);

% Générer des règles d'association à partir des ensembles d'éléments fréquents

associationRules =generate_association_rules(frequentItemsets);

% Afficher les ensembles d'éléments fréquents et les règles d'association

disp('Ensembles d'éléments fréquents :');

disp('------------------');

pour i =1:longueur(frequentItemsets)

fprintf('%s\n', strjoin(frequentItemsets{i}, ', '));

fin

disp('Règles d'association :');

disp('------------------');

pour i =1:longueur(associationRules)

lhs =strjoin(associationRules{i}.lhs, ', ');

rhs =strjoin(associationRules{i}.rhs, ', ');

confiance =associationRules{i}.confidence * 100 ;

support =associationRules{i}.support * 100 ;

fprintf('Si %s, alors %s. Confiance =%f%%, Support =%f%%\n', gauche, droite, confiance, soutien);

fin

% Fonction pour créer un arbre de modèles fréquents à partir d'une matrice de transactions binaires

fonction fpTree =fptree (transactions)

headerTable =create_header_table(transactions);

root =add_node(-1, headerTable.id);

fpTree =struct('racine', racine, 'headerTable', headerTable);

pour i =1:taille(transactions, 1)

add_transaction(transactions(i, :), racine, headerTable);

fin

fin

% Fonction pour créer un tableau d'en-tête à partir des transactions

fonction headerTable =create_header_table (transactions)

headerTable =struct();

uniqueItems =unique([transactions{:}]);

pour i =1:size(uniqueItems, 2)

headerTable(uniqueItems{i}).id =i;

headerTable(uniqueItems{i}).count =sum(sum(transactions ==uniqueItems{i}));

headerTable(uniqueItems{i}).link =[];

fin

fin

% Fonction pour ajouter une transaction au FP-Tree

fonction add_transaction (transaction, nœud, headerTable)

si je suis vide (transaction)

retour;

fin

% Trouver l'article avec la fréquence la plus élevée dans la transaction

fréquencemax =0 ;

maxItem ='';

pour i =1:longueur(transaction)

si headerTable(transaction{i}).count> maxFrequency

maxFrequency =headerTable(transaction{i}).count;

maxItem =transaction{i} ;

fin

fin

% Si le nœud n'a pas d'enfant pour le maxItem, créez-en un

si je suis vide (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 =noeud;

autre

si isfield (node.children, maxItem)

node.children(maxItem).count =node.children(maxItem).count + 1;

autre

node.children(maxItem).id =headerTable(maxItem).id;

node.children(maxItem).count =1;

node.children(maxItem).link =headerTable(maxItem).link;

node.children(maxItem).parent =noeud;

fin

fin

% Mettre à jour le tableau d'en-tête

headerTable(maxItem).link =noeud;

% Ajouter de manière récursive les éléments restants à l'arborescence

pour i =1:longueur(transaction)

si ~(strcmp(maxItem, transaction{i}))

add_transaction(transaction(2:end), node.children(maxItem), headerTable);

fin

fin

fin

% Fonction pour trouver tous les éléments fréquents du FP-Tree

fonction fréquentItemsets =find_frequent_itemsets(fpTree, minSupport)

fréquentItemsets ={};

% Trouver de manière récursive des ensembles d'éléments fréquents de chaque branche du FP-Tree

pour la branche dans fpTree.root.children.keys

branchFrequency =fpTree.headerTable(branch).count;

% Si la fréquence de branchement est inférieure au support minimum, passez à la branche suivante

si branchFrequency continuer;

fin

% Ajouter l'élément de branche comme ensemble d'éléments fréquents

fréquentItemsets{end + 1} ={branche} ;

% Rechercher de manière récursive des ensembles d'éléments fréquents pour tous les sous-arbres de la branche actuelle

subFrequentItemsets =find_frequent_itemsets(subtrees(fpTree.root, branch), minSupport);

% Ajouter l'élément de branche à tous les ensembles d'éléments fréquents du sous-arbre

pour i =1:longueur(subFrequentItemsets)

subFrequentItemsets{i}{1} =[branche, subFrequentItemsets{i}{1}] ;

fréquentItemsets{end + 1} =subFrequentItemsets{i} ;

fin

fin

fin

% Fonction pour générer des règles d'association à partir des ensembles d'éléments fréquents

fonction associationRules =generate_association_rules (frequentItemsets)

associationRules ={};

% Pour chaque ensemble d'éléments fréquents, générer toutes les règles d'association possibles

pour itemset =fréquentItemsets

pour i =1:longueur(ensemble d'éléments)

% Créer l'antécédent et le conséquent de la règle

antécédent =itemset(1:i-1);

conséquent =itemset(i+1:end);

% Calculer le soutien, la confiance et la levée de la règle

support =100 * (find_support(union(antecedent, consequent)) / find_support(antecedent));

confiance =100 * (find_support(union(antecedent, consequent)) / find_support(antecedent));

lift =confiance / (100 * find_support(consequent) / find_support(antecedent));

% Ajouter la règle d'association à la liste

associationRules{end + 1} =struct('lhs', antécédent, 'rhs', conséquent, 'confiance', confiance, 'support', support);

fin

fin

fin

% Fonction pour trouver le support d'un ensemble d'éléments

support de fonction =find_support (itemset)

soutien =0 ;

% Parcourez toutes les transactions et vérifiez si elles contiennent l'ensemble d'éléments

pour i =1:size(binaryTransactions, 1)

if all(binaryTransactions(i, ismember(unique([binaryTransactions{:}]), itemset)))

soutien =soutien + 1;

fin

fin

fin

```