机器学习基础

目录

• 机器学习开发流程
  • 一、特征工程
    • 1.数据获取
      • 以鸢尾花为例
    • 2.特征抽取
      • 字典特征提取
      • 文本特征提取
        • 普通文本特征提取
        • jieba分词
        • TF-IDF重要程度
    • 3.特征编码
    • 4.特征预处理
      • 归一化
      • 标准化
    • 5.特征降维
  • 二、分类算法
    • KNN算法
      • knn算法实现
      • 模型选择与调优
      • 案例:facebook签到位置
    • 朴素贝叶斯
    • 决策树
  • 三、回归算法
    • 逻辑回归(二分类问题)
    • 线性回归

机器学习开发流程

机器学习开发流程
    1）获取数据
    2）数据处理
    3）特征工程
    4）机器学习算法训练 - 模型
    5）模型评估
    6）应用
    
  学习框架和资料介绍
        1）算法是核心，数据与计算是基础
        2）找准定位
        3）怎么做？
            1、入门
            2、实战类书籍
            3、机器学习 -”西瓜书”- 周志华
               统计学习方法 - 李航
               深度学习 - “花书”
      机器学习库与框架

一、特征工程

1.数据获取

数据集
	来源: 公司内部 / 数据接口 / 学习数据集(sklearn kaggle 等)
	
	sklearn数据集获取:
		sklearn.datasets
			load_* 获取小规模数据集
			fetch_* 获取大规模数集
			
			
	

以鸢尾花为例

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
def datasets_demo():
    """
    sklearn数据集使用
    :return:
    """
    # 获取数据集
    iris = load_iris()
    print("鸢尾花数据集：\n", iris)
    print("查看数据集描述：\n", iris["DESCR"])
    print("查看特征值的名字：\n", iris.feature_names)
    print("查看特征值：\n", iris.data, iris.data.shape)

    # 数据集划分
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
    print("训练集的特征值：\n", x_train, x_train.shape)

    return None

2.特征抽取

sklearn特征工程 
	pandas数据清洗、数据处理
	特征抽取/特征提取 
		机器学习算法 - 统计方法 - 数据公式
		文本类型 -> 数值
		类型 -> 数值

字典特征提取

 vector 数学：向量 物理：矢量
         矩阵 matrix 二维数组
         向量 vector 一维数组
     父类：转换器类
     返回sparse矩阵
         sparse稀疏
             将非零值 按位置表示出来
             节省内存 - 提高加载效率
     应用场景：
         （1）pclass, sex 数据集当中类别特征比较多
              1、将数据集的特征-》字典类型
              2、DictVectorizer转换
         2）本身拿到的数据就是字典类型

from sklearn.feature_extraction import DictVectorizer
def dict_demo():
    """
    字典特征抽取
    :return:
    """
    data = [{'city': '北京','temperature':100}, {'city': '上海','temperature':60}, {'city': '深圳','temperature':30}]
    # 1、实例化一个转换器类
    transfer = DictVectorizer(sparse=True)

    # 2、调用fit_transform()
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new.toarray(), type(data_new))
    print("特征名字：\n", transfer.get_feature_names())

文本特征提取

 单词 作为 特征
    句子、短语、单词、字母
    特征：特征词
    方法1：CountVectorizer
         统计每个样本特征词出现的个数
         stop_words停用的
         停用词表
         关键词：在某一个类别的文章中，出现的次数很多，但是在其他类别的文章当中出现很少
    方法2：TfidfVectorizer
          TF-IDF - 重要程度    IDF - 逆向文档频率     TF - 词频（term frequency，tf)
          两个词 “经济”，“非常”
          1000篇文章-语料库     100篇文章 - "非常"    10篇文章 - “经济”
          两篇文章
                  文章A(100词) : 10次“经济” TF-IDF:0.2     tf:10/100 = 0.1   idf:lg 1000/10 = 2
                  文章B(100词) : 10次“非常” TF-IDF:0.1     tf:10/100 = 0.1   idf: log 10 1000/100 = 1
                                对数？ 2 ^ 3 = 8       log 2 8 = 3       log 10 10 = 1

普通文本特征提取

from sklearn.feature_extraction.text import CountVectorizer


def count_demo():
    """
    文本特征抽取：CountVecotrizer
    :return:
    """
    data = ["life is short,i like like python", "life is too long,i dislike python"]
    # 1、实例化一个转换器类
    transfer = CountVectorizer(stop_words=["is", "too"])

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new.toarray())
    print("特征名字：\n", transfer.get_feature_names())

    return None

