Ассоциация горнодобывающей промышленности

Проще говоря, нахождение отношений между объектами. Например, большинство людей, должно быть, купили хлеб, если купили масло. Таким образом, некоторые супермаркеты хранят предметы, которые с высокой вероятностью могут быть куплены вместе, в одних и тех же проходах, в то время как другие могут хранить их в двух разных углах, чтобы покупатель, обнаруживая другую необходимость, просматривал и покупал другие продукты. Следовательно, ассоциативный анализ может иметь фундаментальное значение для принятия и улучшения решений и бизнес-правил для дизайна каталогов, продаж, маркетинга и т. Д.

Частый анализ закономерностей - это обнаружение закономерностей в наборе данных, которые часто появляются, например, обнаружение ассоциаций и корреляций. Шаблоны могут быть в виде набора элементов, таких как молоко и печенье, или в виде последовательности, например. покупка мобильного телефона, затем карты памяти и наушников. Анализ рыночной корзины - это пример анализа покупательских привычек и установления правил на основе «покупательских привычек». Выкройки представлены в виде правил.

Меры интереса к шаблонам

Отражайте уровень юзабилити и достоверность установленных правил.

  1. Поддержка: это отношение транзакций с конкретным элементом к общему количеству транзакций. Он определяет популярность предмета. Он колеблется от 0 до 1.
  2. Уверенность: это отношение количества транзакций с участием двух элементов X и Y к количеству транзакций с участием X. Таким образом, он говорит о возможности того, как часто элементы X и Y встречаются вместе, учитывая количество раз X произошло. Он колеблется от 0 до 1.
  3. Рост: рост указывает на достоверность правила. Насколько увеличилась продажа X, когда B продан?

Подъем (X = ›Y) = Уверенность (X, Y) / Поддержка (Y)

Пример: A = ›B [поддержка = 5%, достоверность = 80%]

5% всех транзакций показывают, что A и B были куплены вместе. 80% покупателей, купивших А, также купили Б.

Распространенные алгоритмы - Априори, FP-рост и другие.

Такие гиганты компаний, как Amazon, Flipkart, Capital One, Walmart, используют эти методы анализа для своих больших данных. Пример: «Часто покупаемые вместе товары».

Примечание. Связь и рекомендация различаются, потому что связь связана не с предпочтениями конкретного человека, а с отношениями между наборами элементов.

О данных

Association Mining может использоваться в задачах, где вам нужно принимать более правильные решения, основываясь на привычках ваших клиентов.

Например. Продуктовые и основные магазины, Интернет-рынки, Жанры музыки и фильмов, Покупка программного обеспечения и т. Д.

Данные, как правило, представляют собой неструктурированные данные большого размера. То есть данные не будут в строгом табличном формате. В одной строке может быть любое количество элементов (столбцов), поэтому нам нужно будет решить проблему с различным количеством столбцов.

Априорный алгоритм

1. Найти все часто встречающиеся наборы элементов: наборы элементов, которые встречаются не реже, чем минимальное количество поддерживаемых элементов.

2. Создайте строгие правила ассоциации из часто встречающихся наборов элементов: правила, удовлетворяющие минимальной поддержке и минимальной достоверности.

Стандартный набор данных - groceries.csv

Размеры: 9834 X 41

Реализация

A. Исследовательский анализ данных по данным.

  • Получить форму
  • Найдите 20 самых популярных элементов в наборе данных.
  • Сколько составляют эти 20 предметов? - Процент предмета

Б. Сократите набор данных на основе количества элементов в транзакции и общего процента продаж.

C. Примените алгоритм априори и получите правила.

Давайте начнем и получим ответы на поставленные выше вопросы!

  1. Импортировать библиотеки
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import csv
from apyori import apriori
import itertools

2. Придайте форму

data = pd.read_csv('groceries.csv')
data.shape

Выход:

(9835, 41)

3. Затем, чтобы найти 20 лучших элементов и сколько они относятся к общему проценту.

