齐刘海的小柴

统计在机器学习中的应用

Wed, 24 Jun 2020 00:00:00 +0000

了解：

探索性的数据分析、数据归纳和数据可视化有助于构建预测模型以及更好地理解数据。
统计学方法可以用来清洗和准备建模要用的数据。
统计假设检验和估计统计可以帮助进行模型选择，并展示最终模型的技能和预测结果。

1、问题架构

问题的架构包括问题类型的选择，例如是回归还是分类，例如这个问题的输入和输出的结构即类型。
统计方法在问题的架构阶段有助于对数据的探索，其中包括：
- 探索性的数据分析。为了从数据中探索到特别的观点，从而进行的汇总和可视化。
- 数据挖掘。自动探索数据间的结构关系和模式。

2、数据理解

数据理解的意思是对变量的分布和变量之间的关系有一个更详细的理解。
用在理解数据的统计学模型的两类主流分支是：
- 汇总统计。使用统计数值来汇总变量间的分布和关系的方法。
- 数据可视化。总结变量间的分布和关系的方法需要用到可视化的方法，例如：图表，绘图和图形。

3、数据清洗

数据清洗是对某些瑕疵数据（数据破坏、数据错误、数据损失）进行识别和修复的过程。
统计方法应用于数据清洗中例子有：
- 异常点检测。在数据分布中识别出离期望值很远的观察值的方法。
- 数据填补。修复或填补观察值中损坏或缺失数据的方法。

4、数据选择

数据选择是在建模时选出相关变量和观测值进行预测的过程。
应用在数据选择的两种统计学方法：
- 数据采样。从较大的数据集中系统化创建较小的代表性样本的方法。
- 特征选择。自动识别与结果变量更有相关性的变量的方法。

5、数据准备

数据准备通过对数据进行必要的转化，改变数据的形状或结构，使数据更适用于选定的问题架构或学习算法。
数据准备用到统计模型包括：
- 缩放。例如标准化和规范化。
- 编码。例如整数编码和独热编码。
- 变换。例如 Box-Cox 变换那样的次方转换。

6、模型评估

模型评估通过对未经过训练的数据进行预测来评估学习方法。
通常，训练过程和评估预测模型的规划过程叫作实验设计，这是统计方法的一个子领域。
- 实验设计。设计系统化的实验来比较独立的变量对结果影响的方法，比如对比预测的精度来选择机器学习算法。
作为实现实验设计的一部分，为了对可利用的数据做最合理的利用同时也为了评估模型的能力，统计学方法被用来重采样一个数据集。
- 重采样方法。为了训练和评估预测模型而将数据集系统化分出子集的方法。

7、模型配置

给定的机器学习算法通常有一套使学习方法能够适应特定问题的超参数。
超参数的配置通常是经验性的，而不是由分析得出的。这需要大量的实验，以评估不同超参数值对模型性能的影响。
两种统计学的子领域的方法可以用于对不同超参数配置产生的结果进行解释和比较，它们是：
- 统计假设检验。根据对结果的假设或期望值，对观察到的结果出现概率进行量化的方法。（提出使用临界值和 p 值）
- 估计统计。使用置信区间去量化一个结果的不确定性的方法。

8、模型选择

模型选择在众多机器学习算法中选择最适合给定的预测建模问题的方法，这可能涉及到项目参与者的自身条件以及用于评估问题的方法的估计技能能否对其给出详细解释。
与模型配置一样，可以使用两类统计方法来解释不同模型的估计技能，并用于模型选择。他们是：
- 统计假设检验。根据对结果的假设或期望值，对观察到的结果出现概率进行量化的方法。（提出使用临界值和 p 值）
- 估计统计。使用置信区间去量化一个结果的不确定性的方法。

9、模型表示

模型表示是在部署模型对真实数据进行预测前展示给相关人员查看。
展示最终模型的一个环节包括展示模型的估计技能。
估计统计领域中的方法可以通过容忍区间和置信区间对机器学习模型的评估能力的不确定性进行量化。
- 估计统计。使用置信区间去量化一个结果的不确定性的方法。

10、模型预测

模型预测是通过使用最终的模型来对我们不知道其输出的新数据进行预测。
作为预测的一部分，量化预测的置信度非常重要。
就像模型表示的过程一样，我们可以使用估计统计领域的方法来量化这种不确定性，例如置信区间和预测区间。
- 估计统计。使用置信区间去量化一个结果的不确定性的方法。

数据挖掘之路

Wed, 24 Jun 2020 00:00:00 +0000

一、数据挖掘经典案例

预测产品未来一段时间用户是否会流失，流失情况怎么样；
公司做了某个促销活动，预估活动效果怎么样，用户接受度如何；
评估用户信用度好坏；
对现有客户市场进行细分，到底哪些客户才是目标客群；
产品上线投放市场后，用户转化率如何，到底哪些运营策略最有效；
运营做了很多工作，公司资源也投了很多，怎么提升产品投入产出比；
一些用户购买了很多商品后，哪些商品同时被购买的几率高；
预测产品未来一年的销量及收益。。。。

二、数据挖掘问题的分类

1、分类问题

用户流失率、促销活动响应、评估用户度都属于数据挖掘的分类问题。
常见的分类方法：决策树、贝叶斯、KNN、逻辑回归、支持向量机和神经网络等。

2、聚类问题

细分市场、细分客户群体都属于数据挖掘的聚类问题。
常见的聚类算法：划分聚类、层次聚类、密度聚类、网格聚类、基于模型聚类等。

3、关联问题

交叉销售问题等属于关联问题
关联分析也叫购物篮分析，常见的关联分析算法：Aprior算法、Carma算法，序列算法等。

4、预测问题

我们要掌握简单线性回归分析、多重线性回归分析、时间序列等。

三、利用 Python 进行数据挖掘

1、Pandas库的操作

Pandas主要用于数据分析
需要掌握：
- pandas 分组计算
- pandas 索引与多重索引（索引比较难，但是却是非常重要的）
- pandas 多表操作与数据透视表

2、Numpy数值计算

Numpy主要用作数据挖掘
需要掌握：
- Numpy array理解；
- 数组索引操作；
- 数组计算；
- Broadcasting(线性代数里面的知识)

3、数据可视化——matplotlib 与 seaborn

Matplotib语法

python最基本的可视化工具就是matplotlib。咋一看Matplotlib与matlib有点像，要搞清楚二者的关系是什么，这样学习起来才会比较轻松。

seaborn的使用

seaborn是一个非常漂亮的可视化工具。

pandas绘图功能

前面说过pandas是做数据分析的，但它也提供了一些绘图的API。

四、核心数据挖掘算法

