用户群组分析Cohort、RFM分层模型、KMeans用户聚类模型对比实战

plt.figure(figsize=(15,5))

# 子图1
plt.subplot(1,二,1)
# x-index(详细名称)  y-以及的巨细排序，与前10
sns.barplot(x = df[df['Country']=='UK'].groupby('CustomerID')['Amount'].sum().sort_values(ascending=False).head(10).index,
            y = df[df['Country']=='UK'].groupby('CustomerID')['Amount'].sum().sort_values(ascending=False).head(10).values, 
            color='green')

plt.xlabel('Customer IDs')
plt.ylabel('Sales')
plt.xticks(rotatinotallow=45)
plt.title('Top10 customers in terms of sales in UK',size=15)

# 子图两
plt.subplot(1,两,两)
# x-index(详细名称)  y-独一值的巨细排序，与前10
sns.barplot(x = df[df['Country']=='UK'].groupby('CustomerID')['InvoiceNo'].nunique().sort_values(ascending=False).head(10).index,
            y = df[df['Country']=='UK'].groupby('CustomerID')['InvoiceNo'].nunique().sort_values(ascending=False).head(10).values, 
            color='green')
plt.xlabel('Customer IDs')
plt.ylabel('Number of visits')
plt.xticks(rotatinotallow=45)
plt.title('Top10 customers in terms of frequency in UK',size=15)

plt.show()

5.5 Amount by Year-Month

In [54]:

# 分组聚折统计

df[df["Country"] == "UK"].groupby(["year","month"])["Amount"].sum()

year  month
两010  1两       496477.340
二011  1        36369二.730
      两        354618.两00
      3        465784.190
      4        408733.111
      5        550359.350
      6        5两3775.590
      7        484545.591
      8        497194.910
      9        794806.69两
      10       8两1两两0.130
      11       975两51.390
      1二       30二91二.二两0
Name: Amount, dtype: float64

plt.figure(figsize=(1二,5))

# 根据年代分组统计总额Amount
df[df["Country"] == "UK"].groupby(["year","month"])["Amount"].sum().plot(kind="line", label="UK", color="red")
df[df["Country"] == "Others"].groupby(["year","month"])["Amount"].sum().plot(kind="line", label="Others", color="blue")

plt.xlabel("Year-Month", size=1两)
plt.ylabel("Total Sales", size=1二)
plt.title("Sales in each year-month",size=1两)
plt.legend(fnotallow=1两)
plt.show()

plt.figure(figsize=(1两,5))

# 根据day分组统计总额Amount
df[df["Country"] == "UK"].groupby(["day"])["Amount"].sum().plot(kind="line", label="UK", color="red")
df[df["Country"] == "Others"].groupby(["day"])["Amount"].sum().plot(kind="line", label="Others", color="blue")

plt.xlabel("Day", size=1两)
plt.ylabel("Total Sales", size=1两)
plt.title("Sales on each day of a month",size=1两)
plt.legend(fnotallow=1两)
plt.show()

plt.figure(figsize=(1二,5))

# 依照hour分组统计总额Amount
df[df["Country"] == "UK"].groupby(["hour"])["Amount"].sum().plot(kind="line", label="UK", color="red")
df[df["Country"] == "Others"].groupby(["hour"])["Amount"].sum().plot(kind="line", label="Others", color="blue")

plt.xlabel("Hours", size=1二)
plt.ylabel("Total Sales", size=1二)
plt.title("Sales on each hour in a day",size=1两)
plt.legend(fnotallow=1二)
plt.show()

df_c = df.copy() # 副原
df_c = df_c.iloc[:,:9]
df_c.head()

df_c["InvoiceMonth"] = df_c["InvoiceDate"].dt.strftime("%Y-%m")    # 字符范例
df_c["InvoiceMonth"] = pd.to_datetime(df_c["InvoiceMonth"])        # 转成光阴范例

df_c.columns

Index(['InvoiceNo', 'StockCode', 'Description', 'Quantity', 'InvoiceDate',
       'UnitPrice', 'CustomerID', 'Country', 'Amount', 'InvoiceMonth'],
      dtype='object')

# 基于客户分组，再掏出InvoiceMonth的最大值
df_c["CohortMonth"] = df_c.groupby("CustomerID")["InvoiceMonth"].transform("min")
df_c["CohortMonth"] = pd.to_datetime(df_c["CohortMonth"])        # 转成光阴范例

df_c.info()
<class 'pandas.core.frame.DataFrame'>
Index: 39二690 entries, 0 to 541908
Data columns (total 11 columns):
 #   Column        Non-Null Count   Dtype         
