[toc]
# 關聯規則 (Association Rules)
如同字面上意思，關聯分析就是在大量數據中找尋資料彼此之間的關聯，它是透過兩種主要的方式來進行分析: 頻繁項集、關聯規則。例如，「如果有人買了麵包，那麼他們也很可能買牛奶」這樣的規則。
* Antecedent (前件)：如果某事件發生，比如「買了麵包」。
* Consequent (後件)：可能會發生的事件，比如「買了牛奶」。
規則的格式通常為： $A ⇒ B$ 這代表「如果A發生，那麼B可能也會發生」。
在關聯規則中，有三個主要指標來評估規則的有效性：
1. Support (支持度)：這個規則出現的頻率。例如，如果「買了麵包和牛奶」出現在20%的交易中，那麼這個規則的支持度就是0.2。
2. Confidence (信心度)：在已經發生A的情況下，B發生的可能性。例如，如果有80%的「買麵包」的人也買了牛奶，那麼信心度就是0.8。
3. Lift (提升度)：表示前件與後件的依賴性。如果Lift > 1，表示A和B有正向的關聯性。如果Lift = 1，則A和B是獨立的。
> i. 頻繁項集(Frequent Itemsets): 經常一起出現的物品集合
> ii. 關聯規則(Association Rules): 表達數據之間的可能存在很強關聯性
# Binary Association Rule Mining
Binary Association Rule Mining 是一種在資料探勘 (Data Mining) 中常用的技術，用來發現資料集中不同項目之間的關聯性。這些技術特別常見於市場籌碼分析 (Market Basket Analysis)，例如找出超市購物車裡面哪些產品經常一起被購買。和一般的 Association Rules 主要區別在於處理資料的類型和分析方式。一般的 Association Rules 可以應用於各種類型的資料，而 Binary Association Rule Mining 則特別針對二元資料 (binary data) 進行處理和分析。
Binary Association Rule Mining：專門處理二元資料，也就是「0」或「1」的資料。例如，某商品是否被購買、某行為是否發生。這在市場籌碼分析中特別常見，因為我們通常關心的是商品有無被購買的狀態。
一般的 Association Rules：可以處理更多種類型的資料，除了二元資料之外，還可以處理數值資料、類別資料等。例如，一般的 Association Rules 可能處理「消費者購買了多少件商品」這類非二元的資料。
> 二元資料的特徵是它的值只有「0」或「1」。在市場籌碼分析中，「1」代表某個商品被購買，而「0」代表該商品未被購買。例如：
| 牛奶 | 麵包 | 咖啡 |
| -------- | -------- | -------- |
| 1 | 1 | 0 |
| 0 | 1 | 1 |
這個例子顯示第一筆交易中買了牛奶和麵包，但沒買咖啡，而第二筆交易中買了麵包和咖啡，但沒買牛奶。
# 關聯規則的重要評估指標
首先，我們先假設一個情境: 在超市購物中，我們可以使用關聯規則來了解哪些商品經常一起被購買。這樣的規則能幫助超市進行促銷活動或優化商品擺放。
假設超市有以下五筆購物交易：
1. 交易1：{牛奶, 麵包, 奶酪}
2. 交易2：{牛奶, 麵包}
3. 交易3：{牛奶, 咖啡}
4. 交易4：{麵包, 奶酪}
5. 交易5：{牛奶, 麵包, 咖啡}
## Support (支持度)
支持度是某一項集在所有交易中出現的頻率。換句話說，支持度衡量的是某個項集出現的比例。用於衡量項集的流行程度或普遍性。
公式: 支持度 = $\frac{項集在所有交易中的出現次數}{總交易數量}$
假如我們要計算「牛奶和麵包」這個項集的支持度：
「牛奶和麵包」出現於交易1、交易2和交易5，共3次。
總交易數量為5。
支持度 = $\frac{3}{5}$ = 0.6 。這表示「牛奶和麵包」這個組合在所有交易中出現的頻率是60%。
## Confidence (信心度)
信心度衡量的是當前項集出現時，另一個項集也會出現的條件概率。這告訴我們在已知前件的情況下，後件發生的可能性。用於衡量在某個項集出現的情況下，另一個項集出現的機率。
公式: $P（B|A） = \frac{P(A \cap B)}{P(B)}$ or 信心度 = $\frac{前件和後件一起出現的次數}{前件出現的次數}$
> 條件機率 $P(B∣A)$ 是在事件 A 已經發生的情況下，事件 B 發生的機率。$P(A \cap B)$:事件 A 和 B 同時發生的機率（即兩者的聯合機率）。 $P(B)$: 事件 B 發生的機率。
在上述的交易數據中，我們計算「牛奶 -> 麵包」的信心度：
「牛奶和麵包」出現3次（即「牛奶」和「麵包」一起出現的次數）。
「牛奶」出現在交易1、交易2、交易3和交易5，共4次。
信心度 = $\frac{3}{4}$ = 0.75。 這表示在「牛奶」出現的情況下，「麵包」出現的機率是75%。
## Lift (提升度)
提升度衡量的是兩個項集之間的關聯強度。它比較了觀察到的頻率和預期的頻率。如果提升度大於1，表示項集之間有正相關；如果小於1，則表示有負相關。用於衡量兩個項集之間的關聯強度，相對於它們的獨立性。
提升度可以看作是兩個商品之間購買關聯性的一種衡量方式，它告訴我們兩個商品同時購買的可能性，比起它們各自被單獨購買的情況，有沒有更強的關聯。
公式: 提升度 = $\frac{信心度}{後件的支持度}$
舉例: 我們會假設想要分析的關聯規則是：「牛奶 → 麵包」，即「當有人購買了牛奶，是否會一起購買麵包？」。
### 步驟 1：計算支持度 (Support)。
支持度是某個項集在所有交易中出現的頻率。我們需要計算兩種支持度：
1. 支持度(牛奶 $\cap$ 麵包)（牛奶和麵包同時出現的交易）：
* 交易1、交易2、交易5 同時包含牛奶和麵包。
* 出現次數 = 3。
* 支持度： 支持度(牛奶 $\cap$ 麵包) = $\frac{3}{5}$ = 0.6
* 這表示 60% 的交易同時包含牛奶和麵包。
2. 支持度(麵包)（麵包出現的次數）：
* 交易1、交易2、交易4、交易5 包含麵包。
* 出現次數 = 4。
* 支持度：支持度(麵包) = $\frac{4}{5}$ = 0.8
* 這表示 80% 的交易中有購買麵包。
### 步驟 2：計算信心度 (Confidence)
信心度告訴我們，在購買了牛奶的情況下，有多大機率會購買麵包。我們要計算「牛奶 $→$ 麵包」的信心度：
1. 支持度(牛奶)（牛奶出現的次數）：
* 交易1、交易2、交易3、交易5 包含牛奶。
* 出現次數 = 4。
* 支持度：支持度(牛奶)= $\frac{4}{5}$ = 0.8
2. 信心度(牛奶 $→$ 麵包):
信心度(牛奶 $→$ 麵包) = $\frac{支持度(牛奶 $\cap$ 麵包)}{支持度(牛奶)}$ = $\frac{0.6}{0.8}$ = 0.75
* 這表示，如果有人購買了牛奶，75% 的機率他們會一起購買麵包。
### 步驟 3：計算提升度 (Lift)
提升度告訴我們兩個商品一起購買的強度，與它們獨立購買時的機率相比。提升度的公式為：
提升度(牛奶 → 麵包) = $\frac{信心度(牛奶 → 麵包)}{支持度(麵包)}$ = $\frac{0.75}{0.8}$ = 0.9375
在這個例子中，0.9375 說明購買牛奶和購買麵包之間有些許的負相關。也就是說，買了牛奶的人略微傾向於不會同時買麵包。
> i. 提升度 > 1 : 表示數據間越相關，呈正相關
> ii. 提升度 = 1 : 表示兩數據獨立，不相關
> iii. 提升度 < 1 : 表示兩數據呈負相關
# FP-growth (9/19新增)
FP-growth 的目標是快速找到交易資料中的頻繁項目集。頻繁項目集是指在多筆交易中同時出現的商品或項目，它可以幫助我們發現消費者的行為模式。例如：如果在許多交易中「牛奶」和「麵包」經常一起出現，那這就是一個頻繁項目集。
假設我們有一個小型的超市購物資料集，如下：
| 交易ID | 項目 |
| ----- | ----- |
| 1 | 牛奶, 麵包, 蛋 |
| 2 | 牛奶, 蛋 |
| 3 | 牛奶, 麵包 |
| 4 | 麵包, 蛋 |
這個資料集告訴我們不同顧客買了什麼商品。FP-growth 演算法的工作就是要找出這些資料中的頻繁模式，例如「牛奶」和「麵包」常常一起出現。
假設我們設定一個「支持度門檻」（Support Threshold），如 2。這代表我們只關心至少出現 2 次的項目或項目組合。
頻繁項目集可以包括單個項目，例如「牛奶」，也可以是多個項目，例如「牛奶和麵包」。FP-growth 演算法的目標是有效率地找出所有這樣的頻繁項目集，而不需要生成大量的候選項目集。
FP-growth 和 Apriori 不同，它不會先生成所有可能的項目集，然後一個個去計算出現次數。FP-growth 使用了一個更聰明的方式——FP樹（頻繁模式樹）。
### FP-tree 建立過程：
1. 計算每個項目的支持度（出現次數）。 在我們的例子中：
* 牛奶出現了 3 次
* 麵包出現了 3 次
2. 建立 Header Table。
* 在這一步，我們根據支持度結果生成 **Header Table**，Header Table 會包含每個頻繁項目的支持度，並且按支持度從高到低排列。這個表不僅儲存了每個項目和其支持度，還包含一個指標，指向 FP-tree 中對應節點的鏈接位置，這能幫助我們在後續遞歸挖掘頻繁項目集時快速找到每個項目在 FP-tree 中的所有位置。
* 例如，我們的 Header Table 可能會是這樣的：
| 項目 | 支持度 | 指標 |
| ------ | ------ | ---- |
| 牛奶 | 3 | -> 牛奶節點 |
| 麵包 | 3 | -> 麵包節點 |
| 蛋 | 3 | -> 蛋節點 |
Header Table 是 FP-growth 進行遞歸挖掘的關鍵部分，因為它使得我們能夠輕鬆追蹤頻繁項目在 FP 樹中的位置，進行模式挖掘。
3. 將資料重新排序。 我們將項目根據它們的出現次數進行排序，出現次數較多的項目排在前面。對於每筆交易，我們重新排列它們，變成這樣：
* 交易 1: 牛奶, 麵包, 蛋
* 交易 2: 牛奶, 蛋
* 交易 3: 牛奶, 麵包
* 交易 4: 麵包, 蛋
4. 構建 FP 樹。 FP-growth 的關鍵是使用這個排序後的資料構建一棵 FP-tree。這是一棵壓縮樹，重複的部分會合併。
* 交易 1 的路徑：牛奶 → 麵包 → 蛋
* 交易 2 的路徑：牛奶 → 蛋
* 交易 3 的路徑：牛奶 → 麵包
* 交易 4 的路徑：麵包 → 蛋
> FP-growth 演算法的核心思想是壓縮交易路徑，並只在項目共用前綴時進行合併。這意味著如果多筆交易共享相同的前綴，那麼它們可以在樹中共用這些前綴節點。如果交易之間的前綴不同，則無法壓縮為同一條路徑，它們會在樹中表現為不同的分支。因此，FP 樹中會有一個獨立的「麵包 → 蛋」分支，因為這條路徑來自交易 4，而交易 4 並不包含「牛奶」。
> 每個節點旁邊的數字代表的是該商品在具體前綴（即前面的項目固定順序）下出現的次數。這個數字不是全局的商品出現次數，而是在該前綴情況下，商品出現的次數。
### 挖掘頻繁項目集的遞歸過程
現在，我們要利用這棵 FP-tree 來挖掘頻繁項目集。從 FP-growth 的過程來說，我們會逐步從 Header Table 中的最後一個頻繁項目（在這裡是「蛋」）開始，進行條件模式基的遞歸過程。
我們先看「蛋」，從 FP-tree 中找出所有包含「蛋」的路徑。根據 FP-tree：
* 路徑 1：牛奶 → 麵包 → 蛋，對應的前綴是「牛奶 → 麵包」
* 路徑 2：牛奶 → 蛋，對應的前綴是「牛奶」
* 路徑 3：麵包 → 蛋，對應的前綴是「麵包」
這些前綴組成了「蛋」的條件模式基：
* 「牛奶 → 麵包」
* 「牛奶」
* 「麵包」
這些前綴可以看作是「新交易集」，我們將它們重新計算支持度：
* 牛奶：2 次（出現在兩條前綴路徑中）
* 麵包：2 次（出現在兩條前綴路徑中）
現在，我們根據這個「新交易集」建立條件 FP-tree。條件 FP-tree 會只有這兩個節點：
在這個條件 FP-tree 中，因為「牛奶」和「麵包」的支持度都超過門檻，我們可以將這兩個項目繼續組成頻繁項目集：
* 頻繁項目集：「牛奶，麵包，蛋」
挖掘「麵包」的頻繁項目集。接下來，我們看「麵包」：
* 路徑 1：牛奶 → 麵包，前綴是「牛奶」
* 路徑 2：牛奶 → 麵包 → 蛋，前綴是「牛奶」
這些前綴組成了「麵包」的條件模式基：
* 「牛奶」
因此，我們可以說「麵包」的頻繁項目集是：「牛奶，麵包」
挖掘「牛奶」的頻繁項目集。由於「牛奶」本身就已經是頻繁項目，所以它不需要進行進一步的挖掘。它本身就是一個頻繁項目集。
通過這個遞歸過程，我們找到了以下頻繁項目集：
* {牛奶}
* {麵包}
* {蛋}
* {牛奶, 麵包}
* {牛奶, 蛋}
* {麵包, 蛋}
* {牛奶, 麵包, 蛋}
# 程式碼實作
## 使用 mlxtend 套件來進行 Apriori 演算法
```python=
# 導入所需模組
import pandas as pd
from mlxtend.frequent_patterns import apriori, association_rules
from mlxtend.preprocessing import TransactionEncoder
# 交易資料
transactions = [
["牛奶", "麵包", "奶酪"], # 交易1
["牛奶", "麵包"], # 交易2
["牛奶", "咖啡"], # 交易3
["麵包", "奶酪"], # 交易4
["牛奶", "麵包", "咖啡"], # 交易5
]
# 交易編碼（將交易轉換為二進位表示）
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)
# 使用 apriori 算法來找到頻繁項集，設定最低支持度為 0.6
frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
# 產生關聯規則，並計算信心度和提升度
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.6)
# 顯示結果
print(frequent_itemsets)
print(rules)
```
這段程式碼使用 `mlxtend` 套件進行關聯分析，具體來說是使用 `Apriori` 演算法，來找出在交易資料中常見的商品組合以及關聯規則。以下逐行解釋程式碼並說明每一步的目的。
1. 導入所需模組
```python=
import pandas as pd
from mlxtend.frequent_patterns import apriori, association_rules
from mlxtend.preprocessing import TransactionEncoder
```
* `pandas as pd`: `pandas` 用於處理資料框（`DataFrame`），這是存儲和操作交易資料的結構。
* `apriori`: 這是 `mlxtend` 套件提供的 `Apriori` 演算法函數，用來找出頻繁項集。
* `association_rules`: 用來根據頻繁項集生成關聯規則。
* `TransactionEncoder`: 用來將交易資料轉換成二進位的編碼形式，這樣才能餵入 `apriori` 函數。
> 為何要使用到 `pandas` ?
`mlxtend` 套件中的 `apriori` 函數要求輸入的資料必須是 `DataFrame` 格式，而且這個 `DataFrame` 的值應該是布林值或二進位格式（0 或 1），代表每個交易中是否包含某個商品。
在進行 apriori 分析時，通常會先將交易資料轉換成「one-hot encoding」格式。每個商品對應一個欄位，交易中有該商品則標示為 True 或 1，沒有則為 False 或 0。這是因為 `apriori` 算法需要知道每個交易中包含哪些商品，而布林格式最能清楚表示。
2. 交易編碼（將交易轉換為二進位表示）
```python=
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)
```
* `TransactionEncoder()`: 創建一個 `TransactionEncoder` 物件，用來將交易資料轉換為布林值（True 或 False）的二進位表示，表示每個商品是否出現在該交易中。
* `fit(transactions)`: 掃描所有交易，確定交易中的不同商品。
* `transform(transactions)`: 將原始交易資料轉換成二進位的矩陣（1 表示商品在交易中出現，0 表示未出現）。
* `pd.DataFrame(te_ary, columns=te.columns_)`: 將轉換後的二進位矩陣轉換為 `DataFrame` 格式，並指定欄位名稱（商品名稱）。輸出後的 df 如同上圖
> 為何要轉換成二進位?
> 為了便於後續的頻繁項目集挖掘和關聯規則計算。以下是具體原因:
> 1. 簡化計算：二進位表示可以簡化計算過程。每個項目在每筆交易中要麼存在（1），要麼不存在（0），這樣可以方便地計算支持度（support）和信心度（confidence）。
> 2. 適合算法需求：許多頻繁項目集挖掘算法（如 Apriori）需要對交易資料進行布爾操作。二進位表示使得這些操作更加高效。
> 3. 數據結構一致性：將交易資料轉換為二進位矩陣後，每一列代表一個項目，每一行代表一筆交易，這樣的數據結構便於進行矩陣運算和統計分析。
3. 使用 Apriori 算法來找到頻繁項集
```python=
frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
```
* `apriori(df, min_support=0.6, use_colnames=True)`: 使用 `Apriori` 演算法來找出頻繁項集。這裡有兩個參數：
* `min_support=0.6`: 設定最低支持度（Support），表示我們只關心支持度至少為 0.6 的項集。支持度是指一個項集出現在所有交易中的比例。0.6 表示這個項集至少在 60% 的交易中出現。
* `use_colnames=True`: 保留商品名稱，否則會顯示為索引。
4. 產生關聯規則，並計算信心度和提升度
```python=
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.6)
```
* `association_rules(frequent_itemsets, metric="confidence", min_threshold=0.6)`: 根據上一步生成的頻繁項集，計算關聯規則。
* `metric="confidence"`: 使用信心度作為篩選條件，信心度表示在已經購買商品 X 的情況下，同時購買商品 Y 的可能性。
* `min_threshold=0.6`: 設定最低信心度為 0.6，表示我們只關心信心度大於或等於 60% 的規則。
5. 顯示結果
* antecedents（前件）：規則的「如果」部分，表示購買了哪些商品。例如，(麵包) 表示顧客購買了麵包。
* consequents（後件）：規則的「那麼」部分，表示在購買了前件後，可能會購買的商品。例如，(牛奶) 表示顧客在購買麵包後也可能會購買牛奶。
* antecedent support（前件支持度）：表示前件（如「麵包」）出現在所有交易中的比例。0.8 表示在 80% 的交易中出現了「麵包」。
* consequent support（後件支持度）：表示後件（如「牛奶」）出現在所有交易中的比例。0.8 表示在 80% 的交易中出現了「牛奶」。
* support（支持度）：表示規則「如果購買了前件（如麵包），那麼也購買了後件（如牛奶）」的情況出現在所有交易中的比例。0.6 表示這樣的規則出現在 60% 的交易中。
* confidence（信心度）：表示在購買了前件的情況下，同時購買後件的比例。0.75 表示在購買了麵包的顧客中，有 75% 也購買了牛奶。
* lift（提升度）：衡量購買前件會使購買後件的可能性提高多少。lift 值大於 1 表示購買前件會增加購買後件的可能性；小於 1 表示反之。這裡的 0.9375 小於 1，表示購買「麵包」對購買「牛奶」的影響是負面的，兩者購買的關聯性低於隨機發生的機率。
* leverage（杠杆值）：表示該規則相比於隨機發生的增加了多少機率。負值意味著購買前件實際上減少了購買後件的機率。這裡的值是 -0.04。
* conviction（確信度）：衡量「如果購買了前件但沒有購買後件」的可能性。值越高，表明規則越強。這裡的值是 0.8，這表示該規則的強度較弱。
* zhangs_metric（張氏指標）：這是用來衡量規則是否具有因果關係的一個指標。範圍從 -1 到 1，正值表示正相關，負值表示負相關，0 表示不相關。這裡的值是 -0.25，表示「麵包」和「牛奶」之間可能存在負關聯。
---
## 使用 mlxtend 套件來進行 FP-growth 演算法
```python=
import pandas as pd
from mlxtend.frequent_patterns import fpgrowth
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import association_rules
dataset = [
['牛奶', '麵包', '蛋'],
['牛奶', '蛋'],
['牛奶', '麵包'],
['麵包', '蛋']
]
te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_ary, columns=te.columns_)
frequent_itemsets = fpgrowth(df, min_support=0.5, use_colnames=True)
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.6)
print(rules)
```
1. 匯入所需模組
```python=
import pandas as pd
from mlxtend.frequent_patterns import fpgrowth
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import association_rules
```
* pandas：這是 Python 中的數據處理庫，用來處理資料表結構。
* fpgrowth：mlxtend 提供的 FP-growth 演算法，負責挖掘頻繁項目集。
* TransactionEncoder：用來將交易資料集轉換為 FP-growth 可以使用的格式。
* association_rules：用來從頻繁項目集中生成關聯規則。
2. 準備交易資料集
```python=
dataset = [
['牛奶', '麵包', '蛋'],
['牛奶', '蛋'],
['牛奶', '麵包'],
['麵包', '蛋']
]
```
這是一個小型交易資料集，每筆交易包含購買的商品。你定義了一個列表，其中每一個內部列表代表一筆交易。這是 FP-growth 演算法的輸入數據。
3. 將交易資料轉換為 FP-growth 可用的格式
```python=
te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_ary, columns=te.columns_)
```
這部分代碼的作用是將交易資料轉換為布林值矩陣，這是 FP-growth 演算法可以接受的格式。
* TransactionEncoder()：這個工具用來將交易資料編碼為可以處理的矩陣形式。它會將每個項目轉換為布林值，表示每個商品在每筆交易中是否存在。
* fit(dataset)：這一步學習資料集中的項目名稱，準備進行轉換。
* transform(dataset)：將原始資料集轉換為布林矩陣，例如，交易 ['牛奶', '麵包'] 會轉換為 [True, True, False]，表示這筆交易中購買了牛奶和麵包，但沒有購買蛋。
* pd.DataFrame(te_ary, columns=te.columns_)：將這個布林矩陣轉換為一個 DataFrame，這是方便處理和視覺化的資料表格式。te.columns_ 包含所有項目的名稱，並且會被用作 DataFrame 的欄位名稱。
4. 挖掘頻繁項目集
```python=
frequent_itemsets = fpgrowth(df, min_support=0.5, use_colnames=True)
```
這行代碼使用 FP-growth 演算法來挖掘頻繁項目集。
* fpgrowth()：這個函數會從輸入的布林值矩陣中挖掘頻繁項目集。
* df：這是經過 TransactionEncoder 編碼的 DataFrame，它告訴我們每個交易中是否包含特定的商品。
* min_support=0.5：表示最小支持度門檻是 0.5，意思是我們只關心那些在至少 50% 的交易中出現的項目集（即至少兩筆交易）。
* use_colnames=True：這個參數確保輸出的頻繁項目集顯示的是項目名稱，而不是數字編碼。
這一步的輸出將是一個 DataFrame，顯示每個頻繁項目集及其支持度。
5. 生成關聯規則
```python=
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.6)
```
這行代碼會從頻繁項目集中生成關聯規則。
* association_rules(frequent_itemsets)：這個函數會從我們挖掘出的頻繁項目集中生成關聯規則。
* metric="confidence"：我們選擇使用 信賴度（Confidence） 來評估規則。信賴度衡量的是：當前項（antecedent）發生時，後項（consequent）也發生的機率。
* min_threshold=0.6：表示只生成信賴度高於 60% 的規則。
這一步將生成一個 DataFrame，包含每個關聯規則的詳細資訊，例如規則的信賴度、支持度和提升度。
6. 顯示規則
```python=
print(rule)
```
在上面的Apriori有解釋過結果，這裡就不在贅述
## 完全不使用套件
```python=
from itertools import combinations
transactions = [
{"牛奶", "麵包", "奶酪"}, # 交易1
{"牛奶", "麵包"}, # 交易2
{"牛奶", "咖啡"}, # 交易3
{"麵包", "奶酪"}, # 交易4
{"牛奶", "麵包", "咖啡"}, # 交易5
]
# Step 2: 提取單項集
def get_single_itemsets(transactions):
itemsets = set()
for transaction in transactions:
itemsets.update(transaction)
return [{item} for item in itemsets]
single_itemsets = get_single_itemsets(transactions)
# print(single_itemsets)
# Step 3: 計算支持度
def calculate_support(itemset, transactions):
count = sum([1 for transaction in transactions if itemset.issubset(transaction)])
return count / len(transactions)
# 計算單項集的支持度
min_support = 0.6 # 設定最低支持度閾值
frequent_itemsets = []
for itemset in single_itemsets:
support = calculate_support(itemset, transactions)
if support >= min_support:
frequent_itemsets.append((itemset, support))
# print(frequent_itemsets)
# Step 4: 合併生成更大的項集
def generate_candidate_itemsets(frequent_itemsets, k):
# 合併項集，生成k項集
items = set()
for itemset, _ in frequent_itemsets:
items.update(itemset)
return [set(combo) for combo in combinations(items, k)]
# 生成二項集
candidate_2_itemsets = generate_candidate_itemsets(frequent_itemsets, 2)
# print(candidate_2_itemsets)
# Step 5: 計算二項集的支持度
frequent_2_itemsets = []
for itemset in candidate_2_itemsets:
support = calculate_support(itemset, transactions)
if support >= min_support:
frequent_2_itemsets.append((itemset, support))
# print(frequent_2_itemsets)
# Step 6: 計算信心度和提升度
def calculate_confidence(itemset_A, itemset_B, transactions):
support_A = calculate_support(itemset_A, transactions)
support_AB = calculate_support(itemset_A.union(itemset_B), transactions)
return support_AB / support_A
def calculate_lift(itemset_A, itemset_B, transactions):
support_A = calculate_support(itemset_A, transactions)
support_B = calculate_support(itemset_B, transactions)
support_AB = calculate_support(itemset_A.union(itemset_B), transactions)
return support_AB / (support_A * support_B)
# 對於每個頻繁的二項集，生成規則並計算指標
for itemset, support in frequent_2_itemsets:
itemset_list = list(itemset)
for i in range(len(itemset_list)):
itemset_A = {itemset_list[i]}
itemset_B = itemset.difference(itemset_A)
confidence = calculate_confidence(itemset_A, itemset_B, transactions)
lift = calculate_lift(itemset_A, itemset_B, transactions)
print(f"規則: {itemset_A} -> {itemset_B}, 信心度: {confidence:.2f}, 提升度: {lift:.2f}")
```
詳細步驟說明可看: [Google Colab](https://colab.research.google.com/drive/1MxDlQz_6MIRHesf96dtkGTkdPaLCSQRT#scrollTo=f737Mn0kLLxR) 或 [Github](https://github.com/hakuei0115/Data_mining/blob/master/Association%20Rules/no_module.ipynb) 中的.ipynb檔
# reference
[Machine Learning -關聯分析-Apriori演算法-詳細解說啤酒與尿布的背後原理 Python實作-Scikit Learn一步一步教學](https://chwang12341.medium.com/machine-learning-%E9%97%9C%E8%81%AF%E5%88%86%E6%9E%90-apriori%E6%BC%94%E7%AE%97%E6%B3%95-%E8%A9%B3%E7%B4%B0%E8%A7%A3%E8%AA%AA%E5%95%A4%E9%85%92%E8%88%87%E5%B0%BF%E5%B8%83%E7%9A%84%E8%83%8C%E5%BE%8C%E5%8E%9F%E7%90%86-python%E5%AF%A6%E4%BD%9C-scikit-learn%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5%E6%95%99%E5%AD%B8-76b7778f8f34)
[新手解讀Apriori — 商品關聯法則](https://weilihmen.medium.com/%E6%96%B0%E6%89%8B%E8%A7%A3%E8%AE%80apriori-%E5%95%86%E5%93%81%E9%97%9C%E8%81%AF%E6%B3%95%E5%89%87-1613c0e4185f)
[FP Tree算法原理總結](https://www.cnblogs.com/pinard/p/6307064.html)
Sign in with Wallet
Connect another wallet