Exploration des données | analyse de l'affinité des produits avec Python

Appelez - moi frère. 2022-01-15 03:55:01 阅读数:149

exploration des donn es analyse

Les cas suivants sont tirés de《PythonIntroduction et pratique de l'exploration des données(Deuxième édition)》Chapitre I1.3Exemple simple d'analyse d'affinité.

Commençons par quelques concepts et flux de travail sur l'affinité dans ce cas,Ensuite, nous discuterons de quelques options de traitement plus optimisées.

Note::Le livre indique clairement que pour faciliter la compréhension,Parfois, on s'intéresse davantage à la clarté et à la compréhension des codes et des flux de travail,Plutôt que de savoir si la méthode utilisée est la plus efficace.

1. Qu'est - ce que l'analyse d'affinité

L'analyse d'affinité est une méthode d'extraction de données utilisée pour calculer la similarité des échantillons,Cette similitude peut apparaître dans les scénarios suivants:

Utilisateurs du site,Développer des services ou des annonces ciblées;

Marchandises vendues,Films ou autres produits recommandés(Je suppose que ça te plaît.).

À propos de l'analyse d'affinité,On s'attend à ce que vous voyiez l'exemple classique suivant:

Il y a une telle légende dans le commerce de détail aux États - Unis,Les grands magasins Wal - Mart vendent leurs couches côte à côte avec de la bière,Résultats les ventes de couches et de bière ont augmenté!

Dans le cas présent,Pour simplifier le Code et faciliter la compréhension,Nous envisageons seulement d'acheter simultanément2Situation des articles,Comme les règles simples suivantes:

Si l'utilisateur a acheté l'articleX,Alors, ils ont aussi tendance à acheter des biensY

Ici, nous donnons2Concepts d'indicateurs de données utilisés pour évaluer les règles:SoutienEtDegré de confiance.

Soutien Est le nombre de fois qu'une règle apparaît dans un ensemble de données,C'est - à - dire le nombre d'échantillons correspondant à la règle,Comme acheter des biens en même tempsXEtYNombre de transactions;

Degré de confiance Mesure l'exactitude des règles d'appariement,Comme acheter des marchandisesX Achat simultané de marchandises dans le cadre d'une transaction YProportion de.

2. Détails du cas

Cette section est une introduction aux cas dans le livre , Les bibliothèques d'outils utilisées sont les suivantes: :

  • numpy
  • collections

2.1. Charger l'ensemble de données

Réponse de fond de l'ensemble de données 955 Recevoir, Les étudiants intéressés peuvent également utiliser numpy Construire vos propres ensembles de données aléatoires .

import numpy as np
dataset_filename = "affinity_dataset.txt"
X = np.loadtxt(dataset_filename)
n_samples, n_features = X.shape
print(f" Cet ensemble de données Oui. {
n_samples} D'accord Et {
n_features} Colonnes")
print(X[:5])
 Cet ensemble de données Oui. 100 D'accord Et 5 Colonnes
[[0. 1. 0. 0. 0.]
[1. 1. 0. 0. 0.]
[0. 0. 1. 0. 1.]
[1. 1. 0. 0. 0.]
[0. 0. 1. 1. 1.]]

Cet ensemble de données est relativement petit ,Total100D'accord5Données de colonne.Ici, nous allons Chaque ligne de données est considérée comme une transaction , Chaque colonne représente un article ,Nombre1 Le représentant a acheté ,0 Le représentant n'a pas acheté .

Pour cela5Colonnes,Représenté séparément Pain、Lait、Fromages、 Pommes et bananes .Comme la première ligne[0. 1. 0. 0. 0.] Afficher les produits de la première transaction , Les consommateurs n'achètent que du lait , Sans acheter d'autres produits .

features = ["Pain", "Lait", "Fromages", "Pommes", "Bananes"]

Et puis..., Nous avons commencé à étudier les calculs de soutien et de confiance .

2.2. S'il te plaît. -> Affinité banane

Selon le concept, Le degré de confiance doit connaître le nombre de transactions d'un article dans le soutien , Prenons par exemple la banane. , Regardez le nombre de transactions .