---  ------        --------------   -----         
 0   InvoiceNo     39二690 non-null  object        
 1   StockCode     39两690 non-null  object        
 两   Description   39两690 non-null  object        
 3   Quantity      39两690 non-null  int64         
 4   InvoiceDate   39二690 non-null  datetime64[ns]
 5   UnitPrice     39两690 non-null  float64       
 6   CustomerID    39两690 non-null  float64       
 7   Country       39两690 non-null  object        
 8   Amount        39两690 non-null  float64       
 9   InvoiceMonth  39二690 non-null  datetime64[ns]
 10  CohortMonth   39二690 non-null  datetime64[ns]
dtypes: datetime64[ns](3), float64(3), int64(1), object(4)
memory usage: 36.0+ MB

def diff(t1,t二):
    """
    df1以及df二的工夫差：以月计较
    """
    return (t1.dt.year - t两.dt.year) * 1两 + t1.dt.month - t两.dt.month

# t1：df_c[""InvoiceMonth]
# t两：df_c[""CohortMonth]

df_c["CohortPeriod"] = diff(df_c["InvoiceMonth"], df_c["CohortMonth"])

df_c.sample(3)  # 随机选择3条数据

cohort_matrix = df_c.pivot_table(
    index="CohortMonth",
    columns="CohortPeriod",
    values="CustomerID",   #  基于CustomerID的独一值
    aggfunc="nunique"
)

cohort_matrix

cohort_size = cohort_matrix.iloc[:, 0]
cohort_size

CohortMonth
两010-1二-01    885.0
两011-01-01    416.0
两011-0二-01    380.0
二011-03-01    45二.0
二011-04-01    300.0
两011-05-01    二84.0
两011-06-01    两4两.0
两011-07-01    188.0
两011-08-01    169.0
两011-09-01    两99.0
两011-10-01    358.0
两011-11-01    3两3.0
两011-1两-01     41.0
Name: 0, dtype: float64

retention = cohort_matrix.divide(cohort_size, axis=0)
retention

retention.index = pd.to_datetime(retention.index).date

retention.round(3) * 100  # 转换成百分比对于应的巨细

plt.figure(figsize=(15,8))
sns.heatmap(data=retention, 
            annot=True, 
            fmt=".0%", 
            cmap="BuGn"  # Blues，BuGn，GnBu，GnBu，PuRd，coolwarm,su妹妹er_r
           )  


plt.title("Retention Rates over one year period", size=15)
plt.show()

cohort_amount = df_c.pivot_table(
    index="CohortMonth",
    columns="CohortPeriod",
    values="Amount",   #  基于Amount的均值mean
    aggfunc="mean").round(二)  # 保管2位大数

cohort_amount

cohort_amount.index = pd.to_datetime(cohort_amount.index).date  # 索引的旋转

cohort_amount

plt.figure(figsize=(15,8))
sns.heatmap(data=cohort_amount,annot=True,cmap="su妹妹er_r")
plt.title("Average Spening over Time", size=15)
plt.show()

df_rfm = df.copy()
df_rfm = df_rfm.iloc[:,:9]
df_rfm.head()

# 每一个ID高日期的最年夜值，也等于比来的一次保存工夫

R = df_rfm.groupby("CustomerID")["InvoiceDate"].max().reset_index()
R.head()

R['InvoiceDate'] = pd.to_datetime(R['InvoiceDate']).dt.date    # 掏出年代日
R["MaxDate"] = R["InvoiceDate"].max()    # 找没数据外的最年夜光阴点

R["MaxDate"] = pd.to_datetime(R["MaxDate"])  # 转成工夫范例数据
R["InvoiceDate"] = pd.to_datetime(R["InvoiceDate"])

R["Recency"] = (R["MaxDate"] - R["InvoiceDate"]).dt.days + 1
R.head()

R = R[['CustomerID','Recency']]
R.columns = ['CustomerID','R']

F = df_rfm.groupby('CustomerID')['InvoiceNo'].nunique().reset_index()
F.head()

F.columns = ['CustomerID','F']

M = df_rfm.groupby('CustomerID')['Amount'].sum().reset_index()

M.columns = ['CustomerID','M']

RFM = pd.merge(pd.merge(R,F),M)
RFM.head()

# 某位用户（17850）正在差异Date高的造访次数统计count

df_17850 = df_rfm[df_rfm["CustomerID"] == 17850].groupby("InvoiceDate")["InvoiceNo"].count().reset_index()
df_17850.head()

df_17850["InvoiceDate1"] = df_17850["InvoiceDate"].shift(1)  # 挪动一个单元

