devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

机器学习基础之《特征工程（4）—特征降维》_删除低方差的一些特征,前面讲过方差的意义。再结合方差的大小来考虑这个方式的角

作者：菜鸟追梦旅行 | 2024-04-04 21:17:41

赞

踩

删除低方差的一些特征,前面讲过方差的意义。再结合方差的大小来考虑这个方式的角

一、什么是特征降维

降维是指在某些限定条件下，降低随机变量（特征）个数，得到一组“不相关”主变量的过程

1、降维
降低维度
ndarry
    维数：嵌套的层数
    0维：标量，具体的数0 1 2 3...
    1维：向量
    2维：矩阵
    3维：多个二维数组嵌套
    n维：继续嵌套下去

2、特征降维降的是什么
降的是二维数组，特征是几行几列的，几行有多少样本，几列有多少特征
降低特征的个数（就是列数）

二、降维的两种方式

1、特征选择
2、主成分分析（可以理解一种特征提取的方式）

三、什么是特征选择

1、定义
数据中包含冗余或相关变量（或称特征、属性、指标等），旨在从原有特征中找出主要特征

2、例子：想要对鸟进行类别的区分

特征？
（1）羽毛颜色
（2）眼睛宽度
（3）眼睛长度
（4）爪子长度
（5）体格大小

比如还有的特征：是否有羽毛、是否有爪子，那这些特征就没有意义

3、方法
Filter（过滤式）：主要探究特征本身特点、特征与特征和目标值之间关联
（1）方差选择法：低方差特征过滤，过滤掉方差比较低的特征
（2）相关系数：特征与特征之间的相关程度
（3）方差选择法在文本分类中表现非常不好，对噪声的处理能力几乎为0，还删除了有用的特征

Embedded（嵌入式）：算法自动选择特征（特征与目标值之间的关联）
（1）决策树：信息熵、信息增益
（2）正则化：L1、L2
（3）深度学习：卷积等
（4）对于Embedded方式，只能在讲解算法的时候再进行介绍，更好的去理解

4、模块
sklearn.feature_selection

四、低方差特征过滤

1、删除低方差的一些特征，前面讲过方差的意义。再结合方差的大小来考虑这个方式的角度
（1）特征方差小：某个特征大多样本的值比较相近
（2）特征方差大：某个特征很多样本的值都有差别

2、API
sklearn.feature_selection.VarianceThreshold(threshold = 0.0)
删除所有低方差特征，设置一个临界值，低于临界值的都删掉
Variance：方差
Threshold：阈值

3、Variance.fit_transform(X)
X：numpy array格式的数据[n_samples, n_features]
返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征