#Finding all items present in our data - groceries.csv
#We will have to use the csv package so that we can read each line one by one and update any new grocery item.
all_items = set()#set of all items
with open("groceries.csv") as f:
    reader = csv.reader(f, delimiter=",")
    for i, line in enumerate(reader):
        all_items.update(line)
#Now, we count if a particular item appears in the a particular row and update it in a list format.
counting = list()
with open("groceries.csv") as f:
    reader = csv.reader(f, delimiter=",")
    for i, line in enumerate(reader):
        row = {item:0 for item in all_items}
        row.update({item:1 for item in line})
        counting.append(row)
#Next, convert the list in to Pandas DataFrame so that wecan do pandas operations.
groceries = pd.DataFrame(counting)
groceries.head()
# 0 represents that the item is not present in a particular row/ item order list.

# Finding item count is now easy - we need to sum it up.
# 1. Find total number of items sum of all the sums of rows
tot_item_count = sum(groceries.sum()) # Answer is 43368
# 2. Sum the rows and sort is descending order to get top 20 items
item_sum = groceries.sum().sort_values(ascending = False).reset_index().head(n=20)
item_sum.rename(columns={item_sum.columns[0]:'Item_name',item_sum.columns[1]:'Item_count'}, inplace=True)
# 3. Add the percent so that we know how much it contributes. #Tot_percent of x determines the percentage of x and above elements in the total percentage i.e cumulative sum.
item_sum['Item_percent'] = item_sum['Item_count']/tot_item_count
item_sum['Tot_percent'] = item_sum.Item_percent.cumsum()
item_sum.head(20) # List of top 20 items with percents
# Plotting Code
# We will plot later, so that we can plot items + frequent items.
# But the function can be called here as well.
# Alternative Code
obj = (list(item_sum['Item_name'].head(n=20)))
y_pos = np.arange(len(obj))
performance = list(item_sum['Item_count'].head(n=20))
 
plt.bar(y_pos, performance, align='center', alpha=0.5)
plt.xticks(y_pos, obj, rotation='vertical')
plt.ylabel('Item count')
plt.title('Item sales distribution')

5 лучших позиций = 21,74% и 20 лучших позиций = 50,37%.

Следовательно, нам нужно сократить / сократить набор данных, потому что большинство элементов вносят ноль в общий объем продаж.

4. Мы выполнили часть нашего проекта / постановки задачи. Теперь заглянем в раздел B.

Для этого мы определим функцию prune_dataset, которая может принимать следующие параметры от пользователя / аналитика.

  • Фрейм входных данных
  • Минимальная длина транзакций (т. Е. Минимальное количество элементов в строке), которое необходимо учитывать.
  • Минимальный общий процент продаж для рассматриваемого товара.
def prune_dataset(olddf, len_transaction, tot_sales_percent):
    # Delete the last column tot_items if present
    if 'tot_items' in olddf.columns:
        del(olddf['tot_items'])
    #Finding the item_count for each item and total number of items.
    #This is the same code as in step 3    
    Item_count = olddf.sum().sort_values(ascending = False).reset_index()
    tot_items = sum(olddf.sum().sort_values(ascending = False))
    Item_count.rename(columns={Item_count.columns[0]:'Item_name',Item_count.columns[1]:'Item_count'}, inplace=True)
    
    # Code from Step 3 to find Item Percentage and Total Percentage.
    Item_count['Item_percent'] = Item_count['Item_count']/tot_items
    Item_count['Tot_percent'] = Item_count.Item_percent.cumsum()
    
    # Taking items that fit the condition/ minimum threshold for total sales percentage.
    selected_items = list(Item_count[Item_count.Tot_percent < tot_sales_percent].Item_name)
    olddf['tot_items'] = olddf[selected_items].sum(axis = 1)
    
    # Taking items that fit the condition/ minimum threshold for length of transaction or number of items in a row.
    olddf = olddf[olddf.tot_items >= len_transaction]
    del(olddf['tot_items'])
    
    #Return pruned dataframe.
    return olddf[selected_items], Item_count[Item_count.Tot_percent < tot_sales_percent]