最小二乘算法
梯度下降
向量化
极大似然估计
Logistic Regression
Decision Tree
RandomForesrt
XGBoost

降维方法总结（未完）

Tue, 23 Jun 2020 00:00:00 +0000

一、降维方法的分类

降维方法主要分为两种：

特征选择：仅保留原始数据集中最相关的变量。
降维：寻找一组较少的新变量，其中每个变量都是输入变量的组合。

二、常用的降维方法

1、缺失值比率（Missing Value Ratio）

（1）理论

当缺失值在数据集中的占比过高时，可以选择直接删除这个变量，因为它包含的信息太少了。
通常设置一个阈值，如果缺失值占比高于阈值，删除它所在的列。
阈值越高，降维方法越积极。

（2）编程实现

# 导入需要的库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 读取数据
train = pd.read_csv("Train_example.csv")

# 用 .isnull().sum() 检查每个变量中缺失值的占比
train.isnumm().sum()/len(train)*100 # 由结果设阈值为20%

# 保存变量中的缺失值
a = train.isnull().sum()/len(train)*100
# 保存列名
variables = train.columns
variable = []
for i in range(0,12):
  if a[i] <= 20:			# 设阈值为20%
    variable.append(variables[i])

2、低方差滤波（Low Variance Filter）

（1）理论

通常认为低方差变量携带的信息量很少，所以可以直接删除。
注意：方差与数据范围相关，因此采用该方法前需对数据归一化。

（2）编程实现

# 接上例，我们现估算缺失值
train['Weight'].fillna(train['Weight'].median, inplace=True)
train['Size'].fillna(train['Size'].mode()[0], inplace=True)

# 检查缺失值是否已经被填充
train.isnull().sum()/len(train)*100

# 计算所有数值变量的方差
train.var()

# 保留方差大于10的变量
numeric = train[['Weight','Visibility','MRP','Size']] # 提取数值列
var = numeric.var()
numeric = numeric.columns
variable = []
for i in range(0,len(var)):
  if var[i] >= 10:		# 将阈值设置为10
    variable.append(numeric[i+1])

3、高相关滤波（High Correlation filter）

（1）理论

如果两个变量间高度相关，意味着它们具有相似的趋势并且可能携带类似的信息。
并且这类变量的存在会降低某些模型的性能（例如线性和逻辑回归模型）。
我们可以计算独立数值变量间的相关性，如果相关系数超过某个阈值，就删除其中一个变量。
通常情况下，如果一对变量间相关性大于0.5-0.6，就可以考虑删除一列。

（2）编程实现

# 首先删除因变量（Sales），并将剩余的变量保存在新的数据列 df 中
df = train.drop('Sales', 1)
df.corr()

4、随机森林（Random Forest）

（1）理论

随机森林是一种广泛使用的特征选择算法，它会自动计算各个特征的重要性。
随机森林只接受数字输入。

（2）编程实现

# 首先将数据转换为数字格式，并删除不重要的 ID 列
from sklearn.ensemble import RandomForestRegressor
df = df.drop('ID', axis = 1)
df = pd.get_dummies(df)

# 拟合模型
model = RandomForestRegressor(random_state=1, max_depth=10)
model.fit(df,train.Sales)

# 根据特征的重要性绘制成图
features = df.columns
importances = model.feature_importances_
indices = np.argsort(importances[0:9])   # 重要性最高的10个特征
plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Import')
plt.show()

# 可以手动选择重要性最高的特征来减少数据集中的维度
# 也可以直接使用 sklearn 中的 SelectFromModel，它根据权重的重要性选择特征
from sklearn.feature_selection import SelectFromModel
feature = SelectFromModel(model)
Fit = feature.fit_transform(df, train.Sales)

5、反向特征消除（Backward Feature Elimination）

（1）理论

反向特征消除对应的是统计学变量选择方法中的“后退法”。
以下是反向特征消除的主要步骤：
1. 先获取数据集中的全部 n 个变量，然后用他们训练一个模型；
2. 计算模型的性能；
3. 在删除每个变量（n 次）后计算模型的性能，即我们每次都去掉一个变量，用剩余的 n-1 个变量训练模型；
4. 确定对模型性能影响最小的变量，把它删除；
5. 重复此过程，直到不再能删除任何变量。

（2）编程实现

# 构建线性回归模型，Logistic回归模型同理
from sklearn.linear_model import LinearRegression
from sklearn.feature_selection import RFE
from sklearn import datasets
lreg = LinearRegression()
rfe = RFE(lreg, 10)
rfe = rfe.fit_transform(df, train.Sales)

6、前向特征选择（Forward Feature Selection)

（1）理论

前向特征选择其实就是反向特征消除的相反过程，即找到能改善模型性能的最佳特征，而不是删除弱影响特征。
前向特征选择对应的是统计学变量选择方法中的“前进法”。
以下是前向特征选择的主要步骤：
1. 每次选择一个特征，训练模型 n 次，得到 n 个模型；
2. 选择模型性能最佳的变量作为初始变量；
3. 每次添加一个变量继续训练，重复上一过程，最后保留性能提升最大的变量；
4. 一直添加，一直筛选，直到模型性能不再有明显提高。

（2）编程实现

# 返回每个变量的 F 值和相对应的 p 值
from sklearn.feature_selection import f_regression
ffs = f_regression(df, train.Sales)	

# 选择 F 值大于10的变量
variable = []
for i in range(0,len(df.columns)-1):
  if ffs[0][i] >= 10:
    variable.append(df.columns[i])

注：前向特征选择和反向特征消除耗时较久，计算成本也都很高，所以只适用于输入变量较少的数据集。

7、因子分析

（1）原理

因子分析从多个变量中提取共性因子，并得到最优解。例如变量“收入”和“教育”，它们可能是高度相关的，因为总体来看，学历高的人一般收入也越高。所以他们可能存在一个潜在的共性因子：“能力”。
在因子分析中，我们将变量按照其相关性分组，即组内变量相关性较高，组间变量相关性较低。
我们把每个组称为一个因子，它是多个变量的组合。（是否有点像稀疏主成分分析？只是因子分析限定了不同因子的组成变量是不相关的，而稀疏主成分分析没有对此严格限制。）

（2）编程实现

import pandas as pd
import numpy as np
from glob import glob
import cv2
# 这里必须使用 train 文件夹的路径替换 glob 函数内的路径。
images = [cv2.imread(file) for file in glob('train/*.png')]

# 将图像转换为 numpy 数组格式，以便执行数学运算并绘制图像。
images = np.array(images)
images.shape
# Output: (60000,28,28,3)

# 将上面的三位数组转成一维（因为后续只接受一维输入），将图像展平：
image = []
for i in range(0,60000):
  img = images[i].flatten()
  image.append(img)
