python学习笔记第二十三天--------特征抽取实例

最新推荐文章于 2021-10-11 00:08:08 发布

曾鸿举

最新推荐文章于 2021-10-11 00:08:08 发布

阅读量666

点赞数

分类专栏：机器学习文章标签： python

本文链接：https://blog.csdn.net/zenghongju/article/details/104613318

版权

机器学习专栏收录该内容

17 篇文章 1 订阅

订阅专栏

文章目录

1. 特征
2. 数据的特征处理

1. 特征

# 特征抽取，特征抽取针对非连续型数据和对文本等进行特征值化
# 1. 导入Scikit-learn库
# sklearn特征抽取API--------sklearn.feature_extraction
# 文本特征抽取--------类：sklearn.feature_extraction.text.CountVectorizer
# sklearn归一化API:  sklearn.preprocessing.MinMaxScaler
# DictVectorizer：对字典数据进行特征值化
# 使用方法：sklearn.feature_extraction.DictVectorizer
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.preprocessing import MinMaxScaler, StandardScaler, Imputer
from sklearn.feature_selection import VarianceThreshold
from sklearn.decomposition import PCA
import jieba
import numpy as np

1.1 特征抽取

# 2.实例化CountVectorizer

vector = CountVectorizer()
# 3. 调用fit_transform
res = vector.fit_transform(["life is short, i like python","life is too long ,i dislike python"])
# 4. 打印结果
print(vector.get_feature_names())

print(res.toarray())

['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
[[0 1 1 1 0 1 1 0]
 [1 1 1 0 1 1 0 1]]

1.2 字典特征抽取

"""
DictVectorizer语法
DictVectorizer(sparse=True,…)
    DictVectorizer.fit_transform(X)       
        X:字典或者包含字典的迭代器
        返回值：返回sparse矩阵
    DictVectorizer.inverse_transform(X)
        X:array数组或者sparse矩阵
        返回值:转换之前数据格式
    DictVectorizer.get_feature_names()
        返回类别名称
    DictVectorizer.transform(X)
        按照原先的标准转换

"""



def dictvec():
    """
    字典数据抽取
    :return: None
    """
    # 实例化
    dict = DictVectorizer(sparse=False)
    # 调用
    data = dict.fit_transform([{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}])
    print(dict.get_feature_names())
    print(dict.inverse_transform(data))
    print(data)
    
    return None
if __name__ == "__main__":
    dictvec()

['city=上海', 'city=北京', 'city=深圳', 'temperature']
[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]
[[  0.   1.   0. 100.]
 [  1.   0.   0.  60.]
 [  0.   0.   1.  30.]]

1.3 文本特征抽取

"""
CountVectorizer语法
CountVectorizer(max_df=1.0,min_df=1,…)
    返回词频矩阵
    CountVectorizer.fit_transform(X,y)       
        X:文本或者包含文本字符串的可迭代对象
        返回值：返回sparse矩阵
    CountVectorizer.inverse_transform(X)
        X:array数组或者sparse矩阵
        返回值:转换之前数据格式
    CountVectorizer.get_feature_names()
        返回值:单词列表
"""
def Countvec():
    """
    对文本进行特征值化
    ：return: None
    """
    
    cv = CountVectorizer()
    data = cv.fit_transform(["life is short, i like python","life is too long ,i dislike python"])
    print(data)
    print(data.toarray())
    print(cv.get_feature_names())
    return None
if __name__ == "__main__":
    Countvec()

  (0, 5)	1
  (0, 3)	1
  (0, 6)	1
  (0, 1)	1
  (0, 2)	1
  (1, 0)	1
  (1, 4)	1
  (1, 7)	1
  (1, 5)	1
  (1, 1)	1
  (1, 2)	1
[[0 1 1 1 0 1 1 0]
 [1 1 1 0 1 1 0 1]]
['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']

def cutword():

    con1 = jieba.cut("今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")

    con2 = jieba.cut("我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")

    con3 = jieba.cut("如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")

    # 转换成列表
    content1 = list(con1)
    content2 = list(con2)
    content3 = list(con3)

    # 吧列表转换成字符串
    c1 = ' '.join(content1)
    c2 = ' '.join(content2)
    c3 = ' '.join(content3)

    return c1, c2, c3

    
def hanzivec():
    """
    中文特征值化
    :return: None
    """
    c1, c2, c3 = cutword()

    print(c1, c2, c3)

    cv = CountVectorizer()

    data = cv.fit_transform([c1, c2, c3])

    print(cv.get_feature_names())

    print(data.toarray())

    return None

if __name__ == "__main__":
    hanzivec()

Building prefix dict from the default dictionary ...
Loading model from cache /tmp/jieba.cache
Loading model cost 1.100 seconds.
Prefix dict has been built successfully.

今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]
 [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]
 [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]

