１、为什么loss函数的方向传播需要沿着梯度的反方向进行传播

梯度的方向为什么是函数值增加最快的方向？

２、logistic 回归

https://zhuanlan.zhihu.com/p/44583106

https://www.jianshu.com/p/1bf35d61995f

３、softmax回归

４、决策树算法

https://zhuanlan.zhihu.com/p/20794583

https://blog.csdn.net/huacha__/article/details/80919426

决策树：分类树和回归树，分类树用于预测分类标签值，如天气是晴天还是阴天；回归树用于预测实际的值，如天气的气温是多少度，年龄。分类树是定性的，回归树是定量的。

决策树学习算法主要由三部分构成：

https://blog.csdn.net/jiaoyangwm/article/details/79525237

特征选择
决策树生成
决策树的剪枝

特征选择

而我们应该基于什么准则来判定一个特征的分类能力呢？

这时候，需要引入一个概念：信息增益.

举个例子关于熵的，求明天我以什么方式去上学，骑自行车的概率是1/2，走路1/2, p(x1)=1/2,p(x2)=1/2,带入公式就可以了。

决策树生成

决策树学习的算法通常是一个递归地选择最优特征，并根据该特征对训练数据进行分割，使得各个子数据集有一个最好的分类的过程。这一过程对应着对特征空间的划分，也对应着决策树的构建。

1）开始：构建根节点，将所有训练数据都放在根节点，选择一个最优特征，按着这一特征将训练数据集分割成子集，使得各个子集有一个在当前条件下最好的分类。

2）如果这些子集已经能够被基本正确分类，那么构建叶节点，并将这些子集分到所对应的叶节点去。

3）如果还有子集不能够被正确的分类，那么就对这些子集选择新的最优特征，继续对其进行分割，构建相应的节点，如果递归进行，直至所有训练数据子集被基本正确的分类，或者没有合适的特征为止。

4）每个子集都被分到叶节点上，即都有了明确的类，这样就生成了一颗决策树。

信息增益对应的是ＩＤ３算法，信息增益比对应的是Ｃ4.5这个算法。

决策树的剪枝

如果对训练集建立完整的决策树，会使得模型过于针对训练数据，拟合了大部分的噪声，即出现过度拟合的现象。为了避免这个问题，使用决策树剪枝取解决决策树的过拟合现象。

具体的计算方法

为了求信息增益，先求数据的经验熵，熵的公式里面都是概率，如何求得概率，那就是统计每个类别的数目，然后除以数据的总数目，不就是概率吧。关键点还是得求条件熵。还有就是假如一个特征是年龄，数据里面中的年龄是｛10, 50, 30, 60｝,具体如何划分成几个子集的呢？这个自己定义的已解决。

具体例子

https://blog.csdn.net/jiaoyangwm/article/details/79525237

判断是否可以放贷。

from math import log

"""
函数说明：创建测试数据集
Parameters：无
Returns：
    dataSet：数据集
    labels：分类属性
Modify：
    2018-03-12

"""
def creatDataSet():
    # 数据集
    dataSet=[[0, 0, 0, 0, 'no'],
            [0, 0, 0, 1, 'no'],
            [0, 1, 0, 1, 'yes'],
            [0, 1, 1, 0, 'yes'],
            [0, 0, 0, 0, 'no'],
            [1, 0, 0, 0, 'no'],
            [1, 0, 0, 1, 'no'],
            [1, 1, 1, 1, 'yes'],
            [1, 0, 1, 2, 'yes'],
            [1, 0, 1, 2, 'yes'],
            [2, 0, 1, 2, 'yes'],
            [2, 0, 1, 1, 'yes'],
            [2, 1, 0, 1, 'yes'],
            [2, 1, 0, 2, 'yes'],
            [2, 0, 0, 0, 'no']]
    #分类属性
    labels=['年龄','有工作','有自己的房子','信贷情况']
    #返回数据集和分类属性
    return dataSet,labels


"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters：
    dataSet：数据集
Returns：
    shannonEnt：经验熵
Modify：
    2018-03-12