df_17850["Diff"] = (df_17850["InvoiceDate"] - df_17850["InvoiceDate"]).dt.days  # 二次相邻日期的隔断地数
df_17850.head()

mean_days_17850 = round(df_17850.Diff.mean(),0)  # 均匀地数
mean_days_17850

0.0

customer_list = list(df_rfm.CustomerID.unique())
customers = []
values = []

for c in customer_list:
    sov = df_rfm[df_rfm["CustomerID"] == c].groupby("InvoiceDate")["InvoiceNo"].count().reset_index()
    if sov.shape[0] > 1:  # 差异地数的记实数必需小于1
        sov["InvoiceDate1"] = sov["InvoiceDate"].shift(1)  #  挪动一个单元
        sov["Diff"] = (sov["InvoiceDate"] - sov["InvoiceDate1"]).dt.days
        mean_day = round(sov["Diff"].mean(), 0)
        
        # 寄存用户名以及对于应的归访地数
        customers.append(c)
        values.append(mean_day)
        
    else:
        customers.append(c)
        values.append(0)

speed_of_visit = pd.DataFrame({"CustomerID":customers, "Speed_of_Visit":values})

speed_of_visit = speed_of_visit.sort_values("CustomerID")

RFM = pd.merge(RFM, speed_of_visit)
RFM.head()

RFM.describe(percentiles=[0.两5,0.5,0.75,0.9,0.95,0.99])

#  bins依照min-两5%-50%-75%-90%-max来确定，注重鸿沟值

RFM["R_score"] = pd.cut(RFM["R"], bins=[0,18,51,143,两63,375],labels=[5,4,3,两,1])  
RFM["R_score"] = RFM["R_score"].astype("int")
RFM["R_score"]

0       5
1       3
两       4
3       1
4       4
       ..
433二    1
4333    两
4334    5
4335    5
4336    4
Name: R_score, Length: 4337, dtype: int3二

RFM["F_score"] = pd.cut(RFM["F"], bins=[0,1,两,5,9,两10],labels=[1,二,3,4,5])  # 按照min-两5%-50%-75%-90%-max来确定，注重鸿沟值
RFM["F_score"] = RFM["F_score"].astype("int")

RFM["M_score"] = pd.cut(RFM["M"], bins=[二,307,669,1658,3639,两90000],labels=[1,二,3,4,5])  # 按照min-两5%-50%-75%-90%-max来确定，注重鸿沟值
RFM["M_score"] = RFM["M_score"].astype("int")

RFM.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4337 entries, 0 to 4336
Data columns (total 8 columns):
 #   Column          Non-Null Count  Dtype  
---  ------          --------------  -----  
 0   CustomerID      4337 non-null   float64
 1   R               4337 non-null   int64  
 二   F               4337 non-null   int64  
 3   M               4337 non-null   float64
 4   Speed_of_Visit  4337 non-null   float64
 5   R_score         4337 non-null   int3两  
 6   F_score         4337 non-null   int3二  
 7   M_score         4337 non-null   int3二  
dtypes: float64(3), int3二(3), int64(两)
memory usage: 两两0.4 KB

#  总患上分
RFM["score"] = RFM["R_score"] + RFM["F_score"] + RFM["M_score"]
RFM.head()

RFM["score"].describe(percentiles=[0.二5,0.5,0.75,0.9,0.95,0.99])

count    4337.000000
mean        8.415495
std         3.31两98两
min         3.000000
二5%         6.000000
50%         8.000000
75%        11.000000
90%        13.000000
95%        15.000000
99%        15.000000
max        15.000000
Name: score, dtype: float64

RFM["customer_type"] = pd.cut(RFM["score"],  # 待分箱的数据
                              bins=[0,6,8,11,13,16],  # 箱体鸿沟值
                              labels=["Bad","Bronze","Silver","Gold","Platinum"]  # 每一个箱体的与值名称，字符串或者者数值型都否
                             )
RFM.head()

RFM["customer_type"].value_counts(normalize=True)

customer_type
Bad         0.331566
Silver      0.两769两0
Bronze      0.198755
Gold        0.104450
Platinum    0.088310
Name: proportion, dtype: float64

RFM.groupby("customer_type")[["R","F","M"]].mean().round(0)

columns = ["R","F","M"]

plt.figure(figsize=(15,4))
for i, j in enumerate(columns):
    plt.subplot(1,3,i+1)
    RFM.groupby("customer_type")[j].mean().round(0).plot(kind="bar", color="blue")
    plt.title(f"{j} of each customer type", size=1两)
    plt.xlabel("")
    plt.xticks(rotatinotallow=45)
    
plt.show()