1.4 TF-IDF

"""
TfidfVectorizer语法
TfidfVectorizer(stop_words=None,…)
    返回词的权重矩阵
    TfidfVectorizer.fit_transform(X,y)       
        X:文本或者包含文本字符串的可迭代对象
        返回值：返回sparse矩阵
    TfidfVectorizer.inverse_transform(X)
        X:array数组或者sparse矩阵
        返回值:转换之前数据格式
    TfidfVectorizer.get_feature_names()
        返回值:单词列表
"""
def tfidfvec():
    """
    中文特征值化
    :return: None
    """
    c1, c2, c3 = cutword()

    print(c1, c2, c3)

    tf = TfidfVectorizer()

    data = tf.fit_transform([c1, c2, c3])

    print(tf.get_feature_names())

    print(data.toarray())

    return None
if __name__ == "__main__":
    tfidfvec()

今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
[[0.         0.         0.21821789 0.         0.         0.
  0.43643578 0.         0.         0.         0.         0.
  0.21821789 0.         0.21821789 0.         0.         0.
  0.         0.21821789 0.21821789 0.         0.43643578 0.
  0.21821789 0.         0.43643578 0.21821789 0.         0.
  0.         0.21821789 0.21821789 0.         0.         0.        ]
 [0.         0.         0.         0.2410822  0.         0.
  0.         0.2410822  0.2410822  0.2410822  0.         0.
  0.         0.         0.         0.         0.         0.2410822
  0.55004769 0.         0.         0.         0.         0.2410822
  0.         0.         0.         0.         0.48216441 0.
  0.         0.         0.         0.         0.2410822  0.2410822 ]
 [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891
  0.         0.         0.         0.         0.15698297 0.15698297
  0.         0.15698297 0.         0.15698297 0.15698297 0.
  0.1193896  0.         0.         0.15698297 0.         0.
  0.         0.15698297 0.         0.         0.         0.31396594
  0.15698297 0.         0.         0.15698297 0.         0.        ]]

2. 数据的特征处理

2.1 归一化

特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hygeReay-1583135750283)(C:\Users\ASUS\AppData\Local\Temp\1583135496443.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AwEySRfp-1583135750285)(C:\Users\ASUS\AppData\Local\Temp\1583135521788.png)]$

# 特征的预处理：通过特定的统计方法（数学方法）将数据转换成算法要求的数据
# sklearn特征处理API------sklearn. preprocessing 
# 归一化  特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间
# sklearn归一化API--------sklearn归一化API:  sklearn.preprocessing.MinMaxScaler
"""
MinMaxScaler语法
MinMaxScalar(feature_range=(0,1)…)
    每个特征缩放到给定范围(默认[0,1])
    MinMaxScalar.fit_transform(X)       
        X:numpy array格式的数据[n_samples,n_features]
        返回值：转换后的形状相同的array
"""
def mm():
    """
    归一化处理
    :return: NOne
    """
    # 1.实例化MinMaxScalar
    mm = MinMaxScaler()
  # mm = MinMaxScaler(feature_range=(2, 3))
    # 2.通过fit_transform转换
    data = mm.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,13,46]])

    print(data)
 
    return None
if __name__ == "__main__":
    mm()

[[1.         0.         0.         0.        ]
 [0.         1.         1.         0.83333333]
 [0.5        0.5        0.6        1.        ]]

归一化总结

在特定场景下最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。

2.2 标准化