image = np.array(image)

# 创建一个数据框，其中包含每个像素的像素值，以及它们对应的标签：
train = pd.read_csv("/train.csv")
feat_cols = [ 'pixel'+str(i) for i in range(image.shape[1])]
df = pd.DataFrame(image, columns=feat_cols)
df['label'] = train['label']

# 用因子分析分解数据集，n_components 决定转换数据中的因子数量
from sklearn.decomposition import FactorAnalysis
FA = FactorAnalysis(n_components=3).fit_transform(df[feat_cols].values)

# 可视化因子转换结果
%matplotlib inline 
import matplotlib.pyplot as plt
plt.figure(figsize=(12,8))
plt.title('Factor Analysis Components')
plt.scatter(FA[:,0], FA[:,1])
plt.scatter(FA[:,1], FA[:,2])
plt.scatter(FA[:,2], FA[:,0])

8、主成分分析（PCA）

（1）原理

因子分析假设存在一系列潜在因子，能反映变量携带的信息。
主成分分析通过正交变换将原始的 n 维数据集变化到一个新的被称作主成分的数据集中，即从现有的大量变量中提取一组新的变量。

（2）编程实现

# 在降维前，先随机绘制数据集中的某些图
rndperm = np.random.permutation(df.shape[0])
plt.gray()
fig = plt.figure(figsize=(20,20))
for i in range(0,15):
  ax = fig.add_subplot(3,5,i+1)
  ax.matshow(df.loc[rndperm[i],feat_cols].values.
            reshape((28,28*3)).astype(float))

# 实现 PCA，其中 n_components 决定转换数据中的主成分数量
from sklearn.decomposition import PCA
pca = PCA(n_components=4)
pca_result = pca.fit_transform(df[feat_cols].values)

# 接下来看4个主成分解释了多少方差
plt.plot(range(4), pca.explained_variance_ratio_)
plt.plot(range(4), np.cumsum(pca.explained_variance_ratio_))
plt.title("Component-wise and Cumulative Explained Variance")

9、独立分量分析（ICA）

（1）原理

独立分量分析（ICA）基于信息理论，是最广泛使用的降维技术之一。
PCA 和 ICA 之间的主要区别在于，PCA 寻找不相关的因素，而 ICA 寻找独立因素。（如果两个变量不相关，它们之间就没有线性关系。如果它们是独立的，它们就不依赖于其他变量。例如，一个人的年龄和他吃了什么/看了什么电视无关。）
ICA 假设给定变量是一些未知潜在变量的线性混合。它还假设这些潜在变量是相互独立的，即它们不依赖于其他变量，因此它们被称为观察数据的独立分量。
测试分量独立性最常用的方法是非高斯性：
- 根据中心极限定理，多个独立随机变量混合之后会趋向于正态分布（高斯分布）。
- 因此，我们可以寻找所有独立分量中能最大化峰度的分量。
- 一旦峰度被最大化，整个分布会呈现非高斯分布，我们也能得到独立分量。

（2）编程实现

from sklearn.decomposition import FastICA
ICA = FastICA(n_components=3, random_state=12)
X = ICA.fit_transform(df[feat_cols].values)

10、IOSMAP

（1）原理

未完

（2）编码实现

# n_neighbors：决定每个点的相邻点数
# n_components：决定流行的坐标数
# n_jobs=-1：使用所有可用的 CPU 核心
from sklearn import manifold
trans_data = manifold.Isomap(n_neighbors=5, n_components=3, n_jobs=-1).fit_transform(df[feat_cols][:6000].values)

# 可视化
plt.figure(figsize=(12,8))
plt.title('Decomposition using ISOMAP')
plt.scatter(trans_data[:,0], trans_data[:,1])
plt.scatter(trans_data[:,1], trans_data[:,2])
plt.scatter(trans_data[:,2], trans_data[:,3])

11、t-SNE

（1）原理

未完

（2）编程实现

from sklearn.manifold import TSNE
tsne = TSNE(n_components=3, n_iter=300).fit_transform(df[feat_cols][:6000].values)

# 可视化
plt.figure(figsize=(12,8))
plt.title('t-SNE components')
plt.scatter(tsne[:,0], tsne[:,1])
plt.scatter(tsne[:,1], tsne[:,2])
plt.scatter(tsne[:,2], tsne[:,0])

12、UMAP

（1）原理

未完

（2）编码实现

# n_neighbors：确定相邻点的数量
# min_dist：控制允许嵌入的紧密程度，较大的值可确保嵌入点的分布更均匀
import umap
umap_data = umap.UMAP(n_neighbors=5, min_dist=0.3, n_components=3).fit_transform(df[feat_cols][:6000].values)

# 可视化
plt.figure(figsize=(12,8))
plt.title('Decomposition using UMAP')
plt.scatter(umap_data[:,0], umap_data[:,1])
plt.scatter(umap_data[:,1], umap_data[:,2])
plt.scatter(umap_data[:,2], umap_data[:,0])

13、Hash Trick

（1）原理

Hash Trick 是自然语言处理中降维的手段，它可以对类别特征进行降维。
Hash Trick 利用哈希函数来降维。例如对所有的 location_id 取余：location_id(mod p)，就可以将 location 映射到 p 个不同的数值上。在此之上再用 one-hot encoding，我们就只增加了 p 列。

（2）编程实现

未完

三、降维方法总结

方法	适用范围
缺失值比率	适合数据集缺失太多情况
低方差滤波	可以识别和删除常量变量
高相关滤波	可以解决多重共线性
随机森林	可以明确算出每个特征的重要性
前向特征选择	只适用于输入变量较少的数据集
反向特征消除	只适用于输入变量较小的数据集
因子分析	适合数据集中存在高度相关变量集的情况
PCA	广泛用于处理线性数据
ICA	可以得到独立分量数据
ISOMAP	适合非线性数据处理
t-SNE	适合非线性数据处理，相较 ISOMAP，可视化更直接
UMAP	适合高维数据，相较 t-SNE，速度更快
Hash Trick	适合自然语言处理中的类别特征（类别数特别多的情况）

有趣的 scala 语言

Mon, 22 Jun 2020 00:00:00 +0000

一、使用递归的方式去思考

1、一个简单问题：对数列 xs 进行求和（不使用函数）

Python 循环解法：

def my_sum(xs):
  sums = 0
  for i in length(xs):
    sums += xs[i]
  return sums

Scala 递归解法：

//xs.head 返回列表的第一个元素（头元素）
//xs.tail 返回除头元素外剩余元素组成的列表
def my_sum(xs: List[Int]): Int =
  if (xs.isEmpty) 0 else xs.head + my_sum(xs.tail)

使用 Scala 递归，只需一行，更简洁。

