机器学习算法简介

超超是超超

于 2021-04-24 22:46:55 发布

阅读量166

点赞数

本文链接：https://blog.csdn.net/qq_32979147/article/details/116109075

版权

1、EM算法（期望最大化算法）

（0）例如常被用来学习高斯混合模型（Gaussian mixture model，简称GMM）的参数；隐式马尔科夫算法（HMM）、LDA主题模型的变分推断等等

（1）根据已经观察到的变量对隐藏变量进行学习的方法

（2）计算方法中每一次迭代都分两步，其中一个为期望步（E步），另一个为极大步（M步）。因为直接最大化似然函数 $\L \left ( \theta \right )$ 做不到，找到似然函数的一个下限，不断迭代使这个下限一直增大，得到近似最优解，这个下限就是似然函数的期望

（3）基础知识：“极大似然估计”和“Jensen不等式”。

参考：

https://www.cnblogs.com/bigmoyan/p/4550375.html

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

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

https://www.cnblogs.com/zhangchaoyang/articles/2623364.html

https://www.zhihu.com/question/53866462

https://www.zhihu.com/question/40797593

k-近邻算法

一句话总结：采用测量不同特征值之间距离的方法进行分类。

步骤：

（1）计算已知的所有点到当前点之间的距离，选出最近的k个点，排序

（2）确定这k个点所在的类别概率，返回概率最高的类别

优点：精度高，对异常值不敏感；缺点：计算复杂度高，空间复杂度高

决策树

一句话总结：

优点：计算复杂度不高，对中间值的缺失不敏感，可以处理不相关特征函数

缺点：产生过度匹配的问题

逻辑回归

一句话总结：根据分类边界建立回归函数，找出最佳的回归系数

二分类：在两类的情况下，希望函数输出的结果是0或者1，使用用Sigmoid函数（类似于阶跃函数），确定好分类器函数之后，问题就剩下了回归系数？

思考：三分类的情况下如何处理（可在二分类的基础上再次对其中一个作二分类，最终结果为多分类）

最佳回归系数的确定：梯度上升法

支持向量机

一句话总结

分隔超平面：分隔不同类别的的面，也可以是一条直线

支持向量：距离分隔超平面最近的那些点（间隔尽可能大）

超平面的描述以及点到超平面的距离：形式可以写成 $w^{T}x+b$ ，要计算点A到超平面的距离，即点到超平面的法向距离 $|w^{T}+b|/||w||$ ，为了方便数学的处理（用统一的公式来表达所有数据点到超平面的距离），使用了+1和-1来表示不同的两个类别。即 $(label(w^{T}+b))/||w||$

优化目标：最大化支持向量到分隔超平面的距离。找出具有最小间隔距离的数据点（支持向量），接着对间隔最大化，数学表达： $arg max\left \{ min(label(w^{T}+b))/||w||\right \}$

Adaboost

一句话总结：Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。

def stumpClassify(dataMatrix, dimen, threshVal, threshIneq):
    retArray = ones((shape(dataMatrix)[0], 1))
    if threshIneq == "lt":
        retArray[dataMatrix[:, dimen] <= threshVal] = -1.0
    else:
        retArray[dataMatrix[:, dimen] > threshVal] = -1.0
    return retArray

def buildStump(dataArr, classLabels, D):
    dataMatix = mat(dataArr)
    labelMat = mat(classLables).T
    m, n = shape(dataMatrix)
    numSteps = 10.0
    bestStump = {}
    bestClassEst = mat(zeros((m, 1)))
    minError = inf
    for i in range(n):
        rangeMin = dataMatrix[:,i].min()
        rangeMax = dataMatrix[:,i].max()
        stepSize = (rangeMax - rangeMin)/numSteps
        predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)
        errArr = mat(ones(m, 1))
        errArr[predictedVals == labelMat] = 0
        weightedError = D.T*errArr
        weightedError < minError:
            minError = weightError
            bestClassEst = predictedVals.copy()
            bestStump["dim"] = i
            bestStump["thresh"] = threshVal
            bestStump["ineq"] = inequal
    return bestStump, minError, bestClassEst

训练过程：
# 计算alpha值。该值会告诉分类器本次单层决策树输出的结果
def adaBoostTrainDS(dataArr, classLabels, numIt=40):
    weakClassArr = []
    m = shape(dataArr)[0]
    D = mat(ones((m, 1))/m)
    aggClassEst = mat(zeros((m, 1)))
    for i in range(numIt):
        beatStump, error, classEst = buildStump(dataArr, classLabels, D)
        alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))
        bestStump["alpha"] = alpha
        weakClassArr.append(bestStump)
        print("classEst", classEst.T)
        expon = multiply(-1*alpha*mat(classLabels).T, classEst)
        D = mutiply(D, exp(expon))
        D = D/D.sum()
        aggClassEst += alpha*classEst
        print("aggClassEst", aggClassEst.T)
        aggErrors = multiply(sign(aggClassEst)!=mat(classLabels).T, ones((m, 1)))
        errorRate = aggErrors.sum()/m
        print("total error:", errorRate)
        if errorRate == 0.0:
            break
    return weakClassArr


预测
classifierArray = adaBoostTrainDS(dataArr, classLabels, numIt=40)
def adaClassify(dataToClass, calssifierArr):
    dataMatrix = mat(dataToClass)
    m = shape(dataMatrix)[0]
    aggClassEst = mat(zeros((m,1)))
    for i in range(len(calssifierArr)):
        classEst = stumpClassify(dataMatrix, classifierArr[i]["dim"], classifierArr[i]["thresh"], classifierArr[i]["ineq"])
        aggClassEst += classifierArr[i]["alpha"]*classEst
        print(aggClassEst)
    return sign(aggClassEst)