Règles de calcul: Traverser les données de la colonne Apple ,La valeur est:1Alors comptez+1

num_apple_purchases = 0
for sample in X:
if sample[3] == 1: # No4Colonnes
num_apple_purchases += 1
print(f" Le nombre de transactions contenant des pommes est :{
num_apple_purchases}")
 Le nombre de transactions contenant des pommes est :43

Et voilà., On calcule les pommes - Soutien aux bananes .

Règles de calcul: Si la pomme est inscrite comme 1 Et les bananes sont énumérées comme 1,Alors comptez+1

rule_valid = 0
for sample in X:
if sample[3] == 1: # J'ai acheté des pommes 
if sample[4] == 1:
# J'ai aussi acheté des bananes. 
rule_valid += 1
else:
continue
print(f" Le nombre d'achats simultanés de pommes et de bananes est de :{
rule_valid}")
 Le nombre d'achats simultanés de pommes et de bananes est de :27

Après avoir calculé les deux valeurs ci - dessus , Nous avons un accès facile Pommes—>BananesDeDegré de confiance.

Règles de calcul:Avec des pommes.- Soutien aux bananes / Nombre de transactions contenant des pommes

support = rule_valid # Soutien
confidence = rule_valid / num_apple_purchases # Degré de confiance
print(f"Pommes- Le soutien à la banane est {
support}\nPommes—> Le degré de confiance de la banane est {
confidence:.3f}")
# Confidence can be thought of as a percentage using the following:
print(f"Pommes—> Le pourcentage de confiance pour les bananes est {
confidence*100:.1f}%.")
Pommes- Le soutien à la banane est 27
Pommes—> Le degré de confiance de la banane est 0.628
Pommes—> Le pourcentage de confiance pour les bananes est 62.8%

Jusqu'ici., On a calculé les pommes. - Le soutien à la banane est 27, C'est - à - dire que le nombre d'achats simultanés de pommes et de bananes est de 27; Et le pourcentage d'utilisateurs qui ont acheté des pommes qui ont également acheté des bananes est 62.8%,C'est la confiance..

Et voilà., Nous pouvons calculer les données de soutien et de confiance entre toutes les combinaisons , Ensuite, une analyse comparative est effectuée. , Ensuite, nous avons organisé la Stratégie .

2.3. Analyse d'affinité

Nous devons maintenant calculer toutes les règles à partir de l'ensemble de données (Attention!: Les règles sont les suivantes: 2 Exemples de produits , Ne pas étendre plus de combinaisons ).Il faut donc créer1 Dictionnaires utilisés pour stocker les règles correspondantes ,Dictionnairekey- Oui.X—>Y, La valeur est le support ; Un autre dictionnaire est utilisé pour stocker X—>YMoyenneXNombre d'occurrences.

from collections import defaultdict
# Initialisation2Dictionnaires
valid_rules = defaultdict(int)
num_occurences = defaultdict(int)
# Calculer le support et X->YMoyenneXNombre d'occurrences
for sample in X:
for premise in range(n_features):
if sample[premise] == 0:
continue
# EnregistrementX—>YMoyenneXNombre d'occurrences
num_occurences[premise] += 1
for conclusion in range(n_features):
if premise == conclusion: # X—>XÇa n'a aucun sens.,Skip
continue
if sample[conclusion] == 1:
# XEtYEn même temps, Nombre de fois que la règle correspond +1
valid_rules[(premise, conclusion)] += 1
else:
continue
support = valid_rules
confidence = defaultdict(float)
# Calculer le degré de confiance
for premise, conclusion in valid_rules.keys():
confidence[(premise, conclusion)] = valid_rules[(premise, conclusion)] / num_occurences[premise]
#Résultats obtenus
for premise, conclusion in confidence:
premise_name = features[premise]
conclusion_name = features[conclusion]
print(f"Les règles: {
premise_name}—>{
conclusion_name}")
print(f" - Degré de confiance: {
confidence[(premise, conclusion)]*100:.2f}%")
print(f" - Soutien: {
support[(premise, conclusion)]}")
print('-'*20)

Les résultats sont les suivants::