Теперь мы введем разные значения для len_transaction и tot_sales_percent, чтобы получить соответствующий набор данных для априори.

Сокращенный фрейм данных №1

pruneddf, Item_count = prune_dataset(groceries,4,0.4)
print(pruneddf.shape)
print(list(pruneddf.columns))

Вывод (список столбцов - это фактически элементы, которые мы рассматриваем априори.)

(1267, 13)
['whole milk', 'other vegetables', 'rolls/buns', 'soda', 'yogurt', 'bottled water', 'root vegetables', 'tropical fruit', 'shopping bags', 'sausage', 'pastry', 'citrus fruit', 'bottled beer']

В нем приличное количество строк и верхние 13 элементов (столбцов)

Удаленный фрейм данных №2

pruneddf, Item_count = prune_dataset(groceries,4,0.5)
print(pruneddf.shape)
print(list(pruneddf.columns))

Выход:

(1998, 19)
['whole milk', 'other vegetables', 'rolls/buns', 'soda', 'yogurt', 'bottled water', 'root vegetables', 'tropical fruit', 'shopping bags', 'sausage', 'pastry', 'citrus fruit', 'bottled beer', 'newspapers', 'canned beer', 'pip fruit', 'fruit/vegetable juice', 'whipped/sour cream', 'brown bread']

Теперь количество строк хорошее, и у нас также есть первые 19 элементов в нашем сжатом наборе данных.

Сокращенный фрейм данных №3

pruneddf, Item_count = prune_dataset(groceries,2,0.5)
print(pruneddf.shape)
print(list(pruneddf.columns))

Выход:

(5391, 19)
['whole milk', 'other vegetables', 'rolls/buns', 'soda', 'yogurt', 'bottled water', 'root vegetables', 'tropical fruit', 'shopping bags', 'sausage', 'pastry', 'citrus fruit', 'bottled beer', 'newspapers', 'canned beer', 'pip fruit', 'fruit/vegetable juice', 'whipped/sour cream', 'brown bread']

Это очень хороший набор данных, потому что он содержит 19 лучших элементов и очень хорошее (фактически половину) количество строк / транзакций из исходного набора данных. Итак, приступим к этому.

5. Часть B завершена. Теперь мы применим априори и сгенерируем правила и отношения для сокращенных данных, которые содержат только самые важные из данных.

Во-первых, нам нужно преобразовать наш фрейм данных в файл csv, чтобы он выглядел как наш исходный набор данных, но с уменьшенными размерами.

# Converting 1's to appropriate item name(column name)
y = list(pruneddf.columns)
for s in y:
    pruneddf.loc[(pruneddf[s] == 1),s]=s
#Removing Zero's
lol = pruneddf.values.tolist() 
for a in lol:
    while (0 in a):
        a.remove(0)