2、常见数据结构：反转字符串

Python 解法：

def reverse(xs):
  return xs[::-1]

Scala 解法：

def reverse(xs: String): String =
  if (xs.length==1) xs else reverse(xs.tail) + xs.head  

使用 scala 递归，仍然只需一行。

3、经典数据结构：快速排序

Python 解法：

def quickSort(xs):
  pivot = xs[0]
  left = [elem for elem in xs if elem < pivot]
  right = [elem for elem in xs if elem >= pivot]
  return quickSort(left) + pivot + quickSort(right)

Scala 解法：

def quickSort(xs: List[Int]): List[Int] = {
  if (xs.isEmpty) xs
  else
    quickSort(xs.filter(x=>x<xs.head)):::xs.head::quickSort(xs.filter(x=>x>xs.head))
}

4、尾递归

问题：相比循环，递归存在效率问题。因为每一次递归调用，都会分配一个新的函数栈，如果递归嵌套很深，容易出现栈溢出的问题。
解决方案：尾递归（在函数调用的最后一步，只调用该递归函数本身。此时无需记住其他的变量，当前的函数栈可以被重复使用）？

递归求阶乘（当 n 很大时，函数栈将很快被耗尽）

def factorial(n: Int): Int = 
  if (n == 0) 1 else n * factorial(n - 1)

尾递归求阶乘

def factorial(n: Int): Int = {
  @tailrec //该注释用来确保程序员写出来的是正确的尾递归程序，如果不是，则编译器会报错
  def loop(acc: Int, n: Int): Int = 
    if n == 0 acc else loop(n * acc, n - 1)
  loop(1, n)
}

Note：在上面的尾递归程序中，在阶乘函数内部又定义了一个新的递归函数，该函数最后一步要么返回结果，要么定义该递归函数本身（对比前面的递归程序，可以发现它们非常相似，不同在于前面的递归程序最后一步不能直接返回结果，还需要计算）。新递归函数多出一个变量 acc，每次递归调用都会更新该变量，直到递归边界条件满足时返回该值，即为最后的计算结果。

5、零钱兑换问题

问题描述：假设某国的货币有若干面值，现给一张大面值的货币要兑换成零钱，问有多少种兑换方式？

Python 动态规划求解需要的最小硬币个素

def countChange(money, coins):
  coins.sort()
  dp = {0:0}
  for i in range(1, money + 1):
    dp[i] = money + 1
    for j in coins:
      if j <= i:
        dp[i] = min(dp[i], dp[i-j] + 1)
  if dp[money] == money + 1: #当最小硬币个数为最小值时，代表不存在硬币组合能构成此金额
    return -1
  else:
    return dp[money] 

Python 非递归解法：动态规划

def change(money, coins):
  dp = [0] * (money + 1)
  dp[0] = 1
  for coin in coins:
    for x in range(coin, money + 1):
      dp[x] += dp[x - coin]
  return dp[money]

Scala 递归解法

def countChange(money: Int, coins: List[Int]): Int = {
  if (money == 0) 
    0 
  else if (coins.size == 0 || money < 0) 
    0 
  else 
    countChange(money, coins.tail) + countChange(money - coins.head, coins) //找零的方法数 = 不使用第一种硬币进行找零的方法数 + 使用第一种硬币进行找零的方法数
}

二、函数式编程

1、高阶函数与匿名函数

问题：练习题：求1-10的和、求1-10的平方和、求1-10的立方和、求1-10的阶乘和，如何编程求解？

使用高阶函数定义求和函数

def id(n: Int) = n 
def cube(n: Int) = n * n * n //定义函数求立方
def square(n : Int) = n * n  //定义函数求平方
def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) //定义函数求阶乘
 
// 高阶函数
def sum(f: Int => Int, a: Int, b: Int): Int = 
  if (a > b) 0 else f(a) + sum(f, a + 1, b) //定义求和函数
 
// 使用高阶函数定义求和函数
def sumInt(a: Int, b: Int): Int = sum(id, a, b) 
def sumCube(a: Int, b: Int): Int = sum(cube, a, b) 
def sumSquare(a: Int, b: Int): Int = sum(square, a, b) 
def sumFact(a: Int, b: Int): Int = sum(fact, a, b) 

思考：多数情况下，我们关心的是高阶函数，而不是作为参数传入的函数，所以为其单独定义一个函数是没有必要的。

在高阶函数中使用匿名函数

def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
 
// 高阶函数
def sum(f: Int => Int, a: Int, b: Int): Int = 
   if (a > b) 0 else f(a) + sum(f, a + 1, b) 
 
// 使用高阶函数重新定义求和函数
def sumCube(a: Int, b: Int): Int = sum(x => x * x * x, a, b) //使用匿名函数 x => x * x * x
def sumSquare(a: Int, b: Int): Int = sum(x => x * x, a, b) //使用匿名函数 x => x * x
def sumFact(a: Int, b: Int): Int = sum(fact, a, b) 
def sumInt(a: Int, b: Int): Int = sum(x => x, a, b) //使用匿名函数 x => x

2、柯里化

Don’t Repeat Yourself !

问题：上面几个求和函数的上下限变量 a、b 被重复传来传去，如何解决？

返回函数的高阶函数

def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
 
// 高阶函数
def sum(f: Int => Int): (Int, Int) => Int = { 
  def sumF(a: Int, b: Int): Int = 
    if (a > b) 0 else f(a) + sumF(a + 1, b) 
  sumF 
} 

// 使用高阶函数重新定义求和函数
def sumCube: Int = sum(x => x * x * x) 
def sumSquare: Int = sum(x => x * x) 
def sumFact: Int = sum(fact) 
def sumInt: Int = sum(x => x) 

再简化：

直接调用高阶函数

def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
 
// 高阶函数
def sum(f: Int => Int): (Int, Int) => Int = { 
  def sumF(a: Int, b: Int): Int = 
    if (a > b) 0 else f(a) + sumF(a + 1, b)
  sumF 
} 
  
// 这些函数没有必要了
//def sumCube: Int = sum(x => x * x * x) 
//def sumSquare: Int = sum(x => x * x) 
//def sumFact: Int = sum(fact) 
//def sumInt: Int = sum(x => x) 
 
// 直接调用高阶函数 ! 
sum(x => x * x * x) (1, 10) //=> sumCube(1, 10) 
sum(x => x) (1, 10)           //=> sumInt(1, 10) 
sum(x => x * x) (1, 10)      //=> sumSquare(1, 10) 
sum(fact) (1, 10)             //=>  sumFact(1, 10)

上面的sum函数可以简写为：

高阶函数的语法糖