def count_chinese_demo():
    """
    中文文本特征抽取：CountVecotrizer
    :return:
    """
    data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
    # 1、实例化一个转换器类
    transfer = CountVectorizer()

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new.toarray())
    print("特征名字：\n", transfer.get_feature_names())

    return None

jieba分词

from sklearn.feature_extraction.text import CountVectorizer
import jieba
def cut_word(text):
    """
    进行中文分词："我爱北京天安门" --> "我 爱 北京 天安门"
    :param text:
    :return:
    """
    return " ".join(list(jieba.cut(text)))



def count_chinese_demo2():
    """
    中文文本特征抽取，自动分词
    :return:
    """
    # 将中文文本进行分词
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]

    data_new = []
    for sent in data:
        data_new.append(cut_word(sent))
    # print(data_new)
    # 1、实例化一个转换器类
    transfer = CountVectorizer(stop_words=["一种", "所以"])

    # 2、调用fit_transform
    data_final = transfer.fit_transform(data_new)
    print("data_new:\n", data_final.toarray())
    print("特征名字：\n", transfer.get_feature_names())

    return None

TF-IDF重要程度

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
import jieba
def tfidf_demo():
    """
    用TF-IDF的方法进行文本特征抽取
    :return:
    """
    # 将中文文本进行分词
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]

    data_new = []
    for sent in data:
        data_new.append(cut_word(sent))
    # print(data_new)
    # 1、实例化一个转换器类
    transfer = TfidfVectorizer(stop_words=["一种", "所以"])

    # 2、调用fit_transform
    data_final = transfer.fit_transform(data_new)
    print("data_new:\n", data_final.toarray())
    print("特征名字：\n", transfer.get_feature_names())

    return None

3.特征编码

from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# 假设我们有一个包含类别特征的简单数据集
data = [['Male', 'First'],
        ['Female', 'Second'],
        ['Female', 'Third'],
        ['Male', 'First']]

# 1. 使用OneHotEncoder进行独热编码
# 将数据转换为numpy数组，因为OneHotEncoder需要二维数组
data_np = np.array(data)

# 创建OneHotEncoder对象，并指定需要转换的列
encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
encoded_data = encoder.fit_transform(data_np)

# 打印编码后的数据
print("独热编码后的数据:")
print(encoded_data)

# 打印类别特征对应的列名
print("独热编码的列名:")
print(encoder.get_feature_names_out())

# 2. 使用LabelEncoder进行标签编码
# 对于单列数据，我们可以使用LabelEncoder进行标签编码
label_encoder = LabelEncoder()
encoded_labels = label_encoder.fit_transform(data_np[:, 0])

# 打印标签编码后的数据
print("标签编码后的性别数据:")
print(encoded_labels)

# 打印原始类别和编码后的标签的对应关系
print("性别类别与编码标签的对应关系:")
print(dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_))))

4.特征预处理

无量纲化 - 减小数据之间的误差，比如 A、B 列   A 是尺寸  100   B 是 数量 10000  训练时不统一处理，会导致数据倾斜问题  
    归一化 (x - min) / (max - min)
        异常值：最大值、最小值
    标准化
        (x - mean) / std
        标准差：集中程度
        应用场景：
        在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

归一化

from sklearn.preprocessing import MinMaxScaler, StandardScaler
def minmax_demo():
    """
    归一化
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("dating.txt")
    data = data.iloc[:, :3]
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = MinMaxScaler(feature_range=[2, 3])

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)

    return None

标准化

from sklearn.preprocessing import MinMaxScaler, StandardScaler
def minmax_demo():
    """
    归一化
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("dating.txt")
    data = data.iloc[:, :3]
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = MinMaxScaler(feature_range=[2, 3])

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)

    return None


