特征抽取: sklearn.feature_extraction.FeatureHasher

sklearn.feature_extraction.FeatureHasher(n_features=1048576, input_type="dict", dtype=<class ‘numpy.float64‘>, alternate_sign=True, non_negative=False):
　　特征散列化的实现类。
　　此类将符号特性名称(字符串)的序列转换为scipy.sparse矩阵，使用哈希函数计算与名称对应的矩阵列。使用的散列函数是带符号的32位版本的Murmurhash3.

　　字节字符串类型的特征名称按原样使用。Unicode字符串首先转换为UTF-8，但没有进行Unicode规范化。特征值必须是（有限）数字
　　本类是DictVectorizer和CountVectorizer的低内存替代品，用于大规模（在线）学习和内存紧张的情况，例如在嵌入式设备上运行预测代码时。

　　n_features: integer
　　　　输出矩阵的特征数，少量的特征可能引发hash冲突，大量的特征会导致线性学习的维度扩大。
　　input_type:
　　　　"dict"表示输入数据是字典形式的[{feature_name: value}, …],
　　　　"pair"表示输入数据是pair形式的[[(feature_name1, value1), (feature_name2, value2)], …]
　　　　"string"表示数据是字符串形式的[[feature_name1, feature_name1]]，其中有个value1个feature_name1,value2个feature_name2
　　　　其中feature_name必须是字符串，value必须是数字。在"string"的情况下，每个feature_name隐含value是1。特征名称会进行hash处理，来计算该特征名称对应的hash列。value的符号在输出的数据中可能会发生反转。
　　dtype:
　　　　特征值得类型。这个值将传递给scipy.sparse矩阵作为构造器dtype参数的值。这个参数不能设置为bool，np.boolean或者其他无符号的整型。
　　alternate_sign:
　　　　如果为True，则在特征计算出的hash值上交替添加一个符号(正数变成负数)，以便于在散列空间中大致的保留内部积。这种方法类似于稀疏随机投影。

　　non_negative:
　　　　如果为真，在计算结果返回前，对特征矩阵进行绝对值计算。当与alternate_sign=True一同使用时，会显著降低内部积的保存性能。

　　该类的方法与其他的特征提取类的方法一致。
　　以下代码例子来源自sklearn官网API。
　　地址: https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.FeatureHasher.html#sklearn.feature_extraction.FeatureHasher

例子1:

 　 from sklearn.feature_extraction import FeatureHasher
    h = FeatureHasher(n_features=10, input_type=‘string‘, dtype=int, alternate_sign=False)
    d = [{‘dog‘: 1, ‘cat‘: 2, ‘elephant‘: 4}, {‘dog‘: 2, ‘run‘: 5}]
    d = [[(‘dog‘, 1), (‘cat‘, 2), (‘elephant‘, 4)], [(‘dog‘, 2), (‘run‘, 5)]]
    d = [[‘dog‘, ‘cat‘, ‘cat‘, ‘elephant‘, ‘elephant‘,‘elephant‘,‘elephant‘,],
         ["dog", "dog", "run", ‘run‘, ‘run‘, ‘run‘, ‘run‘],
         ["run", "run"]]
    f = h.transform(d)
    print(f.toarray())
    print(h.get_params())

例子2:

from __future__ import print_function
from collections import defaultdict
import re
import sys
from time import time

import numpy as np

from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction import DictVectorizer, FeatureHasher
from memory_profiler import profile

def n_nonzero_columns(X):
    """Returns the number of non-zero columns in a CSR matrix X."""
    return len(np.unique(X.nonzero()[1]))

def tokens(doc):
    """
    简单的将doc拆分成词语，删除英文字母外的符号，并且都小写化
    :param doc:
    :return:
    """
    return (tok.lower() for tok in re.findall(r"\w+", doc))

def token_freqs(doc):
    """
    对doc中的词语进行频率统计
    :param doc:
    :return:
    """
    freq = defaultdict(int)
    for tok in tokens(doc):
        freq[tok] += 1
    return freq

@profile
def dict_vectorizer(raw_data, data_size_mb):
    print("DictVectorizer")
    t0 = time()
    vectorizer = DictVectorizer()
    X = vectorizer.fit_transform(token_freqs(d) for d in raw_data)
    duration = time() - t0
    print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    print("Found %d unique terms\n" % len(vectorizer.get_feature_names()))
    print("X.shape: ", X.shape)

@profile
def feature_hasher_freq(raw_data, data_size_mb, n_features):
    print("FeatureHasher on frequency dicts")
    t0 = time()
    hasher = FeatureHasher(n_features=n_features)
    X = hasher.transform(token_freqs(d) for d in raw_data)
    duration = time() - t0
    print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    print("Found %d unique terms\n" % n_nonzero_columns(X))
    print("X.shape: ", X.shape)
    del X