4、数据计算
我们对某些股票的指标特征之间进行一个筛选，数据在factor_returns.csv文件当中，除去index、date、return列不考虑（这些类型不匹配，也不是所需要的指标）

  1. from sklearn.datasets import load_iris
  2. from sklearn.model_selection import train_test_split
  3. from sklearn.feature_extraction import DictVectorizer
  4. from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
  5. from sklearn.preprocessing import MinMaxScaler, StandardScaler
  6. from sklearn.feature_selection import VarianceThreshold
  7. import jieba
  8. import pandas as pd
  9.  
  10. def datasets_demo():
  11.     """
  12.     sklearn数据集使用
  13.     """
  14.     #获取数据集
  15.     iris = load_iris()
  16.     print("鸢尾花数据集：\n", iris)
  17.     print("查看数据集描述：\n", iris["DESCR"])
  18.     print("查看特征值的名字：\n", iris.feature_names)
  19.     print("查看特征值几行几列：\n", iris.data.shape)
  20.    
  21.     #数据集的划分
  22.     x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
  23.     print("训练集的特征值：\n", x_train, x_train.shape)
  24.  
  25.     return None
  26.  
  27. def dict_demo():
  28.     """
  29.     字典特征抽取
  30.     """
  31.     data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
  32.     # 1、实例化一个转换器类
  33.     transfer = DictVectorizer(sparse=False)
  34.  
  35.     # 2、调用fit_transform()
  36.     data_new = transfer.fit_transform(data)
  37.     print("data_new：\n", data_new)
  38.     print("特征名字：\n", transfer.get_feature_names())
  39.  
  40.     return None
  41.  
  42. def count_demo():
  43.     """
  44.     文本特征抽取
  45.     """
  46.     data = ["life is short,i like like python", "life is too long,i dislike python"]
  47.     # 1、实例化一个转换器类
  48.     transfer = CountVectorizer()
  49.     # 2、调用fit_transform()
  50.     data_new = transfer.fit_transform(data)
  51.     print("data_new：\n", data_new.toarray())
  52.     print("特征名字：\n", transfer.get_feature_names()) 
  53.  
  54.     return None
  55.  
  56. def count_chinese_demo():
  57.     """
  58.     中文文本特征抽取
  59.     """
  60.     data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
  61.     # 1、实例化一个转换器类
  62.     transfer = CountVectorizer()
  63.     
  64.     # 2、调用fit_transform
  65.     data_new = transfer.fit_transform(data)
  66.     print("data_new:\n", data_new.toarray());
  67.     print("特征名字：\n", transfer.get_feature_names())
  68.     
  69.     return None
  70.  
  71. def cut_word(text):
  72.     """
  73.     进行中文分词
  74.     """
  75.     return " ".join(list(jieba.cut(text)))  #返回一个分词生成器对象，强转成list，再join转成字符串
  76.  
  77. def count_chinese_demo2():
  78.     """
  79.     中文文本特征抽取，自动分词
  80.     """
  81.     # 1、将中文文本进行分词
  82.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  83.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  84.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  85.  
  86.     data_new = []
  87.     for sent in data:
  88.         data_new.append(cut_word(sent))
  89.     print(data_new)
  90.     # 2、实例化一个转换器类
  91.     transfer = CountVectorizer()
  92.     # 3、调用fit_transform()
  93.     data_final = transfer.fit_transform(data_new)
  94.     print("data_final：\n", data_final.toarray())
  95.     print("特征名字：\n", transfer.get_feature_names())
  96.     return None
  97.  
  98. def tfidf_demo():
  99.     """
  100.     用tf-idf的方法进行文本特征抽取
  101.     """
  102.     # 1、将中文文本进行分词
  103.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  104.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  105.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  106.  
  107.     data_new = []
  108.     for sent in data:
  109.         data_new.append(cut_word(sent))
  110.     print(data_new)
  111.     # 2、实例化一个转换器类
  112.     transfer = TfidfVectorizer()
  113.     # 3、调用fit_transform()
  114.     data_final = transfer.fit_transform(data_new)
  115.     print("data_final：\n", data_final.toarray())
  116.     print("特征名字：\n", transfer.get_feature_names())
  117.     return None
  118.  
  119. def minmax_demo():
  120.     """
  121.     归一化
  122.     """
  123.     # 1、获取数据
  124.     data = pd.read_csv("dating.txt")
  125.     #print("data：\n", data)
  126.     data = data.iloc[:, 0:3] #行都要，列取前3列
  127.     print("data：\n", data)
  128.     # 2、实例化一个转换器
  129.     transfer = MinMaxScaler()
  130.     # 3、调用fit_transform
  131.     data_new = transfer.fit_transform(data)
  132.     print("data_new：\n", data_new)
  133.     return None
  134.  
  135. def stand_demo():
  136.     """
  137.     标准化
  138.     """
  139.     # 1、获取数据
  140.     data = pd.read_csv("dating.txt")
  141.     #print("data：\n", data)
  142.     data = data.iloc[:, 0:3] #行都要，列取前3列
  143.     print("data：\n", data)
  144.     # 2、实例化一个转换器
  145.     transfer = StandardScaler()
  146.     # 3、调用fit_transform
  147.     data_new = transfer.fit_transform(data)
  148.     print("data_new：\n", data_new)
  149.     return None
  150.  
  151. def variance_demo():
  152.     """
  153.     过滤低方差特征
  154.     """
  155.     # 1、获取数据
  156.     data = pd.read_csv("factor_returns.csv")
  157.     #print("data：\n", data)
  158.     data = data.iloc[:, 1:-2]
  159.     print("data：\n", data)
  160.     # 2、实例化一个转换器类
  161.     transfer = VarianceThreshold(threshold=3)
  162.     # 3、调用fit_transform
  163.     data_new = transfer.fit_transform(data)
  164.     print("data_new：\n", data_new, data_new.shape)
  165.     return None
  166.  
  167. if __name__ == "__main__":
  168.     # 代码1：sklearn数据集使用
  169.     #datasets_demo()
  170.     # 代码2：字典特征抽取
  171.     #dict_demo()
  172.     # 代码3：文本特征抽取
  173.     #count_demo()
  174.     # 代码4：中文文本特征抽取
  175.     #count_chinese_demo()
  176.     # 代码5：中文文本特征抽取，自动分词
  177.     #count_chinese_demo2()
  178.     # 代码6： 测试jieba库中文分词
  179.     #print(cut_word("我爱北京天安门"))
  180.     # 代码7：用tf-idf的方法进行文本特征抽取
  181.     #tfidf_demo()
  182.     # 代码8：归一化
  183.     #minmax_demo()
  184.     # 代码9：标准化
  185.     #stand_demo()
  186.     # 代码10：低方差特征过滤
  187.     variance_demo()

