精华内容
下载资源
问答
  • 2019-06-13 11:05:54

    K-Means算法对航空公司客户进行分类

    1.数据预处理:

    import numpy as np
    import pandas as pd
    
    data = pd.read_csv("./air_data.csv", encoding='gb18030', engine='python')
    print(data.columns)
    print(data.shape)
    # 保留票价不为空的值
    mask1 = data["SUM_YR_1"].notnull() & data["SUM_YR_2"].notnull()
    data1 = data.loc[mask1, :]
    print(data1.shape)
    # 保留票价不为0,平均折扣率不为0,总飞行公里数大于0的记录
    mask2 = data["SUM_YR_1"] != 0
    mask3 = data["SUM_YR_2"] != 0
    mask4 = data["avg_discount"] != 0
    mask5 = data["SEG_KM_SUM"] > 0
    mask = mask4 & mask5 & (mask2 | mask3)
    airline = data1.loc[mask, :]
    print(airline.shape)
    
    # 选取需求特征
    airline_selection = airline[["FFP_DATE", "LOAD_TIME", "FLIGHT_COUNT", "LAST_TO_END", "avg_discount", "SEG_KM_SUM"]]
    
    # 构建L特征
    L = pd.to_datetime(airline_selection["LOAD_TIME"]) - pd.to_datetime(airline_selection["FFP_DATE"])
    
    # 提取数字,由于模型中L单位为:月,所以需要除以30
    # apply 对整列数据进行操作
    L = L.apply(lambda x: round(int(str(x).split(' ')[0]) / 30, 1))
    
    # 合并特征
    airline_features = pd.concat([L, airline_selection.iloc[:, 2:]], axis=1)
    print('构建的LRFMC特征前5行为:\n', airline_features.head())
    
    # 标准差标准化: 使用sklearn 中preprocessing 模块的StandardScaler 函数; 也可以使用自定义的方法(数据分析中标准化方法,因为此处不需要对训练集与测试集用同一套规则)
    from sklearn.preprocessing import StandardScaler  # 标准差标准化
    
    data = StandardScaler().fit_transform(airline_features)
    np.savez('airline_scale.npz', data)
    print('标准化后LRFMC五个特征为:\n', data[:5, :])
    
    

    2.K-Means算法进行分类:

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans  # 导入kmeans算法
    
    airline_scale = np.load('airline_scale.npz')['arr_0']
    k = 5  # 确定聚类中心数
    # 构建模型
    kmeans_model = KMeans(n_clusters=k)
    fit_kmeans = kmeans_model.fit(airline_scale)  # 模型训练
    
    # kmeans_model.cluster_centers_  # 查看聚类中心
    # kmeans_model.labels_  # 查看样本的类别标签
    print(type(kmeans_model.labels_))
    # 统计不同类别样本的数目
    
    # 易错:只有pandas中Series类型才有value_counts()属性
    r1 = pd.Series(kmeans_model.labels_).value_counts()
    print('最终每个类别的数目为:\n', r1)
    
    # 任务3 航空分析结果可视化
    # 做可视化:
    plt.figure(figsize=(6, 6))
    L = 5
    angles = np.linspace(0, 2 * np.pi, L, endpoint=False)
    labels = ['L', 'R', 'F', 'C', 'M']
    data = kmeans_model.cluster_centers_
    # 闭合曲线:
    angles = np.concatenate((angles, [angles[0]]))
    data = np.concatenate((data, data[:, 0].reshape(5, 1)), axis=1).T
    
    # 绘图:
    plt.polar(angles, data)
    plt.xticks(angles, labels)
    plt.show()
    
    
    更多相关内容
  • 与本人博客https://blog.csdn.net/sinat_38068807/article/details/90703685配套使用,这个压缩包里面有数据分析所用数据源,分析需求文档以及本人编写的代码
  • # return data # data = stand_sca(data) # print("标准化之后的数据", data) # 数据标准化 # 计算出数据的均值和方差 data = StandardScaler().fit_transform(data) # np.savez('../tmp/airline_scale.npz', data) ...

    我的这个项目放在百度网盘了,你可以提取。数据表都有。

    链接:https://pan.baidu.com/s/1il9Uzs7xlcEkssIzeiZpfA 
    提取码:ys9e

    一、对于数据的抽取

    #1、数据抽取
    import pandas as pd
    
    datafile = './air_data.csv'  # 航空原始数据路径
    data = pd.read_csv(datafile, encoding = 'utf-8') #读取原始数据,指定UTF-8编码

    二、数据探索分析

    #2、数据探索分析
    import pandas as pd
    
    datafile= './air_data.csv' #航空原始数据,第一行为属性标签
    resultfile = './explore.xls' #数据探索结果表
    data = pd.read_csv(datafile, encoding = 'utf-8') #读取原始数据,指定UTF-8编码
    explore = data.describe(percentiles = [], include = 'all').T #包括对数据的基本描述,percentiles参数是指定计算多少的分位数表(如1/4分位数、中位数等);T是转置,转置后更方便查阅
    explore['null'] = len(data)-explore['count'] #describe()函数自动计算非空值数,需要手动计算空值数
    explore = explore[['null', 'max', 'min']]
    explore.columns = [u'空值数', u'最大值', u'最小值'] #表头重命名
    explore.to_excel(resultfile) #导出结果
    

    三、对于数据的清洗

    import pandas as pd
    datafile = './air_data.csv'  # 航空原始数据路径
    cleanedfile = './data_cleaned.csv'  # 数据清洗后保存的文件路径
    #对数据的清洗
    def data_cleansing(datafile,cleanedfile):
        # 读取数据
        airline_data = pd.read_csv(datafile,encoding = 'utf-8')
        print('原始数据的形状为:',airline_data.shape)
        # 去除票价为空的记录
        airline_notnull = airline_data.loc[airline_data['SUM_YR_1'].notnull() &
                                           airline_data['SUM_YR_2'].notnull(),:]
        print('删除缺失记录后数据的形状为:',airline_notnull.shape)
    
        # 只保留票价非零的,或者平均折扣率不为0且总飞行公里数大于0的记录。
        index1 = airline_notnull['SUM_YR_1'] != 0
        index2 = airline_notnull['SUM_YR_2'] != 0
        # 保留平均折扣率不为0且总飞行公里数大于0的记录。
        index3 = (airline_notnull['SEG_KM_SUM']> 0) & (airline_notnull['avg_discount'] != 0)
        index4 = airline_notnull['AGE'] > 100  # 去除年龄大于100的记录
        airline = airline_notnull[(index1 | index2) & index3 & ~index4]
        print('数据清洗后数据的形状为:',airline.shape)
        airline.to_csv(cleanedfile,index=False, encoding='utf_8_sig')  # 保存清洗后的数据
    if __name__=='__main__':
        data_cleansing(datafile,cleanedfile)
    

     运行结果:

    四、标准化后LRFMC

    import pandas as pd
    from sklearn.preprocessing import StandardScaler
    datafile = './air_data.csv'  # 航空原始数据路径
    cleanedfile = './data_cleaned.csv'  # 数据清洗后保存的文件路径
    inputfile = '../tmp/zscoreddata.xls' #待聚类的数据文件
    
    def data_extraction(cleanedfile, inputfile):
        data = pd.read_csv(cleanedfile, encoding='utf-8')
        # 入会时间 、观察窗口结束时间  最后一次飞行至结束的时长  飞行次数  飞行里程  折扣系数
        data = data[['FFP_DATE', 'LOAD_TIME', 'LAST_TO_END', 'FLIGHT_COUNT', 'SEG_KM_SUM', 'avg_discount']]
        # print(data)
        # print("data 的shape:", data.shape)
        # print("data columns:", data.columns)
        # L、R、F、M和C五个特征的数据
        # 求取L 会员人会时间距观测窗口结束的月数=观测窗口的结束时间一人会时间[单位:月]
        # 计算结束时间和入会时间的差值
        # L= LOAD_TIME—FFP_DATE/30
        # 转换为时间格式
        date = pd.to_datetime(data['LOAD_TIME']) - pd.to_datetime(data['FFP_DATE'])
        # 取出其天数
        date_list = [tmp.days for tmp in date]
        data["date_list"] = date_list
        data["L"] = data["date_list"] / 30
        ## 求 R 客户最近一次乘坐公司飞机距观测窗口结束的月数=最后一次乘机时间至观察窗口末端时长[单位:月]
        # R= LAST_TO_END/30
        data['R'] = data['LAST_TO_END'] / 30
        # F  客户在观测窗口内乘坐公司飞机的次数=观测窗口的飞行次数[单位:次]
        # F = FLIGHT_COUNT
        data['F'] = data['FLIGHT_COUNT']
        # M 客户在观测时间内在公司累计的飞行里程=观测窗口的总飞行公里数[单位:公里]
        # M= SEG_KM_SUM
        data['M'] = data['SEG_KM_SUM']
        # C 客户在观测时间内乘坐舱位所对应的折扣系数的平均值=平均折扣率[单位:无]
        # C= AVG_DISCOUNT
        data['C'] = data['avg_discount']
        # 只提取5个指标的数据
        data = data.iloc[:, -5:]
        # print(data)
        # 标准化数据
        # 调用标准差标准化
        # def stand_sca(data):
        #     """
        #         标准差标准化    x-u/a
        #         :param data: 数据
        #         :return: 标准化后的数据
        #         """
        #     data=(data-data.mean()/data.std())
        #     return data
        # data = stand_sca(data)
        # print("标准化之后的数据", data)
        # 数据标准化
        # 计算出数据的均值和方差
        data = StandardScaler().fit_transform(data)
        # np.savez('../tmp/airline_scale.npz', data)
        print('标准化后LRFMC五个属性为:\n', data[:5, :])
        # 数据写入
        da = pd.DataFrame(data, columns=['L', 'R', 'F', 'M', 'C'])
        print(da)
        da.to_excel(inputfile, index=False, encoding='utf_8_sig')
    
    
    if __name__=='__main__':
        data_extraction(cleanedfile, inputfile)
    

     运行结果:

     五、客户特征分析雷达图

    def show_res(cluster_center):
        '''
        :param center: 聚类中心
        :param data: 5列航空数据
        :return:
        '''
        # 客户分群雷达图
        labels = ['L', 'R', 'F', 'M', 'C']
        legen = ['客户群' + str(i + 1) for i in cluster_center.index]  # 客户群命名,作为雷达图的图例
        lstype = ['-', '--', (0, (3, 5, 1, 5, 1, 5)), ':', '-.']
        kinds = list(cluster_center.iloc[:, 0])
        # 由于雷达图要保证数据闭合,因此再添加L列,并转换为 np.ndarray
        cluster_center = pd.concat([cluster_center, cluster_center[['L']]], axis=1)
        centers = np.array(cluster_center.iloc[:, 0:])
    
        # 分割圆周长,并让其闭合
        n = len(labels)
        angle = np.linspace(0, 2 * np.pi, n, endpoint=False)
        angle = np.concatenate((angle, [angle[0]]))
    
        # 绘图
        fig = plt.figure(figsize=(8, 6))
        ax = fig.add_subplot(111, polar=True)  # 以极坐标的形式绘制图形
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        # 画线
        for i in range(len(kinds)):
            ax.plot(angle, centers[i], linestyle=lstype[i], linewidth=2, label=kinds[i])
        # 添加属性标签
        ax.set_thetagrids(angle * 180 / np.pi, labels)
        plt.title('客户特征分析雷达图')
        plt.legend(legen)
        plt.show()
        plt.close

    完整代码:

    # 处理缺失值与异常值
    import numpy as np
    import pandas as pd
    from sklearn.cluster import KMeans
    import matplotlib.pyplot as plt
    from sklearn.preprocessing import StandardScaler
    datafile = './air_data.csv'  # 航空原始数据路径
    cleanedfile = './data_cleaned.csv'  # 数据清洗后保存的文件路径
    inputfile = './zscoreddata.xls' #待聚类的数据文件
    outfile = './zscoreddata_1.xls' #聚类后的数据文件
    def data_cleansing(datafile,cleanedfile):
        # 读取数据
        airline_data = pd.read_csv(datafile,encoding = 'utf-8')
        print('原始数据的形状为:',airline_data.shape)
    
        # 去除票价为空的记录
        airline_notnull = airline_data.loc[airline_data['SUM_YR_1'].notnull() &
                                           airline_data['SUM_YR_2'].notnull(),:]
        print('删除缺失记录后数据的形状为:',airline_notnull.shape)
    
        # 只保留票价非零的,或者平均折扣率不为0且总飞行公里数大于0的记录。
        index1 = airline_notnull['SUM_YR_1'] != 0
        index2 = airline_notnull['SUM_YR_2'] != 0
        # 保留平均折扣率不为0且总飞行公里数大于0的记录。
        index3 = (airline_notnull['SEG_KM_SUM']> 0) & (airline_notnull['avg_discount'] != 0)
        index4 = airline_notnull['AGE'] > 100  # 去除年龄大于100的记录
        airline = airline_notnull[(index1 | index2) & index3 & ~index4]
        print('数据清洗后数据的形状为:',airline.shape)
    
        airline.to_csv(cleanedfile,index=False, encoding='utf_8_sig')  # 保存清洗后的数据
    def data_extraction(cleanedfile,inputfile):
        data=pd.read_csv(cleanedfile,encoding='utf-8')
        # 入会时间 、观察窗口结束时间  最后一次飞行至结束的时长  飞行次数  飞行里程  折扣系数
        data = data[['FFP_DATE', 'LOAD_TIME', 'LAST_TO_END', 'FLIGHT_COUNT', 'SEG_KM_SUM', 'avg_discount']]
        # print(data)
        # print("data 的shape:", data.shape)
        # print("data columns:", data.columns)
        # L、R、F、M和C五个特征的数据
        # 求取L 会员人会时间距观测窗口结束的月数=观测窗口的结束时间一人会时间[单位:月]
        # 计算结束时间和入会时间的差值
        # L= LOAD_TIME—FFP_DATE/30
        #转换为时间格式
        date=pd.to_datetime(data['LOAD_TIME'])-pd.to_datetime(data['FFP_DATE'])
        # 取出其天数
        date_list = [tmp.days for tmp in date]
        data["date_list"] = date_list
        data["L"] = data["date_list"] / 30
        ## 求 R 客户最近一次乘坐公司飞机距观测窗口结束的月数=最后一次乘机时间至观察窗口末端时长[单位:月]
        # R= LAST_TO_END/30
        data['R']=data['LAST_TO_END']/30
        # F  客户在观测窗口内乘坐公司飞机的次数=观测窗口的飞行次数[单位:次]
        # F = FLIGHT_COUNT
        data['F']=data['FLIGHT_COUNT']
        # M 客户在观测时间内在公司累计的飞行里程=观测窗口的总飞行公里数[单位:公里]
        # M= SEG_KM_SUM
        data['M']=data['SEG_KM_SUM']
        # C 客户在观测时间内乘坐舱位所对应的折扣系数的平均值=平均折扣率[单位:无]
        # C= AVG_DISCOUNT
        data['C']=data['avg_discount']
        # 只提取5个指标的数据
        data=data.iloc[:,-5:]
        # print(data)
        # 标准化数据
        # 调用标准差标准化
        # def stand_sca(data):
        #     """
        #         标准差标准化    x-u/a
        #         :param data: 数据
        #         :return: 标准化后的数据
        #         """
        #     data=(data-data.mean()/data.std())
        #     return data
        # data = stand_sca(data)
        # print("标准化之后的数据", data)
        # 数据标准化
        # 计算出数据的均值和方差
        data = StandardScaler().fit_transform(data)
        # np.savez('../tmp/airline_scale.npz', data)
        print('标准化后LRFMC五个属性为:\n', data[:5, :])
        #数据写入
        da=pd.DataFrame(data,columns=['L', 'R', 'F', 'M', 'C'])
        print(da)
        da.to_excel(inputfile,index=False, encoding='utf_8_sig')
    
    def show_res(cluster_center):
        '''
        :param center: 聚类中心
        :param data: 5列航空数据
        :return:
        '''
        # 客户分群雷达图
        labels = ['L', 'R', 'F', 'M', 'C']
        legen = ['客户群' + str(i + 1) for i in cluster_center.index]  # 客户群命名,作为雷达图的图例
        lstype = ['-', '--', (0, (3, 5, 1, 5, 1, 5)), ':', '-.']
        kinds = list(cluster_center.iloc[:, 0])
        # 由于雷达图要保证数据闭合,因此再添加L列,并转换为 np.ndarray
        cluster_center = pd.concat([cluster_center, cluster_center[['L']]], axis=1)
        centers = np.array(cluster_center.iloc[:, 0:])
    
        # 分割圆周长,并让其闭合
        n = len(labels)
        angle = np.linspace(0, 2 * np.pi, n, endpoint=False)
        angle = np.concatenate((angle, [angle[0]]))
    
        # 绘图
        fig = plt.figure(figsize=(8, 6))
        ax = fig.add_subplot(111, polar=True)  # 以极坐标的形式绘制图形
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        # 画线
        for i in range(len(kinds)):
            ax.plot(angle, centers[i], linestyle=lstype[i], linewidth=2, label=kinds[i])
        # 添加属性标签
        ax.set_thetagrids(angle * 180 / np.pi, labels)
        plt.title('客户特征分析雷达图')
        plt.legend(legen)
        plt.show()
        plt.close
    
    if __name__=='__main__':
        data_extraction(cleanedfile,inputfile)
        K=5 #需要聚类的级别数
        #进行K-means聚类
        #确认聚类的类别
        data=pd.read_excel(inputfile,encoding='utf-8',)
        print(data.head())
        # 构建模型,随机种子设为123
        km=KMeans(n_clusters = K,n_jobs=4,random_state=123)
        km.fit(data)    #训练数据
        y_predict = km.predict(data)    #进行预测
        # # #获取聚类中心
        center=km.cluster_centers_
        print('聚类中心为:',center)
        print('预测值:',y_predict)
        kmeans_labels=km.labels_    #样本的类别标签
        print('各个样本的类别标签为:\n',kmeans_labels)
        r1=pd.Series(km.labels_).value_counts() #统计不同类别样本的数目
        print('最终每个类别的数目为:\n',r1)    #输出聚类分群的结果
        # 将聚类中心放在数据框中
        cluster_center=pd.DataFrame(km.cluster_centers_,
                                    columns=['L','R','F','M','C'])
        # 将聚类中心放在数据框中
        cluster_center.index=pd.DataFrame(km.labels_).drop_duplicates().iloc[:,0]
        # 将样本类别作为数据框索引
        # print('111111111111111111111111111111111')
        # print(cluster_center)
        # cluster_center.to_excel(outfile,index=False,encoding='utf_8_sig')
        show_res(cluster_center)
    

    运行结果:

     

    展开全文
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 Python实验报告2——航空公司数据分析数据预处理 ...airline_data = pd.read_csv("../data/air_data.csv", encoding="gb18030")

    一、 实验目标与基本要求

    1. 实验目标

    重点

    结合航空公司客户价值分析的案例介绍K-Means聚类算法在客户价值分析中的应用。此外,介绍基于RFM客户价值分析模型的不足,使用K-Means算法构建航空客户价值分析LRFMC模型,详细的描述数据分析的整个过程。

    2. 基本要求

    (1) 了解RFM模型的基本原理。
    (2) 掌握K-Means算法的基本原理与使用方法。
    (3) 比较不同类别客户的客户价值,制定相应的营销策略。

    二、 主要知识点、重点与难点

    1. 主要知识点

    (1) RFM模型的基本原理。
    (2) K-Means算法的基本原理与使用方法。
    (3) 比较不同类别客户的客户价值,制定相应的营销策略。

    2. 重点

    (1) 航空客户价值分析的步骤和流程。
    (2) RFM模型的基本原理。
    (3) K-Means算法的基本原理与使用方法。
    (4) 比较不同类别客户的客户价值。

    3. 难点

    (1) RFM模型的基本原理。
    (2) KMeans算法的基本原理与使用方法。

    三、 实验过程设计

    1. 实验理论

    (1) 分析航空公司现状。
    (2) 认识客户价值分析。
    (3) 熟悉航空客户价值分析的步骤与流程。
    (4) 处理缺失值与异常值。
    (5) 构建爱你航空客户价值分析关键特征。
    (6) 标准化LRFMC 5个特征。
    (7) 了解K-Means聚类算法。
    (8) 分析聚类结果。
    (9) 模型应用。

    2. 实验教学过程

    (1) 处理数据缺失值与异常值。
    (2) 构建航空客户价值分析的关键特征。
    (3) 标准化LRFMC 5个特征。
    (4) 构建K-Means聚类模型。
    (5) 评价K-Means聚类模型。


    三、实现

    数据预处理

    数据清洗

    首先调用describe()函数对数据进行一个大致的了解,主要是查看缺失值和异常值。

    import numpy as np
    import pandas as pd
    from sklearn.preprocessing import StandardScaler
    
    airline_data = pd.read_csv("../data/air_data.csv",
                               encoding="gb18030")  # 导入航空数据
    print('原始数据的形状为:', airline_data.shape)
    print(type(airline_data))
    print(airline_data.describe().T)
    explore = airline_data.describe().T  # 对数据的统计性描述,T是我进行了转置
    explore['null'] = len(airline_data) - explore['count']
    df = explore[['max', 'min', 'null']]
    df.to_excel("数据描述.xls")
    

    根据数据的格式,发现数据的行少列多,无法全部显示,因此使用原Dataframe的转置,显示结果如下
    在这里插入图片描述
    在这里插入图片描述

    第一列表示最大值,第二列最小值,第三列为空值个数,可以发现空值数量不多,可以直接删除这些无效数据。

    exp1 = airline_data["SUM_YR_1"].notnull()
    exp2 = airline_data["SUM_YR_2"].notnull()
    exp = exp1 & exp2
    '''
        多条件筛选 使用&,DF6[(DF6.B>1) & (DF6.D > 10)]
        两个筛选结果与好像也可以
    '''
    print('exp的形状是:', exp.shape)
    
    airline_notnull = airline_data.loc[exp, :]
    
    

    丢弃第一年或第二年票价为0,平均折扣率不为0且总飞行公里数大于零的记录。

    index1 = airline_notnull['SUM_YR_1'] != 0
    index2 = airline_notnull['SUM_YR_2'] != 0
    index3 = (airline_notnull['SEG_KM_SUM'] > 0) & \
             (airline_notnull['avg_discount'] != 0)
    airline = airline_notnull[(index1 | index2) & index3]
    

    数据筛选

    评估航空公司客户价值通常根据LRFMC模型:

    客户关系长度L、消费时间间隔R、消费频率F、飞行里程M、折扣系数的平均值C

    与其相关的只有六个属性:

    LOAD_TIME、FFP_DATE、LAST_TO_END、FLIGHT_COUNT、SEG_KM_SUMAVG_DISCOUNT。

    关系如下:

    L = LOAD_TIME - FFP_DATE
    会员入会时间距观测窗口结束的月数=观测窗口结束的时间-入会时间
    R=LAST_TO_END
    客户最近一次乘坐公司飞机距观测窗口结束的月数=最后一次乘机时间至观察窗口末端时长[单位:月] F=FLIGHT_COUNT
    客户在观测窗口内乘坐公司飞机的次数=观测窗口的飞行次数[单位:次]
    M=SEG_KM_SUM
    客户在观测时间内在公司累计的飞行里程=观测窗口的总飞行公里数[单位:公里]
    C=AVG_DISCOUNT
    折扣率

    那么只要筛选这些数据即可

    airline_selection = airline[["FFP_DATE", "LOAD_TIME",
                                 "FLIGHT_COUNT", "LAST_TO_END",
                                 "avg_discount", "SEG_KM_SUM"]]
                                 '''
        选取需要的特征值:入会时间、观测窗口结束时间(即本组数据的时间宽度)、飞行次数、
        最后一次飞行时间到观测窗口结束的时间间隔、平局折扣率、本窗口内的总飞行距离
        L(入会至当前时间的间隔,反映可能的活跃时长)、
        R(最近消费时间距当前的间隔,反映当前的活跃状态)、
        F(乘机次数,反映客户的忠诚度)、
        M(飞行里程数,反映客户对乘机的依赖性)、
        C(舱位等级对应的折扣系数,侧面反映客户价值高低)
    '''
    L = pd.to_datetime(airline_selection["LOAD_TIME"]) - \
        pd.to_datetime(airline_selection["FFP_DATE"])
    # print(L)
    L = L.astype("str").str.split().str[0]
    # print(L)
    L = L.astype("int") / 30
    '''
        强制把datetime修改为str类型,以空格为分隔符进行分割,为什么?
        打印之后发现数据格式为  2706 days,分隔之后去掉days,保留下来的就是天数
        分析下来L就等于 (LOAD_TIME - FFP_DATE)/30,其中两个时间都是以天为单位
        计算了用户如会到现在的月数
    '''
    

    除了L特征需要计算,其余都可以直接获得。

    airline_features = pd.concat([L,airline_selection.iloc[:, 2:]],axis=1)
    

    把计算得到的L特征和其他特征合并。

    data = StandardScaler().fit_transform(airline_features)
    

    数据标准化,降维,归一化等操作。
    StandardScaler就是对数据进行归一化和标准化, 不仅计算训练数据的均值和方差,还会基于计算出来的均值和方差来转换训练数据,从而把数据转换成标准的正太分布,限制在固定的区间里。

    客户数据分析

    读入数据

    airline_scale = np.load('../tmp/airline_scale.npz')['arr_0']
    

    在这里插入图片描述

    在这里插入图片描述
    airline_scale类型:ndarry

    kmeans聚类

    k = 5  # 聚类中心数
    kmeans_model = KMeans(n_clusters=k, n_jobs=4, random_state=123)
    # 聚类中心数,并行的CPU核的数量,随机数种子
    fit_kmeans = kmeans_model.fit(airline_scale)  # 模型训练
    print(kmeans_model.cluster_centers_)  # 查看聚类中心
    print(kmeans_model.labels_)  # 查看样本的类别标签
    

    在这里插入图片描述
    用kmeans分为五个聚类,每个聚类内部的数据为一个list,五个list组成聚类中心。

    labels显示按照kmeans划分之后每个数据属于哪个聚类。

    # 统计不同类别样本的数目
    r1 = pd.Series(kmeans_model.labels_).value_counts()
    print('最终每个类别的数目为:\n', r1)
    result = kmeans_model.predict([[1.5, 1.5, 1.5, 1.5, 1.5]])
    print(result)
    # 最终确定在五个参数都是1.5的情况下的用户属于类别1
    

    r1显示每个聚类内部的元素个数,同时测试一组特定特征值的数据会被分配到哪个组中。

    聚类模型评价

    对于之前建立的kmeans进行评价。

    random-state

    随机数种子,用于随机划分数据为训练集和测试集。

    1、FMI评价法

    这种评价法应该是针对已经有标签的数据(label-true),采用不同的聚类数量进行计算,与源数据的标签进行匹配,得出训练模型与原先数据的匹配程度。

    for i in range(2, 7):
        kmeans = KMeans(n_clusters=i, random_state=123).fit(airline_scale)
        # print(kmeans.labels_)
        # print(type(kmeans.labels_))
        score = fowlkes_mallows_score(kmeans_model.labels_, kmeans.labels_)
        print('iris数据聚%d类FMI评价分值为:%f' % (i, score))
    

    因为原先的数据没有标签,所以选取聚类数为5的数据作为基准,比较不同聚类数量的优越性。
    在这里插入图片描述
    在这里插入图片描述

    可以总结出,聚类数为5是区间内的最优选择。

    2.轮廓系数评价法(silhouette_score)

    结合内聚度和分离度两种因素。
    可以用来在相同原始数据的基础上用来评价不同算法、或者算法不同运行方式对聚类结果所产生的影响
    1.计算样本i到同簇其他样本的平均距离ai。ai 越小,说明样本i越应该被聚类到该簇。
    将ai 称为样本i的簇内不相似度,某一个簇C中所有样本的a i 均值称为簇C的簇不相似度
    2.计算样本i到其他某簇Cj的所有样本的平均距离bij,称为样本i与簇Cj的不相似度。
    某一个样本的簇间不相似度为该样本到所有其他簇的所有样本的平均距离中最小的那一个
    在这里插入图片描述

    si接近1,则说明样本i聚类合理;
    si接近-1,则说明样本i更应该分类到另外的簇;
    si 近似为0,则说明样本i在两个簇的边界上。

    所有样本的s i 的均值称为聚类结果的轮廓系数,定义为S,是该聚类是否合理、有效的度量。聚类结果的轮廓系数的取值在【-1,1】之间,值越大,说明同类样本相距约近,不同样本相距越远,则聚类效果越好。

    silhouettteScore = []
    for i in range(2, 7):
        kmeans = KMeans(n_clusters=i, random_state=123).fit(airline_scale)
        score = silhouette_score(airline_scale, kmeans.labels_)
        print('航空公司数据聚%d类silhouette评价分值为:%f' % (i, score))
        silhouettteScore.append(score)
    plt.figure(figsize=(10, 6))
    plt.plot(range(2, 7), silhouettteScore, linewidth=1.5, linestyle="-")
    plt.show()
    

    在这里插入图片描述

    3.3.calinski_harabaz指数评价法

    Calinski-Harabasz分数值ss越大则聚类效果越好。
    在这里插入图片描述

    for i in range(2, 7):
        # 构建并训练模型
        kmeans = KMeans(n_clusters=i, random_state=123).fit(airline_scale)
        score = calinski_harabasz_score(airline_scale, kmeans.labels_)
        print('iris数据聚%d类calinski_harabaz指数为:%f' % (i, score))
    

    在这里插入图片描述

    对比

    score = fowlkes_mallows_score(kmeans_model.labels_, kmeans.labels_)
    score = silhouette_score(airline_scale, kmeans.labels_)
    score = calinski_harabasz_score(airline_scale, kmeans.labels_)
    
    

    外部度量:需要知道真实标签的度量

    对于不需要外部度量的情况下,可以直接使用kmeans算法自己产生的标签,而对于需要的FMI算法,必须要有本身带标签的数据,因此参数是前一次kmeans算法得到的数据。

    利用聚类的训练结果预测新的数据

    工具:支持向量机SVC

    支持向量机(support vector machine)是一种分类算法,也可以做回归,根据输入的数据不同可做不同的模型(若输入标签为连续值则做回归,若输入标签为分类值则用SVC()做分类)。

    可以确定需要输入标签,即监督学习。
    目的是测试之前聚类为的kmeans模型,因此输入参数是航空公司数据和标签。

    airline_data_train, airline_data_test, \
    airline_target_train, airline_target_test = \
        train_test_split(airline_scale, kmeans_model.labels_,
                         test_size=0.2, random_state=22)
    

    对数据进行标准化,训练和测试数据来自同一源,因此可以同同一个归一化函数。

    stdScaler = StandardScaler().fit(airline_data_train)
    
    airline_trainStd = stdScaler.transform(airline_data_train)
    airline_testStd = stdScaler.transform(airline_data_test)
    
    svm = SVC().fit(airline_trainStd, airline_target_train)
    print('建立的SVM模型为:\n', svm)
    #  预测训练集结果
    airline_target_pred = svm.predict(airline_testStd)
    print('预测前20个结果为:\n', airline_target_pred[:20])
    
    

    在这里插入图片描述

    雷达图分析客户信息

    datafile = 'standard_data.csv'
    data = pd.read_csv(datafile)
    r1 = pd.Series(kmeans_model.labels_).value_counts()  # 聚类内部的个数
    r2 = pd.DataFrame(kmeans_model.cluster_centers_)  # 聚类的数学数值
    r3 = pd.Series(['客户群1', '客户群2', '客户群3', '客户群4', '客户群5', ])
    labels = np.array(list(data.columns))  # 标签
    print(labels)
    dataLenth = 5  # 数据个数
    r4 = r2.T
    r4.columns = list(data.columns)
    fig = plt.figure()
    y = []
    for x in list(data.columns):
        dt = r4[x]
        dt = np.concatenate((dt, [dt[0]]))
        y.append(dt)
    ax = fig.add_subplot(111, polar=True)
    angles = np.linspace(0, 2 * np.pi, dataLenth, endpoint=False)
    angles = np.concatenate((angles, [angles[0]]))
    # labels = np.concatenate(labels,[labels[0]])
    labels = np.concatenate((labels, [labels[0]]))
    ax.plot(angles, y[0], 'b-', linewidth=2)
    ax.plot(angles, y[1], 'r-', linewidth=2)
    ax.plot(angles, y[2], 'g-', linewidth=2)
    ax.plot(angles, y[3], 'y-', linewidth=2)
    ax.plot(angles, y[4], 'm-', linewidth=2)
    plt.rcParams['font.sans-serif'] = ['SimHei']
    ax.legend(r3, loc=1)
    ax.set_thetagrids(angles * 180 / np.pi, labels, fontproperties="SimHei")
    ax.set_title("matplotlib雷达图", va='bottom', fontproperties="SimHei")
    ax.grid(True)
    plt.show()
    
    

    在这里插入图片描述

    这里有一个细节,labels需要的是一个列表里的列表,单纯的列表是不能画图的。

    上图可以很清晰的看到每个客户群的指标情况,将每个客户群的优势特征,劣势特征总结如下:

    优势特征:

    客户群1:R
    
    客户群2:F、M、L
    
    客户群3:L
    
    客户群4:C
    
    客户群5:无
    

    劣势特征:

    客户群1:F、M
    
    客户群2:R
    
    客户群3:R、F、M、C
    
    客户群4:F、M
    
    客户群5:R、L、C
    

    基于LRFMC模型的具体含义,我们可以对这5个客户群进行价值排名。
    同时,将这5个客户群重新定义为五个等级的客户类别:重要保持客户,重要挽留客户,重要发展客户,一般客户,低价值客户。
    重要保持客户:这类客户平均折扣率(C)和入会员时间(L)都很高(入会员时间越长,会员级别越高,折扣越大),最近乘坐过本航班时间间隔(R)低,乘坐的次数(F)或(M)高。说明他们经常乘坐飞机,且有一定经济实力,是航空公司的高价值 客户。对应客户群2。
    重要发展客户:这类客户平均折扣率高(C),最近乘坐过本航班时间间隔(R)短,但是乘坐的次数(F)和(M)都很低。说明这些乘客刚入会员不久,所以乘坐飞机次数少,是重要发展客户,对应客户群4。
    重要挽留客户:这类客户入会时间长(L),最近乘坐过本航班时间间隔(R)较长,里程数和乘坐次数都变低,为重要挽留客户。对应客户群3
    一般与低价值客户:这类客户乘坐时间间隔长(R)或乘坐次数(F)和总里程(M)低,平均折扣也很低。对应客户群5和客户群1.

    在聚类的基础上进行降维

    tsne = TSNE(n_components=2, init='random',
                random_state=177).fit(airline_scale)
    # init:初始化,可以是PCA或random;随机数种子
    df = pd.DataFrame(tsne.embedding_)  # 将原始数据转换为DataFrame
    print(df)
    df['labels'] = kmeans_model.labels_  # 将聚类结果存储进df数据表
    
    
    # 提取不同标签的数据
    df1 = df[df['labels'] == 0]
    df2 = df[df['labels'] == 1]
    df3 = df[df['labels'] == 2]
    df4 = df[df['labels'] == 3]
    df5 = df[df['labels'] == 5]
    
    #  绘制图形
    fig = plt.figure(figsize=(9, 6))  # 设定空白画布,并制定大小
    # 用不同的颜色表示不同数据
    plt.plot(df1[0], df1[1], 'bo', df2[0], df2[1], 'r*',
             df3[0], df3[1], 'gD',df4[0], df4[1], 'kD',df5[0], df5[1], 'lD')
    plt.savefig('../tmp/聚类结果.png')
    plt.show()  # 显示图片
    

    df1 = df[df[‘labels’] == 0]

    是一个技巧,可以取得指定列的数据。
    跑不出结果,应该输参数问题、

    K-means算法原理和改进

    定义

    字面上,K即原始数据最终被聚为K类或分为K类,Means即均值点。K-Means的核心就是将一堆数据聚集为K个簇,每个簇中都有一个中心点称为均值点,簇中所有点到该簇的均值点的距离都较到其他簇的均值点更近。
    在这里插入图片描述

    计算步骤

    1. 确定K值(决定数据聚为几类,K值是K-Means算法中唯一的参数);
    2. 从原始数据集中随机选择K个点作为初始均值点;
    3. 依次从原始数据集中取出数据,每取出一个数据就和K个均值点分别计算距离(默认计算点间的欧氏距离),和谁更近就归为这个均值点所在的簇;
    4. 分别计算各簇当前的均值点(即求该簇中所有点的平均值);
    5. 比较当前的均值点和上一步得到的均值点是否相同,如果相同,则K-Means算法结束,否则,将当前的均值点替换掉之前的均值点,然后重新划分族,重复步骤三。

    基于划分的方法(Partitional):K-means(K均值)
    1 随机选取K个数据点作为‘种子’
    2 根据数据点与‘种子’的距离大小进行类分配
    3 更新类中心点的位置,以新的类中心点作为‘种子’
    4 按照新的‘种子’对数据归属的类进行重新分配
    5 更新类中心点(–>3–>4),不断迭代,直到类中心点变得很小
    缺点:
    K是事先给定的,K值选定难确定
    对孤立点、噪声敏感
    结果不一定是全局最优,只能保证局部最优。

    在这里插入图片描述

    包内模型是基于欧式距离的,如果要是用别的标准就要自己实现。

    import numpy as np
    import matplotlib.pyplot as plt
    
    '''标志位统计递归运行次数'''
    flag = 0
    
    '''欧式距离'''
    def ecludDist(x, y):
        return np.sqrt(sum(np.square(np.array(x) - np.array(y))))
    
    '''曼哈顿距离'''
    def manhattanDist(x, y):
        return np.sum(np.abs(x - y))
    
    '''夹角余弦'''
    def cos(x, y):
        return np.dot(x, y)/(np.linalg.norm(x) * np.linalg.norm(y))
    
    '''计算簇的均值点'''
    def clusterMean(dataset):
        return sum(np.array(dataset)) / len(dataset)
    
    '''生成随机均值点'''
    def randCenter(dataset, k):
        temp = []
        while len(temp) < k:
            index = np.random.randint(0, len(dataset)-1)
            if  index not in temp:
                temp.append(index)
        return np.array([dataset[i] for i in temp])
    
    '''以数据集的前k个点为均值点'''
    def orderCenter(dataset, k):
        return np.array([dataset[i] for i in range(k)])
    
    '''聚类'''
    def kMeans(dataset, dist, center, k):
        global flag
        #all_kinds用于存放中间计算结果
        all_kinds = []
        for _ in range(k):
            temp = []
            all_kinds.append(temp)
        #计算每个点到各均值点的距离  
        for i in dataset:
            temp = []
            for j in center:
                temp.append(dist(i, j))
            all_kinds[temp.index(min(temp))].append(i)
        #打印中间结果    
        for i in range(k):
            print('第'+str(i)+'组:', all_kinds[i], end='\n')
        flag += 1
        print('************************迭代'+str(flag)+'次***************************')
        #更新均值点
        center_ = np.array([clusterMean(i) for i in all_kinds])
        if (center_ == center).all():
            print('结束')
            for i in range(k):
                print('第'+str(i)+'组均值点:', center_[i], end='\n')
                plt.scatter([j[0] for j in all_kinds[i]], [j[1] for j in all_kinds[i]], marker='*')
            plt.grid()
            plt.show()
        else:
            #递归调用kMeans函数
            center = center_
            kMeans(dataset, dist, center, k)
    
    def main(k):
        '''生成随机点''' 
        x = [np.random.randint(0, 50) for _ in range(50)]
        y = [np.random.randint(0, 50) for _ in range(50)]
        points = [[i,j] for i, j in zip(x, y)]
        plt.plot(x, y, 'b.')
        plt.show()
        initial_center = randCenter(dataset=points, k=k)
        kMeans(dataset=points, dist=ecludDist, center=initial_center, k=k)
    
    if __name__ == '__main__':
        main(3) 
    

    如果使用夹角余弦的话,需要将kMeans()函数中all_kinds[temp.index(min(temp))].append(i)语句里的min改为max

    欧氏距离和曼哈顿距离,都是计算结果越小表示两个点越相近,而夹角余弦则是计算结果越大表示两点越相近

    K的选择

    最合适的K值
    肘部法则(Elbow method):找到随着K值变大,损失函数的拐点。
    损失函数:各个类畸变程度(distortions)之和

    肘方法的核心指标是 SSESSE (sum of the squared errors,误差平方和),CiCi是第 ii 个簇,pp 是 CiCi 中的样本点,mimi是CiCi的质心(CiCi中所有样本的均值),SSE是所有样本的聚类误差,代表了聚类效果的好坏。

    在这里插入图片描述

    SSE是每个属性的SSE之和:
    1. 对于所有的簇,某变量的SSE都很低,都意味着什么?
    2. 如果只对一个簇很低,意味着什么?
    3. 如果只对一个簇很高,意味着什么?
    4. 如果对所有簇都很高,意味着什么?
    5. 如何使用每个变量的SSE信息改进聚类?
    解答:
    1. 说明该属性本质上为常量,不能作为聚类依据。
    2. 那么该属性有助于该簇的定义
    3. 那么该属性为噪声属性
    4. 那么该属性 与 定义该属性提供的信息不一致,也意味着该属性不利于簇的定义。
    5. 消除对于所有簇都是 低的SSE(高的SSE)的属性。因为这些属性对聚类没有帮助,
    这些属性在SSE的总和计算中引入了噪声。

    也可以对其中某些属性用加权概率来计算,使该属性有助于该簇的定义,
    去除某些不利于该簇定义的影响因子(那些可能是噪声)。从而更有利于簇的聚类。

    K-means 附加问题
    1.处理空簇:如果数据量少,寻找替补质心,使SSE最小。如果数据量大,保留该空簇
    2.离群点:不能删除。建议聚类之前离群检测。分析看能否删除
    3.降低SSE :将大的分散的簇再次拆开;引入新的簇将之前的大簇拆分。
    4.增量更新质心:再次在质心附近寻找测试点,看能否再次找到更优的质心。

    展开全文
  • 一、数据读取 1、读写数据库数据 读取函数: pandas.read_sql_table(table_name, con, schema=None, index_col=None, coerce_float=True, columns=None) pandas.read_sql_query(sql, con, index_col=None, coerce...

    一、数据读取

    1、读写数据库数据

    读取函数:

    • pandas.read_sql_table(table_name, con, schema=None, index_col=None, coerce_float=True, columns=None)
    • pandas.read_sql_query(sql, con, index_col=None, coerce_float=True)
    • pandas.read_sql(sql, con, index_col=None, coerce_float=True, columns=None)
    • sqlalchemy.creat_engine('数据库产品名+连接工具名://用户名:密码@数据库IP地址:数据库端口号/数据库名称?charset = 数据库数据编码')

    写出函数:

    • DataFrame.to_sql(name, con, schema=None, if_exists=’fail’, index=True, index_label=None, dtype=None)

     

    2、读写文本文件/csv数据

    读取函数:

    • pandas.read_table(filepath_or_buffer, sep=’\t’, header=’infer’, names=None, index_col=None, dtype=None, engine=None, nrows=None)
    • pandas.read_csv(filepath_or_buffer, sep=’,’, header=’infer’, names=None, index_col=None, dtype=None, engine=None, nrows=None)

    写出函数:

    • DataFrame.to_csv(path_or_buf=None, sep=’,’, na_rep=”, columns=None, header=True, index=True,index_label=None,mode=’w’,encoding=None)

     

    3、读写excel(xls/xlsx)数据

    读取函数:

    • pandas.read_excel(io, sheetname=0, header=0, index_col=None, names=None, dtype=None)

    写出函数:

    • DataFrame.to_excel(excel_writer=None, sheetname=None’, na_rep=”, header=True, index=True, index_label=None, mode=’w’, encoding=None)

     

    4、读取剪贴板数据:

    • pandas.read_clipboard()

     

    二、数据预处理

    1、数据清洗

    重复数据处理

    1. 样本重复:

      pandas.DataFrame(Series).drop_duplicates(self, subset=None, keep='first', inplace=False)

    2. 特征重复:

    • 通用
    
    def FeatureEquals(df):
        dfEquals=pd.DataFrame([],columns=df.columns,index=df.columns)
        for i in df.columns:
           for j in df.columns:
               dfEquals.loc[i,j]=df.loc[:,i].equals(df.loc[:,j])
        return dfEquals
    • 数值型特征
    
    def drop_features(data,way = 'pearson',assoRate = 1.0):
        '''
        此函数用于求取相似度大于assoRate的两列中的一个,主要目的用于去除数值型特征的重复
        data:数据框,无默认
        assoRate:相似度,默认为1
        '''
        assoMat = data.corr(method = way)
        delCol = []
        length = len(assoMat)
        for i in range(length):
            for j in range(i+1,length):
                if assoMat.iloc[i,j] >= assoRate:
                    delCol.append(assoMat.columns[j])
        return(delCol)

     

    缺失值处理

    识别缺失值

    • DataFrame.isnull()
    • DataFrame.notnull()
    • DataFrame.isna()
    • DataFrame.notna()

    处理缺失值

    • 删除:DataFrame.dropna(self, axis=0, how='any', thresh=None, subset=None, inplace=False)

    • 定值填补: DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None)

    • 插补: DataFrame.interpolate(method=’linear’, axis=0, limit=None, inplace=False,limit_direction=’forward’, limit_area=None, downcast=None,**kwargs)

       

    异常值处理

    • 3σ原则
    
    def outRange(Ser1):
        boolInd = (Ser1.mean()-3*Ser1.std()>Ser1) | (Ser1.mean()+3*Ser1.var()< Ser1)
        index = np.arange(Ser1.shape[0])[boolInd]
        outrange = Ser1.iloc[index]
        return outrange

    注: 此方法只适用于正态分布

    • 箱线图分析
    
    def boxOutRange(Ser):
        '''
        Ser:进行异常值分析的DataFrame的某一列
        '''
        Low = Ser.quantile(0.25)-1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
        Up = Ser.quantile(0.75)+1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
        index = (Ser< Low) | (Ser>Up)
        Outlier = Ser.loc[index]
        return(Outlier)

    2、合并数据

    • 数据堆叠:pandas.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)
    • 主键合并:pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False,suffixes=('_x', '_y'), copy=True, indicator=False)
    • 重叠合并:pandas.DataFrame.combine_first(self, other)

    3、数据变换

    • 哑变量处理:pandas.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False)
    • 数据离散化:pandas.cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False)

    4、数据标准化

    • 标准差标准化:sklearn.preprocessing.StandardScaler
    • 离差标准化: sklearn.preprocessing.MinMaxScaler

    三、模型构建

    1、训练集测试集划分

    sklearn.model_selection.train_test_split(*arrays, **options)

    2、 降维

    class sklearn.decomposition.PCA(n_components=None, copy=True, whiten=False, svd_solver=’auto’, tol=0.0, iterated_power=’auto’, random_state=None)

    3、交叉验证

    sklearn.model_selection.cross_validate(estimator, X, y=None, groups=None, scoring=None, cv=None, n_jobs=1, verbose=0, fit_params=None, pre_dispatch=‘2*n_jobs’, return_train_score=’warn’)

    4、模型训练与预测

    • 有监督模型
    
    clf = lr.fit(X_train, y_train)
    clf.predict(X_test)

    5、聚类

    常用算法:

    • K均值:class sklearn.cluster.KMeans(n_clusters=8, init=’k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=’auto’, verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm=’auto’)
    • DBSCAN密度聚类:class sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=’euclidean’, metric_params=None, algorithm=’auto’, leaf_size=30, p=None, n_jobs=1)
    • Birch层次聚类:class sklearn.cluster.Birch(threshold=0.5, branching_factor=50, n_clusters=3, compute_labels=True, copy=True)

    评价:

    • 轮廓系数:sklearn.metrics.silhouette_score(X, labels, metric=’euclidean’, sample_size=None, random_state=None, **kwds)
    • calinski_harabaz_score:sklearn.metrics.calinski_harabaz_score(X, labels)
    • completeness_score:sklearn.metrics.completeness_score(labels_true, labels_pred)
    • fowlkes_mallows_score:sklearn.metrics.fowlkes_mallows_score(labels_true, labels_pred, sparse=False)
    • homogeneity_completeness_v_measure:sklearn.metrics.homogeneity_completeness_v_measure(labels_true, labels_pred)
    • adjusted_rand_score:sklearn.metrics.adjusted_rand_score(labels_true, labels_pred)
    • homogeneity_score:sklearn.metrics.homogeneity_score(labels_true, labels_pred)
    • mutual_info_score:sklearn.metrics.mutual_info_score(labels_true, labels_pred, contingency=None)
    • normalized_mutual_info_score:sklearn.metrics.normalized_mutual_info_score(labels_true, labels_pred)
    • v_measure_score:sklearn.metrics.v_measure_score(labels_true, labels_pred)

    注:后续含labels_true参数的均需真实值参与

    6、分类

    常用算法

    • Adaboost分类:class sklearn.ensemble.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm=’SAMME.R’, random_state=None)
    • 梯度提升树分类:class sklearn.ensemble.GradientBoostingClassifier(loss=’deviance’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, min_impurity_split=None, init=None, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)
    • 随机森林分类:class sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=’gini’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=1, random_state=None, verbose=0, warm_start=False, class_weight=None)
    • 高斯过程分类:class sklearn.gaussian_process.GaussianProcessClassifier(kernel=None, optimizer=’fmin_l_bfgs_b’, n_restarts_optimizer=0, max_iter_predict=100, warm_start=False, copy_X_train=True, random_state=None, multi_class=’one_vs_rest’, n_jobs=1)
    • 逻辑回归:class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, verbose=0, warm_start=False, n_jobs=1)
    • KNN:class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)
    • 多层感知神经网络:class sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(100, ), activation=’relu’, solver=’adam’, alpha=0.0001, batch_size=’auto’, learning_rate=’constant’, learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
    • SVM:class sklearn.svm.SVC(C=1.0, kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape=’ovr’, random_state=None)
    • 决策树:class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, class_weight=None, presort=False)

    评价:

    • 准确率:sklearn.metrics.accuracy_score(y_true, y_pred, normalize=True, sample_weight=None)
    • AUC:sklearn.metrics.auc(x, y, reorder=False)
    • 分类报告:sklearn.metrics.classification_report(y_true, y_pred, labels=None, target_names=None, sample_weight=None, digits=2)
    • 混淆矩阵:sklearn.metrics.confusion_matrix(y_true, y_pred, labels=None, sample_weight=None)
    • kappa:sklearn.metrics.cohen_kappa_score(y1, y2, labels=None, weights=None, sample_weight=None)
    • F1值:sklearn.metrics.f1_score(y_true, y_pred, labels=None, pos_label=1, average=’binary’, sample_weight=None)
    • 精确率:sklearn.metrics.precision_score(y_true, y_pred, labels=None, pos_label=1, average=’binary’, sample_weight=None)
    • 召回率:sklearn.metrics.recall_score(y_true, y_pred, labels=None, pos_label=1, average=’binary’, sample_weight=None)
    • ROC:sklearn.metrics.roc_curve(y_true, y_score, pos_label=None, sample_weight=None, drop_intermediate=True)

    7、回归

    常用算法:

    • Adaboost回归:class sklearn.ensemble.AdaBoostRegressor(base_estimator=None, n_estimators=50, learning_rate=1.0, loss=’linear’, random_state=None)
    • 梯度提升树回归:class sklearn.ensemble.GradientBoostingRegressor(loss=’ls’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, min_impurity_split=None, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)
    • 随机森林回归:class sklearn.ensemble.RandomForestRegressor(n_estimators=10, criterion=’mse’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=1, random_state=None, verbose=0, warm_start=False)
    • 高斯过程回归:class sklearn.gaussian_process.GaussianProcessRegressor(kernel=None, alpha=1e-10, optimizer=’fmin_l_bfgs_b’, n_restarts_optimizer=0, normalize_y=False, copy_X_train=True, random_state=None)
    • 保序回归:class sklearn.isotonic.IsotonicRegression(y_min=None, y_max=None, increasing=True, out_of_bounds=’nan’)
    • Lasso回归:class sklearn.linear_model.Lasso(alpha=1.0, fit_intercept=True, normalize=False, precompute=False, copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, positive=False, random_state=None, selection=’cyclic’)
    • 线性回归:class sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)
    • 岭回归: class sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None)
    • KNN回归:class sklearn.neighbors.KNeighborsRegressor(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)
    • 多层感知神经网络回归:class sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(100, ), activation=’relu’, solver=’adam’, alpha=0.0001, batch_size=’auto’, learning_rate=’constant’, learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
    • SVM回归:class sklearn.svm.SVR(kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, tol=0.001, C=1.0, epsilon=0.1, shrinking=True, cache_size=200, verbose=False, max_iter=-1)
    • 决策树回归:class sklearn.tree.DecisionTreeRegressor(criterion=’mse’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, presort=False)

    评价:

    • 可解释方差值:sklearn.metrics.explained_variance_score(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)
    • 平均绝对误差:sklearn.metrics.mean_absolute_error(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)[source]
    • 均方误差:sklearn.metrics.mean_squared_error(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)
    • 均方对数误差:sklearn.metrics.mean_squared_log_error(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)
    • 中值绝对误差:sklearn.metrics.median_absolute_error(y_true, y_pred)
    • R²值:sklearn.metrics.r2_score(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)

    八、demo

    
     from sklearn import neighbors, datasets, preprocessing
     from sklearn.cross_validation import train_test_split
     from sklearn.metrics import accuracy_score
     iris = datasets.load_iris()
     X, y = iris.data, iris.target
     X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33)
     scaler = preprocessing.StandardScaler().fit(X_train)
     X_train = scaler.transform(X_train)
     X_test = scaler.transform(X_test)
     knn = neighbors.KNeighborsClassifier(n_neighbors=5)
     knn.fit(X_train, y_train)
     y_pred = knn.predict(X_test)
     accuracy_score(y_test, y_pred)

    四、绘图

    1、创建画布或子图

    函数名称函数作用
    plt.figure创建一个空白画布,可以指定画布大小,像素。
    figure.add_subplot创建并选中子图,可以指定子图的行数,列数,与选中图片编号。

    2、绘制

    函数名称函数作用
    plt.title在当前图形中添加标题,可以指定标题的名称,位置,颜色,字体大小等参数。
    plt.xlabel在当前图形中添加x轴名称,可以指定位置,颜色,字体大小等参数。
    plt.ylabel在当前图形中添加y轴名称,可以指定位置,颜色,字体大小等参数。
    plt.xlim指定当前图形x轴的范围,只能确定一个数值区间,而无法使用字符串标识。
    plt.ylim指定当前图形y轴的范围,只能确定一个数值区间,而无法使用字符串标识。
    plt.xticks指定x轴刻度的数目与取值
    plt.yticks指定y轴刻度的数目与取值
    plt.legend指定当前图形的图例,可以指定图例的大小,位置,标签。

    3、中文

    
    plt.rcParams['font.sans-serif'] = 'SimHei' ##设置字体为SimHei显示中文
    plt.rcParams['axes.unicode_minus'] = False ##设置正常显示符号

    4、不同图形

    • 散点图:matplotlib.pyplot.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, hold=None, data=None,**kwargs)
    • 折线图: matplotlib.pyplot.plot(*args, **kwargs)
    • 直方图:matplotlib.pyplot.bar(left,height,width = 0.8,bottom = None,hold = None,data = None,** kwargs )
    • 饼图:matplotlib.pyplot.pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, hold=None, data=None)
    • 箱线图:matplotlib.pyplot.boxplot(x, notch=None, sym=None, vert=None, whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_xticks=True, autorange=False, zorder=None, hold=None, data=None)

    5、Demo

    
    import numpy as np
    import matplotlib.pyplot as plt
    
    box = dict(facecolor='yellow', pad=5, alpha=0.2)
    
    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
    fig.subplots_adjust(left=0.2, wspace=0.6)
    
    # Fixing random state for reproducibility
    np.random.seed(19680801)
    
    ax1.plot(2000*np.random.rand(10))
    ax1.set_title('ylabels not aligned')
    ax1.set_ylabel('misaligned 1', bbox=box)
    ax1.set_ylim(0, 2000)
    
    ax3.set_ylabel('misaligned 2',bbox=box)
    ax3.plot(np.random.rand(10))
    
    labelx = -0.3  # axes coords
    
    ax2.set_title('ylabels aligned')
    ax2.plot(2000*np.random.rand(10))
    ax2.set_ylabel('aligned 1', bbox=box)
    ax2.yaxis.set_label_coords(labelx, 0.5)
    ax2.set_ylim(0, 2000)
    
    ax4.plot(np.random.rand(10))
    ax4.set_ylabel('aligned 2', bbox=box)
    ax4.yaxis.set_label_coords(labelx, 0.5)
    
    plt.show()

    五、完整Demo

    
    import numpy as np
    import pandas as pd
    airline_data = pd.read_csv("../data/air_data.csv",
        encoding="gb18030") #导入航空数据
    print('原始数据的形状为:',airline_data.shape)
    
    ## 去除票价为空的记录
    exp1 = airline_data["SUM_YR_1"].notnull()
    exp2 = airline_data["SUM_YR_2"].notnull()
    exp = exp1 & exp2
    airline_notnull = airline_data.loc[exp,:]
    print('删除缺失记录后数据的形状为:',airline_notnull.shape)
    
    #只保留票价非零的,或者平均折扣率不为0且总飞行公里数大于0的记录。
    index1 = airline_notnull['SUM_YR_1'] != 0
    index2 = airline_notnull['SUM_YR_2'] != 0
    index3 = (airline_notnull['SEG_KM_SUM']> 0) & \
        (airline_notnull['avg_discount'] != 0)  
    airline = airline_notnull[(index1 | index2) & index3]
    print('删除异常记录后数据的形状为:',airline.shape)
    
    airline_selection = airline[["FFP_DATE","LOAD_TIME",
        "FLIGHT_COUNT","LAST_TO_END",
        "avg_discount","SEG_KM_SUM"]]
    ## 构建L特征
    L = pd.to_datetime(airline_selection["LOAD_TIME"]) - \
    pd.to_datetime(airline_selection["FFP_DATE"])
    L = L.astype("str").str.split().str[0]
    L = L.astype("int")/30
    ## 合并特征
    airline_features = pd.concat([L,
        airline_selection.iloc[:,2:]],axis = 1)
    print('构建的LRFMC特征前5行为:\n',airline_features.head())
    
    from sklearn.preprocessing import StandardScaler
    data = StandardScaler().fit_transform(airline_features)
    np.savez('../tmp/airline_scale.npz',data)
    print('标准化后LRFMC五个特征为:\n',data[:5,:])
    
    from sklearn.cluster import KMeans #导入kmeans算法
    airline_scale = np.load('../tmp/airline_scale.npz')['arr_0']
    k = 5 ## 确定聚类中心数
    
    #构建模型
    kmeans_model = KMeans(n_clusters = k,n_jobs=4,random_state=123)
    fit_kmeans = kmeans_model.fit(airline_scale)   #模型训练
    kmeans_model.cluster_centers_ #查看聚类中心
    
    kmeans_model.labels_ #查看样本的类别标签
    
    #统计不同类别样本的数目
    r1 = pd.Series(kmeans_model.labels_).value_counts()
    print('最终每个类别的数目为:\n',r1)
    
    #绘制直方图矩阵
    center = kmeans_model.cluster_centers_ 
    names = ['入会时长','最近乘坐过本公司航班','乘坐次数','里程','平均折扣率']
    import matplotlib.pyplot as plt
    %matplotlib inline
    ax = plt.figure(figsize=(8,8))
    for i in range(k):
        ax1 = ax.add_subplot(k,1,i+1)
        plt.bar(range(5),center[:,i],width = 0.5)
        plt.xlabel('类别')
        plt.ylabel(names[i])
    plt.savefig('聚类分析柱形图.png')
    plt.show()
    
    #绘制雷达图
    fig = plt.figure(figsize=(8,8))
    ax = fig.add_subplot(111, polar=True)# polar参数
    angles = np.linspace(0, 2*np.pi, k, endpoint=False)
    angles = np.concatenate((angles, [angles[0]])) # 闭合
    Linecolor = ['bo-','r+:','gD--','yv-.','kp-'] #点线颜色
    Fillcolor = ['b','r','g','y','k']
    for i in range(k):
        data = np.concatenate((center[i], [center[i][0]])) # 闭合
        ax.plot(angles,data,Linecolor[i], linewidth=2)# 画线
        ax.fill(angles, data, facecolor=Fillcolor[i], alpha=0.25)# 填充
    ax.set_thetagrids(angles * 180/np.pi, names)
    ax.set_title("客户分群雷达图", va='bottom')## 设定标题
    ax.set_rlim(-1,3)## 设置各指标的最终范围
    ax.grid(True)
    展开全文
  • '../tmp/airline_scale.npz' , data ) print ( '标准化后LRFMC五个属性为:\n' , data [ : 5 , : ] ) 筛选的属性前5行为: FFP_DATE LOAD_TIME LAST_TO_END FLIGHT_COUNT SEG_KM_SUM avg_discount 0 2006/...
  • 航空公司客户价值分析(python)

    千次阅读 2021-07-13 20:46:03
    #保存处理好的数据 print('标准化后LRFMC五个特征为:\n',data[:5,:]) 3、使用K-Means算法进行客户分群 airline_scale = np.load('../dates/airline_scale.npz')['arr_0'] k = 5 ## 确定聚类中心数 #构建模型 kmeans...
  • data │ │ │ air_data.csv │ │ │ │ │ └─tmp │ │ airline_scale.npz │ │ │ └─训数据 │ credit_card.csv │ ├─第8章 │ ├─习题程序 │ │ │ 第8章选择题答案.txt │ │ │ │ │ ├─code │ │...
  • numpy.savez的使用方法

    万次阅读 2018-07-13 16:19:29
    np.savez('bottleneck_features/DogResnet50Data.npz',train=train_Resnet50,valid=valid_Resnet50,test=test_Resnet50)   bottleneck_features = np.load('bottleneck_features/DogResnet50Data.npz') ...
  • 第1章 python数据分析的概述 由于数据量比较大,已经远远超过了人力所能处理的范畴。那么管理和使用这些数据,就成为一个全新的研究课题 1.1 认识数据分析 数据分析技能,成为数据从业人员需要具备的技能之一。...
  • airline_scale = np.load('airline_scale.npz')['arr_0'] k = 5 ## 确定聚类中心数 #构建模型 kmeans_model = KMeans(n_clusters = k) fit_kmeans = kmeans_model.fit(airline_scale) #模型训练 #kmeans_model....
  • numpy数据集练习(运用jupyter notebook) 1. 导入scipy,numpy,sklearn包 import scipy#加载scipy包 import numpy#加载numpy包 from sklearn.datasets import load_iris #加载sklearn包 ...2. 从sklearn包自带的...
  • 3.4 任务实现 导入包 from sklearn.cluster import KMeans #导入kmeans算法 k = 5 #确认聚类中心数 # airline_scale = np.load('./airline_scale.npz')['arr_0'] # 构建模型 kmeans_model = KMeans(n_clusters = k,...
  • 在Jupyter notebook 中如何加载数据集

    千次阅读 2020-06-04 21:44:48
    首先打开Jupyter notebook,显示的页面如下: 需要注意的是,Jupyter notebook只能打开当前目录下的数据集,简单粗暴的方法就是直接把数据集拷贝到Jupyter notebook的目录下,比如,我们把我们需要的数据集放到...
  • Python-航空公司客户价值分析

    千次阅读 2020-12-19 17:10:31
    airline_scale = np.load(' ../data /airline_scale.npz')['arr_0'] k = 5 ## 确定聚类中心数 #构建模型 kmeans_model = KMeans(n_clusters = k,n_jobs=4,random_state=123) fit_kmeans = kmeans_model.fit...
  • scale.npz │ └── 训数据 │ └── credit_card.csv ├── 第8章 │ ├── 习题程序 │ │ ├── code │ │ │ └── 第8章操作题.py │ │ ├── data │ │ │ └── data.csv │ │ └...
  • '../tmp/airline_scale.npz' , data ) print ( ' 标准化后 LRFMC 五个特征为: \n' , data [ : 5 , : ] ) Out [ 4 ] : 标准化后 LRFMC 五个特征为: [ [ 1.43571897 14.03412875 - 0.94495516 1....
  • # 去除票价为空的记录 airline_notnull = airline_data.loc[airline_data['SUM_YR_1'].notnull() & airline_data['SUM_YR_2'].notnull(),:] print('删除缺失记录后数据的形状为:',airline_notnull.shape) # 只保留...
  • 第一次写博客,估计会很乱!! File "c:\programdata\anaconda3\lib\site-packages\IPython\utils\io.py", line 88, in &lt;module&gt; devnull = open(os.devnull, 'w')FileNotFoundError: ...
  • StandardScaler().fit_transform(airline_features) np.savez('../tmp/airline_scale.npz',data) print('标准化后LRFMC五个属性为:\n',data[:5,:]) *代码详见:demo/code/zscore_data.py。 标准差标准化处理后,...
  • means算法 airline_scale = np.load('D:\\myData\\code\\python\\data\\airline_scale.npz')['arr_0'] k =5 #确定聚类中心数 #构造模型 kmeans_model = KMeans(n_clusters = k,n_jobs=4,random_state=123) fit_...
  • 第七章

    2019-11-04 18:39:26
    #课本例题 import numpy as np ...airline_data=pd.read_csv(“C:\data\air_data.csv”,encoding=‘gb18030’) print(airline_data.shape) exp1=airline_data[‘SUM_YR_1’].notnull() exp2=airline_data[‘SU...
  • 使用K-Means算法进行客户分群 import numpy as np import pandas as pd from sklearn.cluster import KMeans #导入kmeans算法 airline_scale = np.load('./tmp/airline_scale.npz')['arr_0'] k = 5 ## 确定聚类中心...
  • 航空公司客户价值分析完整版

    千次阅读 2021-07-15 19:15:02
    ---->标准差标准化数据 #对数据做标准化处理 from sklearn.preprocessing import StandardScaler data = StandardScaler().fit_transform(airline_features) np.savez('../datas/airline_scale_test1.npz',...
  • # 标准差标准化数据 from sklearn.preprocessing import StandardScaler data = StandardScaler().fit_transform(airline_features) np.savez('tmp/airline_scale.npz',data) print('标准化后 LRFMC 模型的5个特征...
  • Python学习6之简单实战

    2020-10-18 12:10:32
    airline_scale = np.load('airline_scale.npz')['arr_0'] k = 5 ## 确定聚类中心数 #构建模型 kmeans_model = KMeans(n_clusters = k,n_jobs=4,random_state=123) fit_kmeans = kmeans_model.fit(airline_scale) #...
  • 代码清单1 K-meas聚类标准化后的数据 import pandas as pd import numpy as np from sklearn.cluster import KMeans # 导入kmeans算法 # 读取标准化后的数据 airline_scale = np.load('../tmp/airline_scale.npz'...

空空如也

空空如也

1 2 3
收藏数 60
精华内容 24
关键字:

airline_scale.npz

友情链接: MB_Slave().rar