"""
def calcShannonEnt(dataSet):
    #返回数据集行数
    numEntries=len(dataSet)
    #保存每个标签（label）出现次数的字典
    labelCounts={}
    #对每组特征向量进行统计
    for featVec in dataSet:
        currentLabel=featVec[-1]                     #提取标签信息
        if currentLabel not in labelCounts.keys():   #如果标签没有放入统计次数的字典，添加进去
            labelCounts[currentLabel]=0
        labelCounts[currentLabel]+=1                 #label计数

    shannonEnt=0.0                                   #经验熵
    #计算经验熵
    for key in labelCounts:
        prob=float(labelCounts[key])/numEntries      #选择该标签的概率
        shannonEnt-=prob*log(prob,2)                 #利用公式计算
    return shannonEnt                                #返回经验熵


"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters：
    dataSet：数据集
Returns：
    shannonEnt：信息增益最大特征的索引值
Modify：
    2018-03-12

"""


def chooseBestFeatureToSplit(dataSet):
    #特征数量
    numFeatures = len(dataSet[0]) - 1
    #计数数据集的香农熵
    baseEntropy = calcShannonEnt(dataSet)
    #信息增益
    bestInfoGain = 0.0
    #最优特征的索引值
    bestFeature = -1
    #遍历所有特征
    for i in range(numFeatures):
        # 获取dataSet的第i个所有特征
        featList = [example[i] for example in dataSet]
        #创建set集合{}，元素不可重复
        uniqueVals = set(featList)
        #经验条件熵
        newEntropy = 0.0
        #计算信息增益
        for value in uniqueVals:
            #subDataSet划分后的子集
            subDataSet = splitDataSet(dataSet, i, value)
            #计算子集的概率
            prob = len(subDataSet) / float(len(dataSet))
            #根据公式计算经验条件熵
            newEntropy += prob * calcShannonEnt((subDataSet))
        #信息增益
        infoGain = baseEntropy - newEntropy
        #打印每个特征的信息增益
        print("第%d个特征的增益为%.3f" % (i, infoGain))
        #计算信息增益
        if (infoGain > bestInfoGain):
            #更新信息增益，找到最大的信息增益
            bestInfoGain = infoGain
            #记录信息增益最大的特征的索引值
            bestFeature = i
            #返回信息增益最大特征的索引值
    return bestFeature

"""
函数说明：按照给定特征划分数据集
Parameters：
    dataSet：待划分的数据集
    axis：划分数据集的特征
    value：需要返回的特征的值
Returns：
    shannonEnt：经验熵
Modify：
    2018-03-12

"""
def splitDataSet(dataSet,axis,value):
    retDataSet=[]
    for featVec in dataSet:
        if featVec[axis]==value:
            reducedFeatVec=featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet


#main函数
if __name__=='__main__':
    dataSet,features=creatDataSet()
    # print(dataSet)
    # print(calcShannonEnt(dataSet))
    print("最优索引值："+str(chooseBestFeatureToSplit(dataSet)))

结果

第0个特征的增益为0.083
第1个特征的增益为0.324
第2个特征的增益为0.420
第3个特征的增益为0.363
最优索引值：2

５、随机森林

随机森林的随机体现在随机选取样本，还有一个是随机选取特征。

随机森林是一个Bagging方法，Bagging是一种有放回抽样方法：取出一个样本加入训练集，然后再把该样本放回原始样本空间，以使下次取样本依然能取到该样本。使用这种方式，可以取样出T个包含m个样本的训练集，并且每个训练集都不一样。随机森林在Bagging的基础上，进一步在决策树的训练过程中引入了一些随机性，随机选取特征：随机选择部分特征，比如说所有特征的80%，然后在这80%的特征，建立决策树。实际情况是对于每一个特征都进行概率选择（0.8选择，0.2不选择）。

6、ＳＶＭ

https://www.bilibili.com/video/av50327129/?p=7

https://zhuanlan.zhihu.com/p/24638007

SVM主要用在分类和回归中，如果是分类，直接使用超平面将训练数据分开。ＳＶＭ的主要点就是如何求得超平面，超平面由参数Ｗ和截距ｂ组成，wx + b = 0就是超平面方程。如何找到最优的超平面，所有样本到超平面距离的最小值的最大的那个超平面就是最优的。据此我们可以新建一个目标函数得到最优的解。

求得目标函数中的直线参数w和h, 具体使用的是拉格朗日乘子法。

只有部分数据是支持向量（就是决定了超平面的那些数据），其他的就不是支持向量。

C/ $\gamma$ 的

7、聚类

聚类的定义：

聚类就是对大量未知标注的数据集，按数据的内在相似性将数据集化分为多个类别，使类别内的数据相似度较大而类别间的数据相似度较小。无监督。

