```

% Maak de originele transactiedatabase als een celarray

transacties ={ ...

{'Brood', 'Melk', 'Boter'}, ...

{'Brood', 'Luiers', 'Bier', 'Eieren'}, ...

{'Melk', 'Luiers', 'Bier', 'Cola'}, ...

{'Brood', 'Melk', 'Luiers', 'Cola'}, ...

{'Brood', 'Eieren', 'Bier'} ...

};

% Converteer transacties naar een binaire matrix

binaryTransactions =nullen(grootte(transacties, 1), grootte(uniek([transacties{:}]), 2));

voor i =1:grootte(transacties, 1)

voor j =1:grootte(transacties{i}, 2)

binaryTransactions(i, strcmp(transacties{i}{j}, uniek([transacties{:}]))) =1;

einde

einde

% Creëer een frequente patroonboom op basis van de binaire transactiematrix

fpTree =fptree(binairetransacties);

% Vind alle frequente itemsets met minimale ondersteuning van 2

frequentItemsets =find_frequent_itemsets(fpTree, 2);

% Genereer associatieregels uit de frequente itemsets

associatieRules =genereren_association_rules(frequentItemsets);

% Geef de frequente itemsets en associatieregels weer

disp('Veelgebruikte itemsets:');

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

for i =1:lengte(frequenteitemsets)

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

einde

disp('Associatieregels:');

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

for i =1:lengte(associatieregels)

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

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

vertrouwen =associatieregels{i}.vertrouwen * 100;

ondersteuning =associatieregels{i}.support * 100;

fprintf('Als %s, dan %s. Vertrouwen =%f%%, Ondersteuning =%f%%\n', lhs, rhs, vertrouwen, ondersteuning);

einde

% Functie om een ​​frequente patroonboom te creëren op basis van een binaire transactiematrix

functie fpTree =fptree(transacties)

headerTable =create_header_table(transacties);

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

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

voor i =1:grootte(transacties, 1)

add_transaction(transacties(i, :), root, headerTable);

einde

einde

% Functie om een ​​koptabel van de transacties te maken

functie headerTable =create_header_table (transacties)

headerTabel =struct();

uniqueItems =uniek([transacties{:}]);

for i =1:grootte(uniekeitems, 2)

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

headerTable(uniqueItems{i}).count =som(som(transacties ==uniekeItems{i}));

headerTabel(uniekeItems{i}).link =[];

einde

einde

% Functie om een ​​transactie toe te voegen aan de FP-Tree

functie add_transaction(transactie, knooppunt, headertabel)

indien leeg(transactie)

opbrengst;

einde

% Zoek het item met de hoogste frequentie in de transactie

maxFrequentie =0;

maxItem ='';

voor i =1:lengte(transactie)

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

maxFrequency =headerTabel(transactie{i}).count;

maxItem =transactie{i};

einde

einde

% Als het knooppunt geen onderliggend element voor het maxItem heeft, maakt u er een

if isempty(node.children)

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

node.children(maxItem).count =1;

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

node.children(maxItem).parent =knooppunt;

anders

if isfield(node.children, maxItem)

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

anders

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

node.children(maxItem).count =1;

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

node.children(maxItem).parent =knooppunt;

einde

einde

% Update de headertabel

headerTable(maxItem).link =knooppunt;

% Voeg de overige items recursief toe aan de boomstructuur

voor i =1:lengte(transactie)

if ~(strcmp(maxItem, transactie{i}))

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

einde

einde

einde

% Functie om alle frequente itemsets uit de FP-Tree te vinden

functie frequentItemsets =find_frequent_itemsets(fpTree, minSupport)

frequentItemsets ={};

% Vind recursief frequente itemsets uit elke tak van de FP-Tree

voor vertakking in fpTree.root.children.keys

branchFrequency =fpTree.headerTable(branch).count;

% Als de aftakkingsfrequentie lager is dan de minimale ondersteuning, ga dan door naar de volgende aftakking

als branchFrequency doorgaan;

einde

% Voeg het filiaalitem toe als een frequente itemset

frequentItemsets{end + 1} ={branch};

% Vind recursief frequente itemsets voor alle subbomen van de huidige vertakking

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

% Voeg het vertakkingsitem toe aan alle frequente itemsets uit de subboom

voor i =1:lengte(subFrequentItemsets)

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

frequentItemsets{end + 1} =subFrequentItemsets{i};

einde

einde

einde

% Functie om associatieregels te genereren uit de frequente itemsets

functie associatieRules =genereren_association_rules(frequentItemsets)

associatieregels ={};

% Genereer voor elke frequente itemset alle mogelijke associatieregels

voor itemset =frequentItemsets

voor i =1:lengte(itemset)

% Creëer het antecedent en het gevolg voor de regel

antecedent =itemset(1:i-1);

consequent =itemset(i+1:einde);

% Bereken de steun, het vertrouwen en de lift van de regel

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

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

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

% Voeg de associatieregel toe aan de lijst

associatieRules{end + 1} =struct('lhs', antecedent, 'rhs', consequent, 'vertrouwen', vertrouwen, 'ondersteuning', ondersteuning);

einde

einde

einde

% Functie om de ondersteuning van een itemset te vinden

functieondersteuning =find_support(itemset)

ondersteuning =0;

% Doorloop alle transacties en controleer of ze de itemset bevatten

voor i =1:grootte(binairetransacties, 1)

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

ondersteuning =ondersteuning + 1;

einde

einde

einde

```