字典数据特征抽取
sklearn的DictVectorizer可以对字典做特征抽取，并以onehot形式编码。
from sklearn.feature_extraction import DictVectorizer
有如下字典：
data = [
{
"city": "北京",
"temperature": 100
},
{
"city": "上海",
"temperature": 80
},
{
"city": "深圳",
"temperature": 30
}
]
创建DictVectorizer对其抽取特征，其抽取结果默认是个sparse矩阵，为了方便观察，这里禁用它：
# 实例化一个字典抽取对象
vec = DictVectorizer(sparse=False)
# 特征抽取
result = vec.fit_transform(data)
# 特征名
print(vec.get_feature_names())
# 特征
print(result)
输出：
['city=上海', 'city=北京', 'city=深圳', 'temperature']
[[ 0. 1. 0. 100.]
[ 1. 0. 0. 80.]
[ 0. 0. 1. 30.]]
文本特征抽取
CountVectorizer可以统计文本词频，以空格和标点为词语分隔，得到的特征忽略了单字和标点：
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import CountVectorizer
data = [
"life is short, i like python.",
"life is too long, i dislike python."
]
vec = CountVectorizer()
result = vec.fit_transform(data)
print(vec.get_feature_names())
print(result.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]]
中文文本分词
中文不像英文那样每个单词都有空格，所以如何识别出文本中的一个个词语，是个问题。
有一个不错的python中文分词组件：结巴(jieba)。
用jieba的cut方法就可以分词，它返回一个可迭代对象，我们用空格把每一次迭代连接起来就得到用空格分隔了词语的文本：
def cutword():
"""
jieba分词
:return:
"""
con1 = jieba.cut("今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")
con2 = jieba.cut("我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")
con3 = jieba.cut("如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")
text1 = " ".join(con1)
text2 = " ".join(con2)
text3 = " ".join(con3)
return text1, text2, text3
输出：
今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。
我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。
如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。
然后再统计词频：
text1, text2, text3 = cutword()
vec = TfidfVectorizer()
result = vec.fit_transform((text1, text2, text3))
print(vec.get_feature_names())
print(result.toarray())
输出：
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
[[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]]
TD-IDF
一种用于信息检索与数据挖掘的常用加权技术。TF意思是词频(Term Frequency)，IDF意思是逆文本频率指数(Inverse Document Frequency)。
如果我们需要评估词语在文本中的重要程度，TD-IDF是个基本的分析方法。
TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，
并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分
能力，适合用来分类。
sklearn也提供基于TD-IDF的文本抽取类：
from sklearn.feature_extraction.text import TfidfVectorizer
我们使用和上一节相同的文本数据：
text1, text2, text3 = cutword()
vec = TfidfVectorizer()
result = vec.fit_transform((text1, text2, text3))
print(vec.get_feature_names())
print(result.toarray())
输出：
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
[[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. ]]
一个词的TD-IDF值越大，越能代表其在文本的重要程度，可作为文本的重要特征。
缺失值处理
缺失值处理方法主要有删除和插补两种。
pandas对nan已经有一些好用的处理方法了，如 dropna，fillna 方法。
此外，sklearn也提供了缺失值的处理方法API：
from sklearn.preprocessing import Imputer
origin = [
[1, 2],
[np.nan, 3],
[7, 6]
]
print("== origin ==")
print(origin)
im = Imputer(missing_values="NaN", strategy="mean")
result = im.fit_transform(origin)
print("== result ==")
print(result)
输出：
== origin ==
[[1, 2], [nan, 3], [7, 6]]
== result ==
[[1. 2.]
[4. 3.]
[7. 6.]]
归一化
归一化对原始数据进行变换，把数据映射到(默认为[0,1])之间。
也可以理解为把数据缩小(放大)到[0, 1]区间。
它的方法是取最小值与最大值构成的空间，作为[0, 1]两端，然后把每一个值投放在其内。
from sklearn.preprocessing import MinMaxScaler
origin = [
[90, 2, 10, 40],
[60, 4, 15, 45],
[75, 3, 13, 46]
]
print("== origin ==")
print(origin)
mm = MinMaxScaler()
result = mm.fit_transform(origin)
print("== result ==")
print(result)
输出：
== origin ==
[[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]]
== result ==
[[1. 0. 0. 0. ]
[0. 1. 1. 0.83333333]
[0.5 0.5 0.6 1. ]]
归一化严重依赖最大值最小值，所以容易受到极端异常数据影响。
标准化
标准化对原始数据进行变换，把数据变换到均值为0,方差为1范围内
from sklearn.preprocessing import StandardScaler
origin = [
[1., -1., 3.],
[2., 4., 2.],
[4., 6., -1.]
]
print("== origin ==")
print(origin)
std = StandardScaler()
result = std.fit_transform(origin)
print("== result ==")
print(result)
输出：
== origin ==
[[1.0, -1.0, 3.0], [2.0, 4.0, 2.0], [4.0, 6.0, -1.0]]
== result ==
[[-1.06904497 -1.35873244 0.98058068]
[-0.26726124 0.33968311 0.39223227]
[ 1.33630621 1.01904933 -1.37281295]]
标准化即是对每个特征分别求标准差，受异常值影响较小。
PCA 降维
PCA，Principle Component Analysis，主成分分析法，在保留大部分信息的前提下，减少特征数量。
sklearn提供了PCA的实现:
from sklearn.decomposition import PCA
比如有一个 5 x 10 数据集，对其应用PCA降维，并保留95%信息(n_components=0.95)：
raw_data = np.random.randint(5, 100, size=(5, 10), dtype=int)
print("=== RAW ===")
print(raw_data)
pca = PCA(n_components=0.95)
result = pca.fit_transform(raw_data)
print("=== RESULT === ")
print(result)
输出：
=== RAW ===
[[16 22 39 76 41 15 56 88 97 62]
[84 34 30 29 92 93 86 43 58 71]
[22 25 5 91 95 20 26 21 76 96]
[61 91 89 5 74 81 54 49 53 19]
[42 76 46 94 51 67 63 98 67 14]]
=== RESULT ===
[[-54.82621578 41.33087911 4.65604456 35.53316399]
[ 33.51882474 -60.81853048 38.16806292 5.40682073]
[-84.87973219 -40.6909857 -23.12093168 -18.78662462]
[ 88.83122554 -2.71020618 -37.00028489 7.79019057]
[ 17.35589769 62.88884325 17.29710909 -29.94355068]]
可以看到，PCA把这个数据集的10个特征降维到4个。