数据相似性

K-Means

https://blog.csdn.net/baidu_27643275/article/details/88673185

随机选择ｋ个聚类中心
就算所有数据集到ｋ个聚类中心的距离，距离短的就分配给这个聚类了。
移动聚类中心到新的聚类的均值处
重复步骤２，直到聚类中心不再移动为止。

https://zhuanlan.zhihu.com/p/67042130

数据图演示k-means的操作步骤

1. 加载数据（分析有几个聚类，k的值等于聚类数量）

现在我们分析出大致有2个类。于是我们设置k=2。

2. 随机选k个点作为聚类中心

在本文章第1.步提到了k=2.所以我们随机选2个点作为聚类中心。可以看到下面有两个点已经被选中作为聚类中心了。一个是绿色一个是橘黄。

3. 遍历所有点计算这些点到k个聚类中心点的距离

举个例子，现在我们到了一个点。然后计算了它到两个聚类中心的距离。可以看到它离绿色点比离橘黄色近。所以认为当前这个点属于绿色这个点所在的聚类里面。我们需要遍历所有点。

第一轮遍历所有点，并把这些点归类后的结果。（橘黄色那堆是上图绿色点所代表的聚类，蓝色点是橘黄色那个点代表的聚类）

4. 根据3.中得到的两个聚类，重新计算聚类中心

绿色点是橘黄色那堆点的新聚类中心，红色点是蓝色那堆点的新聚类中心。

5. 重复步骤3.和4.（重复多少次你自己决定）

这是重复循环3.和4.三次后的结果（效果还是非常惊艳的）。

python代码实现k-means

def Distance(dataA, dataB):
    return np.sqrt(np.sum((dataA-dataB)**2))

def kmeans(data_array, k):
    M, N = data_array.shape
    #数据属于那个聚类中心
    label = np.array([0]*M)
    #聚类中心
    centroids = np.zeros((k, N))
    #初始化聚类中心
    for i in range(N):
        min = np.min(data_array[:, i])
        max = np.max(data_array[:, i])
        centroids[:, i] = min + float(max-min)*np.random.rand(k)

    for time in range(10):
        #更新每一个数据的标签
        for i in range(M):
            dist = []
            for j in range(k):
                dist.append(Distance(data_array[i], centroids[j]))
            label[i] = np.argmin(dist)
        #更新聚类中心
        for i in range(k):
            cluster_data = data_array[label == i]
            size = len(cluster_data)
            centroids[i] = np.sum(cluster_data, 0)/size

        return label, centroids

https://blog.csdn.net/qq_30091945/article/details/82184489

为了方便代码测试，我自己写了一个ｄａｔａ文件，命名为test.txt

1.2 1.3
1.5 1.8
0.5 0.92
0.9 1.51
0.95 0.93
1.5 1.91
1.8 2.1
0.8 1.81
1.2 1.92
1.3 1.91
4.1 3.24
4.5 3.67
4.8 3.65
4.9 5.17
4.4 4.47
5.5 5.65
4.3 5.12
4.4 6.11
4.5 6.63
8.8 9.0
7.5 9.51
7.9 8.58
9.6 8.71
9.5 7.87
9.3 7.81
9.6 7.2

代码，将代码变为numpy的矩阵

#-*-coding:utf-8-*-
import numpy as np
import matplotlib.pyplot as plt


def data2array(file_path):
    data = np.loadtxt(file_path)
    return data

class KMeans:
    def __init__(self,train_data,k):
        """
        K-Means聚类算法的构造函数
        :param train_data: 训练数据
        :param k: 聚类簇数
        """
        self.Train_Data = train_data
        self.K = k
        row,col = np.shape(train_data)
        self.Label = np.array([0]*row)
        self.centroids = np.zeros((k,col))             # 质心坐标
        # 初始化质心坐标
        for i in range(col):
            Min = np.min(self.Train_Data[:,i])
            Max = np.max(self.Train_Data[:,i])
            self.centroids[:,i] = Min+float(Max-Min)*np.random.rand(k)

    def EcludDistance(self,dataA,dataB):
        """
        计算欧式距离
        :param dataA: 数据A
        :param dataB: 数据B
        """
        return np.sqrt(np.sum((dataA-dataB)**2))

    def kmeans(self):
        """
        这是进行K-Means聚类算法的函数
        """
        dist = 0
        olddist = 1
        row,col = np.shape(self.Train_Data)
        while np.abs(dist-olddist) > 1E-6:
            olddist = dist
            # 更新每组训练数据的标签
            for i in range(row):
                dist = []
                # 计算一组数据与质心之间的距离
                for j in range(self.K):
                    dist.append(self.EcludDistance(self.Train_Data[i],self.centroids[j])**2)
                self.Label[i] = np.argmin(dist)
            # 更新聚类质心的坐标
            for i in range(self.K):
                cluster_data = self.Train_Data[self.Label == i]
                size = len(cluster_data)
                self.centroids[i] = np.sum(cluster_data,0)/size
            # 计算距离函数
            dist = 0
            for (data, label) in zip(self.Train_Data,self.Label):
                dist += self.EcludDistance(data,self.centroids[label])**2
        return self.Label, self.centroids