def stand_demo():
    """
    标准化
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("dating.txt")
    data = data.iloc[:, :3]
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = StandardScaler()

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    return None

5.特征降维

特征降维 - 降低维度 / 减少消耗 / 最大程度保留
		方法:
        	Filter过滤式:
                	 方差选择法：低方差特征过滤
                                相关系数 - 特征与特征之间的相关程度
                                    取值范围：–1≤ r ≤+1
                                    皮尔逊相关系数  0.9942
                                    特征与特征之间相关性很高：
                                        1）选取其中一个
                                        2）加权求和
                                        3）主成分分析
           主成分分析(pca)
           			 sklearn.decomposition.PCA(n_components=None)
                      n_components
                      小数 表示保留百分之多少的信息
                      整数 减少到多少特征

from sklearn.feature_selection import VarianceThreshold
from sklearn.decomposition import PCA
from scipy.stats import pearsonr
import pandas as pd
def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("factor_returns.csv")
    data = data.iloc[:, 1:-2]
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = VarianceThreshold(threshold=10)

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new, data_new.shape)

    # 计算某两个变量之间的相关系数
    r1 = pearsonr(data["pe_ratio"], data["pb_ratio"])
    print("相关系数：\n", r1)
    r2 = pearsonr(data['revenue'], data['total_expense'])
    print("revenue与total_expense之间的相关性：\n", r2)

    return None


def pca_demo():
    """
    PCA降维
    :return:
    """
    data = [[2,8,4,5], [6,3,0,8], [5,4,9,1]]

    # 1、实例化一个转换器类
    transfer = PCA(n_components=0.95)

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    return None

二、分类算法

有监督学习  特征值  -> 目标值
目标值：类别
        1、sklearn转换器和预估器
        	3.1 sklearn转换器和估计器
            转换器(Transformer)
            估计器(estimator)
            转换器 - 特征工程的父类
                实例化 (实例化的是一个转换器类(Transformer))
                调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)
                标准化：
                    (x - mean) / std
                    fit_transform()
                        fit()           计算 每一列的平均值、标准差
                        transform()     (x - mean) / std进行最终的转换
           估计器(sklearn机器学习算法的实现)
                估计器(estimator)
                    1 实例化一个estimator
                    2 estimator.fit(x_train, y_train) 计算
                        —— 调用完毕，模型生成
                    3 模型评估：
                        1）直接比对真实值和预测值
                            y_predict = estimator.predict(x_test)
                            y_test == y_predict
                        2）计算准确率
                            accuracy = estimator.score(x_test, y_test)
        2、KNN算法
        3、模型选择与调优
        4、朴素贝叶斯算法
        5、决策树
        6、随机森林

KNN算法

K-近邻算法
	根据你的"邻居"来判断你的类别
	计算距离:
		欧式距离   (x1 - x2)^2 + (y1 - y2)^2  + (z1 - z2)^2 
		曼哈顿距离 绝对值
		明可夫斯基距离
	处理；
		 无钢量化 - 标准化
	优点：简单，易于理解，易于实现，无需训练
    缺点：
           1）必须指定K值，K值选择不当则分类精度不能保证
           2）懒惰算法，对测试样本分类时的计算量大，内存开销大
         使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试

knn算法实现

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

def knn_iris():
    """
    用KNN算法对鸢尾花进行分类
    :return:
    """
    # 1）获取数据
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)

    # 3）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)

    # 5）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

    return None

模型选择与调优

 模型选择与调优
     1 什么是交叉验证(cross validation)
     2 超参数搜索-网格搜索(Grid Search)

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
def knn_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    :return:
    """
    # 1）获取数据
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)

    # 3）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）KNN算法预估器
    estimator = KNeighborsClassifier()

    # 加入网格搜索与交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)

    # 5）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

    # 最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    # 最佳估计器：best_estimator_
    print("最佳估计器:\n", estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果:\n", estimator.cv_results_)

案例:facebook签到位置

import pandas as pd
def facebook_demo():
    # 1、获取数据
    data = pd.read_csv("./FBlocation/train.csv")
    
    # 2、基本的数据处理
    # 1）缩小数据范围
    data = data.query("x < 2.5 & x > 2 & y < 1.5 & y > 1.0")	
    
    # 2）处理时间特征
    time_value = pd.to_datetime(data["time"], unit="s")
    date = pd.DatetimeIndex(time_value)
    data.loc["day",:] = date.day
    data.loc["weekday",:] = date.weekday
    data.loc["hour",:] = date.hour
    
    # 3）过滤签到次数少的地点
    place_count = data.groupby("place_id").count()["row_id"]
    data.groupby("place_id").count().head()
    place_count[place_count > 3].head()
    data_final = data[data["place_id"].isin(place_count[place_count > 3].index.values)]
    data_final.head()
    
    # 筛选特征值和目标值
    x = data_final[["x", "y", "accuracy", "day", "weekday", "hour"]]
    x.head()
    y = data_final["place_id"]	
    y.head()
    
    # 数据集划分
    from sklearn.model_selection import train_test_split
    x_train, x_test, y_train, y_test = train_test_split(x, y)
    
    from sklearn.preprocessing import StandardScaler
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.model_selection import GridSearchCV
    
    # 3.特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
	
    # 4.KNN算法预估器
    estimator = KNeighborsClassifier()

    # 加入网格搜索与交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [3, 5, 7, 9]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

    # 最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    # 最佳估计器：best_estimator_
    print("最佳估计器:\n", estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果:\n", estimator.cv_results_)

朴素贝叶斯

什么是朴素贝叶斯分类方法
    概率基础
        1 概率(Probability)定义
        3.4.3 联合概率、条件概率与相互独立
            联合概率：包含多个条件，且所有条件同时成立的概率
            P(程序员, 匀称) P(程序员, 超重|喜欢)
            P(A, B)
            条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
            P(程序员|喜欢) P(程序员, 超重|喜欢)
            P(A|B)
            相互独立:
                P(A, B) = P(A)P(B) <=> 事件A与事件B相互独立
        朴素？ 假设：特征与特征之间是相互独立
        朴素贝叶斯算法：朴素 + 贝叶斯
        应用场景：文本分类   单词作为特征   拉普拉斯平滑系数P(F1|C) = (Ni + α) / (N + αm)
        
   优点：
         对缺失数据不太敏感，算法也比较简单，常用于文本分类。
         分类准确度高，速度快
   缺点：
        由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    # 1）获取数据
    news = fetch_20newsgroups(subset="all")

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)

    # 3）特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)

    # 5）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

决策树

 决策树
    1 认识决策树
        如何高效的进行决策？
            特征的先后顺序
    2 决策树分类原理详解
        已知 四个特征值 预测 是否贷款给某个人
        先看房子，再工作 -> 是否贷款 只看了两个特征
        年龄，信贷情况，工作 看了三个特征
    3.信息论基础
        1）信息
            香农：消除随机不定性的东西
            小明 年龄 “我今年18岁” - 信息
            小华 ”小明明年19岁” - 不是信息
        2）信息的衡量 - 信息量 - 信息熵
            bit
            g(D,A) = H(D) - 条件熵H(D|A)
    4 决策树的划分依据之一------信息增益
        没有免费的午餐
   5 决策树可视化
   6 决策树总结
        优点：
            可视化 - 可解释能力强
        缺点：
            容易产生过拟合 - 剪枝
   案例：泰坦尼克号乘客生存预测

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_graphviz
def decision_iris():
    """
    用决策树对鸢尾花进行分类
    :return:
    """
    # 1）获取数据集
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)

    # 3）决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy")
    estimator.fit(x_train, y_train)

    # 4）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

    # 可视化决策树
    export_graphviz(estimator, out_file="iris_tree.dot", feature_names=iris.feature_names)

    return None