@profile
def feature_hasher_terms(raw_data, data_size_mb, n_features):
    print("FeatureHasher on raw tokens")
    t0 = time()
    hasher = FeatureHasher(n_features=n_features, input_type="string")
    X = hasher.transform(tokens(d) for d in raw_data)
    duration = time() - t0
    print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    print("Found %d unique terms" % n_nonzero_columns(X))
    print("X.shape: ", X.shape)
    del X

@profile
def compare():
    # 1. 只选择一部分数据
    categories = [
        ‘alt.atheism‘,
        ‘comp.graphics‘,
        ‘comp.sys.ibm.pc.hardware‘,
        ‘misc.forsale‘,
        ‘rec.autos‘,
        ‘sci.space‘,
        ‘talk.religion.misc‘,
    ]

    print("Usage: %s [n_features_for_hashing]" % sys.argv[0])
    print("       The default number of features is 2**18.\n\n")

    try:
        n_features = int(sys.argv[1])
    except IndexError:
        n_features = 2 ** 18
    except ValueError:
        print("not a valid number of features: %r" % sys.argv[1])
        sys.exit(1)

    print("Loading 20 newsgroups training data")
    # 2. 第一次运行时，下载文件需要较长的时间
    # data_home 下载下来的文件保存的位置
    # 如果data_home中没有文件，download_if_missing设置为True，程序会自动下载文件到data_home
    raw_data = fetch_20newsgroups(data_home=r"D:\学习\sklearn_dataset\20newsbydate",
                                  subset=‘train‘,
                                  categories=categories,
                                  download_if_missing=True
                                  ).data

    # 3. 计算文本的大小
    data_size_mb = sum(len(s.encode(‘utf-8‘)) for s in raw_data) / 1e6
    print("%d documents - %0.3fMB\n" % (len(raw_data), data_size_mb))

    dict_vectorizer(raw_data, data_size_mb)
    feature_hasher_freq(raw_data, data_size_mb, n_features)
    feature_hasher_terms(raw_data, data_size_mb, n_features)

if __name__ == ‘__main__‘:
    compare()

例子2输出:
　　

Usage: D:/Project/nlplearn/sklearn_learn/plot_hashing_vs_dictvectorizer.py [n_features_for_hashing]
       The default number of features is 2**18.

Loading 20 newsgroups training data
3803 documents - 6.245MB

DictVectorizer
done in 16.495944s at 0.379MB/s
Found 47928 unique terms

X.shape:  (3803, 47928)
Filename: D:/Project/nlplearn/sklearn_learn/plot_hashing_vs_dictvectorizer.py

Line #    Mem usage    Increment   Line Contents
================================================
    42     98.9 MiB     98.9 MiB   @profile
    43                             def dict_vectorizer(raw_data, data_size_mb):
    44     98.9 MiB      0.0 MiB       print("DictVectorizer")
    45     98.9 MiB      0.0 MiB       t0 = time()
    46     98.9 MiB      0.0 MiB       vectorizer = DictVectorizer()
    47    130.7 MiB      1.3 MiB       X = vectorizer.fit_transform(token_freqs(d) for d in raw_data)
    48    130.7 MiB      0.0 MiB       duration = time() - t0
    49    130.7 MiB      0.0 MiB       print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    50    130.7 MiB      0.0 MiB       print("Found %d unique terms\n" % len(vectorizer.get_feature_names()))
    51    130.7 MiB      0.0 MiB       print("X.shape: ", X.shape)

FeatureHasher on frequency dicts
done in 8.953512s at 0.697MB/s
Found 43873 unique terms

X.shape:  (3803, 262144)
Filename: D:/Project/nlplearn/sklearn_learn/plot_hashing_vs_dictvectorizer.py

Line #    Mem usage    Increment   Line Contents
================================================
    53    106.5 MiB    106.5 MiB   @profile
    54                             def feature_hasher_freq(raw_data, data_size_mb, n_features):
    55    106.5 MiB      0.0 MiB       print("FeatureHasher on frequency dicts")
    56    106.5 MiB      0.0 MiB       t0 = time()
    57    106.5 MiB      0.0 MiB       hasher = FeatureHasher(n_features=n_features)
    58    116.8 MiB      4.0 MiB       X = hasher.transform(token_freqs(d) for d in raw_data)
    59    116.8 MiB      0.0 MiB       duration = time() - t0
    60    116.8 MiB      0.0 MiB       print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    61    116.8 MiB      0.0 MiB       print("Found %d unique terms\n" % n_nonzero_columns(X))
    62    116.8 MiB      0.0 MiB       print("X.shape: ", X.shape)
    63    106.6 MiB      0.0 MiB       del X