if __name__ == '__main__':
    file_path = 'test.txt'
    data = data2array(file_path)
    k = 3
    color = ['r', 'g', 'b']
    kmeans = KMeans(data, k)
    predict_label, centroids = kmeans.kmeans()
    for i in range(k):
        plt.scatter(centroids[i][0], centroids[i][1], c=color[i], marker='x', s=40)
    for (_data, _label) in zip(data, predict_label):
        plt.scatter(_data[0], _data[1], color=color[_label], alpha=0.3)
    plt.show()

有时候测试的时候显示不出来，是因为k-means受初始聚类中心影像比较大

如果直接使用sklearn的话

#-*-coding:utf-8-*-

from sklearn.cluster import KMeans as _KMeans
import numpy as np
import matplotlib.pyplot as plt

def data2array(file_path):
    data = np.loadtxt(file_path)
    return data

def run_main():
    """
       这是主函数
    """

    file_path = 'test.txt'
    data = data2array(file_path)
    # sklearn的KMeans
    k = 3
    kmeans = _KMeans(n_clusters=k,max_iter=1000)
    kmeans.fit(data)
    predict_label = kmeans.predict(data)
    centroids = kmeans.cluster_centers_
    color = ['r', 'g', 'b']
    for i in range(k):
        plt.scatter(centroids[i][0], centroids[i][1], c=color[i], marker='x', s=40)
    for (_data, _label) in zip(data, predict_label):
        plt.scatter(_data[0], _data[1], color=color[_label],alpha=0.3)
    plt.show()

if __name__ == '__main__':
    run_main()

寻找最佳K值

https://zhuanlan.zhihu.com/p/67042130

K-means++

https://zhuanlan.zhihu.com/p/32375430

由于 K-means 算法的分类结果会受到初始点的选取而有所区别，因此有提出这种算法的改进:k-means++

算法步骤

其实这个算法也只是对初始点的选择有改进而已，其他步骤都一样。初始质心选取的基本思路就是，初始的聚类中心之间的相互距离要尽可能的远。

算法描述如下：

步骤一：随机选取一个样本作为第一个聚类中心 c1；
步骤二：计算每个样本与当前已有类聚中心最短距离（即与最近一个聚类中心的距离），用 D(x)表示；这个值越大，表示被选取作为聚类中心的概率较大；最后，用轮盘法选出下一个聚类中心；
步骤三：重复步骤二，知道选出 k 个聚类中心。

选出初始点后，就继续使用标准的 k-means 算法了。

极大似然估计

https://www.cnblogs.com/sylvanas2012/p/5058065.html

EM算法

https://zhuanlan.zhihu.com/p/36331115

https://blog.csdn.net/weixin_43661031/article/details/91358990

https://blog.csdn.net/u010834867/article/details/90762296

里面的例子比较好

提到参数估计，最常见的方法莫过于极大似然估计，如果模型中存在隐变量时，极大似然估计所遇到的困难，从而引入了EM算法。EM算法可以看作是极大似然估计的一个扩充。

高斯混合模型（GMM）

基本思想：高斯混合模型的核心思想是，假设数据可以看作从多个高斯分布（分布的个数类似于Kmeans里的K，也是超参数）中生成出来的。在该假设下，每个单独的分模型都是标准高斯模型，其均值 $\mu _{i}$ 和方差 $\sigma _{i}$ 是待估计的参数。此外，每个分模型都还有一个参数 $\pi _{i}$ ，可以理解为权重或生成数据的概率。
算法步骤：

初始随机选择各参数的值（每个分布三个参数）
EM迭代：
E步：根据每个分布当前的参数，计算每个点由每个分模型生成的概率
M步：使用E步骤估计出的概率，来改进每个分模型的均值，方差和权重

