精华内容
下载资源
问答
  • # 聚类前 X = np.random.rand(100, 2) plt.scatter(X[:, 0], X[:, 1], marker='o') plt.show() # 聚类后 kmeans = KMeans(n_clusters=2).fit(X) label_pred = kmeans.labels_ plt.scatter(X[:, 0], X[:, 1], c=...

    在这里插入图片描述
    在这里插入图片描述

    sklearn

    # 聚类前
    X = np.random.rand(100, 2)
    plt.scatter(X[:, 0], X[:, 1], marker='o')
    plt.show()

    在这里插入图片描述

    # 聚类后
    kmeans = KMeans(n_clusters=2).fit(X)
    label_pred = kmeans.labels_
    plt.scatter(X[:, 0], X[:, 1], c=label_pred)
    plt.show()

    在这里插入图片描述

    k均值聚类

    # -*- coding: UTF-8 -*-
    
    import matplotlib.pyplot as plt
    import numpy as np
    
    
    def distEclud(vecA, vecB):
        '''
        欧氏距离计算函数
        :param vecA:
        :param vecB:
    
        :return: float
        '''
        dist = 0.0
        # ========= show me your code ==================
        # here
        dist = np.sqrt(np.sum(vecA - vecB)**2 )
        # ========= show me your code ==================
        return dist
    
    def randCent(dataMat, k):
        '''
        为给定数据集构建一个包含K个随机质心的集合,
        随机质心必须要在整个数据集的边界之内,这可以通过找到数据集每一维的最小和最大值来完成
        然后生成0到1.0之间的随机数并通过取值范围和最小值,以便确保随机点在数据的边界之内
        :param np.dataMat:
        :param k:
    
        :return: np.dataMat
        '''
        # 获取样本数与特征值
        m, n = np.shape(dataMat)
        # 初始化质心,创建(k,n)个以零填充的矩阵
        centroids = np.mat(np.zeros((k, n)))
        print(centroids)
        # ========= show me your code ==================
        # 循环遍历特征值
        # here
        for i in range(n - 1):
            mindata = dataMat[:, i].min()
            maxdata = dataMat[:, i].max()
            diffdata = maxdata - mindata
            centroids[i] = mindata + np.random.random(k) * diffdata
        # ========= show me your code ==================
        # 返回质心
        return centroids.A
    
    def kMeans(dataMat, k, distMeas=distEclud):
        '''
        创建K个质心,然后将每个点分配到最近的质心,再重新计算质心。
        这个过程重复数次,直到数据点的簇分配结果不再改变为止
        :param dataMat: 数据集
        :param k: 簇的数目
        :param distMeans: 计算距离
        :return:
        '''
        # 获取样本数和特征数
        m, n = np.shape(dataMat)
        # 初始化一个矩阵来存储每个点的簇分配结果
        # clusterAssment包含两个列:一列记录簇索引值,第二列存储误差(误差是指当前点到簇质心的距离,后面会使用该误差来评价聚类的效果)
        clusterAssment = np.mat(np.zeros((m, 2)))
        # 创建质心,随机K个质心
        centroids = randCent(dataMat, k)
    
        # 初始化标志变量,用于判断迭代是否继续,如果True,则继续迭代
        clusterChanged = True
        while clusterChanged:
            clusterChanged = False
            # 遍历所有数据找到距离每个点最近的质心,
            # 可以通过对每个点遍历所有质心并计算点到每个质心的距离来完成
            for i in range(m):
                minDist = float("inf")
                minIndex = -1
                for j in range(k):
                    # 计算数据点到质心的距离
                    # 计算距离是使用distMeas参数给出的距离公式,默认距离函数是distEclud
                    distJI = distMeas(centroids[j, :], dataMat[i, :])
                    # 如果距离比minDist(最小距离)还小,更新minDist(最小距离)和最小质心的index(索引)
                    if distJI < minDist:
                        minDist = distJI
                        minIndex = j
                # 如果任一点的簇分配结果发生改变,则更新clusterChanged标志
                # ========= show me your code ==================
                # here
                if clusterAssment[i, 0] != minIndex:
                    clusterChanged = True
                # ========= show me your code ==================
                    # 更新簇分配结果为最小质心的index(索引),minDist(最小距离)的平方
                    clusterAssment[i, :] = minIndex, minDist ** 2
                print(centroids)
                # 遍历所有质心并更新它们的取值
                # ========= show me your code ==================
                # here
                for j in range(k):
                    pointsInCluster = dataMat[np.nonzero(clusterAssment[:, 0].A == j)[0]]  # 获取簇类所有的点
                    centroids[j, :] = np.mean(pointsInCluster, axis=0)   # 对矩阵的行求均值
                # ========= show me your code ==================
    
            # 返回所有的类质心与点分配结果
            return centroids, clusterAssment
    if __name__ == '__main__':
        X = np.random.rand(100, 2)
    # 运行Kmeans,假设有两聚类中心
        center,label_pred = kMeans(X, k=2)
    # 将标签转化成易绘图的形式
        label = label_pred[:, 0].A.reshape(-1)
    # 将结果可视化
        plt.scatter(X[:, 0], X[:, 1], c=label)
        plt.scatter(center[0, 0], center[0, 1], marker="*", s=100)
        plt.scatter(center[1, 0], center[1, 1], marker="*", s=100)
        plt.show()
    

    在这里插入图片描述

    参考文献: 西瓜书 维基百科 机器学习实战https://www.zybuluo.com/rianusr/note/1199877http://ddrv.cn/a/66611https://blog.csdn.net/zhouxianen1987/article/details/68945844http://ddrv.cn/a/66611https://zhuanlan.zhihu.com/p/29538307

    展开全文
  • 非监督学习聚类、降维聚类:K-means1.随意画出聚类中心2.分配3.优化连接集群中心,画等距垂直于两集群连线的线优化:移动中心再分配,再优化········直至两个类的正确中心位置很有意思的k-means可视化工具...

    非监督学习:聚类、降维

    聚类:K-means

    1.随意画出聚类中心

    2.分配

    3.优化

    连接集群中心,画等距垂直于两集群连线的线


    优化:移动中心


    再分配,再优化········直至两个类的正确中心位置



    很有意思的k-means可视化工具 http://www.naftaliharris.com/blog/visualizing-k-means-clustering/

    聚类算法 http://scikit-learn.org/stable/modules/clustering.html

    k-means http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html

    使用k-means       一开始就要确定聚类数量,工作原理各点之间的距离

    n_clusters 聚类数量,默认8

    max_iter 最大迭代数

    n_init 控制算法的初始化次数(????)


    k-means局限性:对于一个固定的数据集,一个固定数量的簇中心,预测出的结果是不同的(初始聚类中心的位置决定)

    K-means的最初中心点选择对最后的分类效果有很大关系,比如下图出现的聚类,就有很大的问题



    k-means均值聚类迷你项目


    1. 可以在 k_means/k_means_cluster.py 中找到初始代码,该代码会读入电子邮件 + 财务 (E+F) 数据集,让我们为聚类做好准备。首先你将基于两个财务特征开始执行 K-means,请查看代码并确定代码使用哪些特征进行聚类。

    运行代码,这将创建数据的散点图

    salary  、exercised_stock_options


    2.在 financial_features 数据上部署 k-均值聚类,并将 2 个聚类指定为参数。将聚类预测存储到名为 pred 的列表,以便脚本底部的 Draw()命令正常工作

    ### cluster here; create predictions of the cluster labels
    ### for the data and store them to a list called pred
    
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters=2).fit(finance_features)
    pred = kmeans.predict(finance_features)


    3.向特征列表(features_list)中添加第三个特征:“total_payments”。现在使用 3 个,而不是 2 个输入特征重新运行聚类(很明显,我们仍然可以只显示原来的 2 个维度)。将聚类绘图与使用 2 个输入特征获取的绘图进行比较。是否有任何点切换群集?多少个点?这种使用 3 个牲的新聚类无法通过肉眼加以猜测——必须通过 k-均值算法才能识别它。

    ### the input features we want to use 
    ### can be any key in the person-level dictionary (salary, director_fees, etc.) 
    feature_1 = "salary"
    feature_2 = "exercised_stock_options"
    feature_3 = "total_payments"
    poi  = "poi"
    features_list = [poi, feature_1, feature_2, feature_3]
    data = featureFormat(data_dict, features_list )
    poi, finance_features = targetFeatureSplit( data )
    
    
    ### in the "clustering with 3 features" part of the mini-project,
    ### you'll want to change this line to 
    ### for f1, f2, _ in finance_features:
    ### (as it's currently written, the line below assumes 2 features)
    for f1, f2, _ in finance_features:
        plt.scatter( f1, f2)
    plt.show()


    4.

    本例中使用的“exercised_stock_options”特征取的最大值和最小值是什么?34348384、3285

    本例中使用的“salary”特征取的最大值和最小值是什么?1111258、477

    (注意:如果查看 finance_features,会发现有些“NaN”值已被清理并被零值取代——因此尽管那些值可能看起来像是最小值,但却具有欺骗性,因此它们更像是你不具有其相关信息而必须填入一个数字的点。对于此问题,请返回 data_dict 并查找显示的最大值和最小值,忽略所有“NaN”条目。)

    stocklist = []
    salarylist = []
    for item in data_dict:
        stock = data_dict[item]['exercised_stock_options']
        salary = data_dict[item]['salary']
        if stock != 'NaN':
            stocklist.append(stock)
        if salary != 'NaN':
            salarylist.append(salary)
    
    print 'max stock:',np.max(stocklist)
    print 'min stock:',np.min(stocklist)
    print 'max salary:',np.max(salarylist)
    print 'min salary:',np.min(salarylist)

    5.特征缩放之后的效果图以及和原图有变化的点


    展开全文
  • 文章目录1 概述2 性能度量2.1 外部指标2.2 内部指标3 距离计算3.1 有序属性的距离3.1.1 闵可夫斯基距离3.1.2 欧氏距离(L2范数)3.1.3 曼哈顿...算法4.1 kmeans算法4.2 学习向量量化(LVQ)4.3 高斯混合聚类整合代码...

    1 概述

    kmeans:可看作高斯混合聚类在混合成分方差相等,且每个样本仅指派给一个混合成分时的特例
    常用聚类算法:

    • k-medoids:

    • k-modes

    • Fuzzy C-means(soft clustering)

    • kernel k-means

    • spectral clustering

    • LVQ、LVQ2、LVQ3(学习向量量化)

    • DBSCAN、OPTICS、DENCLUE、AGNES…(基于密度聚类)

    • 集成聚类

    • 异常检测

    2 性能度量

    2.1 外部指标

    将聚类结果与某个参考模型进行比较

    将样本两两配对考虑:

    在这里插入图片描述

    聚类C 聚类C*(参考模型)
    a same same
    b same different
    c different same
    d different different

    常用的聚类性能度量外部指标:

    • Jaccard系数(Jaccard Coefficient,JC)

    JC=aa+b+c JC=\frac{a}{a+b+c}

    • FM指数

    FMI=aa+baa+c FMI=\sqrt{\frac{a}{a+b}*\frac{a}{a+c}}

    • Rand指数(RI)

    RI=2(a+d)m(m1) RI=\frac{2(a+d)}{m(m-1)}

    以上三个外部指标均在[0,1]区间,且越大越好。

    2.2 内部指标

    聚类结果的簇划分为
    {C1,C2,...,Ck} \{C_1,C_2,...,C_k\}
    定义:
    avg(C)=2C(C1)1i<jCdist(xi,xj) avg(C)=\frac{2}{|C|(|C|-1)}\sum_{1≤i<j≤|C|}dist(x_i,x_j)
    在这里插入图片描述

    DBI越小越好,DI越大越好

    在这里插入图片描述

    除此之外,还有F值、互信息、平均廓宽等。

    3 距离计算

    3.1 有序属性的距离

    3.1.1 闵可夫斯基距离

    distmk(xi,xj)=(u=1nxiuxjup)1p dist_{mk}(x_i,x_j)=(\sum_{u=1}^{n}|x_{iu}-x_{ju}|^p)^{\frac{1}{p}}

    3.1.2 欧氏距离(L2范数)

    disted(xi,xj)=xixj2=(u=1nxiuxju2)12 dist_{ed}(x_i,x_j)=||x_i-x_j||_2=(\sum_{u=1}^{n}|x_{iu}-x_{ju}|^2)^{\frac{1}{2}}

    3.1.3 曼哈顿距离(L1范数)

    distman(xi,xj)=xixj1=u=1nxiuxju dist_{man}(x_i,x_j)=||x_i-x_j||_1=\sum_{u=1}^{n}|x_{iu}-x_{ju}|

    3.2 无序属性的距离

    VDM距离:
    VDMp(a,b)=i=1kmu,a,imu,amu,b,imu,bp VDM_p(a,b)=\sum_{i=1}^{k}|\frac{m_{u,a,i}}{m_{u,a}}-\frac{m_{u,b,i}}{m_{u,b}}|^p

    3.3 混合属性的距离

    闵可夫斯基和VDM结合可以处理混合属性。

    在这里插入图片描述

    3.4 非度距离

    现实中存在一些无法直接用相似度度量的距离,例如:

    在这里插入图片描述

    不少情况下,我们需要基于数据样本来确定合适的距离公式,可以通过“距离度量学习”来实现。

    4 原型算法

    4.1 kmeans算法

    1. 从D中随机选择k个样本作为初始均值向量
    2. 计算每个样本与均值向量的距离,并给每个样本做簇标记
    3. 计算并更新均值向量
    4. 重复操作2,直至均值向量基本不变或达到所需迭代次数

    4.2 学习向量量化(LVQ)

    在这里插入图片描述

    4.3 高斯混合聚类

    高斯混合聚类采用概率模型来表达聚类原型。

    多元高斯分布的概率密度函数:
    p(x)=1(2π)n212e12(xμ)T1(xμ) p(x)=\frac{1}{(2\pi)^{\frac{n}{2}}|\sum|^{\frac{1}{2}}}e^{-\frac{1}{2}(x-\mu)^T\sum^{-1}(x-\mu)}

    E:计算x_i由各个混合成分生成的后验概率

    M:求新均值向量、新协方差矩阵、新混合系数,并更新μ和Σ。

    继续迭代,满足条件时终止。

    更新每个高斯混合成的均值mu(由加权平均估计):
    μi=j=1mγjixjj=1mγji \mu_i=\frac{\sum_{j=1}^{m}\gamma_{ji}x_j}{\sum_{j=1}^{m}\gamma_{ji}}
    更新gamma(由最大似然LL(D)对gamma的偏导数为0):
    i=j=1mγji(xjμi)(xjμi)Tj=1mγji \sum_i=\frac{\sum_{j=1}^{m}\gamma_{ji}(x_j-\mu_i)(x_j-\mu_i)^T}{\sum_{j=1}^m\gamma_{ji}}
    更新每个高斯成分的混合系数alpha(由该成分的平均后验概率确定):
    αi=1mj=1mγji \alpha_i=\frac{1}{m}\sum_{j=1}^m\gamma_{ji}

    整合代码

    参考文章——GMM高斯混合聚类

    import numpy as np
    import matplotlib.pyplot as plt
     
    def multiGaussian(x,mu,sigma):
        return 1/((2*np.pi)*pow(np.linalg.det(sigma),0.5))*np.exp(-0.5*(x-mu).dot(np.linalg.pinv(sigma)).dot((x-mu).T))
     
    def computeGamma(X,mu,sigma,alpha,multiGaussian):
        n_samples=X.shape[0]
        n_clusters=len(alpha)
        gamma=np.zeros((n_samples,n_clusters))
        p=np.zeros(n_clusters)
        g=np.zeros(n_clusters)
        for i in range(n_samples):
            for j in range(n_clusters):
                p[j]=multiGaussian(X[i],mu[j],sigma[j])
                g[j]=alpha[j]*p[j]
            for k in range(n_clusters):
                gamma[i,k]=g[k]/np.sum(g)
        return gamma
     
    class MyGMM():
        def __init__(self,n_clusters,ITER=50):
            self.n_clusters=n_clusters
            self.ITER=ITER
            self.mu=0
            self.sigma=0
            self.alpha=0
          
        def fit(self,data):
            n_samples=data.shape[0]
            n_features=data.shape[1]
            '''
            mu=data[np.random.choice(range(n_samples),self.n_clusters)]
            '''
            alpha=np.ones(self.n_clusters)/self.n_clusters
            
            mu=np.array([[.403,.237],[.714,.346],[.532,.472]])
            
            sigma=np.full((self.n_clusters,n_features,n_features),np.diag(np.full(n_features,0.1)))
            for i in range(self.ITER):
                gamma=computeGamma(data,mu,sigma,alpha,multiGaussian)
                alpha=np.sum(gamma,axis=0)/n_samples
                for i in range(self.n_clusters):
                    mu[i]=np.sum(data*gamma[:,i].reshape((n_samples,1)),axis=0)/np.sum(gamma,axis=0)[i]
                    sigma[i]=0
                    for j in range(n_samples):
                        sigma[i]+=(data[j].reshape((1,n_features))-mu[i]).T.dot((data[j]-mu[i]).reshape((1,n_features)))*gamma[j,i]
                    sigma[i]=sigma[i]/np.sum(gamma,axis=0)[i]
            self.mu=mu
            self.sigma=sigma
            self.alpha=alpha
            
        def predict(self,data):
            pred=computeGamma(data,self.mu,self.sigma,self.alpha,multiGaussian)
            cluster_results=np.argmax(pred,axis=1)
            return cluster_results
    

    西瓜实验:

    import pandas as pd
    data = pd.read_csv(r'C:\Users\Asus\Desktop\jobs\machine learning\寒假机器学习笔记\datasets4.0.csv')
    data=data.values
     
    model1=MyGMM(3)
    model1.fit(data)
    result=model1.predict(data)
    plt.scatter(data[:,0],data[:,1],c=result)
    plt.scatter(model1.mu[:,0],model1.mu[:,1],marker='x',color='red')
    

    在这里插入图片描述

    展开全文
  • 点与聚类匹配(K均值算法)步骤: 分配 将点按照离聚类中心的距离分好 优化 移动使聚类中心到这些点的总二次距离降到最小 3.重复上述步骤 可视化工具中来看具体操作:随机放...

    点与聚类匹配(K均值算法)

    步骤:

    1. 分配

    将点按照离聚类中心的距离分好

    这里写图片描述

    1. 优化

    移动使聚类中心到这些点的总二次距离降到最小

    这里写图片描述

    3.重复上述步骤

    这里写图片描述

    可视化工具中来看具体操作:

    随机放中心,对点按距离分类

    这里写图片描述

    移动中心至其点的总二次距离最小的位置,再次对点分类

    这里写图片描述

    再次移动中心至点的总二次距离最小的位置

    这里写图片描述

    SKlearn Clustering

    Method name —— K-Means

    注意:必须在一开始就表明要查找的聚类数(最具挑战性的工作)

    k-means文档

    需要注意的参数:

    • n_clusters(聚类数量,默认为8)
      根据自己的需要反复调整(基本需要调整)最重要的参数

    • max_iter=300
      在查找聚类时,需要进行迭代,将各个点分配到矩心,然后移动矩心,然后重新分配这些点,重新移动矩心。max_iter表示进行迭代的次数,300一般足够了。

    • n_init=10 控制算法初始化的次数,提出聚类的次数
      k-means聚类有一个挑战——完全取决于初始状况,你有时最终会得到不同的聚类结果,然后,你需要多次重复该算法。尽管任意这些聚类可能都不对,但所有聚类的集合总会有满足你要求的聚类。
      如果觉得你的聚类特别容易出现糟糕或艰难的初始化过程,就需要调整这个参数

    class sklearn.cluster.KMeans(n_clusters=8, init=’k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=’auto’, verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm=’auto’)

    K-均值的局限

    • 同一个训练集训练出的模型总是会预测出同样的结果吗?

      不是
      K-均值是爬山算法,他非常依赖于你的初始聚类中心所处的位置

    • 局部最小值:取决于聚类中心点的最初设定

    例子1:

    这里写图片描述

    在这个例子中,如果你在最初的假设中选择了这三个聚类中心,你将很难离开这些点。

    这里写图片描述

    因此我们必须意识到,在聚类中,这是一个局部的爬山算法,它可以为你提供一个次优解。如果你对它再次进行拆分,就可以得到更好的解

    例子2:

    如果以两个聚类中心对这组数据进行初始化处理,这里存不存在一个局部最小值?有没有稳定的解?

    这里写图片描述

    这里也是存在不好的局部最小值的!!

    你可以把这些聚类中心设置的正好位于彼此的上方,分割线如下图所示,所有上方的点与上方的聚类中心相关联,下方的点与下方的聚类中心相关联

    这里写图片描述

    如果你的越多的聚类中心,就能找到越多的局部最小值

    但是特殊的情况其实存在,所以得用这个将算法多次运行

    • 19.你的聚类算法将会用到哪些特征?

      散点图:

    这里写图片描述

    • 20.部署聚类

    这里写图片描述

    代码:

    feature_1 = "salary"
    feature_2 = "exercised_stock_options"
    poi  = "poi"
    features_list = [poi, feature_1, feature_2]
    data = featureFormat(data_dict, features_list )
    poi, finance_features = targetFeatureSplit( data )
    
    from sklearn.cluster import KMeans
    import numpy as np 
    Kmeans = KMeans(n_clusters=2).fit(finance_features)
    pred=Kmeans.predict(finance_features)
    
    • 21.使用3个聚类特征,有测试点移动到不同的聚类中吗?

    这里写图片描述

    代码:

    feature_1 = "salary"
    feature_2 = "exercised_stock_options"
    feature_3 = "total_payments"
    poi  = "poi"
    features_list = [poi, feature_1, feature_2, feature_3]
    data = featureFormat(data_dict, features_list )
    poi, finance_features = targetFeatureSplit( data )
    
    from sklearn.cluster import KMeans
    import numpy as np 
    Kmeans = KMeans(n_clusters=2).fit(finance_features)
    pred=Kmeans.predict(finance_features)
    
    ### in the "clustering with 3 features" part of the mini-project,
    ### you'll want to change this line to 
    ### for f1, f2, _ in finance_features:
    ### (as it's currently written, the line below assumes 2 features)
    for f1, f2, f3 in finance_features:
        plt.scatter( f1, f2, f3 )
    plt.show()
    • 22.股票期权范围
    import numpy as np 
    stocklist=[]
    for item in data_dict:
        stock = data_dict[item]['exercised_stock_options']
        if stock != 'NaN':
            stocklist.append(stock)
    
    stocklist = np.array(stocklist)
    print "max:",np.max(stocklist)
    print "min:",np.min(stocklist)

    max: 34348384
    min: 3285

    • 23.薪酬范围
    salarylist=[]
    for item in data_dict:
        stock = data_dict[item]['salary']
        if stock != 'NaN':
            salarylist.append(stock)
    
    salarylist = np.array(salarylist)
    print "max:",np.max(salarylist)
    print "min:",np.min(salarylist)

    max: 1111258
    min: 477

    • 24.练习: 聚类更改

    这里写图片描述

    展开全文
  • 密度聚类 顾名思义,密度聚类是基于样本分布的紧密程度来划分的。因为这个性质,密度聚类可以划分出形状不规则的簇,弥补了原型聚类只能划分凸形的聚类簇的不足。 DBSCAN算法 DBSCAN算法是基于邻域参数$(\epsilon,...
  • 聚类算法是在没有给定标签和样本值的前提下进行数据划分,是典型的无监督学习(unsupervised learning)算法。聚类试图将数据集中的样本划分成若干个不相交的子集,称为“簇”,或“类”。一个好的样本划分肯定是簇内...
  •        对于决策树,随机森林,PCA和逻辑回归等算法中,他们虽然有着不同的功能,但却都属于“有监督学习”的...机器学习当中,还有相当一部分算法属于“无监督学习”,无监督的...
  • 解决方法:归一(将不同长度文章置于平等的地位)应用TF-IDF对于重要单词进行优先级排序Key WordTF-IDF文档表示方式检索相似文档最近邻域检索1-最邻近k-最邻近文档聚类根据主题对文档分类聚类->事后回溯聚类算法(k-...
  • 机器学习、数据挖掘领域中,聚类算法有很多中,比方说K-Means、DBSCAN等等,这些也都是入门级的简单算法。使用这些聚类算法后,对聚类结果的优劣程度还是需要进行评价。本博客将从以下两个评价方法展开讨论:欧式...
  • 机器学习入门整理 内容总结来自网课和部分博客,代码数据集来自中国大学mooc北理的机器学习课程,大赞这个课程。 链接想起来再更新上去,私戳可以发评论里,毕竟体积也不算很小。仅学习总结,侵删。 一、无监督学习-...
  • DBSCAN 聚类算法又称为密度聚类,是一种不断发张下线而不断扩张的算法,主要的参数是半径r和k值 DBSCAN的几个概念: 核心对象:某个点的密度达到算法设定的阈值则其为核心点,核心点的意思就是一个点在半径r的范围...
  • 无监督学习是一类机器学习算法,在无监督学习中,训练样本的标记信息是未知的,目标是通过对无标记训练样本的学习来揭示数据的内在性质及规律,为进一步数据分析提供基础。通俗的讲,无监督学习就是“从无规律中找到...
  • 这一讲,我们来学习聚类算法。我们之前学习的算法中,数据都是有标签的,属于有监督学习,如果数据没有标签,那怎么办?这就属于无监督学习了,而聚类算法就是用来解决无标签数据的分类问题。这一讲,我们主要学习两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 633
精华内容 253
关键字:

机器学习入门聚类