精华内容
下载资源
问答
  • 上课,老师让做作业,kmeans分类,将iris进行聚类分类,于是就做了这个作业。很简单,我就将其设置为分三类,重点是我在选择初始center的时候,尝试了使用随机选取和使用大招选取两种方式,随机选择初始点的效果不如...

    上课,老师让做作业,kmeans分类,将iris进行聚类分类,于是就做了这个作业。很简单,我就将其设置为分三类,重点是我在选择初始center的时候,尝试了使用随机选取和使用大招选取两种方式,随机选择初始点的效果不如放大招。这个大招是这样的:先随机选取一个作为center1,再选取一个距离这个center1最远的点作为center2,再选择一个距离center1和center2最远的点作为center3。

    在训练过程中更新质心的时候,我不是选择online模式,来一个点更新一次质心,而是选择了mini_batch的模式,先送进来mini_batch个样本,分别将其划归到对应的中心处,然后再进行更新。说这么多屁话,不如把代码放上来,代码如下:

    import numpy as np
    import csv
    import random
    
    features = np.loadtxt('iris.csv',delimiter=',',usecols=(1,2,3,4))  #read features
    z_min, z_max = features.min(axis=0), features.max(axis=0)          #features normalized
    features = (features - z_min)/(z_max - z_min)
    
    csv_file = open('iris.csv')   #transform string to num label
    csv_reader_lines = csv.reader(csv_file)
    classes_list = []
    for i in csv_reader_lines:
        classes_list.append(i[-1])
    labels = []
    for i in classes_list:
        if i=='setosa':
            labels.append(0)
        elif i=='versicolor':
            labels.append(1)
        else:
            labels.append(2)
    
    labels = np.array(labels)
    labels = labels.reshape((150,1))   # transformm list to numpy type
    
    data_index = np.arange(features.shape[0])
    np.random.shuffle(data_index)
    
    train_input = features[ data_index[0:120] ]
    train_label = labels[ data_index[0:120] ]
    
    test_input = features[ data_index[120:150] ]
    test_label = labels[ data_index[120:150] ]
    
    train_length = 120
    K = 3
    center_1_pos = random.randint(0,train_length)
    center1 = train_input[ center_1_pos ]
    # center1 = train_input[0]
    # center2 = train_input[1]
    # center3 = train_input[2]
    # print(center1)
    # print(center2)
    # print(center3)
    
    biggest_distance = 0.0
    center_2_pos = 0
    
    for i in range(train_length):#选择center2
        dist = np.sum(pow( (center1 - train_input[i]),2 ))
        if dist > biggest_distance:
            biggest_distance = dist
            center_2_pos = i
    
    center2 = train_input[center_2_pos]
    
    
    biggest_distance = 0.0
    center_3_pos = 0
    
    for i in range(train_length):#选择center3
        dist = np.sum(pow( (center1 - train_input[i]), 2 )) + np.sum(pow( (center2 - train_input[i]) , 2))
        if dist > biggest_distance:
            biggest_distance = dist
            center_3_pos = i
    
    center3 = train_input[center_3_pos]
    mini_batch = 20
    
    for epoch in range(10):#在整个数据集上训练10次
        for i in range(6):
            belong1 = []
            belong2 = []
            belong3 = []
            for j in range(mini_batch):#mini_batch
                temp_index = mini_batch * i + j
                belong = 1
                dist_1 = np.sum(pow( ( center1 - train_input[mini_batch*i+j] ),2 ))
                temp_dist = dist_1
    
                dist_2 = np.sum(pow((center2 - train_input[mini_batch * i + j]), 2))
                dist_3 = np.sum(pow((center3 - train_input[mini_batch * i + j]), 2))
    
                if(dist_2 < temp_dist):
                    temp_dist = dist_2
                    belong = 2
                if(dist_3 < temp_dist):
                    belong = 3
    
                if belong==1:
                    belong1.append( temp_index )
                elif belong == 2:
                    belong2.append(temp_index)
                else:
                    belong3.append(temp_index)
    
    
            for k in belong1:
                center1 = center1 + train_input[k]
            center1 = center1 / (1 + len(belong1))
    
            for k in belong2:
                center2 = center2 + train_input[k]
            center2 = center2 / (1 + len(belong2))
    
            for k in belong3:
                center3 = center3 + train_input[k]
            center3 = center3 / (1 + len(belong3))
    
        b_1=[]
        b_2=[]
        b_3=[]
        for l in range(test_input.shape[0]):#在测试机上进行测试
            belong = 1
            dist_1 = np.sum(pow((center1 - test_input[l]), 2))
            temp_dist = dist_1
    
            dist_2 = np.sum(pow((center2 - test_input[ l ]), 2))
            dist_3 = np.sum(pow((center3 - test_input[ l ]), 2))
    
            if (dist_2 < temp_dist):
                temp_dist = dist_2
                belong = 2
            if (dist_3 < temp_dist):
                belong = 3
    
    
    
            if belong == 1:
                b_1.append(test_label[l][0])
            elif belong == 2:
                b_2.append(test_label[l][0])
            else:
                b_3.append(test_label[l][0])
        print()
        print('epoch : {} / 10' .format(epoch+1))
        print('center1: ',b_1)
        print('center2',b_2)
        print('center3: ',b_3)

    下面是我运行程序的结果:

    epoch : 1 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 2 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 3 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 4 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 5 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 6 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 7 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    

         小数据集上结果还是挺好的。

    iris数据集的一个下载链接如下:链接: https://pan.baidu.com/s/1PpIwncqbtQbEuGKSxKyBMg  密码: 7ins

    注意:我在读取iris的数据时候,将第一行的属性名称删除了,要不然处理起来麻烦。

    哎,做这个小作业也挺有意思的,学习了Nummpy数据的归一化还,csv文件的numpy读取,以及如何将csv文件中的字符类型转化为数字标签。

    展开全文
  • PCA-Kmeans 鸢尾花数据集进行分类

    千次阅读 2019-11-21 18:05:05
    首先介绍一下(yuan)鸢尾花数据集,该数据集测量了所有150个样本的4个特征单位都是cm,分别是: 1.sepal length(花萼长度) 2.sepal width(花萼宽度) 3.petal length(花瓣长度) 4.petal width(花瓣宽度)...

    首先介绍一下(yuan)鸢尾花数据集,该数据集测量了所有150个样本的4个特征单位都是cm,分别是:
    1.sepal length(花萼长度)
    2.sepal width(花萼宽度)
    3.petal length(花瓣长度)
    4.petal width(花瓣宽度)
    对应一个150行4列的矩阵,本文思路是通过PCA压缩数据将其从150行四列变成150行3列,4维变3维(每个特征对应一个维度)
    在网上看了很多,k-means和PCA的结果都是二维的,我想用三维图来展示分类的的效果图就自己将代码改了一下。发个博客记录一下代码,思想大概就是将鸢尾花4维的数据转为三维后再使用k-means分类,因为提前知道了这些数据是来自三类的花,所以提前给出K-means要分类的个数为3,算法会提前随机给3个类似于重心的东西,然后离重心近的会被分到该簇。之后每个簇的重心会随着其簇内样本的增加不断改变。重心大概就是结果图中X所在的位置。

    #coding=utf-8
    import matplotlib.pyplot as plt
    from sklearn.decomposition import PCA
    from sklearn.datasets import load_iris
    from mpl_toolkits.mplot3d import Axes3D
    from sklearn.cluster import KMeans
    import numpy as np
    
    
    
    
    
    ##计算欧式距离
    def distEuclid(x, y):
        return np.sqrt(np.sum((x - y) ** 2))
    
    
    ##随机产生n个dim维度的数据 (这里为了展示结果 dim取2或者3)
    def genDataset(n, dim):
        data = []
        while len(data) < n:
            p = np.around(np.random.rand(dim) * size, decimals=2)
            data.append(p)
        return data
    
    
    ## 初始化簇中心点 一开始随机从样本中选择k个 当做各类簇的中心
    def initCentroid(data, k):
        num, dim = data.shape
        centpoint = np.zeros((k, dim))
        l = [x for x in range(num)]
        np.random.shuffle(l)
        for i in range(k):
            index = int(l[i])
            centpoint[i] = data[index]
        return centpoint
    
    
    ##进行KMeans分类
    def KMeans(data, k):
        ##样本个数
        num = np.shape(data)[0]
    
        ##记录各样本 簇信息 0:属于哪个簇 1:距离该簇中心点距离
        cluster = np.zeros((num, 2))
        cluster[:, 0] = -1
    
        ##记录是否有样本改变簇分类
        change = True
        ##初始化各簇中心点
        cp = initCentroid(data, k)
    
        while change:
            change = False
    
            ##遍历每一个样本
            for i in range(num):
                minDist = 9999.9
                minIndex = -1
    
                ##计算该样本距离每一个簇中心点的距离 找到距离最近的中心点
                for j in range(k):
                    dis = distEuclid(cp[j], data[i])
                    if dis < minDist:
                        minDist = dis
                        minIndex = j
    
                ##如果找到的簇中心点非当前簇 则改变该样本的簇分类
                if cluster[i, 0] != minIndex:
                    change = True
                    cluster[i, :] = minIndex, minDist
    
            ## 根据样本重新分类  计算新的簇中心点
            for j in range(k):
                pointincluster = data[[x for x in range(num) if cluster[x, 0] == j]]
                cp[j] = np.mean(pointincluster, axis=0)
    
        print("finish!")
        return cp, cluster
    
    
    ##展示结果  各类簇使用不同的颜色  中心点使用X表示
    def Show(data, k, cp, cluster):
        num, dim = data.shape
        color = ['b', 'r', 'g', 'c', 'y', 'm', 'k']
        ##二维图
        if dim == 2:
            for i in range(num):
                mark = int(cluster[i, 0])
                plt.plot(data[i, 0], data[i, 1], color[mark] + 'o')
    
            for i in range(k):
                plt.plot(cp[i, 0], cp[i, 1], color[i] + 'x')
        ##三维图
        elif dim == 3:
            ax = plt.subplot(122, projection='3d')
            for i in range(num):
                mark = int(cluster[i, 0])
                ax.scatter(data[i, 0], data[i, 1], data[i, 2], c=color[mark])
                ax.set_title('k-means result')
            for i in range(k):
                ax.scatter(cp[i, 0], cp[i, 1], cp[i, 2], c=color[i], marker='x')
    
        plt.show()
    if __name__ == "__main__":
            data = load_iris()#以字典形式加载鸢尾花数据集
            y = data.target #使用y表示数据集中的标签
            x = data.data #使用x表示数据集中的属性数据
            #使用PCA 算法,设置降维后主成分数目为 2
            #print(x,'\n', y)
            #print(x)
            #print(type(x))
            size = 20  ##取值范围
            pca = PCA(n_components=3)
            #对原始数据进行降维,保存在 reduced_X 中
            reduced_X = pca.fit_transform(x)
            print('降维后的数据为:\n',reduced_X)#降维后的数据
            print('各主成分方差解释度为:',pca.explained_variance_ratio_)#方差解释度
            print('主成分对应的载荷矩阵为',pca.components_)
            red_x, red_y , red_z = [], [],[]
            blue_x, blue_y , blue_z= [], [],[]
            green_x, green_y, green_z=[],[],[]
    
            for i in range(len(reduced_X)):
                #标签为0时,3维标签数据保存到列表red_x,red_y,redz中
                if y[i] == 0:
                    red_x.append(reduced_X[i][0])
                    red_y.append(reduced_X[i][1])
                    red_z.append(reduced_X[i][2])#
                elif y[i] == 1:
                    blue_x.append(reduced_X[i][0])
                    blue_y.append(reduced_X[i][1])
                    blue_z.append(reduced_X[i][2])#
                else:
                    green_x.append(reduced_X[i][0])
                    green_y.append(reduced_X[i][1])
                    green_z.append(reduced_X[i][2])#
            X = reduced_X[:, :3]  # #表示我们取特征空间中的3个维度
           #print(X.shape)
           #print(X)
           #print(type(X))
            num = 50 ##点个数
            k=3 ##分类个数
            data = X
            cp,cluster = KMeans(data,k)
            ax=plt.figure().add_subplot(121,projection='3d')
            ax.scatter(red_x, red_y,red_z,c='r', marker='o')
            ax.scatter(blue_x, blue_y,blue_z,c='b', marker='o')
            ax.scatter(green_x, green_y,green_z,c='g', marker='o')#散点图中用s,其余图用markersize可调节散点的大小
            ax.set_title('PCA result')
            Show(data,k,cp,cluster)
    
    
    
    
    
    
    
    
    
    

    result

    展开全文
  • Python实现Iris数据集(鸢尾花卉数据集kmeans聚类

    万次阅读 多人点赞 2019-01-15 10:45:33
    一,鸢尾花Iris数据集解析     二,绘制Iris数据集散点图,数据集已经给出具体类别 from sklearn import datasets import matplotlib.pyplot as plt #加载数据集,是一个字典类似Java中的map lris_df ...

     一,鸢尾花Iris数据集解析

     

     

    二,绘制Iris数据集散点图,数据集已经给出具体类别

    from sklearn import datasets
    import matplotlib.pyplot as plt
    
    #加载数据集,是一个字典类似Java中的map
    lris_df = datasets.load_iris()
    
    
    #挑选出前两个维度作为x轴和y轴,你也可以选择其他维度
    x_axis = lris_df.data[:,0]
    y_axis = lris_df.data[:,2]
    
    #c指定点的颜色,当c赋值为数值时,会根据值的不同自动着色
    plt.scatter(x_axis, y_axis, c=lris_df.target)
    plt.show()

     

     三,Python使用kmeans聚类,并绘制新的聚类散点图。

    from sklearn import datasets
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans
    
    #加载数据集,是一个字典类似Java中的map
    lris_df = datasets.load_iris()
    
    #挑选出前两个维度作为x轴和y轴,你也可以选择其他维度
    x_axis = lris_df.data[:,0]
    y_axis = lris_df.data[:,2]
    
    
    #这里已经知道了分3类,其他分类这里的参数需要调试
    model = KMeans(n_clusters=3)
    
    #训练模型
    model.fit(lris_df.data)
    
    #选取行标为100的那条数据,进行预测
    prddicted_label= model.predict([[6.3, 3.3, 6, 2.5]])
    
    #预测全部150条数据
    all_predictions = model.predict(lris_df.data)
    
    #打印出来对150条数据的聚类散点图
    plt.scatter(x_axis, y_axis, c=all_predictions)
    plt.show()

     

    四,也可以聚成两类:

    #将类别参数改成2
    model = KMeans(n_clusters=2)

     

     五,kmeans算法流程

          1)随机选取k个点作为种子点(这k个点不一定属于数据集,k个点就代表有k类)

          2)分别计算每个数据点到k个种子点的距离,离哪个种子点最近,就属于哪类

          3)重新计算k个种子点的坐标(简单常用的方法是求坐标值的平均值作为新的坐标值)

          4)重复2、3步,直到种子点坐标不变或者循环次数完成

    è¿éåå¾çæè¿°

     六,kmeans的不足

     

        1)初始分类数目k值很难估计,不确定应该分成多少类才最合适(ISODATA算法通过类的自动合并和分裂,得到较为合理的类型数目k)(meanshift也可以不用提前知道分多少类别,参考博文:https://blog.csdn.net/u010916338/article/details/86495308

        2)不同的随机种子会得到完全不同的结果(K-Means++算法可以用来解决这个问题,其可以有效地选择初始点)

    展开全文
  • Python from sklearn import datasets import matplotlib.pyplot as plt from sklearn.cluster ...# 加载数据集,是一个字典类似Java中的map lris_df = datasets.load_iris() # 挑选出前两个维度作为x...
    Python

    from sklearn import datasets
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans
    
    # 加载数据集,是一个字典类似Java中的map
    lris_df = datasets.load_iris()
    
    # 挑选出前两个维度作为x轴和y轴,你也可以选择其他维度
    x_axis = lris_df.data[:, 0]
    y_axis = lris_df.data[:, 2]
    
    # 这里已经知道了分3类,其他分类这里的参数需要调试
    model = KMeans(n_clusters=3)
    
    # 训练模型
    model.fit(lris_df.data)
    
    # 选取行标为100的那条数据,进行预测
    # prddicted_label = model.predict([[6.3, 3.3, 6, 2.5]])
    
    # 预测全部150条数据
    all_predictions = model.predict(lris_df.data)
    
    # 打印出来对150条数据的聚类散点图
    plt.scatter(x_axis, y_axis, c=all_predictions)
    plt.show()
    Spark-Mlib
    package com.kami.demo01
    
    import org.apache.spark.SparkContext
    import org.apache.spark.ml.clustering.{KMeans, KMeansModel}
    import org.apache.spark.ml.feature.{MinMaxScaler, MinMaxScalerModel}
    import org.apache.spark.sql.{DataFrame, SparkSession}
    
    
    object rua01 {
    
      /**
       * 安德森鸢尾花卉数据集
       * https://download.csdn.net/download/qq_33887096/12573555
       * 其数据集包含了150个样本,都属于鸢尾属下的三个亚属,分别是山鸢尾、变色鸢尾和维吉尼亚鸢尾。四个特征被用作样本的定量分析,它们分别是花萼和花瓣的长度和宽度。基于这四个特征的集合,费雪发展了一个线性判别分析以确定其属种。
       * IRIS数据集由Fisher在1936年整理的一个经典数据集,在统计学习和机器学习领域都经常被用作示例。
       * 数据集内包含 3 类共 150 条记录,每类各 50 个数据,每条数据包含4个特征,都是浮点数,单位为厘米。
       * Sepal.Length(花萼长度)
       * Sepal.Width(花萼宽度)
       * Petal.Length(花瓣长度)
       * Petal.Width(花瓣宽度))
       *
       * 目标值为鸢尾花的分类:
       * Iris Setosa(山鸢尾)
       * Iris Versicolour(杂色鸢尾)
       * Iris Virginica(维吉尼亚鸢尾)
       *
       *
       * K-Means 使用的数据格式libSVM
       * libsvm数据格式
       * libsvm使用的训练数据和检验数据文件格式如下:
       * 1. [label] [index1]:[value1] [index2]:[value2] …
       * 2. [label] [index1]:[value1] [index2]:[value2] …
       * label  目标值,就是class(属于哪一类), 要分类的种类,通常是一些整数。
       * index 是有顺序的索引,通常是连续的整数。就是指特征编号,必须按照升序排列
       * value 就是特征值,用来train的数据,通常是一堆实数组成。
       * 样例数据
       * 1 1:5.1 2:3.5 3:1.4 4:0.2
       * 1 1:4.9 2:3.0 3:1.4 4:0.2
       * 1 1:4.7 2:3.2 3:1.3 4:0.2
       * 1 1:4.6 2:3.1 3:1.5 4:0.2
       *
       * @param args
       */
    
      def main(args: Array[String]): Unit = {
        // 屏蔽日志
        //    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
        //    Logger.getLogger("org.apache.jetty.server").setLevel(Level.OFF)
    
        // 设置运行环境
        val sparkSession: SparkSession = SparkSession.builder().master("local[*]").appName("K-Means").getOrCreate()
        val sparkContext: SparkContext = sparkSession.sparkContext
        sparkContext.setLogLevel("warn")
    
        val irisLibSvmDF = sparkSession.read.format("libsvm").load("data\\iris_kmeans.txt")
        //    irisLibSvmDF.show(false)
    
        /**
         * 数据归一化(将数据归一到0-1之间,计算速度快)
         * 把数据映射到0~1范围之内处理,更加便捷快速
         * MinMaxScaler  把有量纲表达式变成无量纲表达式,便于不同单位或量级的指标能够进行比较和加权。
         * x = (x - X_min) / (X_max - X_min)
         */
    
        val scalerDatas: MinMaxScalerModel = new MinMaxScaler()
          .setInputCol("features") //设置需要归一化的列
          .setOutputCol("featuresOut") //归一化后的数据的列名字
          .fit(irisLibSvmDF) //设置数据
    
        val scalerDF: DataFrame = scalerDatas.transform(irisLibSvmDF)
        //    scalerDF.show(false)
    
        //使用kmeans进行计算
        val prediction: KMeansModel = new KMeans()
          .setK(3) //设置需要划分类别的数量/个数
          .setMaxIter(10) //设置最大计算次数
          .setFeaturesCol("featuresOut") //设置特征的列    归一化后的列
          .setPredictionCol("predictionValue") //设置最终预测后的结果列名
          .setSeed(20) //设置随机种子    在运行多次时结果相同
          .fit(scalerDF)
    
    
        val predictionDF: DataFrame = prediction.transform(scalerDF)
        //    predictionDF.show(false)
    
        predictionDF.groupBy("label", "predictionValue").count().show()
    
        sparkContext.stop()
        sparkSession.stop()
      }
    }
    Spark-ML
    package com.kami.demo01
    
    import org.apache.spark.SparkContext
    import org.apache.spark.ml.feature.StringIndexerModel
    import org.apache.spark.rdd.RDD
    import org.apache.spark.sql.types.StructType
    import org.apache.spark.sql.{DataFrame, Row, SparkSession}
    
    /**
     * http://spark.apache.org/docs/latest/mllib-clustering.html#k-means
     * 聚类分析是一个无监督学习 (Unsupervised Learning) 过程, 一般是用来对数据对象按照其特征属性进行分组,经常被应用在客户分群,欺诈检测,图像分析等领域。K-means 应该是最有名并且最经常使用的聚类算法了,其原理比较容易理解,并且聚类效果良好,有着广泛的使用。
     * K-means是聚类算法重较为简单的一种,其属于无监督学习,所以训练样本中没有没有类别标签,只有特征。
     */
    
    /**
     * 安德森鸢尾花卉数据集(英文:Anderson's Iris data set),也称鸢尾花卉数据集(英文:Iris flower data set)或费雪鸢尾花卉数据集(英文:Fisher's Iris data set),是一类多重变量分析的数据集。它最初是埃德加·安德森从加拿大加斯帕半岛上的鸢尾属花朵中提取的形态学变异数据[1],后由罗纳德·费雪作为判别分析的一个例子[2],运用到统计学中。
     * http://archive.ics.uci.edu/ml/datasets/Iris
     * 费雪鸢尾花卉数据集
     * 花萼长度	花萼宽度	花瓣长度	花瓣宽度	属种
     */
    
    object rua02 {
      def main(args: Array[String]): Unit = {
        val sparkSession: SparkSession = SparkSession.builder().master("local[*]").appName("wula").getOrCreate()
        val sparkContext: SparkContext = sparkSession.sparkContext
        sparkContext.setLogLevel("warn")
        val structType: StructType = new StructType().add("Sepal.Length", "double").add("Sepal.Width", "double").add("Petal.Length", "double").add("Petal.Width", "double").add("Species", "string")
        val fileRdd: RDD[String] = sparkContext.textFile("file:///C:\\tool\\dev\\JAVA\\2020.06\\day0624_work01\\data\\iris.data")
        //    fileRdd.foreach(x=>println(x))
        val fileRddC: RDD[Row] = fileRdd.filter(x => !x.equals("")).map(_.split(",")).map(x => Row(x(0).toDouble, x(1).toDouble, x(2).toDouble, x(3).toDouble, x(4)))
        val df: DataFrame = sparkSession.createDataFrame(fileRddC, structType)
        //    df.show(false)
    
        //特征索引转化
        import org.apache.spark.ml.feature.StringIndexer
        val indexer: StringIndexer = new StringIndexer().setInputCol("Species").setOutputCol("categoryIndex")
        val model: StringIndexerModel = indexer.fit(df)
        val indexed: DataFrame = model.transform(df)
        indexed.show()
    
        sparkContext.stop()
        sparkSession.stop()
      }
    }
    展开全文
  • 导入库import numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport seaborn as snsfrom sklearn.datasets import load_irisfrom sklearn.cluster import KMeansfrom sklearn.preprocessing import...
  • PySpark-ClusterClassify 使用AWS Sagemaker在MNIST数据集进行分布式KMeans聚类和XGBoost分类作业
  • 框架:keras,语言:python,使用算法:k-means,需要安装一些安装包
  • 通过kmans算法,实现wine数据集分类
  • 本文使用sklearn的KMeans方法无标签数据集,天气数据集minute_weather进行处理,同时尝试自己编写Kmeans算法进行数据处理,对比两者差异,检查自定义算法可用性。 数据集minute_weather可以在网上找找,笔者也是...
  • 在我的想法是对数据集的某些部分(如训练数据集)运行分类,然后将calssification逐部分应用到数据集的其余部分。在import pandas as pdimport picklefrom sklearn.cluster import KMeansframes = [pd.read_hdf(fin)...
  • 利用kmeans算法对数据集实行分类运算,C++kmeans鸢尾花kmeanskmeanskmeans
  • Kmeans分类(角度分类) 上次的气象云分类还在跟新中【点击这里】,先记录一下这次在做摄像头角度分类用的算法和代码; 主要是针对摄像头的角度不同使得产生的图片也有差异,这里主要使用的是Kmeans算法进行分类,...
  • ——以二维数组、鸢尾花...聚类算法属于无监督学习,其中的KMeans算法是将一组有N个样本的数据划分成K个不相交的 clusters (簇) C。 means (均值)通常被称为 cluster(簇)的 “centroids(质心)”; 注意,它们...
  • 文章目录一、线性LDA1、线性LDA含义2、鸢尾花数据集进行可视化分类3、月亮数据集进行可视化分类二、k-means1、k-means含义2、鸢尾花数据集进行可视化分类3、月亮数据集进行可视化分类三、SVM1、SVM含义2、...
  • 使用sklearn.cluester的KMeans航空公司客户数据进行聚类分析,把乘客分到不同的类别中。 kmeans参数说明 from sklearn.cluster import KMeans k = 5 model = … KMeans(algorithm='auto', copy_x=True, init='k-...
  • 这里写自定义目录标题数据挖掘——KMeans算法入门学习KMeans算法介绍KMeans算法实例(8个样本点进行分类KMeans算法调优(直接调用sklearn库函数) 数据挖掘——KMeans算法入门学习 **个人的学习笔记,欢迎大佬...
  • 工具:jupyter notebook, 包含文件:ipython源码及excel数据集。使用Kmeans模型进行用户分群,肘部法则判断聚类个数,根据概率密度图用户进行分类
  • 采用线性LDA、k-means和SVM算法鸢尾花数据集和月亮数据集进行分类可视化分析SVM,k-means,线性LDA算法简介两个数据集采用线性LDA进行分类采用k-means进行分类采用SVM算法进行分类SVM算法的优点 SVM,k-means...
  • Python Kmeans K均值分类

    2021-02-11 18:30:45
    Python Kmeans K均值分类 1 声明 本文的数据来自网络,部分代码也有所参照,这里做了注释和延伸,旨在技术交流,如有冒犯之处请联系博主及时处理。 2 Kmeans简介 相关概念见下: Kmeans是无监督分类算法,即不...
  • from sklearn.cluster import KMeans as k import matplotlib.pyplot as plt from sklearn.datasets import load_iris#导入数据 from mpl_toolkits.mplot3d import Axes3D#3d图 import numpy as np import sklearn ...
  • 1 importnumpy as np2 importrandom3 from matplotlib importpyplot as plt45 classK_means(object):6 def __init__(self,X,k,maxIter):7 self.X = X#数据集 是一个矩阵8 self.k = k#所需要分的类的数9 ...
  • kmeans+分类

    2020-04-11 16:57:10
    path_filenames = get_file_name("/home/xiaozhen/UCMerced_LandUse/Images/") #下载的数据集的路径(需要改) labels, cluster_centers = knn_detect(path_filenames, 2) res_dict = res_fit(path_filenames, ...
  • 110 代码 实验结果 解释 优点 ...所有内容均来源于贾志刚老师的知识星球——OpenCV研习社,本文为个人整理学习,已获得贾老师授权,有兴趣、有能力的可以加入贾老师的知识星球进行深入学习。 ...
  • 机器学习系列--kmeans分类算法

    千次阅读 2018-09-09 18:27:39
    K-means算法是简单和经典于一身的基于距离的聚类算法,采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为类簇是由距离靠近的对象组成的,因为把得到紧凑且独立的簇作为最终目标...
  • FCM聚类iris和sonar数据集,以及图像分割(更新中)kmeans问题概述kmeans运行效果代码部分结构总览函数1载入数据load_iris(),load_sonar()函数2初始化样本中心点init_kmeans(bool is_iris)函数3 分类函数sort(bool ...
  • Kmeans&HCA + iris数据集+python实现

    千次阅读 2018-12-30 16:19:05
    遍历所有数据,将每个数据划分到最近的中心点中 c. 计算每个聚类的平均值,并作为新的中心点 d. 重复2-3,直到这k个中线点不再变化(收敛了),或执行了足够多的迭代 时间复杂度:O(Inkm) 空间复杂度:O(nm) 层次...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,938
精华内容 3,575
关键字:

对数据集进行kmeans分类