运行结果：

  1. data：
  2.        pe_ratio  pb_ratio    market_cap  return_on_asset_net_profit  du_return_on_equity            ev  earnings_per_share       revenue  total_expense
  3. 0       5.9572    1.1818  8.525255e+10                      0.8008              14.9403  1.211445e+12              2.0100  2.070140e+10   1.088254e+10
  4. 1       7.0289    1.5880  8.411336e+10                      1.6463               7.8656  3.002521e+11              0.3260  2.930837e+10   2.378348e+10
  5. 2    -262.7461    7.0003  5.170455e+08                     -0.5678              -0.5943  7.705178e+08             -0.0060  1.167983e+07   1.203008e+07
  6. 3      16.4760    3.7146  1.968046e+10                      5.6036              14.6170  2.800916e+10              0.3500  9.189387e+09   7.935543e+09
  7. 4      12.5878    2.5616  4.172721e+10                      2.8729              10.9097  8.124738e+10              0.2710  8.951453e+09   7.091398e+09
  8. ...        ...       ...           ...                         ...                  ...           ...                 ...           ...            ...
  9. 2313   25.0848    4.2323  2.274800e+10                     10.7833              15.4895  2.784450e+10              0.8849  1.148170e+10   1.041419e+10
  10. 2314   59.4849    1.6392  2.281400e+10                      1.2960               2.4512  3.810122e+10              0.0900  1.731713e+09   1.089783e+09
  11. 2315   39.5523    4.0052  1.702434e+10                      3.3440               8.0679  2.420817e+10              0.2200  1.789082e+10   1.749295e+10
  12. 2316   52.5408    2.4646  3.287910e+10                      2.7444               2.9202  3.883803e+10              0.1210  6.465392e+09   6.009007e+09
  13. 2317   14.2203    1.4103  5.911086e+10                      2.0383               8.6179  2.020661e+11              0.2470  4.509872e+10   4.132842e+10
  14.  
  15. [2318 rows x 9 columns]
  16. data_new：
  17.  [[ 5.95720000e+00  1.18180000e+00  8.52525509e+10 ...  1.21144486e+12
  18.    2.07014010e+10  1.08825400e+10]
  19.  [ 7.02890000e+00  1.58800000e+00  8.41133582e+10 ...  3.00252062e+11
  20.    2.93083692e+10  2.37834769e+10]
  21.  [-2.62746100e+02  7.00030000e+00  5.17045520e+08 ...  7.70517753e+08
  22.    1.16798290e+07  1.20300800e+07]
  23.  ...
  24.  [ 3.95523000e+01  4.00520000e+00  1.70243430e+10 ...  2.42081699e+10
  25.    1.78908166e+10  1.74929478e+10]
  26.  [ 5.25408000e+01  2.46460000e+00  3.28790988e+10 ...  3.88380258e+10
  27.    6.46539204e+09  6.00900728e+09]
  28.  [ 1.42203000e+01  1.41030000e+00  5.91108572e+10 ...  2.02066110e+11
  29.    4.50987171e+10  4.13284212e+10]] (2318, 8)

五、相关系数

1、皮尔逊相关系数(Pearson Correlation Coefficient)
反映变量之间相关关系密切程度的统计指标

2、公式计算案例
（1）公式

（2）比如说我们计算年广告费投入与月均销售额

（3）那么之间的相关系数怎么计算

（4）最终计算

（5）结果=0.9942
所以我们最终得出结论是广告投入费与月平均销售额之间有高度的正相关关系

4、API
from scipy.stats import pearsonr
X：(N,) array_like
Y：(N,) array_like
Returns：(Pearson’s correlation coefficient, p-value)，返回值是两个
注：pandas上面也有这个求相关系数的方法