Les règles: Pain—>Lait
- Degré de confiance: 46.43%
- Soutien: 13
--------------------
Les règles: Lait—>Pain
- Degré de confiance: 25.00%
- Soutien: 13
--------------------
Les règles: Fromages—>Bananes
- Degré de confiance: 51.28%
- Soutien: 20
--------------------
Les règles: Bananes—>Fromages
- Degré de confiance: 35.09%
- Soutien: 20
--------------------
Les règles: Fromages—>Pommes
- Degré de confiance: 56.41%
- Soutien: 22
--------------------
Les règles: Pommes—>Fromages
- Degré de confiance: 51.16%
- Soutien: 22
--------------------
Les règles: Pommes—>Bananes
- Degré de confiance: 62.79%
- Soutien: 27
--------------------
Les règles: Bananes—>Pommes
- Degré de confiance: 47.37%
- Soutien: 27
--------------------
Les règles: Lait—>Pommes
- Degré de confiance: 34.62%
- Soutien: 18
--------------------
Les règles: Pommes—>Lait
- Degré de confiance: 41.86%
- Soutien: 18
--------------------
Les règles: Lait—>Bananes
- Degré de confiance: 51.92%
- Soutien: 27
--------------------
Les règles: Bananes—>Lait
- Degré de confiance: 47.37%
- Soutien: 27
--------------------
Les règles: Pain—>Fromages
- Degré de confiance: 17.86%
- Soutien: 5
--------------------
Les règles: Fromages—>Pain
- Degré de confiance: 12.82%
- Soutien: 5
--------------------
Les règles: Pain—>Bananes
- Degré de confiance: 57.14%
- Soutien: 16
--------------------
Les règles: Bananes—>Pain
- Degré de confiance: 28.07%
- Soutien: 16
--------------------
Les règles: Lait—>Fromages
- Degré de confiance: 21.15%
- Soutien: 11
--------------------
Les règles: Fromages—>Lait
- Degré de confiance: 28.21%
- Soutien: 11
--------------------
Les règles: Pain—>Pommes
- Degré de confiance: 32.14%
- Soutien: 9
--------------------
Les règles: Pommes—>Pain
- Degré de confiance: 20.93%
- Soutien: 9
--------------------

Nous pouvons produire Avant le niveau de confiance 5Les règles sont les suivantes:( Vous pouvez également essayer de produire le support avant 5Règles)

def print_rule(premise, conclusion, support, confidence, features):
premise_name = features[premise]
conclusion_name = features[conclusion]
print(f"Les règles: {
premise_name}—>{
conclusion_name}")
print(f" - Degré de confiance: {
confidence[(premise, conclusion)]*100:.2f}%")
print(f" - Soutien: {
support[(premise, conclusion)]}")
print('-'*20)
from operator import itemgetter
sorted_support = sorted(support.items(), key=itemgetter(1), reverse=True)
sorted_confidence = sorted(confidence.items(), key=itemgetter(1), reverse=True)
for index in range(5):
print("Rule #{0}".format(index + 1))
(premise, conclusion) = sorted_confidence[index][0]
print_rule(premise, conclusion, support, confidence, features)

Les résultats sont les suivants::

Rule #1
Les règles: Pommes—>Bananes
- Degré de confiance: 62.79%
- Soutien: 27
--------------------
Rule #2
Les règles: Pain—>Bananes
- Degré de confiance: 57.14%
- Soutien: 16
--------------------
Rule #3
Les règles: Fromages—>Pommes
- Degré de confiance: 56.41%
- Soutien: 22
--------------------
Rule #4
Les règles: Lait—>Bananes
- Degré de confiance: 51.92%
- Soutien: 27
--------------------
Rule #5
Les règles: Fromages—>Bananes
- Degré de confiance: 51.28%
- Soutien: 20
--------------------

Lorsque nous obtenons les données ci - dessus, , La prochaine étape de l'ajustement de la stratégie de vente est , Simple comme Acheter des pommes vous donne droit à des rabais sur l'achat de bananes, etc . Pas de discussion approfondie ici. , On va faire un suivi Pour plus de détails dans l'analyse des règles d'association .

3. Optimisation des algorithmes