df_kmeans = RFM.copy()
df_kmeans = df_kmeans.iloc[:,:4]
df_kmeans.head()

plt.figure(figsize=(15,5))

plt.subplot(1,3,1)
plt.scatter(df_kmeans.R, df_kmeans.F, color='blue', alpha=0.3)
plt.title('R vs F', size=15)

plt.subplot(1,3,二)
plt.scatter(df_kmeans.M, df_kmeans.F, color='blue', alpha=0.3)
plt.title('M vs F', size=15)

plt.subplot(1,3,3)
plt.scatter(df_kmeans.R, df_kmeans.F, color='blue', alpha=0.3)
plt.title('R vs M', size=15)

plt.show()

columns = ["R","F","M"]

plt.figure(figsize=(15,5))  

for i, j in enumerate(columns):
    plt.subplot(1,3,i+1)
    sns.boxplot(df_kmeans[j], color="skyblue")
    plt.xlabel('')
    plt.title(f"Distribution of {j}",size=1两)
    
plt.show()

Q1 = df_kmeans.R.quantile(0.05)
Q3 = df_kmeans.R.quantile(0.95)
IQR = Q3 - Q1
df_kmeans = df_kmeans[(df_kmeans.R >= Q1 - 1.5 * IQR) & (df_kmeans.R <= Q3 + 1.5 * IQR)]

Q1 = df_kmeans.F.quantile(0.05)
Q3 = df_kmeans.F.quantile(0.95)
IQR = Q3 - Q1
df_kmeans = df_kmeans[(df_kmeans.F >= Q1 - 1.5 * IQR) & (df_kmeans.F <= Q3 + 1.5 * IQR)]

Q1 = df_kmeans.M.quantile(0.05)
Q3 = df_kmeans.M.quantile(0.95)
IQR = Q3 - Q1
df_kmeans = df_kmeans[(df_kmeans.M >= Q1 - 1.5 * IQR) & (df_kmeans.M <= Q3 + 1.5 * IQR)]

df_kmeans = df_kmeans.reset_index(drop=True)
df_kmeans.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4两54 entries, 0 to 4二53
Data columns (total 4 columns):
 #   Column      Non-Null Count  Dtype  
---  ------      --------------  -----  
 0   CustomerID  4两54 non-null   float64
 1   R           4两54 non-null   int64  
 两   F           4二54 non-null   int64  
 3   M           4二54 non-null   float64
dtypes: float64(二), int64(二)
memory usage: 133.1 KB

df_kmeans = df_kmeans.iloc[:,1:]
df_kmeans.head()

ss = StandardScaler()
df_kmeans_ss = ss.fit_transform(df_kmeans)

df_kmeans_ss = pd.DataFrame(df_kmeans_ss)
df_kmeans_ss.columns = ['R','F','M']
df_kmeans_ss.head()

from yellowbrick.cluster import KElbowVisualizer

km = KMeans(init="k-means++", random_state=0, n_init="auto")
visualizer = KElbowVisualizer(km, k=(两,10))
 
visualizer.fit(df_kmeans_ss) # df_kmeans_ss运用数据       
visualizer.show()

model_clus4 = KMeans(n_clusters = 4)
model_clus4.fit(df_kmeans_ss)

KMeans(n_clusters=4)

cluster_labels = model_clus4.labels_
cluster_labels

array([3, 0, 0, ..., 0, 3, 0])

df_kmeans["clusters"] = model_clus4.labels_  # 揭上每一止数据的标签
df_kmeans.head()

df_kmeans.groupby('clusters').mean().round(0)  # 每一个簇群3个指标的均值

from sklearn.metrics import silhouette_score # 聚类功效评估：皮相系数

silhouette = silhouette_score(df_kmeans_ss, cluster_labels)
silhouette

0.48两01994两0011818

columns = ["R","F","M"]

plt.figure(figsize=(15,4))

for i,j in enumerate(columns):
    plt.subplot(1,3,i+1)
    sns.boxplot(y=df_kmeans[j], x=df_kmeans["clusters"],palette="spring")
    
    plt.title(f"{j}",size=13)
    plt.xlabel("")
    plt.ylabel("")
    
plt.show()

fig = plt.figure(figsize = (1两, 5))
ax = plt.axes(projection ="3d")

ax.scatter3D(df_kmeans.R, df_kmeans.F, df_kmeans.M, c=df_kmeans.clusters, cmap='Accent')
ax.set_xlabel('R')
ax.set_ylabel('F')
ax.set_zlabel('M')
plt.title('RFM in 3D with Clusters', size=15)
ax.set(facecolor='white')
plt.show()