// 没使用语法糖的 sum 函数
def sum(f: Int => Int): (Int, Int): Int = { 
  def sumF(a: Int, b: Int): Int = 
    if (a > b) 0 else f(a) + sumF(a + 1, b) 
 sumF 
} 

// 使用语法糖后的 sum 函数
def sum(f: Int => Int)(a: Int, b: Int): Int = 
  if (a > b) 0 else f(a) + sum(f)(a + 1, b)

知识图谱原理（未完成）

Mon, 22 Jun 2020 00:00:00 +0000

想象一个场景，在百度中输入“姚明有多高”，会出现哪些界面？

十年前的百度，可能会出现百度百科、相关新闻等等；
现在的百度（直接给出结果）：

这里运用了知识图谱。

当然，作为知识图谱的创建者，Google给出的结果更为高级：

一、什么是知识图谱？

Google知识图谱的宣传语“things not strings”给出了知识图谱的精髓，即，不要无意义的字符串，而是获取字符串背后隐含的对象或事物。

1、知识图谱的定义

抽象：知识图谱本质上是语义网络（Semantic Network）的知识库
实际应用：可以简单地把知识图谱理解成多关系图（Multi-relational Graph）

2、什么是多关系图？

多关系图一般包含多种类型的节点和多种类型的边。比如左下图表示一个经典的图结构，右边的图则表示多关系图，因为图里包含了多种类型的节点和边。这些类型由不同的颜色来标记。

现实世界中的很多场景非常适合用知识图谱来表达。比如一个社交网络图谱里，我们既可以有“人”的实体，也可以包含“公司”实体。人和人之间的关系可以是“朋友”，也可以是“同事”关系。人和公司之间的关系可以是“现任职”或者“曾任职”的关系。类似的，一个风控知识图谱可以包含“电话”、“公司”的实体，电话和电话之间的关系可以是“通话”关系，而且每个公司它也会有固定的电话。

3、深度学习与知识图谱

我们将深度学习归纳为隐性的模型，它通常是面向某一个具体任务，比如说下围棋、识别猫、人脸识别、语音识别等等。通常而言，在很多任务上它能够取得非常优秀的结果，同时它也有非常多的局限性，比如说它需要海量的训练数据，以及非常强大的计算能力，难以进行任务上的迁移，而且可解释性比较差。
另一方面，知识图谱是人工智能的另外一大技术驱动力，它能够广泛地适用于不同的任务。相比深度学习，知识图谱中的知识可以沉淀，可解释性非常强，类似于人类的思考。

二、知识图谱的表示

深度学习入门

Mon, 22 Jun 2020 00:00:00 +0000

引言：多层感知器（MLP）

MLP 是我们最开始学习的神经网络模型结构，它具有输入层、多个隐藏层以及输出层，通过反向传播进行学习。
利用MLP的方式并不能处理所有问题，因为它没法辨别处理时序性的问题，，例如：当输入为[1, 2, 3] 希望输出4 ，而当输入[3, 2, 1] 时希望输出0 ，对于MLP来说，[1, 2, 3] 和 [3, 2, 1] 是相同的，因此无法得到预期的结果。

一、循环神经网络（RNN）

1、语言模型

语言模型：给定一句话前面的部分，预测接下来最有可能的一个词是什么。

（1）N-Gram 模型

预测横线处内容

我 昨天 上学 迟到 了，老师 批评 了 ___。

如果使用 2-Gram，电脑会在语料库中，搜索【了】后面最可能的一个词（显然不靠谱）。
如果使用 3-Gram，电脑会在语料库中，搜索【批评了】后面最可能的一个词（比上者靠谱，但远远不够，因为最关键的信息是【我】）。

（2）RNN

RNN 理论上可以往前看（往后看）任意多个单词。

2、循环神经网络

网络在 t 时刻接收到输入值 x_t 之后，隐藏层的值是 s_t，输出层的值是 o_t。可以用下面的公式来表示循环神经网络的计算方法： $o_t = g(V s_t) \quad(1)\\ s_t = f(U x_t + W s_{t-1}) \quad(2)$ 式(1)是输出层的计算公式，输出层是一个全连接层，也就是它的每个节点都和隐藏层的每个节点相连。V是输出层的权重矩阵，g是激活函数。式(2)是隐藏层的计算公式，它是循环层。U是输入x的权重矩阵，W是上一次的值作为这一次的输入的权重矩阵，f是激活函数。

从上面可以看出，循环神经网络的输出值，是受前面历次输入值 $x_t$，$x_{t-1}$，$x_{t-2}$ $\cdots$影响的，这就是为什么循环神经网络可以往前看任意多个输入值的原因。

3、双向循环神经网络

对于语言模型来说，很多时候光看前面的词是不够的，比如：

预测横线处内容

我 的 手机 坏 了，我 打算____一部 新 手机。

可以想象，如果我们只看横线前面的词，手机坏了，那么我是打算修一修？换一部新的？还是大哭一场？这些都是无法确定的。但如果我们也看到了横线后面的词是『一部新手机』，那么，横线上的词填『买』的概率就大得多了。

在上一小节中的基本循环神经网络是无法对此进行建模的，因此，我们需要双向循环神经网络，如下图所示：

从上图可以看出，双向循环神经网络的隐藏层要保存两个值，一个 A_i 参与正向计算，另一个值 A’_i 参与反向计算。最终的输出值 $y_i$取决于$ A_i$ 和 $A’_i$。

其计算方法为： $y_i = g(V A_i + V' A'_i)\\ A_{i+1} = f(W A_i + U x_{i+1})\\ A'_{i+1} = f(W' A'_{i+2} + U' x_{i+1})$

从而，我们可以总结出双向循环神经网络的计算方法： $o_t = g(V s_t + V' s'_t)\\ s_{t+1} = f(W s_t + U x_{t+1})\\ s'_{t+1} = f(W' s'_{t+2} + U' x_{t+1})$

二、长短时记忆网络（LSTM）

LSTM 是 RNN 的一种，不同之处在于其有了更多的控制单元：input gate、output gate 以及 forget gate。

在t时刻，LSTM的输入有三个：当前时刻网络的输入值 $x_t$、上一时刻LSTM的输出值 $h_{t-1}$、以及上一时刻的单元状态 $c_{t-1}$；LSTM的输出有两个：当前时刻LSTM输出值 $h_t$、和当前时刻的单元状态 $c_t$。

LSTM的关键，就是怎样控制长期状态 c。在这里，LSTM的思路是使用三个控制开关。第一个开关，负责控制继续保存长期状态 c；第二个开关，负责控制把即时状态输入到长期状态 c；第三个开关，负责控制是否把长期状态 c 作为当前的LSTM的输出。

文本挖掘入门

Mon, 22 Jun 2020 00:00:00 +0000