5、案例：股票的财务指标相关性计算
计算某两个变量之间的相关系数
data [ ] 里面的关键字要用你自己表里面的列名

  1. from sklearn.datasets import load_iris
  2. from sklearn.model_selection import train_test_split
  3. from sklearn.feature_extraction import DictVectorizer
  4. from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
  5. from sklearn.preprocessing import MinMaxScaler, StandardScaler
  6. from sklearn.feature_selection import VarianceThreshold
  7. from scipy.stats import pearsonr
  8. import jieba
  9. import pandas as pd
  10.  
  11. def datasets_demo():
  12.     """
  13.     sklearn数据集使用
  14.     """
  15.     #获取数据集
  16.     iris = load_iris()
  17.     print("鸢尾花数据集：\n", iris)
  18.     print("查看数据集描述：\n", iris["DESCR"])
  19.     print("查看特征值的名字：\n", iris.feature_names)
  20.     print("查看特征值几行几列：\n", iris.data.shape)
  21.    
  22.     #数据集的划分
  23.     x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
  24.     print("训练集的特征值：\n", x_train, x_train.shape)
  25.  
  26.     return None
  27.  
  28. def dict_demo():
  29.     """
  30.     字典特征抽取
  31.     """
  32.     data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
  33.     # 1、实例化一个转换器类
  34.     transfer = DictVectorizer(sparse=False)
  35.  
  36.     # 2、调用fit_transform()
  37.     data_new = transfer.fit_transform(data)
  38.     print("data_new：\n", data_new)
  39.     print("特征名字：\n", transfer.get_feature_names())
  40.  
  41.     return None
  42.  
  43. def count_demo():
  44.     """
  45.     文本特征抽取
  46.     """
  47.     data = ["life is short,i like like python", "life is too long,i dislike python"]
  48.     # 1、实例化一个转换器类
  49.     transfer = CountVectorizer()
  50.     # 2、调用fit_transform()
  51.     data_new = transfer.fit_transform(data)
  52.     print("data_new：\n", data_new.toarray())
  53.     print("特征名字：\n", transfer.get_feature_names()) 
  54.  
  55.     return None
  56.  
  57. def count_chinese_demo():
  58.     """
  59.     中文文本特征抽取
  60.     """
  61.     data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
  62.     # 1、实例化一个转换器类
  63.     transfer = CountVectorizer()
  64.     
  65.     # 2、调用fit_transform
  66.     data_new = transfer.fit_transform(data)
  67.     print("data_new:\n", data_new.toarray());
  68.     print("特征名字：\n", transfer.get_feature_names())
  69.     
  70.     return None
  71.  
  72. def cut_word(text):
  73.     """
  74.     进行中文分词
  75.     """
  76.     return " ".join(list(jieba.cut(text)))  #返回一个分词生成器对象，强转成list，再join转成字符串
  77.  
  78. def count_chinese_demo2():
  79.     """
  80.     中文文本特征抽取，自动分词
  81.     """
  82.     # 1、将中文文本进行分词
  83.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  84.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  85.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  86.  
  87.     data_new = []
  88.     for sent in data:
  89.         data_new.append(cut_word(sent))
  90.     print(data_new)
  91.     # 2、实例化一个转换器类
  92.     transfer = CountVectorizer()
  93.     # 3、调用fit_transform()
  94.     data_final = transfer.fit_transform(data_new)
  95.     print("data_final：\n", data_final.toarray())
  96.     print("特征名字：\n", transfer.get_feature_names())
  97.     return None
  98.  
  99. def tfidf_demo():
  100.     """
  101.     用tf-idf的方法进行文本特征抽取
  102.     """
  103.     # 1、将中文文本进行分词
  104.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  105.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  106.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  107.  
  108.     data_new = []
  109.     for sent in data:
  110.         data_new.append(cut_word(sent))
  111.     print(data_new)
  112.     # 2、实例化一个转换器类
  113.     transfer = TfidfVectorizer()
  114.     # 3、调用fit_transform()
  115.     data_final = transfer.fit_transform(data_new)
  116.     print("data_final：\n", data_final.toarray())
  117.     print("特征名字：\n", transfer.get_feature_names())
  118.     return None
  119.  
  120. def minmax_demo():
  121.     """
  122.     归一化
  123.     """
  124.     # 1、获取数据
  125.     data = pd.read_csv("dating.txt")
  126.     #print("data：\n", data)
  127.     data = data.iloc[:, 0:3] #行都要，列取前3列
  128.     print("data：\n", data)
  129.     # 2、实例化一个转换器
  130.     transfer = MinMaxScaler()
  131.     # 3、调用fit_transform
  132.     data_new = transfer.fit_transform(data)
  133.     print("data_new：\n", data_new)
  134.     return None
  135.  
  136. def stand_demo():
  137.     """
  138.     标准化
  139.     """
  140.     # 1、获取数据
  141.     data = pd.read_csv("dating.txt")
  142.     #print("data：\n", data)
  143.     data = data.iloc[:, 0:3] #行都要，列取前3列
  144.     print("data：\n", data)
  145.     # 2、实例化一个转换器
  146.     transfer = StandardScaler()
  147.     # 3、调用fit_transform
  148.     data_new = transfer.fit_transform(data)
  149.     print("data_new：\n", data_new)
  150.     return None
  151.  
  152. def variance_demo():
  153.     """
  154.     过滤低方差特征
  155.     """
  156.     # 1、获取数据
  157.     data = pd.read_csv("factor_returns.csv")
  158.     #print("data：\n", data)
  159.     data = data.iloc[:, 1:-2]
  160.     print("data：\n", data)
  161.     # 2、实例化一个转换器类
  162.     transfer = VarianceThreshold(threshold=3)
  163.     # 3、调用fit_transform
  164.     data_new = transfer.fit_transform(data)
  165.     print("data_new：\n", data_new, data_new.shape)
  166.     # 4、计算某两个变量之间的相关系数
  167.     r = pearsonr(data["pe_ratio"], data["pb_ratio"])
  168.     print("相关系数：\n", r)
  169.     return None
  170.  
  171. if __name__ == "__main__":
  172.     # 代码1：sklearn数据集使用
  173.     #datasets_demo()
  174.     # 代码2：字典特征抽取
  175.     #dict_demo()
  176.     # 代码3：文本特征抽取
  177.     #count_demo()
  178.     # 代码4：中文文本特征抽取
  179.     #count_chinese_demo()
  180.     # 代码5：中文文本特征抽取，自动分词
  181.     #count_chinese_demo2()
  182.     # 代码6： 测试jieba库中文分词
  183.     #print(cut_word("我爱北京天安门"))
  184.     # 代码7：用tf-idf的方法进行文本特征抽取
  185.     #tfidf_demo()
  186.     # 代码8：归一化
  187.     #minmax_demo()
  188.     # 代码9：标准化
  189.     #stand_demo()
  190.     # 代码10：低方差特征过滤
  191.     variance_demo()