三、回归算法

逻辑回归(二分类问题)

import pandas as pd
import numpy as np
def logic_demo():
    # 1、读取数据
    path = "https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data"
    column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',
                       'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',
                       'Normal Nucleoli', 'Mitoses', 'Class']

    data = pd.read_csv(path, names=column_name)

    # 2、缺失值处理
    # 1）替换-》np.nan
    data = data.replace(to_replace="?", value=np.nan)
    # 2）删除缺失样本
    data.dropna(inplace=True)

    # 3、划分数据集
    from sklearn.model_selection import train_test_split

    # 筛选特征值和目标值
    x = data.iloc[:, 1:-1]
    y = data["Class"]

    x_train, x_test, y_train, y_test = train_test_split(x, y)

    # 4、标准化
    from sklearn.preprocessing import StandardScaler
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 5、预估器流程
    from sklearn.linear_model import LogisticRegression
    estimator = LogisticRegression()
    estimator.fit(x_train, y_train)

    # 逻辑回归的模型参数：回归系数和偏置
    print(estimator.coef_)
    print(estimator.intercept_)

    # 6、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)

    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)

    # 查看精确率、召回率、F1-score
    from sklearn.metrics import classification_report

    report = classification_report(y_test, y_predict, labels=[2, 4], target_names=["良性", "恶性"])
    print(report)

    # y_true：每个样本的真实类别，必须为0(反例),1(正例)标记
    # 将y_test 转换成 0 1
    y_true = np.where(y_test > 3, 1, 0)

    from sklearn.metrics import roc_auc_score
    roc_auc_score(y_true, y_predict)