一、什么是文本挖掘？

文本挖掘的意义就是从文本数据中寻找有价值的信息，来发现或者解决一些实际问题。文本挖掘中最重要最基本的应用是实现文本的分类和聚类，前者是有监督的挖掘算法，后者是无监督的挖掘算法。
wiki版本：文本挖掘，也称为文本数据挖掘，大致相当于文本分析，是从文本中获取高质量信息的过程。文本挖掘通常涉及构造输入文本的过程（通常解析，添加一些派生的语言特征和删除其他特征，然后插入到数据库中），在结构化数据中导出模式，最后评估和解释输出。典型的文本挖掘任务包括文本分类，文本聚类，概念/实体提取，粒度分类法的生成，情感分析，文档摘要和实体关系建模（即，命名实体之间的学习关系）。

二、文本挖掘的步骤

Step1. 文本数据收集
Step2. 文本预处理
- Step2.1 文本数据清洗
- Step2.2 文本分词（自定义字典➡️自定义停止词➡️分词）
Step3. 构建文档-词条矩阵并转换为数据框
Step4. 对数据框建立统计、挖掘模型
Step5. 模型评估

三、文本挖掘的分类

1、关键词提取

对长文本的内容进行分析，输出能够反映文本关键信息的关键词。

2、文本摘要

许多文本挖掘应用程序需要总结文本文档，以便对大型文档或某一主题的文档集合做出简要概述。

3、聚类

聚类是从未标注文本中获取隐藏数据结构的技术，常见的有 K均值聚类和层次聚类。

4、文本分类

文本分类使用监督学习的方法，以对未知数据的分类进行预测。

5、文本主题模型

LDA（Latent Dirichlet Allocation）是一种文档主题生成模型，为一个三层贝叶斯概率模型，包含词、主题和文档三层结构。

6、观点抽取

对文本（主要针对评论）进行分析，抽取出核心观点，并判断极性(正负面)，主要用于电商、美食、酒店、汽车等评论进行分析。

7、情感分析

对文本进行情感倾向判断，将文本情感分为正向、负向、中性。用于口碑分析、话题监控、舆情分析。

四、中文文本挖掘预处理总结

1、收集数据

2、除去数据中非文本部分

少量的非文本内容可以用 python 的正则表达式（re）删除，复杂的则可以用 beautifulsoup 来去除。

3、中文分词

常见的中文分词软件有很多，比如 jieba 分词。

4、引用停用词

在分词后的文本中有很多无效的词，比如“着”，“和”，还有一些标点符号，这些我们不想在文本分析的时候引入，因此需要去掉，这些词就是停用词。常用的中文停用词表是1208个，下载地址在这。

在我们用scikit-learn做特征处理的时候，可以通过参数stop_words来引入一个数组作为停用词表。

5、特征处理

现在我们就可以用scikit-learn来对我们的文本特征进行处理了，在文本挖掘预处理之向量化与Hash Trick中，我们讲到了两种特征处理的方法，向量化与Hash Trick。而向量化是最常用的方法，因为它可以接着进行TF-IDF的特征处理。在文本挖掘预处理之TF-IDF中，我们也讲到了TF-IDF特征处理的方法。

（1）词袋模型

词袋模型（Bag of Words, BoW）：词袋模型假设我们不考虑文本中词与词之间的上下文关系，仅仅只考虑所有词的权重。而权重与词在文本中出现的频率有关。

词袋模型三部曲：分词（tokenizing），统计修订词特征值（counting）与标准化（normalizing）

词袋模型局限性：它仅仅考虑了词频，没有考虑上下文的关系，因此会丢失一部分文本的语义。但是大多数时候，如果我们的目的是分类聚类，则词袋模型表现的很好。

（2）特征处理之向量化

在词袋模型的统计词频这一步，我们会得到该文本中所有词的词频，有了词频，我们就可以用词向量表示这个文本。

Scikit-learn 的 CountVectorizer 类可以帮我们完成文本的词频统计与向量化。

向量化的方法很好用，也很直接，但是在有些场景下很难使用，比如分词后的词汇表非常大，达到100万+，此时如果我们直接使用向量化的方法，将对应的样本对应特征矩阵载入内存，有可能将内存撑爆，在这种情况下我们怎么办呢？第一反应是我们要进行特征的降维，说的没错！而Hash Trick就是非常常用的文本特征降维方法。

（3）特征处理之 Hash Trick

A. 什么是 Hash trick？

Hashing trick，有时候也叫做feature hashing，是自然语言处理中降维的手段。在一般的机器学习任务中，它也可以对categorical feature进行降维。

举个例子，比如你是淘宝的算法工程师，你要做一个退货的预测模型，假设有一个 feature 是 location_id，表示商品的产地。这个是 categorical feature ，所以你通常需要做 one-hot encoding，把这一列转化为 dummy variable。商品来自全国各市、全球各国，可能这个 location_id 就有成千上万个数值。转码之后，模型就会增加这一万个 dummy 变量。这对数据的读取、操作，模型的训练都是极大的挑战。

Hashing trick 就是用 hashing function 这个小技巧来降维。若 location_id 都是整数，我们可以对所有的 location_id 取余，location_id (mod p)，这个取余函数就是我们使用的 hashing function。很显然进行取余操作之后，我们最多只有p个不同的数值了。在此之上再用 one-hot encoding，我们只增加了p列。

B. Hash trick 的优缺点

Hashing trick有三个主要的优点

降维程度大
计算快速、方便
不要额外的存储空间（额外的参考词典等）

但是，也有些缺点。比如我们观察到上面产地编号9126和21除以5的余数都是1，它们就被放到了一起。在Hashing trick中，这种冲突和合并是无法避免的。但是根据一些论文和大量业界应用的结果，这种冲突合并对预测模型的表现的影响微乎其微。另一个缺点，因为大量的数值并合并，这使得模型和结果不易interpret。

（4）文本挖掘预处理之TF-IDF

TF-IDF是Term Frequency - Inverse Document Frequency的缩写，即“词频-逆文本频率”。它由两部分组成，TF和IDF。

前面的TF也就是我们前面说到的词频，我们之前做的向量化也就是做了文本中各个词的出现频率统计，并作为文本特征，这个很好理解。关键是后面的这个IDF，即“逆文本频率”如何理解。在上一节中，我们讲到几乎所有文本都会出现的”to”其词频虽然高，但是重要性却应该比词频低的”China”和“Travel”要低。我们的IDF就是来帮助我们来反应这个词的重要性的，进而修正仅仅用词频表示的词特征值。