运行结果：

  1. data：
  2.        pe_ratio  pb_ratio    market_cap  return_on_asset_net_profit  du_return_on_equity            ev  earnings_per_share       revenue  total_expense
  3. 0       5.9572    1.1818  8.525255e+10                      0.8008              14.9403  1.211445e+12              2.0100  2.070140e+10   1.088254e+10
  4. 1       7.0289    1.5880  8.411336e+10                      1.6463               7.8656  3.002521e+11              0.3260  2.930837e+10   2.378348e+10
  5. 2    -262.7461    7.0003  5.170455e+08                     -0.5678              -0.5943  7.705178e+08             -0.0060  1.167983e+07   1.203008e+07
  6. 3      16.4760    3.7146  1.968046e+10                      5.6036              14.6170  2.800916e+10              0.3500  9.189387e+09   7.935543e+09
  7. 4      12.5878    2.5616  4.172721e+10                      2.8729              10.9097  8.124738e+10              0.2710  8.951453e+09   7.091398e+09
  8. ...        ...       ...           ...                         ...                  ...           ...                 ...           ...            ...
  9. 2313   25.0848    4.2323  2.274800e+10                     10.7833              15.4895  2.784450e+10              0.8849  1.148170e+10   1.041419e+10
  10. 2314   59.4849    1.6392  2.281400e+10                      1.2960               2.4512  3.810122e+10              0.0900  1.731713e+09   1.089783e+09
  11. 2315   39.5523    4.0052  1.702434e+10                      3.3440               8.0679  2.420817e+10              0.2200  1.789082e+10   1.749295e+10
  12. 2316   52.5408    2.4646  3.287910e+10                      2.7444               2.9202  3.883803e+10              0.1210  6.465392e+09   6.009007e+09
  13. 2317   14.2203    1.4103  5.911086e+10                      2.0383               8.6179  2.020661e+11              0.2470  4.509872e+10   4.132842e+10
  14.  
  15. [2318 rows x 9 columns]
  16. data_new：
  17.  [[ 5.95720000e+00  1.18180000e+00  8.52525509e+10 ...  1.21144486e+12
  18.    2.07014010e+10  1.08825400e+10]
  19.  [ 7.02890000e+00  1.58800000e+00  8.41133582e+10 ...  3.00252062e+11
  20.    2.93083692e+10  2.37834769e+10]
  21.  [-2.62746100e+02  7.00030000e+00  5.17045520e+08 ...  7.70517753e+08
  22.    1.16798290e+07  1.20300800e+07]
  23.  ...
  24.  [ 3.95523000e+01  4.00520000e+00  1.70243430e+10 ...  2.42081699e+10
  25.    1.78908166e+10  1.74929478e+10]
  26.  [ 5.25408000e+01  2.46460000e+00  3.28790988e+10 ...  3.88380258e+10
  27.    6.46539204e+09  6.00900728e+09]
  28.  [ 1.42203000e+01  1.41030000e+00  5.91108572e+10 ...  2.02066110e+11
  29.    4.50987171e+10  4.13284212e+10]] (2318, 8)
  30. 相关系数：
  31.  (-0.004389322779936261, 0.8327205496564927)

相关系数：
 (-0.004389322779936261, 0.8327205496564927)
前面一个是相关系数，比较接近于0，说明这两者不太相关
后面是p-value，假设H0：x，y不相关，p-value越大，H0成立的概率越大。p-value值表示显著水平，越小越好
所以这里是说明前面的相关系数成立的可能性很大

6、特征与特征之间相关性很高怎么办
（1）选取其中一个
（2）加权求和
比如revenue和total_expense相关性高，各占50%
（3）主成分分析