线性回归

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge
from sklearn.metrics import mean_squared_error
from sklearn.externals import joblib


def linear1():
    """
    正规方程的优化方法对波士顿房价进行预测
    :return:
    """
    # 1）获取数据
    boston = load_boston()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)

    # 3）标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）预估器
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    # 5）得出模型
    print("正规方程-权重系数为：\n", estimator.coef_)
    print("正规方程-偏置为：\n", estimator.intercept_)

    # 6）模型评估
    y_predict = estimator.predict(x_test)
    print("预测房价：\n", y_predict)
    error = mean_squared_error(y_test, y_predict)
    print("正规方程-均方误差为：\n", error)

    return None


def linear2():
    """
    梯度下降的优化方法对波士顿房价进行预测
    :return:
    """
    # 1）获取数据
    boston = load_boston()
    print("特征数量：\n", boston.data.shape)

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)

    # 3）标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）预估器
    estimator = SGDRegressor(learning_rate="constant", eta0=0.01, max_iter=10000, penalty="l1")
    estimator.fit(x_train, y_train)

    # 5）得出模型
    print("梯度下降-权重系数为：\n", estimator.coef_)
    print("梯度下降-偏置为：\n", estimator.intercept_)

    # 6）模型评估
    y_predict = estimator.predict(x_test)
    print("预测房价：\n", y_predict)
    error = mean_squared_error(y_test, y_predict)
    print("梯度下降-均方误差为：\n", error)

    return None


def linear3():
    """
    岭回归对波士顿房价进行预测
    :return:
    """
    # 1）获取数据
    boston = load_boston()
    print("特征数量：\n", boston.data.shape)

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)

    # 3）标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）预估器
    # estimator = Ridge(alpha=0.5, max_iter=10000)
    # estimator.fit(x_train, y_train)

    # 保存模型
    # joblib.dump(estimator, "my_ridge.pkl")
    # 加载模型
    estimator = joblib.load("my_ridge.pkl")

    # 5）得出模型
    print("岭回归-权重系数为：\n", estimator.coef_)
    print("岭回归-偏置为：\n", estimator.intercept_)

    # 6）模型评估
    y_predict = estimator.predict(x_test)
    print("预测房价：\n", y_predict)
    error = mean_squared_error(y_test, y_predict)
    print("岭回归-均方误差为：\n", error)

    return None

if __name__ == "__main__":
    # 代码1：正规方程的优化方法对波士顿房价进行预测
    linear1()
    # 代码2：梯度下降的优化方法对波士顿房价进行预测
    linear2()
    # 代码3：岭回归对波士顿房价进行预测
    linear3()

四、聚类

K-means

import pandas as pd
# 1、获取数据
order_products = pd.read_csv("./instacart/order_products__prior.csv")
products = pd.read_csv("./instacart/products.csv")
orders = pd.read_csv("./instacart/orders.csv")
aisles = pd.read_csv("./instacart/aisles.csv")

# 2、合并表
# order_products__prior.csv：订单与商品信息

# 字段：order_id, product_id, add_to_cart_order, reordered
# products.csv：商品信息
# 字段：product_id, product_name, aisle_id, department_id
# orders.csv：用户的订单信息
# 字段：order_id,user_id,eval_set,order_number,….
# aisles.csv：商品所属具体物品类别
# 字段： aisle_id, aisle

# 合并aisles和products aisle和product_id
tab1 = pd.merge(aisles, products, on=["aisle_id", "aisle_id"])
tab2 = pd.merge(tab1, order_products, on=["product_id", "product_id"])
tab3 = pd.merge(tab2, orders, on=["order_id", "order_id"])

# 3、找到user_id和aisle之间的关系
table = pd.crosstab(tab3["user_id"], tab3["aisle"])

data = table[:10000]

# 4、PCA降维
from sklearn.decomposition import PCA
# 1）实例化一个转换器类
transfer = PCA(n_components=0.95)

# 2）调用fit_transform
data_new = transfer.fit_transform(data)

# 预估器流程
from sklearn.cluster import KMeans
estimator = KMeans(n_clusters=3)
estimator.fit(data_new)
y_predict = estimator.predict(data_new)
y_predict[:300]
# 模型评估-轮廓系数
from sklearn.metrics import silhouette_score
silhouette_score(data_new, y_predict)