概括来讲， IDF 反应了一个词在所有文本中出现的频率，如果一个词在很多的文本中出现，那么它的IDF值应该低，比如上文中的“to”。而反过来如果一个词在比较少的文本中出现，那么它的IDF值应该高。比如一些专业的名词如“Machine Learning”。这样的词IDF值应该高。一个极端的情况，如果一个词在所有的文本中都出现，那么它的IDF值应该为0。

一个词 𝑥 的 IDF 的基本公式如下： $IDF(x)=\log \frac{N(x)+1}{N+1}+1$ 其中，$𝑁$代表语料库中文本的总数，而$𝑁(𝑥)$代表语料库中包含词𝑥的文本总数。

有了 IDF 的定义，我们就可以计算某一个词的 TF-IDF 值了：

$TF−IDF(x)=TF(x)∗IDF(x)$

其中 TF(x) 指词 𝑥 在当前文本中的词频。

TF-IDF 是非常常用的文本挖掘预处理基本步骤，但是如果预处理中使用了Hash Trick，则一般就无法使用TF-IDF了，因为Hash Trick后我们已经无法得到哈希后的各特征的IDF的值。使用了IF-IDF并标准化以后，我们就可以使用各个文本的词特征向量作为文本的特征，进行分类或者聚类分析。

6、建立分析模型

有了每段文本的TF-IDF的特征向量，我们就可以利用这些数据建立分类模型，或者聚类模型了，或者进行主题模型的分析。

探索性数据分析（EDA）

Mon, 22 Jun 2020 00:00:00 +0000

一文带你探索性数据分析

探索性数据分析

一、什么叫探索性数据分析？

1、定义

探索性数据分析（Exploratory Data Analysis，简称EDA），是指对已有的数据（特别是调查或观察得来的原始数据）在尽量少的先验假定下进行探索，通过作图、制表、方程拟合、计算特征量等手段探索数据的结构和规律的一种数据分析方法。

wiki解释：

In statistics, exploratory data analysis(EDA) is an approach to analyzing data sets to summarize their maincharacteristics, often with visual methods. A statistical model can be used or not, but primarily EDA is for seeing what the data can tell us beyond theformal modeling or hypothesis testing task. Exploratory data analysis waspromoted by John Tukey to encourage statisticians to explore the data, andpossibly formulate hypotheses that could lead to new data collection andexperiments. EDA is different from initial data analysis (IDA), which focuses more narrowly on checking assumptions required for model fitting and hypothesistesting, and handling missing values and making transformations of variables asneeded. EDA encompasses IDA.

2、目的

检测异常值和缺失值
发掘特征变量之间的关系
- 特征变量与目标变量之间的关系
- 除目标变量外，特征变量彼此之间的关系
提取重要的特征变量
测试基本的假设
初步选择合适的模型

注：大多数EDA中，主要关注前三点。

（1）检测异常值和缺失值

异常值：如何发现异常值？发现异常值之后，应该如何处理异常值？（删除）
缺失值：如何发现缺失值？发现缺失值之后，应该如何处理缺失值？（1.删除；2.估计并填充）

（2）发掘特征变量之间的关系

特征变量之间相关性的强弱程度如何？
特征变量与目标变量之间的关系是怎么样的？

（3）提取重要的特征变量

对于目标问题而言，如何判断哪些特征变量是重要的？总的来说，与目标变量强相关的特征变量，通常是重要的特征变量。

二、探索性数据分析的步骤

Form hypotheses/develop investigation theme to explore（形成假设，确定主题去探索）
Wrangle data（清理数据）

网上有一个网址公布斯坦福有一个软件叫datawrangler可以供大家自己免费下载，用于探索数据分析，很快的解决数据清洗的工作，作为一个将来想成为数据科学家的人，处理“脏数据”，是我们必须走的路。

http://vis.stanford.edu/wrangler/

https://www.trifacta.com/products/wrangler/

https://www.douban.com/note/501799325/

Assess quality of data（评价数据质量）
Profile data（数据报表）
Explore each individual variable in the dataset（探索分析每个变量）
Assess the relationship between each variable and the target（探索每个自变量与因变量之间的关系）
Assess interactions between variables（探索每个自变量之间的相关性）
Explore data across many dimensions（从不同的维度来分析数据）

三、其他要做的事

1、写出一系列你自己做的假设，然后接着做更深入的数据分析

2、记录下自己探索过程中更进一步的数据分析过程

3、把自己的中间的结果给自己的同行看看，让他们能够给你一些更有拓展性的反馈、或者意见。不要独自一个人做，国外的思维就是知道了什么就喜欢open to everybody，要走出去，多多交流，打开新的世界。

4、将可视化与结果结合一起。探索性数据分析，就是依赖你好的模型意识，（在《深入浅出数据分析》P34中，把模型的敏感度叫心智模型，最初的心智模型可能错了，一旦自己的结果违背自己的假设，就要立即回去详细的思考）。所以我们在数据探索的尽可能把自己的可视化图和结果放一起，这样便于进一步分析。

四、单变量分析

1、位置估计

均值和加权均值
中位数和稳健估计量（中位数并非唯一的稳健位置估计量，为了消除离群值的影响，也广泛地使用了切尾均值）

2、变异性估计

变异性（variability）也称离差，它测量了数据值是紧密聚集的还是发散的。

标准偏差及相关估计值：平均绝对偏差、方差、标准偏差、中位数绝对偏差
基于百分位数的估计量：顺序统计量（极差）、四分位数、四分位距

3、探索数据分布

百分位数和箱线图
频数表和直方图
密度估计

4、探索二元数据和分类数据

众数
期望：加权均值

5、相关性

相关系数（皮尔逊相关系数）
相关矩阵
散点图

五、双变量及多变量分析

1、列联表

2、六边形图和等势线

3、小提琴图

异常值检测方法总结

Mon, 22 Jun 2020 00:00:00 +0000

一、Numeric outlier（数字异常值）/箱线图

算法介绍：数字异常值方法是一维特征空间中最简单的非参数异常值检测方法，异常值是通过IQR（InterQuartile Range）计算得的。

算法思想：

$\text{异常值} < Q_1 - 1.5 * (Q_3 - Q_1) < Q_3 + 1.5 * (Q_3 - Q_1) < \text{异常值}$

其中$Q_1$：第一四分位数；$Q_3$：第三四分位数。

二、Z-score

算法介绍：Z-score是一维或低维特征空间中的参数异常检测方法。该技术假定数据是高斯分布，异常值是分布尾部的数据点，因此远离数据的平均值。

算法思想： $Z_i=\frac{x_i-\mu}{\sigma}$ 若$|Z_i|>Z_{thr}$（$Z_{thr}$通常取3.0，即$3\sigma$原则），则为异常值。

三、DBSCAN（基于密度的聚类方法）