FeatureHasher on raw tokens
done in 9.989571s at 0.625MB/s
Found 43873 unique terms
X.shape:  (3803, 262144)
Filename: D:/Project/nlplearn/sklearn_learn/plot_hashing_vs_dictvectorizer.py

Line #    Mem usage    Increment   Line Contents
================================================
    65    106.6 MiB    106.6 MiB   @profile
    66                             def feature_hasher_terms(raw_data, data_size_mb, n_features):
    67    106.6 MiB      0.0 MiB       print("FeatureHasher on raw tokens")
    68    106.6 MiB      0.0 MiB       t0 = time()
    69    106.6 MiB      0.0 MiB       hasher = FeatureHasher(n_features=n_features, input_type="string")
    70    118.6 MiB      4.0 MiB       X = hasher.transform(tokens(d) for d in raw_data)
    71    118.6 MiB      0.0 MiB       duration = time() - t0
    72    118.6 MiB      0.0 MiB       print("done in %fs at %0.3fMB/s" % (duration, data_size_mb / duration))
    73    118.6 MiB      0.0 MiB       print("Found %d unique terms" % n_nonzero_columns(X))
    74    118.6 MiB      0.0 MiB       print("X.shape: ", X.shape)
    75    106.7 MiB      0.0 MiB       del X

Filename: D:/Project/nlplearn/sklearn_learn/plot_hashing_vs_dictvectorizer.py

Line #    Mem usage    Increment   Line Contents
================================================
    78     71.5 MiB     71.5 MiB   @profile
    79                             def compare():
    80                                 # 1. 只选择一部分数据
    81                                 categories = [
    82     71.5 MiB      0.0 MiB           ‘alt.atheism‘,
    83     71.5 MiB      0.0 MiB           ‘comp.graphics‘,
    84     71.5 MiB      0.0 MiB           ‘comp.sys.ibm.pc.hardware‘,
    85     71.5 MiB      0.0 MiB           ‘misc.forsale‘,
    86     71.5 MiB      0.0 MiB           ‘rec.autos‘,
    87     71.5 MiB      0.0 MiB           ‘sci.space‘,
    88     71.5 MiB      0.0 MiB           ‘talk.religion.misc‘,
    89                                 ]
    90
    91     71.5 MiB      0.0 MiB       print("Usage: %s [n_features_for_hashing]" % sys.argv[0])
    92     71.5 MiB      0.0 MiB       print("       The default number of features is 2**18.\n\n")
    93
    94     71.5 MiB      0.0 MiB       try:
    95     71.5 MiB      0.0 MiB           n_features = int(sys.argv[1])
    96     71.5 MiB      0.0 MiB       except IndexError:
    97     71.5 MiB      0.0 MiB           n_features = 2 ** 18
    98                                 except ValueError:
    99                                     print("not a valid number of features: %r" % sys.argv[1])
   100                                     sys.exit(1)
   101
   102     71.5 MiB      0.0 MiB       print("Loading 20 newsgroups training data")
   103                                 # 2. 第一次运行时，下载文件需要较长的时间
   104                                 # data_home 下载下来的文件保存的位置
   105                                 # 如果data_home中没有文件，download_if_missing设置为True，程序会自动下载文件到data_home
   106     71.5 MiB      0.0 MiB       raw_data = fetch_20newsgroups(data_home=r"D:\学习\sklearn_dataset\20newsbydate",
   107     71.5 MiB      0.0 MiB                                     subset=‘train‘,
   108     71.5 MiB      0.0 MiB                                     categories=categories,
   109     98.0 MiB     26.5 MiB                                     download_if_missing=True
   110                                                               ).data
   111
   112                                 # 3. 计算文本的大小
   113     98.9 MiB      0.1 MiB       data_size_mb = sum(len(s.encode(‘utf-8‘)) for s in raw_data) / 1e6
   114     98.9 MiB      0.0 MiB       print("%d documents - %0.3fMB\n" % (len(raw_data), data_size_mb))
   115
   116    106.5 MiB      7.6 MiB       dict_vectorizer(raw_data, data_size_mb)
   117    106.6 MiB      0.1 MiB       feature_hasher_freq(raw_data, data_size_mb, n_features)
   118    106.7 MiB      0.1 MiB       feature_hasher_terms(raw_data, data_size_mb, n_features)

　　从输出信息可以看出:
　　　　FeatureHasher相比于DictVectorizer:
　　　　　　1. FeatureHasher转化的速度更快。如果更改n_features, FeatureHasher的速度会发生变化，但是仍然比DictVectorizer更快一些。
　　　　　　2. FeatureHasher的特征数少于DictVectorizer，部分特征被压缩了。