我们并不知道最佳的K个高斯分布的各自3个参数，也不知道每个数据点究竟是哪个高斯分布生成的。所以每次循环时，先固定当前的高斯分布不变，获得每个数据点由各个高斯分布生成的概率。然后固定该生成概率不变，根据数据点和生成概率，获得一个组更佳的高斯分布。循环往复，直到参数的不再变化，或者变化非常小时，便得到了比较合理的一组高斯分布。

GMM和Kmeans的联系和区别

相同点：

它们都是可用于聚类的算法；
都需要指定K值；
都是使用EM算法来求解；
都往往只能收敛于局部最优。

区别：

GMM相比于K均值算法的优点是，可以给出一个样本属于某类的概率是多少；不仅仅可以用于聚类，还可以用于概率密度的估计；并且可以用于生成新的样本点。
GMM算法是生成模型。

PCA算法

PCA（主成分分析）是一种数据降维的方法，即把高维数据在损失最小的情况下转换成低位数据的算法。

ＳＶＤ奇异值分解

集成学习介绍

这篇文章主要讲解集成学习三种方法。集成学习（Emsemble Learning）是通过结合几个模型的元算法（meta-algorithm），使得最后的表现比任何一个模型好。在Kaggle，集成学习是取得高排名的不二法宝。本文介绍集成学习的三种模式，以便帮助读者对自己的最后模型进行决策。这三种方法以及他们的效果分别是：

Bagging:减少 variance
boosting: 减少 bias
stacking:增强预测效果

1.bagging

Bagging 是 bootstrap aggregation的缩写。依据有放回的随机抽样构造的n个采样集，我们就可以对他们分别进行训练，得到n个弱分类器，然后根据每个弱分类器返回的结构，我们可以采用一定的组合策略得到我们需要的强分类器。

例如n=4，m=4，数据条目数味8，bagging过程如下：每个bag从数据集里随机取样，然后训练，如下图

训练好后，预测新数据时，过程是一个投票（voting）。voting过程如下：

Bagging已经有很广泛的应用，例如random forest就是把n个decision tree进行bagging，然后通过投票选出最可能的结果。

为什么bagging可以降低variance？这里打个比方：

一个班级有50个人，如果这个50个人同时朗读，你会觉得对你注意力造成影响。因为他们声音的variance很大。variance衡量的是每个时间点的幅度与总体均值的关系。如果你把他们齐读的声音作为波形图，你会发现波形非常抖，离中轴很远，也就是variance非常大，大概是这样的。

但如何他们是自由读呢?很有可能的是正负波形有一部分抵消，然后各种声音混合，产生这样的声波：

在bagging中，单个人说话的幅度各自产生variance，但加起来总的bias没降低，也就是分贝其实并没降低。

2.boosting

boosting是一个迭代的过程，用来自适应的改变训练样本的分布，使得弱分类器聚焦到那些很难分类的样本上，它的做法是给每个训练样本赋予一个权重，在每一轮的训练结束时自动调整权重。

boosting方法代表的算法有Adaboost, GBDT, XGBoost算法

boosting的算法流程如图：

最常用的方法是AdaBoost[1]，是adaptive boosting的简称，为了使得本文可读性增加，我把这Adaboost单独写一篇文章，具体可以参考

桔了个仔：AdaBoost算法以及公式傻瓜式一步一步超详细讲解带示例zhuanlan.zhihu.com

比喻一下，大家做过作业吧，有收集过错题本吗？今天考试我这道题做错了，我把它记在错题本里，下次考试前，我就单独翻开错题本单独做一遍。如果下次考试做对了，就从错题本里删除，否则，在错题本里把这道题再做一次。这样每次下去，你的考试成绩就很可能提高。Boosting就是这样的原理。

3.Stacking

stacking的算法如上图。其实和和bagging不同的是，stacking通常是不同的模型。

第一步，有T个不同模型，根据数据，各自独立训练。每个模型输出结果为 [公式] ，其中t= 1,2,3...T

第二步，根据每个模型预测，创建新的『训练集』，训练集的数据（X）是预测结果,Y是实际结果。

第三步，再训练一个classifier，这里叫meta-classifier，来从各个预测中再生成最后预测。

和bagging有点相似，不一样的是：

bagging每个classifier其实是同一种模型
bagging每个bag用部分数据训练，stacking每个classifier都用了全部训练数据