À propos de l'analyse d'affinité, Il y a des algorithmes d'exploration de données comme Apriori L'algorithme gère , Et ici non plus .Alors, L'optimisation algorithmique ici se réfère en fait à l'optimisation de la méthode de calcul très directe dans le cas ,Ce qui est utilisé icipandas Outils et ce que nous avons déjà décrit itertools《》.

Principalement l'optimisation logique pour calculer le support ,Il y a plusieurs façons de le faire, Regardez les notes de code pour plus de détails .

import pandas as pd
# Convertir l'ensemble de données en DataframeType
df = pd.DataFrame(X, columns=features)
# Importer d'abord la Bibliothèque standard intégrée 
import itertools
# Combiner( Différentes combinaisons dans l'ordre )
it = itertools.permutations(features,2)
rules = list(it)
for rule in rules:
num_occurence = df[rule[0]].sum() # X—>YMoyenneX Nombre d'occurrences dans l'ensemble de données 
num_rule = df.query(f"{
rule[0]}+{
rule[1]}==2").shape[0] # Acheter en même tempsXEtYNombre de transactions pour(Soutien), Ajoutez deux nombres ici. =2Pour vérifier
# df.query(f"{rule[0]}*{rule[1]}==1").shape[0] # Multiplier par deux nombres =1 Validation
# df[(df[rule[0]]==1) & (df[rule[1]]==1)].shape[0] # Les valeurs correspondantes utilisées directement sont: 1Pour vérifier
# df[df[rule[0]]==1][rule[1]].sum() # AvecX—>YMoyenne,X En cas d'achat YSomme des colonnes( Après tout, acheter pour 1, Ne pas acheter pour 0)
# df[list(rule)].all(axis = 'columns').sum() # Parce que les données sont 0Et1,Pourall()MéthodesboolJugement,Et puissumSomme
confidence = num_rule / num_occurence # Degré de confiance
print(f'Les règles:{
rule[0]}—>{
rule[1]}\n- Degré de confiance:{
confidence*100:.2f}%\n- Soutien:{
num_rule}\n')

Les résultats sont les suivants::( Nous ne montrons que la partie )

Les règles:Pain—>Lait
- Degré de confiance:46.43%
- Soutien:13
Les règles:Pain—>Fromages
- Degré de confiance:17.86%
- Soutien:5
Les règles:Pain—>Pommes
- Degré de confiance:32.14%
- Soutien:9
Les règles:Pain—>Bananes
- Degré de confiance:57.14%
- Soutien:16
Les règles:Lait—>Pain
- Degré de confiance:25.00%
- Soutien:13

Pour faciliter les opérations ultérieures , Nous pouvons convertir les données ci - dessus en DataFrameType,Les opérations sont les suivantes:

columns=['Les règles','Degré de confiance','Soutien']
data = pd.DataFrame(columns=columns)
for rule in rules:
num_occurence = df[rule[0]].sum() # X—>YMoyenneX Nombre d'occurrences dans l'ensemble de données 
num_rule = df[df[rule[0]]==1][rule[1]].sum() # AvecX—>YMoyenne,X En cas d'achat YSomme des colonnes( Après tout, acheter pour 1, Ne pas acheter pour 0)
confidence = num_rule / num_occurence # Degré de confiance
data = data.append(pd.DataFrame([[f'{
rule[0]}—>{
rule[1]}',confidence,num_rule]],columns=columns),ignore_index=True)
data.nlargest(n=5, columns= 'Degré de confiance', keep='first')

 Avant le niveau de confiance 5

Ce qui précède est l'introduction de base de cet article sur l'analyse d'affinité ,Sources des cas《PythonIntroduction et pratique de l'exploration des données(Deuxième édition)》Chapitre I1.3Exemple simple d'analyse d'affinité, Il n'y a pas eu beaucoup de développement .

Nous reviendrons plus en détail sur les scènes concrètes de la vie réelle ,Attendez avec impatience..

Si vous aimez cette introduction , Je vous en prie, donnez - moi un coup de pouce. !

版权声明:本文为[Appelez - moi frère.]所创,转载请带上原文链接,感谢。 https://pythonmana.com/2022/01/202201080611485336.html