```
% Crea il database delle transazioni originale come matrice di celle
transazioni ={...
{'Pane', 'Latte', 'Burro'}, ...
{'Pane', 'Pannolini', 'Birra', 'Uova'}, ...
{'Latte', 'Pannolini', 'Birra', 'Coca Cola'}, ...
{'Pane', 'Latte', 'Pannolini', 'Coca Cola'}, ...
{'Pane', 'Uova', 'Birra'} ...
};
% Convertire le transazioni in una matrice binaria
BinaryTransactions =zeros(size(transactions, 1), size(unique([transactions{:}]), 2));
per i =1:dimensione(transazioni, 1)
per j =1:dimensione(transazioni{i}, 2)
BinaryTransactions(i, strcmp(transazioni{i}{j}, unique([transazioni{:}]))) =1;
FINE
FINE
% Crea un albero di modelli frequenti dalla matrice delle transazioni binarie
fpTree =fptree(transazioni binarie);
% Trova tutti i set di elementi frequenti con supporto minimo di 2
elementifrequenti =find_frequent_itemsets(fpTree, 2);
% Genera regole di associazione dagli insiemi di elementi frequenti
AssociationRules =generate_association_rules(frequentItemsets);
% Visualizza i set di elementi frequenti e le regole di associazione
disp('Set di elementi frequenti:');
disp('------------------');
for i =1:length(frequentItemsets)
fprintf('%s\n', strjoin(frequentItemsets{i}, ', '));
FINE
disp('Regole di associazione:');
disp('------------------');
per i =1:lunghezza(regolediassociazione)
lhs =strjoin(associationRules{i}.lhs, ', ');
rhs =strjoin(associationRules{i}.rhs, ', ');
confidenza =AssociationRules{i}.confidenza * 100;
supporto =AssociationRules{i}.support * 100;
fprintf('Se %s, allora %s. Fiducia =%f%%, Supporto =%f%%\n', sinistra, destra, fiducia, supporto);
FINE
% Funzione per creare un albero di pattern frequente da una matrice di transazioni binarie
funzione fpTree =fptree(transazioni)
headerTable =create_header_table(transazioni);
root =add_node(-1, headerTable.id);
fpTree =struct('root', root, 'headerTable', headerTable);
per i =1:dimensione(transazioni, 1)
add_transaction(transazioni(i, :), root, headerTable);
FINE
FINE
% Funzione per creare una tabella di intestazione dalle transazioni
funzione headerTable =create_header_table(transazioni)
tabellaintestazione =struct();
Oggettiunici =unici([transazioni{:}]);
for i =1:dimensione(oggettiunici, 2)
headerTable(uniqueItems{i}).id =i;
headerTable(uniqueItems{i}).count =sum(sum(transactions ==uniqueItems{i}));
headerTable(uniqueItems{i}).link =[];
FINE
FINE
% Funzione per aggiungere una transazione all'FP-Tree
funzione add_transaction(transazione, nodo, tabellaintestazione)
se è vuoto(transazione)
ritorno;
FINE
% Trova l'articolo con la frequenza più alta nella transazione
frequenza massima =0;
maxArticolo ='';
per i =1:lunghezza(transazione)
if tabellaintestazione(transazione{i}).count> maxFrequency
maxFrequency =headerTable(transazione{i}).count;
maxArticolo =transazione{i};
FINE
FINE
% Se il nodo non ha un figlio per maxItem, creane uno
se è vuoto(node.children)
node.children(maxItem).id =headerTable(maxItem).id;
nodo.bambini(maxItem).count =1;
nodo.bambini(maxItem).link =headerTable(maxItem).link;
nodo.bambini(maxItem).parent =nodo;
altro
if isfield(node.children, maxItem)
nodo.bambini(maxItem).count =nodo.bambini(maxItem).count + 1;
altro
node.children(maxItem).id =headerTable(maxItem).id;
nodo.bambini(maxItem).count =1;
nodo.bambini(maxItem).link =headerTable(maxItem).link;
nodo.bambini(maxItem).parent =nodo;
FINE
FINE
% Aggiorna la tabella delle intestazioni
headerTable(maxItem).link =nodo;
% Aggiunge ricorsivamente gli elementi rimanenti all'albero
per i =1:lunghezza(transazione)
if ~(strcmp(maxItem, transazione{i}))
add_transaction(transaction(2:end), node.children(maxItem), headerTable);
FINE
FINE
FINE
Funzione % per trovare tutti gli insiemi di elementi frequenti dall'albero FP
funzione frequentItemsets =find_frequent_itemsets(fpTree, minSupport)
elementifrequenti ={};
% Trova ricorsivamente set di elementi frequenti da ciascun ramo dell'albero FP
per il ramo in fpTree.root.children.keys
branchFrequency =fpTree.headerTable(branch).count;
% Se la frequenza della diramazione è inferiore al supporto minimo, passare alla diramazione successiva
se branchFrequency
FINE
% Aggiungere l'elemento della filiale come insieme di elementi frequenti
frequentItemsets{fine + 1} ={ramo};
% Trova ricorsivamente insiemi di elementi frequenti per tutti i sottoalberi del ramo corrente
subFrequentItemsets =find_frequent_itemsets(subtrees(fpTree.root, ramo), minSupport);
% Aggiunge l'elemento del ramo a tutti gli insiemi di elementi frequenti dal sottoalbero
for i =1:length(subFrequentItemsets)
subFrequentItemsets{i}{1} =[ramo, subFrequentItemsets{i}{1}];
set di articoli frequenti{fine + 1} =set di articoli frequenti {i};
FINE
FINE
FINE
% Funzione per generare regole di associazione dai set di elementi frequenti
funzione associazioneRules =generate_association_rules(frequentItemsets)
regole di associazione ={};
% Per ogni insieme di elementi frequenti, generare tutte le possibili regole di associazione
per set di articoli =set di articoli frequenti
per i =1:lunghezza(insieme di elementi)
% Crea l'antecedente e il conseguente della regola
antecedente =insieme di elementi(1:i-1);
conseguente =insieme di elementi(i+1:fine);
% Calcolare il supporto, la confidenza e la portanza della regola
supporto =100 * (find_support(union(antecedente, conseguente)) / find_support(antecedente));
confidenza =100 * (find_support(union(antecedente, conseguente)) / find_support(antecedente));
lift =confidenza / (100 * find_support(conseguente) / find_support(antecedente));
% Aggiunge la regola di associazione all'elenco
AssociationRules{end + 1} =struct('lhs', antecedente, 'rhs', conseguente, 'confidenza', confidenza, 'supporto', supporto);
FINE
FINE
FINE
% Funzione per trovare il supporto di un set di elementi
supporto funzione =find_support(itemset)
supporto =0;
% Scorrere tutte le transazioni e verificare se contengono il set di elementi
per i =1:dimensione(transazionibinarie, 1)
if all(binaryTransactions(i, ismember(unique([binaryTransactions{:}]), itemset)))
supporto =supporto + 1;
FINE
FINE
FINE
```
Informazioni correlate
software © www.354353.com