个人实践，如果第三步没有足够训练数据,可以取平均。如果有足够数据，可以用线性回归，毕竟数据维度有点太低。如果有读者有更好实践，请大声在评论区喊出来。

boosting和bagging的区别：

解决的问题不一样。boosting是解决基学习器欠拟合的问题，bagging是解决基学习器过拟合的问题。所以，Boosting的基学习器都是弱学习器，而bagging的学习器都是强学习器。
Bagging的各个基学习器是独立的，可以并行计算，而Boosting是串行的，不可以并行计算。
Bagging的最终的结果是平均的，Boosting对每一个基学习器权重不同。

AdaBoost（Adaptive Boosting）训练过程

刚开始训练时对每一个训练样本赋相等的权重，然后用该算法对训练集训练t轮，每次训练后，对训练失败的训练例赋以较大的权重。也就是让学习算法在每次学习以后更注意学错的样本。
基于调整后的样本训练下一个基学习器，如此反复，知道基学习器数量达到事先制定的值T。
将这T个基学习器进行线性加权组合。

指数损失函数。

最常用的基分类器是决策树，为什么？

决策树可以较为方便地将样本的权重整合到训练过程中，而不需要使用过采样的方法来调整样本权重。
决策树的表达能力和泛化能力，可以通过调节树的层数来做折中。
数据样本的扰动对于决策树的影响较大，因此不同子样本集合生成的决策树基分类器随机性较大，这样的“不稳定学习器”更适合作为基分类器。此外，在决策树节点分裂的时候，随机地选择一个特征子集，从中找出最优分裂属性，很好地引入了随机性。

除了决策树外，神经网络模型也适合作为基分类器，主要由于神经网络模型也比较“不稳定”，而且还可以通过调整神经元数量、连接方式、网络层数、初始权值等方式引入随机性。

GBDT

GBDT的优点：

预测阶段基模型是并行计算的。
它在分布稠密的数据集上，表达能力和泛化能力都很好（拟合能力强和方差小）。
它的基模型是决策树，具有较强可解释性，且不需要对数据归一化等预处理。

GBDT的缺点：

它的训练过程是串行的，无法并行，速度问题。
在高维稀疏数据集上，不如神经网络。
在文本分类的时候表现不太好。

GBDT和XGBOOST的区别和联系：

GBDT是一个算法，XGBOOST是GBDT的工程实现。
当使用CART作为基模型时，XGBOOST显式地加入了正则项。
GBDT在模型训练时只使用了代价函数的一阶导数信息，XGBoost对代价函数进行二阶泰勒展开，可以同时使用一阶和二阶导数。
GBDT的基学习器只能是CART，但XGBOOST还可以使用线性分类器等多种类型的基分类器。
GBDT训练时直接使用全部数据集，XGBOOST则使用了类似随机森林的采样策略。
GBDT对缺失值没有进行处理，XGBOOST能自动学习出缺失值的处理策略。

pursuit_zhangyu

发布了102 篇原创文章 · 获赞 117 · 访问量 33万+

私信关注

机器学习记录

１、为什么loss函数的方向传播需要沿着梯度的反方向进行传播

２、logistic 回归

３、softmax回归

４、 决策树算法

决策树学习算法主要由三部分构成：

特征选择

决策树生成

决策树的剪枝

具体的计算方法

具体例子

５、随机森林

6、ＳＶＭ

7、聚类

数据相似性

K-Means

https://zhuanlan.zhihu.com/p/67042130

数据图演示k-means的操作步骤

1. 加载数据（分析有几个聚类，k的值等于聚类数量）

2. 随机选k个点作为聚类中心

3. 遍历所有点计算这些点到k个聚类中心点的距离

4. 根据3.中得到的两个聚类，重新计算聚类中心

5. 重复步骤3.和4.（重复多少次你自己决定）

python代码实现k-means

寻找最佳K值

K-means++

算法步骤

极大似然估计

EM算法

高斯混合模型（GMM）

GMM和Kmeans的联系和区别

PCA算法

集成学习介绍

1.bagging

2.boosting

3.Stacking

boosting和bagging的区别：

AdaBoost（Adaptive Boosting）训练过程

最常用的基分类器是决策树，为什么？

GBDT

GBDT的优点：

GBDT的缺点：

GBDT和XGBOOST的区别和联系：

猜你喜欢

４、决策树算法