Comment utiliser la base de données MySQL pour l'exploration de règles d'association ?

Comment utiliser la base de données MySQL pour l'exploration de règles d'association ?

Introduction : 
L'exploration de règles d'association est une technique d'exploration de données utilisée pour découvrir des associations entre des éléments d'un ensemble de données. MySQL est un système de gestion de bases de données relationnelles largement utilisé avec de puissantes fonctions de traitement de données et de requête. Cet article explique comment utiliser la base de données MySQL pour l'exploration de règles d'association, y compris la préparation des données, l'algorithme d'exploration de règles d'association, l'implémentation d'instructions SQL et des exemples de code.

1. Préparation des données
Avant les règles de l'association minière, vous devez d'abord préparer un ensemble de données approprié. L'ensemble de données constitue la base de l'exploration de règles d'association, qui contient les transactions et les ensembles d'éléments qui doivent être exploités. Dans MySQL, les ensembles de données peuvent être stockés en créant des tables de données. Par exemple, en supposant que nous souhaitions exploiter les règles d'association dans les données du panier, nous pouvons créer une table de données nommée « transactions » pour stocker les enregistrements d'achats de chaque client, chaque enregistrement contenant plusieurs achats d'un client.

CREATE TABLE transactions (
customer_id INT,
item_id INT
);

Puis insérez les données du panier dans la table de données :

INSERT INTO transactions (customer_id, item_id) VALUES
(1, 101),
(1 , 102),
(1, 103),
(2, 101),
(2, 104),
(3, 102),
(3, 105),
(4, 101),
(4, 103),
(4, 104);

2. Algorithme d'exploration de règles d'association
Les algorithmes d'exploration de règles d'association courants incluent l'algorithme Apriori et l'algorithme FP-Growth. L'algorithme Apriori est un algorithme itératif basé sur des ensembles candidats qui découvre des ensembles d'éléments fréquents et des règles d'association en générant progressivement des ensembles candidats et en calculant des seuils de prise en charge. L'algorithme FP-Growth est un algorithme basé sur une arborescence de préfixes qui peut extraire efficacement des ensembles d'éléments fréquents et des règles d'association. Dans MySQL, nous pouvons utiliser des instructions SQL pour implémenter ces deux algorithmes.

3. Implémentation des instructions SQL

1. Algorithme Apriori
   L'algorithme Apriori comprend deux étapes : la génération fréquente d'ensembles d'éléments et la génération de règles d'association. Tout d'abord, générez des ensembles d'éléments fréquents via l'instruction SQL suivante :

SELECT item_id, COUNT(*) AS support
FROM transactions
GROUP BY item_id
HAVING support >= min_support;

où "item_id" est l'élément dans le itemset , "support" est la prise en charge de l'ensemble d'éléments et "min_support" est le seuil de prise en charge minimum défini. Cette instruction SQL renverra des ensembles d'éléments fréquents qui répondent aux exigences minimales de prise en charge.

Ensuite, générez des règles d'association via l'instruction SQL suivante :

SELECT t1.item_id AS antécédent, t2.item_id AS conséquent,

   COUNT(*) / (SELECT COUNT(*) FROM transactions) AS confidence

FROM transactions AS t1, transactions AS t2
WHERE t1.item_id != t2.item_id
GROUP BY t1.item_id, t2.item_id
HAVING trust >= min_confidence;

Où, "antécédent" est l'antécédent de la règle, "conséquent" est le conséquent de la règle, "confiance" est la confiance de la règle , "min_confidence" est le seuil de confiance minimum défini. Cette instruction SQL renverra des règles d'association qui répondent aux exigences minimales de confiance.

2. Algorithme FP-Growth
   L'algorithme FP-Growth exploite les ensembles d'éléments fréquents et les règles d'association en créant une arborescence de préfixes. Dans MySQL, l'algorithme FP-Growth peut être implémenté à l'aide de tables temporaires et de variables définies par l'utilisateur.

Tout d'abord, créez une table temporaire pour stocker les ensembles d'éléments fréquents :

CREATE TEMPORARY TABLE fréquent_items (
item_id INT,
supporte INT

Ensuite, générez des ensembles d'éléments fréquents via l'instruction SQL suivante :

INSERT INTO); fréquent_items
SELECT item_id, COUNT(*) AS support
FROM transactions
GROUP BY item_id
HAVING support >= min_support;

Ensuite, créez une variable définie par l'utilisateur pour stocker l'ensemble des éléments fréquents :

SET @frequent_items = ' ';

Ensuite, générez des règles d'association via l'instruction SQL suivante :

SELECT t1.item_id AS antécédent, t2.item_id AS conséquent,

   COUNT(*) / (SELECT COUNT(*) FROM transactions) AS confidence

FROM transactions AS t1, transactions AS t2
WHERE t1.item_id != t2 .item_id _ Et Find_in_Set (T1.Item_id, @Frequent_items) & GT ; 0
et Find_in_SET (T2.ITEM_ID, @Frequent_items) & GT ; 0
Groupe par T1.item_id, En ayant confiance & gt ; , Mettez à jour les variables définies par l'utilisateur via l'instruction SQL suivante :

SET @frequent_items = (SELECT GROUP_CONCAT(item_id) FROM fréquent_items);

4. Exemples de code

Ce qui suit est un exemple de code pour l'exploration de règles d'association à l'aide de la base de données MySQL :

.

-- Créer une table de données

CREATE TABLE transactions (
customer_id INT,

item_id INT

);

--Insérer les données du panier
INSERT INTO transactions (customer_id, item_id) VALUES
(1, 101),

(1, 102),

(1, 103),
(2, 101),
(2, 104),
(3, 102),
(3, 105),
(4, 101),
(4, 103 ),
( 4, 104);

-- Algorithme Apriori
-- Générer des ensembles d'éléments fréquents
SELECT item_id, COUNT(*) AS support

FROM transactions

GROUP BY item_id
HAVING support >= 2;

- - Générer des règles d'association
SELECT t1.item_id AS antécédent, t2.item_id AS conséquent,

   COUNT(*) / (SELECT COUNT(*) FROM transactions) AS confidence

FROM transactions AS t1, transactions AS t2

WHERE t1.item_id != t2.item_id
GROUP BY t1.item_id, t2.item_id

AVOIR confiance > = 0,5;

-- Algorithme FP-Growth
-- Créer une table temporaire
CREATE TEMPORARY TABLEfrequent_items (

item_id INT,

support INT
);

-- Générer des ensembles d'éléments fréquents
INSERT INTO fréquent_items
SELECT item_id, COUNT(*) AS support
FROM transactions
GROUP BY item_id
HAVING support >= 2;

-- Créer des variables définies par l'utilisateur
SET @frequent_items = ' ';

-- Générer des règles d'association
SELECT t1.item_id COMME antécédent, t2.item_id COMME conséquent,

   COUNT(*) / (SELECT COUNT(*) FROM transactions) AS confidence

FROM transactions AS t1, transactions AS t2
WHERE t1.item_id != t2.item_id
AND FIND_IN_SET(t1. item_id, @frequent_items) > 0
AND FIND_IN_SET(t2.item_id, @frequent_items) > 0
GROUP BY t1.item_id, t2.item_id
AVANT confiance >= 0.5;

Conclusion :
Grâce à l'introduction de ceci article, Nous avons appris à utiliser la base de données MySQL pour l'exploration de règles d'association. L'algorithme Apriori et l'algorithme FP-Growth peuvent être implémentés via des instructions SQL. J'espère que cet article vous sera utile lorsque vous utiliserez MySQL pour l'exploration de règles d'association.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!