原文地址：https://www.cnblogs.com/hufulinblog/p/10600156.html

时间： 2024-07-29 23:55:17

特征抽取: sklearn.feature_extraction.FeatureHasher的相关文章

Feature extraction - sklearn文本特征提取

http://blog.csdn.net/pipisorry/article/details/41957763 文本特征提取 词袋(Bag of Words)表征 文本分析是机器学习算法的主要应用领域.但是,文本分析的原始数据无法直接丢给算法,这些原始数据是一组符号,因为大多数算法期望的输入是固定长度的数值特征向量而不是不同长度的文本文件.为了解决这个问题,scikit-learn提供了一些实用工具可以用最常见的方式从文本内容中抽取数值特征,比如说: 标记(tokenizing)文本以及为每一个

sklearn数据变化

一.特征抽取 特征抽取sklearn.feature_extraction 模块提供了从原始数据如文本,图像等众抽取能够被机器学习算法直接处理的特征向量. 1.特征抽取方法之 Loading Features from Dicts measurements=[ {'city':'Dubai','temperature':33.}, {'city':'London','temperature':12.}, {'city':'San Fransisco','temperature':18.}, ]

sklearn中模型抽取

特征抽取sklearn.feature_extraction 模块提供了从原始数据如文本,图像等众抽取能够被机器学习算法直接处理的特征向量. 1.特征抽取方法之 Loading Features from Dicts measurements=[ {'city':'Dubai','temperature':33.}, {'city':'London','temperature':12.}, {'city':'San Fransisco','temperature':18.}, ] from sk

scikit-learn：4.2.3. Text feature extraction

http://scikit-learn.org/stable/modules/feature_extraction.html 4.2节内容太多,因此将文本特征提取单独作为一块. 1.the bag of words representation 将raw data表示成长度固定的数字特征向量.scikit-learn提供了三个方式: tokenizing:给每个token(字.词,粒度自己把握)一个整数索引id counting:每一个token在每一个文档中出现的次数 normalizing:

02_特征工程和文本特征提取

02 特征工程和文本特征提取 数据集的构成 数据存放形式 CSV 文件 mysql: 性能瓶颈,读取速度: 格式不符合机器学习的格式 pandas:读取工具 numpy为什么读取速度快: 动态语言 全局解释性锁 GIL : 释放了 (GIL数据安全),真正的多线程 可用的数据集 Kaggle : 大数据竞赛平台.真实数据.数据量大 UCI: 数据集覆盖科学.生活.经济等领域 Scikit-learn: 数据量小,方便学习 数据集的结构组成 结构: 特征值 + 目标值 特征工程的定义 特征工程是什

利用sklearn进行tfidf计算

转自:http://blog.csdn.net/liuxuejiang158blog/article/details/31360765?utm_source=tuicool 在文本处理中,TF-IDF可以说是一个简单粗暴的东西.它可以用作特征抽取,关键词筛选等. 以网页搜索“核能的应用”为例,关键字分成“核能”.“的”.“应用”.根据直觉,我们知道,包含这三个词较多的网页比包含它们较少的网页相关性强.但是仅仅这样,就会有漏洞,那就是文本长的比文本短的关键词数量要多,所以相关性会偏向长文本的网页.

字典特征抽取

#特征抽取 feature_extraction #导包 # from sklearn.feature_extraction.text import CountVectorizer # # vector = CountVectorizer() # # res = vector.fit_transform(["life is short,i like python ", "life is too long ,i dislike python"]) # # print(

Python的Sklearn库的基本用法

Sklearn库是基于Python的第三方库,它包括机器学习开发的各个方面. 机器学习的开发基本分为六个步骤,1)获取数据,2)数据处理,3)特征工程,4)机器学习的算法训练(设计模型),5)模型评估,6)应用. 机器学习的算法一般分为两种:一种既有目标值又有特征值的算法称之为监督学习,另一种只有特征值的算法称之为无监督学习.而监督学习还可以继续细分为分类算法和回归算法. 1)获取数据⑤ Sklearn中获取数据集使用的包为Sklearn.datasets,之后可以接load_* 和fetch_

python库之——sklearn

机器学习库sklearn 官方documentation(资料)中分为不同的部分: 其中我们主要讲User Guide(机器学习算法理论介绍).API(程序实现方法): 一.User Guide https://scikit-learn.org/stable/user_guide.html 模块 说明 Supervised learning监督学习 监督学习的各种算法介绍 Unsupervised learning非监督学习 非监督学习的各种算法介绍 Model selection and ev