算法介绍：该技术基于DBSCAN聚类方法，DBSCAN是一维或多维特征空间中的非参数，基于密度的离群值检测方法。

算法思想：

在DBSCAN聚类技术中，所有数据点都被定义为核心点（Core Points）、边界点（Border Points）或噪声点（Noise Points）。

核心点是在距离$\varepsilon$内至少具有最小包含点数（minPTs）的数据点；
边界点是核心点的距离$\varepsilon$内邻近点，但包含的点数小于最小包含点数（minPTs）；
所有的其他数据点都是噪声点，也被标识为异常值；

四、Isolation Forest

（以上三种方法都在试图寻找数据的常规区域，然后将任何在此定义区域外的点都视为异常值。孤立森林则不同，它明确地隔离异常值。）

算法介绍：该方法是一维或多维特征空间中大数据集的非参数方法，其中的一个重要概念是孤立数。

算法思想：

孤立数是孤立数据点所需的拆分数。通过以下步骤确定此分割数：

随机选择要分离的点“a”；
选择在最小值和最大值之间的随机数据点“b”，并且与“a”不同；
如果“b”的值低于“a”的值，则“b”的值变为新的下限；
如果“b”的值大于“a”的值，则“b”的值变为新的上限；
只要在上限和下限之间存在除“a”之外的数据点，就重复该过程；

与孤立非异常值相比，它需要更少的分裂来孤立异常值，即异常值与非异常点相比具有更低的孤立数。因此，如果数据点的孤立数低于阈值，则将数据点定义为异常值。

理解：

想象这样一个场景，我们用一个随机超平面对一个数据空间进行切割，切一次可以生成两个子空间（也可以想象用刀切蛋糕）。接下来，我们再继续随机选取超平面，来切割第一步得到的两个子空间，以此循环下去，直到每子空间里面只包含一个数据点为止。

直观上来看，我们可以发现，那些密度很高的簇要被切很多次才会停止切割，即每个点都单独存在于一个子空间内，但那些分布稀疏的点，大都很早就停到一个子空间内了。

五、其他方法

$3\sigma$原则：假设原数据服从某个分布（如高斯分布），然后计算$\mu$和$\sigma$，再计算$\mu\pm3\sigma$的区间，最后落在区间之外的数据点就被认为是异常值。

决策树原理

Mon, 22 Jun 2020 00:00:00 +0000

一、什么是决策树？

1、定义

决策树是一种解决分类问题的算法，由下面几种元素组成：

根节点：包含样本的全集
内部节点：对应特征属性测试
叶节点：代表决策的结果

2、步骤

Step1. 特征选择

筛选出跟分类结果相关性较高的特征（通常利用【信息增益】进行筛选）

Step2. 决策树生成

从根结点出发，选择信息增益最大的特征作为节点特征，根据该特征的不同取值建立子节点；对每个子节点采用相同的方式生成新的子节点，直到信息增益很小或者没有新的特征可以选择为止。

Step3. 决策树剪枝

剪枝的主要目的是对抗“过拟合”，通过主动去掉部分分支来降低过拟合的风险。

二、理论基础

1、信息熵模型

（1）信息熵

随机变量 X 的信息熵度量了 X 的不确定性。
公式： $H(X)=−\sum_{i=1}^np_i\log p_i$

其中 n 是 X 不同取值的数目。

（2）联合熵

两个随机变量 X 和 Y 的联合熵公式： $H(X,Y)=-\sum_{i=1}^np(x_i,y_i)\log p(x_i,y_i)$

（3）条件熵

随机变量 X 在 Y 下的条件熵度量了知道 Y 以后 X 剩下的不确定性。
公式： $H(X|Y)=-\sum_{i=1}^np(x_i,y_i)\log p(x_i|y_i)=\sum_{j=1}^np(y_j)H(X|y_j)$

（4）信息增益

信息增益度量了 X 在知道 Y 以后的不确定性减少程度。
公式： $I(X,Y)=H(X)-H(X|Y)$

（5）信息增益比

信息增益比是信息增益和特征熵的比值。
公式： $I_R(X,Y)=\frac{I(X,Y)}{H(Y)}$

2、基尼系数

基尼系数代表了模型的不纯度，基尼系数越小，不纯度越低。
公式： $\text{Gini} = \sum_{i=1}^Kp_i(1-p_i)=1-\sum_{i=1}^Kp_I^2$

三、决策树算法

1、ID3算法

利用信息增益选择特征。
信息增益准则对可取数目较多的属性有所偏好。

2、C4.5算法

引入信息增益比选择特征。
信息增益比对可取数目较少的属性有所偏好。

3、CART算法

既可以用于分类，也可以用于回归问题。
使用基尼系数取代信息熵。

参考资料：

ID3算法和C4.5算法

CART算法

齐刘海的小柴

统计在机器学习中的应用

了解：

1、问题架构

2、数据理解

3、数据清洗

4、数据选择

5、数据准备

6、模型评估

7、模型配置

8、模型选择

9、模型表示

10、模型预测

数据挖掘之路

一、数据挖掘经典案例

二、数据挖掘问题的分类

1、分类问题

2、聚类问题

3、关联问题

4、预测问题

三、利用 Python 进行数据挖掘

1、Pandas库的操作

2、Numpy数值计算

3、数据可视化——matplotlib 与 seaborn

四、核心数据挖掘算法

降维方法总结（未完）

一、降维方法的分类

二、常用的降维方法

1、缺失值比率（Missing Value Ratio）

（1）理论

（2）编程实现

2、低方差滤波（Low Variance Filter）

（1）理论

（2）编程实现

3、高相关滤波（High Correlation filter）

（1）理论

（2）编程实现

4、随机森林（Random Forest）

（1）理论

（2）编程实现

5、反向特征消除（Backward Feature Elimination）

（1）理论

（2）编程实现

6、前向特征选择（Forward Feature Selection)

（1）理论

（2）编程实现

7、因子分析

（1）原理

（2）编程实现

8、主成分分析（PCA）

（1）原理

（2）编程实现

9、独立分量分析（ICA）

（1）原理

（2）编程实现

10、IOSMAP

（1）原理

（2）编码实现

11、t-SNE

（1）原理

（2）编程实现

12、UMAP

（1）原理

（2）编码实现

13、Hash Trick

（1）原理

（2）编程实现

三、降维方法总结

有趣的 scala 语言

一、使用递归的方式去思考

1、一个简单问题：对数列 xs 进行求和（不使用函数）

使用 Scala 递归，只需一行，更简洁。

2、常见数据结构：反转字符串

使用 scala 递归，仍然只需一行。

3、经典数据结构：快速排序

4、尾递归

5、零钱兑换问题

二、函数式编程

1、高阶函数与匿名函数

2、柯里化