7、用图片展示相关性
安装matplotlib
（1）先安装Pillow
参考资料：https://pillow.readthedocs.io/en/latest/installation.html
python3 -m pip install --upgrade pip
python3 -m pip install --upgrade Pillow
（2）再安装matplotlib
pip3 install matplotlib

  1. from sklearn.datasets import load_iris
  2. from sklearn.model_selection import train_test_split
  3. from sklearn.feature_extraction import DictVectorizer
  4. from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
  5. from sklearn.preprocessing import MinMaxScaler, StandardScaler
  6. from sklearn.feature_selection import VarianceThreshold
  7. from scipy.stats import pearsonr
  8. import jieba
  9. import pandas as pd
  10. import matplotlib.pyplot as plt
  11.  
  12. def datasets_demo():
  13.     """
  14.     sklearn数据集使用
  15.     """
  16.     #获取数据集
  17.     iris = load_iris()
  18.     print("鸢尾花数据集：\n", iris)
  19.     print("查看数据集描述：\n", iris["DESCR"])
  20.     print("查看特征值的名字：\n", iris.feature_names)
  21.     print("查看特征值几行几列：\n", iris.data.shape)
  22.    
  23.     #数据集的划分
  24.     x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
  25.     print("训练集的特征值：\n", x_train, x_train.shape)
  26.  
  27.     return None
  28.  
  29. def dict_demo():
  30.     """
  31.     字典特征抽取
  32.     """
  33.     data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
  34.     # 1、实例化一个转换器类
  35.     transfer = DictVectorizer(sparse=False)
  36.  
  37.     # 2、调用fit_transform()
  38.     data_new = transfer.fit_transform(data)
  39.     print("data_new：\n", data_new)
  40.     print("特征名字：\n", transfer.get_feature_names())
  41.  
  42.     return None
  43.  
  44. def count_demo():
  45.     """
  46.     文本特征抽取
  47.     """
  48.     data = ["life is short,i like like python", "life is too long,i dislike python"]
  49.     # 1、实例化一个转换器类
  50.     transfer = CountVectorizer()
  51.     # 2、调用fit_transform()
  52.     data_new = transfer.fit_transform(data)
  53.     print("data_new：\n", data_new.toarray())
  54.     print("特征名字：\n", transfer.get_feature_names()) 
  55.  
  56.     return None
  57.  
  58. def count_chinese_demo():
  59.     """
  60.     中文文本特征抽取
  61.     """
  62.     data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
  63.     # 1、实例化一个转换器类
  64.     transfer = CountVectorizer()
  65.     
  66.     # 2、调用fit_transform
  67.     data_new = transfer.fit_transform(data)
  68.     print("data_new:\n", data_new.toarray());
  69.     print("特征名字：\n", transfer.get_feature_names())
  70.     
  71.     return None
  72.  
  73. def cut_word(text):
  74.     """
  75.     进行中文分词
  76.     """
  77.     return " ".join(list(jieba.cut(text)))  #返回一个分词生成器对象，强转成list，再join转成字符串
  78.  
  79. def count_chinese_demo2():
  80.     """
  81.     中文文本特征抽取，自动分词
  82.     """
  83.     # 1、将中文文本进行分词
  84.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  85.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  86.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  87.  
  88.     data_new = []
  89.     for sent in data:
  90.         data_new.append(cut_word(sent))
  91.     print(data_new)
  92.     # 2、实例化一个转换器类
  93.     transfer = CountVectorizer()
  94.     # 3、调用fit_transform()
  95.     data_final = transfer.fit_transform(data_new)
  96.     print("data_final：\n", data_final.toarray())
  97.     print("特征名字：\n", transfer.get_feature_names())
  98.     return None
  99.  
  100. def tfidf_demo():
  101.     """
  102.     用tf-idf的方法进行文本特征抽取
  103.     """
  104.     # 1、将中文文本进行分词
  105.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  106.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  107.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  108.  
  109.     data_new = []
  110.     for sent in data:
  111.         data_new.append(cut_word(sent))
  112.     print(data_new)
  113.     # 2、实例化一个转换器类
  114.     transfer = TfidfVectorizer()
  115.     # 3、调用fit_transform()
  116.     data_final = transfer.fit_transform(data_new)
  117.     print("data_final：\n", data_final.toarray())
  118.     print("特征名字：\n", transfer.get_feature_names())
  119.     return None
  120.  
  121. def minmax_demo():
  122.     """
  123.     归一化
  124.     """
  125.     # 1、获取数据
  126.     data = pd.read_csv("dating.txt")
  127.     #print("data：\n", data)
  128.     data = data.iloc[:, 0:3] #行都要，列取前3列
  129.     print("data：\n", data)
  130.     # 2、实例化一个转换器
  131.     transfer = MinMaxScaler()
  132.     # 3、调用fit_transform
  133.     data_new = transfer.fit_transform(data)
  134.     print("data_new：\n", data_new)
  135.     return None
  136.  
  137. def stand_demo():
  138.     """
  139.     标准化
  140.     """
  141.     # 1、获取数据
  142.     data = pd.read_csv("dating.txt")
  143.     #print("data：\n", data)
  144.     data = data.iloc[:, 0:3] #行都要，列取前3列
  145.     print("data：\n", data)
  146.     # 2、实例化一个转换器
  147.     transfer = StandardScaler()
  148.     # 3、调用fit_transform
  149.     data_new = transfer.fit_transform(data)
  150.     print("data_new：\n", data_new)
  151.     return None
  152.  
  153. def variance_demo():
  154.     """
  155.     过滤低方差特征
  156.     """
  157.     # 1、获取数据
  158.     data = pd.read_csv("factor_returns.csv")
  159.     #print("data：\n", data)
  160.     data = data.iloc[:, 1:-2]
  161.     print("data：\n", data)
  162.     # 2、实例化一个转换器类
  163.     transfer = VarianceThreshold(threshold=3)
  164.     # 3、调用fit_transform
  165.     data_new = transfer.fit_transform(data)
  166.     print("data_new：\n", data_new, data_new.shape)
  167.     # 4、计算某两个变量之间的相关系数
  168.     r1 = pearsonr(data["pe_ratio"], data["pb_ratio"])
  169.     print("相关系数：\n", r1)
  170.     r2 = pearsonr(data["revenue"], data["total_expense"])
  171.     print("revenue与total_expense之间的相关性：\n", r2)
  172.     #用图片展示相关性
  173.     plt.figure(figsize=(20, 8), dpi=100)
  174.     plt.scatter(data['revenue'], data['total_expense'])
  175.     plt.show()
  176.     return None
  177.  
  178. if __name__ == "__main__":
  179.     # 代码1：sklearn数据集使用
  180.     #datasets_demo()
  181.     # 代码2：字典特征抽取
  182.     #dict_demo()
  183.     # 代码3：文本特征抽取
  184.     #count_demo()
  185.     # 代码4：中文文本特征抽取
  186.     #count_chinese_demo()
  187.     # 代码5：中文文本特征抽取，自动分词
  188.     #count_chinese_demo2()
  189.     # 代码6： 测试jieba库中文分词
  190.     #print(cut_word("我爱北京天安门"))
  191.     # 代码7：用tf-idf的方法进行文本特征抽取
  192.     #tfidf_demo()
  193.     # 代码8：归一化
  194.     #minmax_demo()
  195.     # 代码9：标准化
  196.     #stand_demo()
  197.     # 代码10：低方差特征过滤
  198.     variance_demo()