#Making a new pruned dataset csv file
with open("pruned.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(lol)

У нас есть чистый и организованный файл csv, к которому мы можем применить код априори.

import csv
import itertools
#Delete Files prunedRules and PrunedFItems otherwise new data will be appended.
Groceries = open('pruned.csv', 'r')
#Minimum Support Count
min_support = 0.04
Rules = "prunedRules.txt"
freqItemsets = "prunedFItems.txt"
#Mininum Confidence
min_confidence = 0.30
# Finding all Frequent 1-Item sets
def OneItemSets():
    #Get all 1-itemsets in the list items and their counts in the dictionary counts
    DataCaptured = csv.reader(Groceries, delimiter=',')
    data = list(DataCaptured)
    for e in data:
        e = sorted(e)
    count = {}
    for items in data:
        for item in items:
            if item not in count:
                count[(item)] = 1
            else:
                count[(item)] = count[(item)] + 1
count2 = {k: v for k, v in count.items() if v >= min_support*9835}
return count2, data
#Ck is a superset of Lk. It is a part of Prune Step. its members may or may not be frequent, but all of the frequent k-itemsets are included in Ck.
# Generated by joing two Lk
def generateCk(Lk_1, flag, data):
    Ck = []
    if flag == 1:
        flag = 0
        for item1 in Lk_1:
            for item2 in Lk_1:
                if item2 > item1:
                    Ck.append((item1, item2))
        print("C2: ", Ck[1:3])
        print("length : ", len(Ck))
        print()
else:
        for item in Lk_1:
            k = len(item)
        for item1 in Lk_1:
            for item2 in Lk_1:
                if (item1[:-1] == item2[:-1]) and (item1[-1] != item2[-1]):
                    if item1[-1] > item2[-1]:
                        Ck.append(item2 + (item1[-1],))
                    else:
                        Ck.append(item1 + (item2[-1],))
        print("C" + str(k+1) + ": ", Ck[1:3])
        print("Length : ", len(Ck))
        print()
    L = generateLk(set(Ck), data)
    return L, flag
#If item in Ck belongs to a transaction, it makes it into list Ct Then Ct is thresholded to form L
# For K frequent Itemsets
def generateLk(Ck, data):
    
    count = {}
    for itemset in Ck:
        #print(itemset)
        for transaction in data:
            if all(e in transaction for e in itemset):
                if itemset not in count:
                    count[itemset] = 1
                else:
                    count[itemset] = count[itemset] + 1
print("Ct Length : ", len(count))
    print()
count2 = {k: v for k, v in count.items() if v >= min_support*9835}
    print("L Length : ", len(count2))
    print()
    return count2
#  Generates association rules from the frequent itemsets
def rulegenerator(fitems):
    counter = 0
    for itemset in fitems.keys():
        if isinstance(itemset, str):
            continue
        length = len(itemset)
union_support = fitems[tuple(itemset)]
        for i in range(1, length):
lefts = map(list, itertools.combinations(itemset, i))
            for left in lefts:
                if len(left) == 1:
                    if ''.join(left) in fitems:
                        leftcount = fitems[''.join(left)]
                        conf = union_support / leftcount
                else:
                    if tuple(left) in fitems:
                        leftcount = fitems[tuple(left)]
                        conf = union_support / leftcount
                if conf >= min_confidence:
                    fo = open(Rules, "a+")
                    right = list(itemset[:])
                    for e in left:
                        right.remove(e)
                    fo.write(str(left) + ' (' + str(leftcount) + ')' + ' -> ' + str(right) + ' (' + str(fitems[''.join(right)]) + ')' + ' [' + str(conf) + ']' + '\n')
                    print(str(left) + ' -> ' + str(right) + ' (' + str(conf) + ')')
                    counter = counter + 1
                    #Greater than 1???
                    fo.close()
    print(counter, "rules generated")
def plotitemfreq(L):
    aux = [(L[key], key) for key in L]
    aux.sort()
    aux.reverse()
    z = aux[0:20]
    print(z)
    df = pd.DataFrame(z, columns = ['Count', 'Word'])
    df['Count']=pd.to_numeric(df['Count'])
    print(df.info())
    df.plot.bar(x='Word', y='Count')
def apriori():
    L, data = OneItemSets()
    flag = 1
    FreqItems = dict(L)
    while(len(L) != 0):
        fo = open(freqItemsets, "a+")
        for k, v in L.items():
           
            fo.write(str(k) + ' >>> ' + str(v) + '\n\n')
        fo.close()
        plotitemfreq(L)
L, flag = generateCk(L, flag, data)
        FreqItems.update(L)
    rulegenerator(FreqItems)
apriori()

Все выходы:

  1. Частые элементы и наборы элементов

2. Сгенерированные правила

На этом мы завершили анализ рыночной корзины.

Полный код - Github

По любым вопросам или вопросам, пожалуйста, оставляйте комментарии или пишите по электронной почте.

Обязательно ознакомьтесь с моими другими работами.