1、特点：通过对原始数据进行变换把数据变换到均值为0,方差为1范围内

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlsw1RkJ-1583135750286)(C:\Users\ASUS\Documents\1583135577941.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rX6aGp5H-1583135750288)(C:\Users\ASUS\AppData\Local\Temp\1583135632263.png)]$

# 特点：通过对原始数据进行变换把数据变换到均值为0,方差为1范围内
# sklearn特征化API:  scikit-learn.preprocessing.StandardScaler
"""
StandardScaler语法
StandardScaler(…)
    处理之后每列来说所有数据都聚集在均值0附近方差为1
    StandardScaler.fit_transform(X,y)       
        X:numpy array格式的数据[n_samples,n_features]
        返回值：转换后的形状相同的array
    StandardScaler.mean_
        原始数据中每列特征的平均值
    StandardScaler.std_
        原始数据每列特征的方差
"""
def stand():
    """
    标准化缩放
    :return:
    """
    # 1.实例化StandardScaler
    std = StandardScaler()
    # 2、通过fit_transform转换
    data = std.fit_transform([[ 1., -1., 3.],[ 2., 4., 2.],[ 4., 6., -1.]])
    print(data)
    return None
if __name__ == "__main__":
    stand()

[[-1.06904497 -1.35873244  0.98058068]
 [-0.26726124  0.33968311  0.39223227]
 [ 1.33630621  1.01904933 -1.37281295]]

标准化总结

在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

2.3 缺失值处理

# sklearn缺失值API:  sklearn.preprocessing.Imputer
"""
Imputer语法
Imputer(missing_values='NaN', strategy='mean', axis=0)
    完成缺失值插补
    Imputer.fit_transform(X,y)       
        X:numpy array格式的数据[n_samples,n_features]
        返回值：转换后的形状相同的array
"""

def im():
    """
    缺失值处理
    :return:NOne
    """
    # NaN, nan
    im = Imputer(missing_values='NaN', strategy='mean', axis=0)

    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6]])

    print(data)

    return None
if __name__ == "__main__":
    im()

[[1. 2.]
 [4. 3.]
 [7. 6.]]

2.4 特征选择

# sklearn.feature_selection.VarianceThreshold
"""
VarianceThreshold语法
VarianceThreshold(threshold = 0.0)
    删除所有低方差特征
    Variance.fit_transform(X,y)       
        X:numpy array格式的数据[n_samples,n_features]
        返回值：训练集差异低于threshold的特征将被删除。
        默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。
"""
def var():
    """
    特征选择-删除低方差的特征
    :return: None
    """
    var = VarianceThreshold(threshold=1.0)

    data = var.fit_transform([[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]])

    print(data)
    return None
if __name__ == "__main__":
    var()

[[0]
 [4]
 [1]]

2.5 特征降维

# sklearn. decomposition 
# PCA是一种分析、简化数据集的技术
# 目的：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。
# 作用：可以削减回归分析或者聚类分析中特征的数量
"""
PCA语法
PCA(n_components=None)
    将数据分解为较低维数空间
    PCA.fit_transform(X)       
        X:numpy array格式的数据[n_samples,n_features]
        返回值：转换后指定维度的array
"""
def pca():
    """
    主成分分析进行特征降维
    :return: None
    """
    pca = PCA(n_components=0.9)

    data = pca.fit_transform([[2,8,4,5],[6,3,0,8],[5,4,9,1]])

    print(data)

    return None

if __name__ == "__main__":
    pca()

[[ 1.22879107e-15  3.82970843e+00]
 [ 5.74456265e+00 -1.91485422e+00]
 [-5.74456265e+00 -1.91485422e+00]]

曾鸿举

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
python学习笔记第二十三天--------特征抽取实例

文章目录1. 特征1.1 特征抽取1.2 字典特征抽取1.3 文本特征抽取1.4 TF-IDF2. 数据的特征处理2.1 归一化2.2 标准化2.3 缺失值处理2.4 特征选择2.5 特征降维1. 特征# 特征抽取，特征抽取针对非连续型数据和对文本等进行特征值化# 1. 导入Scikit-learn库# sklearn特征抽取API--------sklearn.feature_extr...
复制链接

扫一扫