六、主成分分析

1、什么是主成分分析（PCA）
定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量
作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息
应用：回归分析或者聚类分析当中

2、如何最好的对一个立体的物体二维表示
现实中是一个水壶，拍成照片就是平面的
相当于将三维降到二维，在这个过程中可能就会有信息的损失
如何去衡量信息损失有多少，直观的检验方法是能不能通过二维的图像，能够还原出它还是一个水壶

从这四个图片中可以看到，最后一个能识别出是水壶，也就是说最后一个从三维降到二维它损失的信息是最少的

3、PCA计算过程
找到一个合适的直线，通过一个矩阵运算得出主成分分析的结果
PCA是一种数据降维的技术，它并不是将数据拟合到一个模型中，而是通过线性变换将原始的高维数据投影到一个低维的子空间中，使得投影后的数据仍然尽可能地保留原始数据的信息，同时减少了特征的数量和减少了冗余性

4、API
sklearn.decomposition.PCA(n_components=None)
将数据分解为较低维数空间
n_components：
如果传小数：表示保留百分之多少的信息
如果传整数：减少到多少特征

5、PCA.fit_transform(X)
X：numpy array格式的数据[n_samples, n_features]
返回值：转换后指定维度的array

6、数据计算

  1. from sklearn.datasets import load_iris
  2. from sklearn.model_selection import train_test_split
  3. from sklearn.feature_extraction import DictVectorizer
  4. from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
  5. from sklearn.preprocessing import MinMaxScaler, StandardScaler
  6. from sklearn.feature_selection import VarianceThreshold
  7. from scipy.stats import pearsonr
  8. from sklearn.decomposition import PCA
  9. import jieba
  10. import pandas as pd
  11. import matplotlib.pyplot as plt
  12.  
  13. def datasets_demo():
  14.     """
  15.     sklearn数据集使用
  16.     """
  17.     #获取数据集
  18.     iris = load_iris()
  19.     print("鸢尾花数据集：\n", iris)
  20.     print("查看数据集描述：\n", iris["DESCR"])
  21.     print("查看特征值的名字：\n", iris.feature_names)
  22.     print("查看特征值几行几列：\n", iris.data.shape)
  23.    
  24.     #数据集的划分
  25.     x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
  26.     print("训练集的特征值：\n", x_train, x_train.shape)
  27.  
  28.     return None
  29.  
  30. def dict_demo():
  31.     """
  32.     字典特征抽取
  33.     """
  34.     data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
  35.     # 1、实例化一个转换器类
  36.     transfer = DictVectorizer(sparse=False)
  37.  
  38.     # 2、调用fit_transform()
  39.     data_new = transfer.fit_transform(data)
  40.     print("data_new：\n", data_new)
  41.     print("特征名字：\n", transfer.get_feature_names())
  42.  
  43.     return None
  44.  
  45. def count_demo():
  46.     """
  47.     文本特征抽取
  48.     """
  49.     data = ["life is short,i like like python", "life is too long,i dislike python"]
  50.     # 1、实例化一个转换器类
  51.     transfer = CountVectorizer()
  52.     # 2、调用fit_transform()
  53.     data_new = transfer.fit_transform(data)
  54.     print("data_new：\n", data_new.toarray())
  55.     print("特征名字：\n", transfer.get_feature_names()) 
  56.  
  57.     return None
  58.  
  59. def count_chinese_demo():
  60.     """
  61.     中文文本特征抽取
  62.     """
  63.     data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
  64.     # 1、实例化一个转换器类
  65.     transfer = CountVectorizer()
  66.     
  67.     # 2、调用fit_transform
  68.     data_new = transfer.fit_transform(data)
  69.     print("data_new:\n", data_new.toarray());
  70.     print("特征名字：\n", transfer.get_feature_names())
  71.     
  72.     return None
  73.  
  74. def cut_word(text):
  75.     """
  76.     进行中文分词
  77.     """
  78.     return " ".join(list(jieba.cut(text)))  #返回一个分词生成器对象，强转成list，再join转成字符串
  79.  
  80. def count_chinese_demo2():
  81.     """
  82.     中文文本特征抽取，自动分词
  83.     """
  84.     # 1、将中文文本进行分词
  85.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  86.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  87.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  88.  
  89.     data_new = []
  90.     for sent in data:
  91.         data_new.append(cut_word(sent))
  92.     print(data_new)
  93.     # 2、实例化一个转换器类
  94.     transfer = CountVectorizer()
  95.     # 3、调用fit_transform()
  96.     data_final = transfer.fit_transform(data_new)
  97.     print("data_final：\n", data_final.toarray())
  98.     print("特征名字：\n", transfer.get_feature_names())
  99.     return None
  100.  
  101. def tfidf_demo():
  102.     """
  103.     用tf-idf的方法进行文本特征抽取
  104.     """
  105.     # 1、将中文文本进行分词
  106.     data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
  107.         "我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
  108.         "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
  109.  
  110.     data_new = []
  111.     for sent in data:
  112.         data_new.append(cut_word(sent))
  113.     print(data_new)
  114.     # 2、实例化一个转换器类
  115.     transfer = TfidfVectorizer()
  116.     # 3、调用fit_transform()
  117.     data_final = transfer.fit_transform(data_new)
  118.     print("data_final：\n", data_final.toarray())
  119.     print("特征名字：\n", transfer.get_feature_names())
  120.     return None
  121.  
  122. def minmax_demo():
  123.     """
  124.     归一化
  125.     """
  126.     # 1、获取数据
  127.     data = pd.read_csv("dating.txt")
  128.     #print("data：\n", data)
  129.     data = data.iloc[:, 0:3] #行都要，列取前3列
  130.     print("data：\n", data)
  131.     # 2、实例化一个转换器
  132.     transfer = MinMaxScaler()
  133.     # 3、调用fit_transform
  134.     data_new = transfer.fit_transform(data)
  135.     print("data_new：\n", data_new)
  136.     return None
  137.  
  138. def stand_demo():
  139.     """
  140.     标准化
  141.     """
  142.     # 1、获取数据
  143.     data = pd.read_csv("dating.txt")
  144.     #print("data：\n", data)
  145.     data = data.iloc[:, 0:3] #行都要，列取前3列
  146.     print("data：\n", data)
  147.     # 2、实例化一个转换器
  148.     transfer = StandardScaler()
  149.     # 3、调用fit_transform
  150.     data_new = transfer.fit_transform(data)
  151.     print("data_new：\n", data_new)
  152.     return None
  153.  
  154. def variance_demo():
  155.     """
  156.     过滤低方差特征
  157.     """
  158.     # 1、获取数据
  159.     data = pd.read_csv("factor_returns.csv")
  160.     #print("data：\n", data)
  161.     data = data.iloc[:, 1:-2]
  162.     print("data：\n", data)
  163.     # 2、实例化一个转换器类
  164.     transfer = VarianceThreshold(threshold=3)
  165.     # 3、调用fit_transform
  166.     data_new = transfer.fit_transform(data)
  167.     print("data_new：\n", data_new, data_new.shape)
  168.     # 4、计算某两个变量之间的相关系数
  169.     r1 = pearsonr(data["pe_ratio"], data["pb_ratio"])
  170.     print("相关系数：\n", r1)
  171.     r2 = pearsonr(data["revenue"], data["total_expense"])
  172.     print("revenue与total_expense之间的相关性：\n", r2)
  173.     #用图片展示相关性
  174.     plt.figure(figsize=(20, 8), dpi=100)
  175.     plt.scatter(data['revenue'], data['total_expense'])
  176.     plt.show()
  177.     return None
  178.  
  179. def pca_demo():
  180.     """
  181.     PCA降维
  182.     """
  183.     data = [[2,8,4,5], [6,3,0,8], [5,4,9,1]]
  184.     # 1、实例化一个转换器类
  185.     transfer = PCA(n_components=3)
  186.     # 2、调用fit_transform
  187.     data_new = transfer.fit_transform(data)
  188.     print("data_new：\n", data_new)
  189.     # 1、实例化一个转换器类
  190.     transfer2 = PCA(n_components=0.9)
  191.     # 2、调用fit_transform
  192.     data_new2 = transfer2.fit_transform(data)
  193.     print("data_new2：\n", data_new2)
  194.     return None
  195.  
  196. if __name__ == "__main__":
  197.     # 代码1：sklearn数据集使用
  198.     #datasets_demo()
  199.     # 代码2：字典特征抽取
  200.     #dict_demo()
  201.     # 代码3：文本特征抽取
  202.     #count_demo()
  203.     # 代码4：中文文本特征抽取
  204.     #count_chinese_demo()
  205.     # 代码5：中文文本特征抽取，自动分词
  206.     #count_chinese_demo2()
  207.     # 代码6： 测试jieba库中文分词
  208.     #print(cut_word("我爱北京天安门"))
  209.     # 代码7：用tf-idf的方法进行文本特征抽取
  210.     #tfidf_demo()
  211.     # 代码8：归一化
  212.     #minmax_demo()
  213.     # 代码9：标准化
  214.     #stand_demo()
  215.     # 代码10：低方差特征过滤
  216.     #variance_demo()
  217.     # 代码11：PCA降维
  218.     pca_demo()

运行结果：

  1. data_new：
  2.  [[ 1.28620952e-15  3.82970843e+00  5.26052119e-16]
  3.  [ 5.74456265e+00 -1.91485422e+00  5.26052119e-16]
  4.  [-5.74456265e+00 -1.91485422e+00  5.26052119e-16]]
  5. data_new2：
  6.  [[ 1.28620952e-15  3.82970843e+00]
  7.  [ 5.74456265e+00 -1.91485422e+00]
  8.  [-5.74456265e+00 -1.91485422e+00]]

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/361172
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号