¿Existe algún código de Matlab para la técnica de minería de datos de algoritmos de asociación de árboles de patrones frecuentes?

A continuación se muestra una implementación simple en MATLAB del algoritmo de asociación FP-Tree para minería de datos. Este código encuentra conjuntos de elementos frecuentes y reglas de asociación de un conjunto de datos de transacciones determinado.

```

% Crear la base de datos de transacciones original como una matriz de celdas

transacciones ={...

{'Pan', 'Leche', 'Mantequilla'}, ...

{'Pan', 'Pañales', 'Cerveza', 'Huevos'}, ...

{'Leche', 'Pañales', 'Cerveza', 'Coca cola'}, ...

{'Pan', 'Leche', 'Pañales', 'Coca cola'}, ...

{'Pan', 'Huevos', 'Cerveza'}...

};

% Convertir transacciones en una matriz binaria

transacciones binarias =ceros(tamaño(transacciones, 1), tamaño(único([transacciones{:}]), 2));

para i =1:tamaño(transacciones, 1)

para j =1:tamaño(transacciones{i}, 2)

binarioTransacciones(i, strcmp(transacciones{i}{j}, único([transacciones{:}]))) =1;

fin

% Crear un árbol de patrones frecuentes a partir de la matriz de transacciones binarias

fpTree =fptree(transacciones binarias);

% Encuentra todos los conjuntos de elementos frecuentes con soporte mínimo de 2

conjuntos de elementos frecuentes =find_itemsets_frecuentes (fpTree, 2);

% Generar reglas de asociación a partir de los conjuntos de elementos frecuentes.

AssociationRules =generate_association_rules(frequentItemsets);

% Muestra los conjuntos de elementos frecuentes y las reglas de asociación.

disp('Conjuntos de elementos frecuentes:');

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

para i =1:longitud(conjuntos de elementos frecuentes)

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

fin

disp('Reglas de asociación:');

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

para i =1:longitud (reglas de asociación)

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

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

confianza =reglas de asociación{i}.confianza * 100;

soporte =AssociationRules{i}.soporte * 100;

fprintf('Si %s, entonces %s. Confianza =%f%%, Apoyo =%f%%\n', izquierda, derecha, confianza, apoyo);

fin

% Función para crear un árbol de patrones frecuentes a partir de una matriz de transacciones binarias

función fpTree =fptree(transacciones)

headerTable =create_header_table(transacciones);

raíz =add_node(-1, headerTable.id);

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

para i =1:tamaño(transacciones, 1)

add_transaction(transacciones(i, :), raíz, headerTable);

fin

% Función para crear una tabla de encabezado a partir de las transacciones.

función headerTable =create_header_table(transacciones)

tabla de encabezado =estructura();

elementos únicos =único([transacciones{:}]);

para i =1:tamaño (elementos únicos, 2)

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

headerTable(uniqueItems{i}).count =suma(suma(transacciones ==UniqueItems{i}));

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

fin

% Función para agregar una transacción al FP-Tree

función add_transaction(transacción, nodo, tabla de encabezado)

si está vacío (transacción)

devolver;

fin

% Encuentra el artículo con mayor frecuencia en la transacción

frecuenciamáx =0;

artículo máximo ='';

para i =1:longitud(transacción)

si headerTable(transacción{i}).count> maxFrequency

maxFrequency =headerTable(transacción{i}).count;

maxItem =transacción{i};

fin

% Si el nodo no tiene un hijo para maxItem, cree uno

si está vacío (nodo.niños)

nodo.niños(maxItem).id =headerTable(maxItem).id;

nodo.niños(maxItem).count =1;

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

nodo.niños(maxItem).padre =nodo;

demás

si es campo (nodo.niños, maxItem)

nodo.niños(maxItem).count =nodo.children(maxItem).count + 1;

demás

nodo.niños(maxItem).id =headerTable(maxItem).id;

nodo.niños(maxItem).count =1;

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

nodo.niños(maxItem).padre =nodo;

fin

% Actualizar la tabla de encabezado

headerTable(maxItem).link =nodo;

% Agregue recursivamente los elementos restantes al árbol

para i =1:longitud(transacción)

si ~(strcmp(maxItem, transacción{i}))

add_transaction(transacción(2:end), node.children(maxItem), headerTable);

fin

% Función para encontrar todos los conjuntos de elementos frecuentes del árbol FP

función conjuntos de elementos frecuentes =find_frequent_itemsets (fpTree, minSupport)

conjuntos de elementos frecuentes ={};

% Encuentra recursivamente conjuntos de elementos frecuentes de cada rama del árbol FP

para rama en fpTree.root.children.keys

BranchFrequency =fpTree.headerTable(rama).count;

% Si la frecuencia de la sucursal es menor que el soporte mínimo, continúe con la siguiente sucursal

si BranchFrequency continuar;

fin

% Agregar el elemento de la sucursal como un conjunto de elementos frecuentes

conjuntos de elementos frecuentes{end + 1} ={rama};

% Encuentra recursivamente conjuntos de elementos frecuentes para todos los subárboles de la rama actual

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

% Agregue el elemento de rama a todos los conjuntos de elementos frecuentes del subárbol

para i =1:longitud (conjuntos de elementos subfrecuentes)

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

conjuntos de elementos frecuentes {end + 1} =subconjuntos de elementos frecuentes {i};

fin

% Función para generar reglas de asociación a partir de los conjuntos de elementos frecuentes

función reglas de asociación =generar_rules_de asociación (conjuntos de elementos frecuentes)

reglas de asociación ={};

% Para cada conjunto de elementos frecuentes, genere todas las reglas de asociación posibles

para conjunto de elementos =conjuntos de elementos frecuentes

para i =1:longitud (conjunto de elementos)

% Crear el antecedente y consecuente de la regla

antecedente =conjunto de elementos(1:i-1);

consecuente =conjunto de elementos(i+1:fin);

% Calcular el apoyo, la confianza y la elevación de la regla.

soporte =100 * (find_support(union(antecedente, consecuente)) / find_support(antecedente));

confianza =100 * (find_support(union(antecedente, consecuente)) / find_support(antecedente));

elevación =confianza / (100 * find_support(consecuente) / find_support(antecedente));

% Agregar la regla de asociación a la lista

AssociationRules{end + 1} =struct('lhs', antecedente, 'rhs', consecuente, 'confianza', confianza, 'apoyo', apoyo);

fin

% Función para encontrar el soporte de un conjunto de elementos.

soporte de función =find_support (conjunto de elementos)

soporte =0;

% Recorrer todas las transacciones y comprobar si contienen el conjunto de elementos

para i =1:tamaño(transacciones binarias, 1)

si todos (transacciones binarias (i, ismember (único ([transacciones binarias {:}]), conjunto de elementos)))

apoyo =apoyo + 1;

fin

```