精华内容
下载资源
问答
  • sonar数据集

    2019-01-03 11:17:17
    sonar数据集是初学机器学习常用的数据集之一,包括R、M两类,208个样本
  • UCI之Sonar数据集

    2017-10-12 11:31:10
    UCI的一个数据集Sonar,已经用MATLAB转化为.mat数据文件了,在MATLAB里面可以直接load
  • SVM算法分类iris和sonar数据集.pdf
  • Iris和sonar数据集

    2021-10-12 00:58:30
    两个txt文件,和官网上下载的差不多
  • Sonar数据集来源于UCI数据库,UCI是加州大学欧文分校(University of CaliforniaIrvine)提出的用于机器学习的数据库。其官网地址如下:http://archive.ics.uci.edu/ml/index.php 1.2 数据介绍 声纳数据集(Sonar ...

    机器学习作业:数据分类

    ps:作者是很用心写的,如果觉得不错,请给作者一点鼓励噢!(点赞收藏评论噢)

    1 数据集

    1.1 数据来源

    Sonar数据集来源于UCI数据库,UCI是加州大学欧文分校(University of CaliforniaIrvine)提出的用于机器学习的数据库。其官网地址如下:http://archive.ics.uci.edu/ml/index.php

    1.2 数据介绍

    声纳数据集(Sonar Dataset )涉及预测根据给定声纳从不同角度返回的强度预测目标物体是岩石还是矿井。数据集一共有208个观察值,60个特征,2个类别(M为矿井,R为岩石),每个类的观察值数量不均等。在该数据集上所做的预测最普遍类的基准性能是约 53% 的分类准确率,最佳结果达到约 88% 的分类准确率。
    如图1所示,本文使用的是经过数据预处理转化为.mat格式的Sonar数据集
    在这里插入图片描述

    2 分类算法

    2.1 Logistic回归算法

    2.11 算法介绍

    logistic回归与分类是一种简单的分类算法。在分类的过程中只需要找到一个划分不同类的权重向量即可,对新的数据只需要乘上这个向量并比较就可以得到分类。logistic回归可以解决二分类问题甚至是多分类问题的,但是二分类的更为常用,也更加容易解释,所以本文主要用logistic回归解决二分类问题。

    2.12 计算步骤

    符号含义:h为权重,b为偏置、C为损失函数、a为预测标签,x为输入的特征,y为预测标签
    (1)计算z
    在这里插入图片描述
    (2)z值用Sigmax映射到(0,1)区间,将标签换为0,1标签
    在这里插入图片描述

    (3)假设使用平方损失函数作为损失函数(损失函数是用来干啥的?用来求参数的!!!)在这里插入图片描述
    (4)计算权重h和偏置b的梯度
    在这里插入图片描述
    在这里插入图片描述

    (5)更新权重(随机梯度下降法)
    可使用的更新权重的方法具体参照:https://blog.csdn.net/suixinsuiyuan33/article/details/69525356
    在这里插入图片描述
    (6)当C的值达到指定小时,结束权重更新,得到的即为理想最优h、b
    (7)将需要预测的数据特征利用得到的h、b计算预测标签达到分类的目的
    参考:https://blog.csdn.net/u014595019/article/details/52554582?spm=1001.2014.3001.5506

    2.2 贝叶斯分类

    2.21 算法原理

    对于给出的待分类项,求解在此项出现的条件下各个类别出现的概率,哪个最大,就认为此待分类项属于哪个类别。

    2.22 算法流程

    在这里插入图片描述
    在这里插入图片描述
    本文的代码是参考周志华老师的《西瓜书》写成的,所以这里引述周志华老师书中的朴素贝叶斯分类器及例子
    在这里插入图片描述
    书中例子在这里插入图片描述
    在这里插入图片描述
    P(好瓜) = 8/17 = 0.471
    P(坏瓜) = 9/17 = 0.529
    在这里插入图片描述
    参考:https://blog.csdn.net/kswkly/article/details/79545326?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161845450216780357296117%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161845450216780357296117&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2blogfirst_rank_v2~rank_v29-1-79545326.nonecase&utm_term=%E8%B4%9D%E5%8F%B6%E6%96%AF

    2.3 高斯分布算法

    2.31 算法原理

    通过两个先验假设:一是样本数据的类别在给定的情况下服从伯努利分布,二是不同类别中的样本数据分别服从多元高斯分布。首先估计出先验概率以及多元高斯分布的均值和协方差矩阵,然后再由贝叶斯公式求出一个新样本分别属于两类别的概率,预测结果取概率值大者。

    2.32 算法步骤

    在这里插入图片描述
    详细推导过程可查看(超推荐!!!感觉超好理解)
    https://zhuanlan.zhihu.com/p/38269530

    2.4 BP神经网络算法

    2.41基本原理

    BP神经网络是一种多层前馈神经网络,该网络的主要特点是信号前向传递,误差反向传播。在前向传播的过程中,输入信号从输入层经隐含层处理,直至输出层。每一层的神经元状态只影响下一层神经元状态。如果输出层得不到期望输出,则转入反向传播,根据预测误差调整网络权值和阈值,从而使BP神经网络预测输出不断逼近期望输出。

    2.42 算法步骤

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

    3 算法流程图

    在这里插入图片描述

    4.2 结果及分析

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

    5 代码附录

    %  Logisti回归
     clc
     clear
     close all
     tic;%开始计时
     load Sonar%加载数据集
     data1=Sonar;
    % 并将标签重新设置为01,方便sigmod函数应用 
    % 这里因为只分两类情况,所以挑选出两类数类,这里挑选的12%index = find((data1(:,61)==1)|(data1(:,61)==2));
    %data1 = data1(index,:);
    data1(:,61) = data1(:,61) - 1;
    %选择训练样本个数
    num_train = 156;
    ac=[];%测试集正确率集
    sc=[]%训练集正确率集
    for k=1:20%计算20%构造随机选择序列
    choose = randperm(size(data1,1));
    train_data = data1(choose(1:num_train),:);%训练集
    label_train = train_data(:,end);%训练集标签
    test_data = data1(choose(num_train+1:end),:);%测试集
    label_test = test_data(:,end);%测试集标签
    data_D = size(train_data,2) - 1;%特征数量
    % 初始化矩阵和偏置
    weights = ones(1,data_D);
    b= ones(1,data_D);
    %% training data weights
    %  随机梯度上升算法
        for j=1:100%迭代伦次数,可根据准确率和自身需要设计
        alpha = 0.1/j;%学习率,可根据准确率和自身需要设计,这里动态设计学习率,先用较大准确率提高效率,随轮数增加逐渐衰减,防止无法收敛
        for i=1:size(train_data,1)
            data = train_data(i,1:end-1);
            h = 1.0/(1+exp(-(data*weights'+b)));%计算sigmod函数
            error = label_train(i) - h;%真实值和预测值的误差
            weights = weights + (alpha * error * data);%梯度上升算法更新权重,根据dJ/dW=error * data
            b=b + (alpha * error);%梯度上升算法更新偏置
        end
        end
    % 整体梯度算法-批量
    % for j = 1:2000
    %     alpha = 0.1/j;
    %     data = train_data(:,1:end-1);
    %     h = 1./(1+exp(-(data*weights')));
    %     error = label_train - h;
    %     weights = weights + (alpha * data' * error)';
    % end
    %训练集预测结果
    diff = zeros(2,size(train_data,1));%损失值矩阵,行数代表类别,列数代表个体数目
    for i = 1:size(train_data,1)
        data = train_data(i,1:end-1);
        h = 1.0/(1+exp(-(data*weights')));
        %计算损失矩阵
        for j = 1:2 
            diff(j,i) = abs((j-1)-h);
        end
    end
    [~,predict1] = min(diff);%返回预测标签
    %计算准确率
    accuracy = length(find(predict1'==(label_train+1)))/length(train_data);
    sc=[sc accuracy];
    %% predict the testing data
    diff = zeros(2,size(test_data,1));
    for i = 1:size(test_data,1)
        data = test_data(i,1:end-1);
        h = 1.0/(1+exp(-(data*weights')));
        %compare to every label
        for j = 1:2 
            diff(j,i) = abs((j-1)-h);
        end
    end
    [~,predict] = min(diff);
    accuracy = length(find(predict'==(label_test+1)))/length(test_data);
    ac=[ac accuracy];
    end
    % 可视化结果
    figure;
    plot(label_train+1,'*')
    hold on
    plot(predict1,"or");
    hold on 
    plot(abs(predict1'-(label_train+1)),'-g');
    axis([0,size(train_data,1),0,3])
    legend('实际类别类别','预测类别','误差曲线')
    title(['基于Logistic算法对Sonar数据分类训练集平均准确率 :',num2str(sum(sc)/length(sc))]);
    figure;
    plot(label_test+1,'*')
    hold on
    plot(predict,'or');
    hold on 
    plot(abs(predict'-(label_test+1)),'-g');
    legend('实际类别类别','预测类别','误差曲线')
    axis([0,length(test_data),0,3])
    title(['基于Logistic算法对Sonar数据分类测试集平均准确率 :',num2str(sum(ac)/length(ac))]);
    toc;%停止计时
    
    
    %贝叶斯分类法
    clc
    clear all;
    tic%计时开始
    load Sonar%加载数据集
    data1=Sonar;
    % 这里因为只分两类情况,所以挑选出两类数类,这里挑选的12类,sonar数据集由于只有两类,所以可以省略
    %index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选12类样本
    data1 = data1(index,:);
    num_train_train = 156;%训练样本个数
    num_train_test=52;%测试样本个数
    feature=60;%特征数量
    ac=[];%测试集准确率集合
    sc=[];%训练集准确率集合
    for k=1:5%运行5轮
    temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
    %构造随机选择序列
    choose = randperm(size(data1,1));
    train=data1(choose(1:num_train_train),:);
    train_data = train(:,1:end-1)
    label_train = train(:,end);
    test = data1(choose(num_train_train+1:end),:);
    test_data=test(:,1:end-1);
    label_test = test(:,end);
    %计算出样本中各个属性的均值、方差和每个类的概率
    pre1=[];%训练集类别概率矩阵
    pre2=[];%测试集类别概率矩阵
    predict1 = [];%训练集类别预测矩阵
    predict=[]%测试集类别预测矩阵
        PXY1=[];%训练集所有个体每个特征的条件概率密度
        PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
        PXY2=[];%测试集所有个体每个特征的条件概率密度
        PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
        X1 = [];%训练集中属于第一类的个体矩阵
        X2 = []%训练集中属于第二类的个体矩阵
        count = 0;%训练集中第一类的个体数
        for j = 1:num_train
            if label_train(j,1)==1
               X1 = [X1;train_data(j,:)];
                count = count + 1;
            end
             if label_train(j,1)==2
               X2 = [X2;train_data(j,:)];
            end
        end
        temp(1,:) = mean(X1,1);%计算第一类各特征的均值
        temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
        temp(3,:) = mean(X2,1);%计算第二类各特征的均值
        temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
        PX1 = count/num_train;%计算个体属于第一类的概率
        PX2=1-PX1;%计算个体属于第二类的概率
    %计算预测结果
    %训练集上
    for j = 1:size(train_data,1)
        %由于Sonar各特征属性值为连续值,所以假设该属性值符合高斯分布,利用高斯分布计算概率密度
            PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
    PXY1=[];
    for j = 1:size(train_data,1)
            PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
    %测试集上预测
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
            PXY2=[PXY2;PXYj2]
    end
    pre2 = [pre2 prod(PXY2,2).*PX1]
           PXY2=[];
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
            PXY2=[PXY2;PXYj2]
    end 
    pre2 = [pre2 prod(PXY2,2).*PX2]
    %返回预测标签,个体属于哪一类的概率大,就判给哪一类
    [~,predict1]=max(pre1');
    accuracy = length(find(predict1'==label_train))/length(train_data);
    sc=[sc accuracy];  
    [~,predict]=max(pre2');
    accuracy = length(find(predict'==label_test))/length(test_data);
    ac=[ac accuracy];
    end
    %可视化结果
    figure;
    plot(label_train,'*')
    hold on
    plot(predict1,"or");
    hold on 
    plot(abs(predict1'-label_train),'-g');
    axis([0,size(train_data,1),0,3])
    legend('实际类别类别','预测类别','误差曲线')
    title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
    figure;
    plot(label_test,'*')
    hold on
    plot(predict,'or');
    hold on 
    plot(abs(predict'-label_test),'-g');
    legend('实际类别类别','预测类别','误差曲线')
    axis([0,length(test_data),0,3])
    title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
    toc%停止计时
    clc
    clear all;
    tic%计时开始
    load Sonar%加载数据集
    data1=Sonar;
    % 这里因为只分两类情况,所以挑选出两类数类,这里挑选的12类,sonar数据集由于只有两类,所以可以省略
    %index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选12类样本
    data1 = data1(index,:);
    num_train_train = 156;%训练样本个数
    num_train_test=52;%测试样本个数
    feature=60;%特征数量
    ac=[];%测试集准确率集合
    sc=[];%训练集准确率集合
    for k=1:5%运行5轮
    temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
    %构造随机选择序列
    choose = randperm(size(data1,1));
    train=data1(choose(1:num_train_train),:);
    train_data = train(:,1:end-1)
    label_train = train(:,end);
    test = data1(choose(num_train_train+1:end),:);
    test_data=test(:,1:end-1);
    label_test = test(:,end);
    %计算出样本中各个属性的均值、方差和每个类的概率
    pre1=[];%训练集类别概率矩阵
    pre2=[];%测试集类别概率矩阵
    predict1 = [];%训练集类别预测矩阵
    predict=[]%测试集类别预测矩阵
        PXY1=[];%训练集所有个体每个特征的条件概率密度
        PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
        PXY2=[];%测试集所有个体每个特征的条件概率密度
        PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
        X1 = [];%训练集中属于第一类的个体矩阵
        X2 = []%训练集中属于第二类的个体矩阵
        count = 0;%训练集中第一类的个体数
        for j = 1:num_train
            if label_train(j,1)==1
               X1 = [X1;train_data(j,:)];
                count = count + 1;
            end
             if label_train(j,1)==2
               X2 = [X2;train_data(j,:)];
            end
        end
        temp(1,:) = mean(X1,1);%计算第一类各特征的均值
        temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
        temp(3,:) = mean(X2,1);%计算第二类各特征的均值
        temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
        PX1 = count/num_train;%计算个体属于第一类的概率
        PX2=1-PX1;%计算个体属于第二类的概率
    %计算预测结果
    %训练集上
    for j = 1:size(train_data,1)
        %由于Sonar各特征属性值为连续值,所以假设该属性值符合高斯分布,利用高斯分布计算概率密度
            PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
    PXY1=[];
    for j = 1:size(train_data,1)
            PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
    %测试集上预测
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
            PXY2=[PXY2;PXYj2]
    end
    pre2 = [pre2 prod(PXY2,2).*PX1]
           PXY2=[];
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
            PXY2=[PXY2;PXYj2]
    end 
    pre2 = [pre2 prod(PXY2,2).*PX2]
    %返回预测标签,个体属于哪一类的概率大,就判给哪一类
    [~,predict1]=max(pre1');
    accuracy = length(find(predict1'==label_train))/length(train_data);
    sc=[sc accuracy];  
    [~,predict]=max(pre2');
    accuracy = length(find(predict'==label_test))/length(test_data);
    ac=[ac accuracy];
    end
    %可视化结果
    figure;
    plot(label_train,'*')
    hold on
    plot(predict1,"or");
    hold on 
    plot(abs(predict1'-label_train),'-g');
    axis([0,size(train_data,1),0,3])
    legend('实际类别类别','预测类别','误差曲线')
    title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
    figure;
    plot(label_test,'*')
    hold on
    plot(predict,'or');
    hold on 
    plot(abs(predict'-label_test),'-g');
    legend('实际类别类别','预测类别','误差曲线')
    axis([0,length(test_data),0,3])
    title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
    toc
    clc
    clear all;
    tic%计时开始
    load Sonar%加载数据集
    data1=Sonar;
    % 这里因为只分两类情况,所以挑选出两类数类,这里挑选的12类,sonar数据集由于只有两类,所以可以省略
    %index = find((data1(:,61)==1)|(data1(:,61)==2));%挑选12类样本
    data1 = data1(index,:);
    num_train_train = 156;%训练样本个数
    num_train_test=52;%测试样本个数
    feature=60;%特征数量
    ac=[];%测试集准确率集合
    sc=[];%训练集准确率集合
    for k=1:5%运行5轮
    temp = zeros(4,feature);%用来存储样本中各类的均值、方差和每个类的概率
    %构造随机选择序列
    choose = randperm(size(data1,1));
    train=data1(choose(1:num_train_train),:);
    train_data = train(:,1:end-1)
    label_train = train(:,end);
    test = data1(choose(num_train_train+1:end),:);
    test_data=test(:,1:end-1);
    label_test = test(:,end);
    %计算出样本中各个属性的均值、方差和每个类的概率
    pre1=[];%训练集类别概率矩阵
    pre2=[];%测试集类别概率矩阵
    predict1 = [];%训练集类别预测矩阵
    predict=[]%测试集类别预测矩阵
        PXY1=[];%训练集所有个体每个特征的条件概率密度
        PXYj1=zeros(1,60);%训练集单个个体每个特征的条件概率密度
        PXY2=[];%测试集所有个体每个特征的条件概率密度
        PXYj2=zeros(1,60);%测试集单个个体每个特征的条件概率密度
        X1 = [];%训练集中属于第一类的个体矩阵
        X2 = []%训练集中属于第二类的个体矩阵
        count = 0;%训练集中第一类的个体数
        for j = 1:num_train
            if label_train(j,1)==1
               X1 = [X1;train_data(j,:)];
                count = count + 1;
            end
             if label_train(j,1)==2
               X2 = [X2;train_data(j,:)];
            end
        end
        temp(1,:) = mean(X1,1);%计算第一类各特征的均值
        temp(2,:) = std(X1,1,1);%计算第一类各特征的方差
        temp(3,:) = mean(X2,1);%计算第二类各特征的均值
        temp(4,:) = std(X2,1,1);%计算第二类各特征的方差
        PX1 = count/num_train;%计算个体属于第一类的概率
        PX2=1-PX1;%计算个体属于第二类的概率
    %计算预测结果
    %训练集上
    for j = 1:size(train_data,1)
        %由于Sonar各特征属性值为连续值,所以假设该属性值符合高斯分布,利用高斯分布计算概率密度
            PXYj1= 1./(temp(2,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(1,:)).^2)./(-2.*(temp(2,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX1]%计算个体属于第一类的概率
    PXY1=[];
    for j = 1:size(train_data,1)
            PXYj1= 1./(temp(4,:).*sqrt(2*pi)).*exp(((train_data(j,:)-temp(3,:)).^2)./(-2.*(temp(4,:).^2)));
            PXY1=[PXY1;PXYj1]
    end
    pre1 = [pre1 prod(PXY1,2).*PX2]%计算个体属于第二类的概率
    %测试集上预测
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(2,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(1,:)).^2)./-2./(temp(2,:).^2));
            PXY2=[PXY2;PXYj2]
    end
    pre2 = [pre2 prod(PXY2,2).*PX1]
           PXY2=[];
    for j = 1:size(test_data,1)
            PXYj2= 1./(temp(4,:).*sqrt(2*pi)).*exp(((test_data(j,:)-temp(3,:)).^2)./-2./(temp(4,:).^2));
            PXY2=[PXY2;PXYj2]
    end 
    pre2 = [pre2 prod(PXY2,2).*PX2]
    %返回预测标签,个体属于哪一类的概率大,就判给哪一类
    [~,predict1]=max(pre1');
    accuracy = length(find(predict1'==label_train))/length(train_data);
    sc=[sc accuracy];  
    [~,predict]=max(pre2');
    accuracy = length(find(predict'==label_test))/length(test_data);
    ac=[ac accuracy];
    end
    %可视化结果
    figure;
    plot(label_train,'*')
    hold on
    plot(predict1,"or");
    hold on 
    plot(abs(predict1'-label_train),'-g');
    axis([0,size(train_data,1),0,3])
    legend('实际类别类别','预测类别','误差曲线')
    title(['基于贝叶斯算法对Sonar数据分类训练集平均准确率 :',num_train2str(sum(sc)/length(sc))]);
    figure;
    plot(label_test,'*')
    hold on
    plot(predict,'or');
    hold on 
    plot(abs(predict'-label_test),'-g');
    legend('实际类别类别','预测类别','误差曲线')
    axis([0,length(test_data),0,3])
    title(['基于贝叶斯算法对Sonar数据分类测试集平均准确率 :',num_train2str(sum(ac)/length(ac))]);
    toc
    
    
    %// GDA参数求解
    % 高斯判别分析模型的参数估计
    % x为样本特征,y为样本类别
    %初始化,代码注释见logistic和贝叶斯代码
    clc
    clear all;
    tic
    load Sonar
    data1=Sonar;
    index = find((data1(:,61)==1)|(data1(:,61)==2));
    data1 = data1(index,:);
    data1(:,61) = data1(:,61) - 1;
    %选择训练样本个数
    num_train = 156;
    num_test=52;
    ac=[]
    sc=[]
    %构造随机选择序列
    for k=1:20
    choose = randperm(size(data1,1));
    train=data1(choose(1:num_train),:);
    train_data = train(:,1:end-1)
    label_train = train(:,end);
    test = data1(choose(num_train+1:end),:);
    test_data=test(:,1:end-1);
    label_test = test(:,end);
    data_D = size(train,2) - 1;%特征数量
    x=train_data ;
    y=label_train;
    m=size(x,1);% 记录样本总数
    x_pos=[];% 样本正例,即标签为1的个体
    x_neg=[];% 样本负例,即标签为0的个体
    y_pos=[];%样本正标签
    y_neg=[];%样本负例标签
    y_pred1=zeros(num_train,1);%训练集预测结果
    y_pred=zeros(num_test,1);%测试集预测结果
    for i=1:size(x,1)
        if y(i)==1
            x_pos=[x_pos;x(i,:)];
            y_pos=[y_pos;y(i)];
        else 
            x_neg=[x_neg;x(i,:)];
            y_neg=[y_neg;y(i)];
        end
    end      
    fi=size(y_pos,1)/m;  %计算参数fi,即样本中正例所占的比例
    Py1=fi^1*(1-fi)^0;%计算个体属于正例的概率
    Py0=fi^0*(1-fi)^1%计算个体属于负例的概率
    u_pos=sum(x_pos,1)./(size(y_pos,1));% 计算参数u1
    u_neg=sum(x_neg,1)./(size(y_neg,1));% 计算参数u0
    for i=1:m
       if y(i)==1
           xx=[xx;x(i,:)-u_pos];
       else
           xx=[xx;x(i,:)-u_neg];
       end  
    end
    sigma=(xx'*xx)./m;    
    
    
    % 类别判断
    %训练集类别预测
    for i=1:size(train_data,1)
    diff1=train_data(i,:)-u_pos;
    diff2=train_data(i,:)-u_neg;
    n=size(train_data(i,:),2);
    sigma=sigma+0.001;%保证矩阵行列式非零
    x_pos=exp((diff1*inv(sigma)*diff1')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
    x_neg=exp((diff2*inv(sigma)*diff2')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
    if Py1*x_pos>x_neg*Py0
            y_pred1(i)=1;
        else
            y_pred1(i)=0;
        end
    end
    accuracy = length(find(y_pred1==label_train))/length(label_train);
    sc=[sc accuracy]
    %测试集类别预测
    for i=1:size(test_data,1)
    diff1=test_data(i,:)-u_pos;
    diff2=test_data(i,:)-u_neg;
    n=size(test_data(i,:),2);
    %sigma=sigma+0.001;%保证矩阵行列式非零
    x_pos=exp((diff1*inv(sigma)*diff1')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
    x_neg=exp((diff2*inv(sigma)*diff2')/(-2))/(((2*pi).^(n/2)).*(abs(det(sigma))).^0.5);
    if Py1*x_pos>x_neg*Py0
            y_pred(i)=1;
        else
            y_pred(i)=0;
        end
    end
    accuracy = length(find(y_pred==label_test))/length(label_test);
    ac=[ac accuracy];
    end
    %结果可视化
    figure
    plot(label_test+1,'*')
    hold on
    plot(y_pred+1,'or');
    hold on 
    plot(abs(y_pred-label_test),'-g');
    axis([0,length(label_test),0,3])
    legend('实际类别','预测类别','误差曲线')
    title(['基于高斯判别的Sonar数据测试集平均分类准确率 :',num2str(sum(ac)/length(ac))]);
    figure
    plot(label_train+1,'*')
    hold on
    plot(y_pred1+1,'or');
    hold on 
    plot(abs(y_pred1-label_train),'-g');
    axis([0,length(label_train),0,3])
    legend('实际类别','预测类别','误差曲线')
    title(['基于高斯判别的Sonar数据训练集集平均分类准确率 :',num2str(sum(sc)/length(sc))]);   
    toc%结束计时
    
    
    
    %% 清空环境变量
    clc
    clear all;
    % 训练数据预测数据提取及归一化
    tic
    load Sonar;%载入数据
    data=Sonar;
    %输入输出数据
    input=data(:,1:end-1);%特征
    output1 =data(:,end);%标签
    ac=[]%测试集准确率集合
    sc=[]%训练集准确率集合
    %把输出从1维变成2维,并且把标签变为01标签
    output=zeros(208,2);
    for i=1:208
        switch output1(i)
            case 1
                output(i,:)=[1 0];
            case 2
                output(i,:)=[0 1];
        end
    end
    
    %随机提取156个样本为训练样本,52个样本为预测样本
    %选择训练样本个数
    num_train = 156;
    num_test=52;
    %构造随机选择序列
    for k=1:20
    choose = randperm(size(data,1));
    input_train=input(choose(1:num_train),:)';%测试集数据
    output_train=output(choose(1:num_train),:)';%测试集标签
    input_test=input(choose(num_train+1:end),:)';%训练集数据
    output_test=output(choose(num_train+1:end),:)';%训练集标签
    
    %输入数据归一化
    [inputn,inputps]=mapminmax(input_train);
    
    %% 网络结构初始化
    innum=60;%输入层节点个数,即数据的特征数
    midnum=18;%隐藏层节点个数,自己设计
    outnum=2;%输出层节点个数,类别数目
    
    
    %权值初始化
    w1=rands(midnum,innum);
    b1=rands(midnum,1);
    w2=rands(midnum,outnum);
    b2=rands(outnum,1);
    
    w2_1=w2;
    w2_2=w2_1;
    w1_1=w1;
    w1_2=w1_1;
    b1_1=b1;
    b1_2=b1_1;
    b2_1=b2;
    b2_2=b2_1;
    
    %学习率
    xite=0.1;
    alfa=0.01;
    loopNumber=10;
    I=zeros(1,midnum);
    Iout=zeros(1,midnum);
    FI=zeros(1,midnum);
    dw1=zeros(innum,midnum);
    db1=zeros(1,midnum);
    
    %% 网络训练
    E=zeros(1,loopNumber);
    for ii=1:loopNumber
        E(ii)=0;
        for i=1:1:156
           %% 网络预测输出 
            x=inputn(:,i);
            % 隐含层输出
            for j=1:1:midnum
                I(j)=inputn(:,i)'*w1(j,:)'+b1(j);
                Iout(j)=1/(1+exp(-I(j)));
            end
            % 输出层输出
            yn=w2'*Iout'+b2;
    
           %% 权值阀值修正
            %计算误差
            e=output_train(:,i)-yn;     
            E(ii)=E(ii)+sum(abs(e));
    
            %计算权值变化率
            dw2=e*Iout;
            db2=e';
    
            for j=1:1:midnum
                S=1/(1+exp(-I(j)));
                FI(j)=S*(1-S);
            end      
            for k=1:1:innum
                for j=1:1:midnum
                    dw1(k,j)=FI(j)*x(k)*(e(1)*w2(j,1)+e(2)*w2(j,2));
                    db1(j)=FI(j)*(e(1)*w2(j,1)+e(2)*w2(j,2));
                end
            end
    
            w1=w1_1+xite*dw1';
            b1=b1_1+xite*db1';
            w2=w2_1+xite*dw2';
            b2=b2_1+xite*db2';
    
            w1_2=w1_1;w1_1=w1;
            w2_2=w2_1;w2_1=w2;
            b1_2=b1_1;b1_1=b1;
            b2_2=b2_1;b2_1=b2;
        end
    end
    
    
    % 语音特征信号测试集分类
    %训练集
    inputn_train=mapminmax('apply',input_train,inputps);
    fore=zeros(2,num_train);
    for ii=1:1
        for i=1:num_train
            %隐含层输出
            for j=1:1:midnum
                I(j)=inputn_train(:,i)'*w1(j,:)'+b1(j);
                Iout(j)=1/(1+exp(-I(j)));
            end
    
            fore(:,i)=w2'*Iout'+b2;
        end
    end
    
    %% 结果分析
    %根据网络输出找出数据属于哪类
    output_fore1=zeros(1,num_train);
    for i=1:num_train
        output_fore1(i)=find(fore(:,i)==max(fore(:,i)));
    end
    
    %BP网络预测误差
    outputfact1=output1(choose(1:num_train),:);
    accuracy = length(find(output_fore1'==outputfact1))/length(outputfact1);
    sc=[sc accuracy];
    %测试集
    inputn_test=mapminmax('apply',input_test,inputps);
    fore=zeros(2,num_test);
    for ii=1:1
        for i=1:num_test%1500
            %隐含层输出
            for j=1:1:midnum
                I(j)=inputn_test(:,i)'*w1(j,:)'+b1(j);
                Iout(j)=1/(1+exp(-I(j)));
            end
    
            fore(:,i)=w2'*Iout'+b2;
        end
    end
    
    %% 结果分析
    %根据网络输出找出数据属于哪类
    output_fore=zeros(1,num_test);
    for i=1:num_test
        output_fore(i)=find(fore(:,i)==max(fore(:,i)));
    end
    
    %BP网络预测误差
    outputfact=output1(choose(num_train+1:end),:);
    accuracy = length(find(output_fore'==outputfact))/length(outputfact);
    ac=[ac accuracy];
    end
    figure
    plot(outputfact1,'*')
    hold on
    plot(output_fore1,'or');
    hold on 
    plot(abs((output_fore1'-outputfact1)),'-g');
    axis([0,length(outputfact1),0,3])
    legend('实际类别','预测类别','误差曲线')
    title(['基于BP神经网络在Sonar数据训练集上分类的平均准确率为 :',num2str(sum(sc)/length(sc))]);
    
    figure
    plot(outputfact,'*')
    hold on
    plot(output_fore,'or');
    hold on 
    plot(abs((output_fore'-outputfact)),'-g');
    axis([0,length(outputfact),0,3])
    legend('实际类别','预测类别','误差曲线')
    title(['基于BP神经网络在Sonar数据测试集上分类的平均准确率为 :',num2str(sum(ac)/length(ac))]);
    toc
    
    
    展开全文
  • SVM分类Iris和Sonar数据集 本文的重点是SVM的使用,所以并未从零开始实现SVM算法,只是关注其应用,具体实现调用SKlearn库中的函数,着重分析其中参数对结果的影响。 一、问题说明 在iris数据集和sonar数据集上使用...

    SVM分类Iris和Sonar数据集

           本文的重点是SVM的使用,所以并未从零开始实现SVM算法,只是关注其应用,具体实现调用SKlearn库中的函数,着重分析其中参数对结果的影响。

    一、问题说明

           在iris数据集和sonar数据集上使用SVM算法进行分类。

    二、数据说明

           UCI数据库是加州大学欧文分校(University of CaliforniaIrvine)提出的用于机器学习的数据库,这个数据库目前共有488个数据集,其数目还在不断增加,UCI数据集是一个常用的标准测试数据集。
    每个数据文件(.data)包含以“属性-值”对形式描述的很多个体样本的记录。对应的.info文件包含的大量的文档资料。有些文件_generate_ databases;他们不包含*.data文件。作为数据集和领域知识的补充,在utilities目录里包含了一些在使用这一数据集时的有用资料。

    三、原理分析

    3.1 相关概念

           线性可分:给出训练数据集,存在向量和位移,使得其构造的超平面可以将数据集中的不同类别的样例正确的划分,则称该数据集为线性可分数据集,否则为线性不可分。
           超平面:即在n维的样本空间中找到一个划分超平面。
           函数间隔:给定一个样本,定义单个样本的函数间隔为:
    在这里插入图片描述
    在这里插入图片描述
           几何间隔:

    在这里插入图片描述

    3.2 基本思想

           Vapnik等人在多年研究统计学习理论基础上对线性分类器提出了另一种设计最佳准则。其原理也从线性可分说起,然后扩展到线性不可分的情况。甚至扩展到使用非线性函数中去,这种分类器被称为支持向量机(Support Vector Machine,简称SVM)。SVM的主要思想可以概括为两点:
           1)它是针对线性可分情况进行分析,对于线性不可分的情况,通过使用非线性映射算法将低维输入空间线性不可分的样本转化为高维特征空间使其线性可分,从而使得高维特征空间采用线性算法对样本的非线性特征进行线性分析成为可能。
           2)它基于结构风险最小化理论之上在特征空间中构建最优超平面,使得学习器得到全局最优化,并且在整个样本空间的期望以某个概率满足一定上界。
           在高维空间中的分类问题实际上是寻找一个超平面,将两类样本分开,这个超平面就叫做分类面。两类样本中离分类面最近的样本到分类面的距离称为分类间隔。最优超平面指的是分类间隔最大的超平面。支持向量机实质上提供了一种利用最优超平面进行分类的方法。由最优分类面可以确定两个与其平行的边界超平面。通过拉格朗日法求解最优分类面,最终可以得出结论:实际决定最优分类面位置的只是那些离分类面最近的样本。这些样本就被称为支持向量,它们可能只是训练样本中很少的一部分。支持向量如图所示:
    在这里插入图片描述
           图中,H是最优分类面,H1和H2别是两个边界超平面。实心样本就是支持向量。由于最优超平面完全是由这些支持向量决定的,所以这种方法被称作支持向量机(SVM)。
           以上是线性可分的情况,对于线性不可分问题,可以在错分样本上增加一个惩罚因子来干预最优分类面的确定。这样一来,最优分类面不仅由离分类面最近的样本决定,还要由错分的样本决定。这种情况下的支持向量就由两部分组成:一部分是边界支持向量;另一部分是错分支持向量。
           对于非线性的分类问题,可以通过特征变换将非线性问题转化为新空间中的线性问题。但是这样做的代价是会造成样本维数增加,进而导致计算量急剧增加,这就是所谓的“维度灾难”。为了避免高维空间中的计算,可以引入核函数的概念。这样一来,无论变换后空间的维数有多高,这个新空间中的线性支持向量机求解都可以在原空间通过核函数来进行。常用的核函数有多项式核、高斯核(径向基核)、Sigmoid函数。

    3.3 核函数

           核函数是一种映射,核技巧并不显式的定义映射函数,通过在学习和预测中定义核函数,特征空间的维度往往很高,甚至是无穷维的,并且对于给定的核函数,特征空间与映射函数的取法不唯一。
    在这里插入图片描述
           核函数的有效性:K一定是一个对称矩阵。
           以下为部分常用的核函数:
    在这里插入图片描述

    四、结果求解

    4.1 sonar数据集

           针对sonar数据集,采用高斯核函数,并随便其惩罚函数的值,得到其准确率随着惩罚函数的变化的曲线图,如下图所示:

    在这里插入图片描述

    4.2 Iris数据集

           针对iris数据集,分别采用高斯核函数,线性核函数和多项式核函数来观察其在不同的核函数的情况下的分类情况:
                                                                        高斯核函数
    在这里插入图片描述
                                                                        线性核函数
    在这里插入图片描述
                                                                        多项式核函数
    在这里插入图片描述

    五、结果分析

           根据求解结果可知,同样的数据集在使用不同的惩罚函数和不同的核函数时都会使得其分类准确率发生改变,因此针对不同的情况,应该选择合适的参数可以达到更高的分类准确率。

    文章的pdf文件:link

    六、附录

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import svm
    import pandas as pd
    sonar=pd.read_csv("D:\\Sonar.csv",header=None)
    sonar_data=sonar.values[0:208,0:61]
    # 训练集
    # 第一类取0:60为训练集 ,第二类取97:180为训练集
    sonar_train_data=sonar_data[range(0,61),0:61]
    sonar_train_data=np.vstack((sonar_train_data,sonar_data[range(97,180),0:61]))
    sonar_train_data=np.array(sonar_train_data)
    sonar_train_label=sonar_train_data[:,0]
    sonar_train_data=sonar_train_data[:,1:61]
    print(sonar_train_data)
    print(sonar_train_label)
    
    # 测试集
    # 第一类取61:97为测试集 ,第二类取180:208为测试集
    sonar_test_data=sonar_data[range(61,97),0:61]
    sonar_test_data=np.vstack((sonar_test_data,sonar_data[range(180,208),0:61]))
    sonar_test_data=np.array(sonar_test_data)
    sonar_test_label=sonar_test_data[:,0]
    sonar_test_data=sonar_test_data[:,1:61]
    print(sonar_test_data)
    print(sonar_test_label)
    b = []
    a = []
    for num in range(1,11):
        clf = svm.SVC(C=num/10, kernel='rbf', decision_function_shape='ovr')
        rf = clf.fit(sonar_train_data, sonar_train_label)
        #C:惩罚函数,默认是1(相当于惩罚松弛变量)
        #kernel:核函数,默认是rbf高斯核,可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
        #ovr:一对多
        c = clf.score(sonar_train_data,sonar_train_label)
        print("训练次数:", num, "交叉验证验证准确率:", c)
        a.append(c)   #交叉验证准确率
        c = clf.score(sonar_test_data,sonar_test_label)
        print("训练次数:", num, "测试集准确率:", c)
    b.append(c)  #测试集准确率
    plt.figure(1)
    plt.plot(range(1,11),a)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    
    iris = pd.read_csv("D:\\iris.csv", header=0)
    # 数据集分类,分训练集和测试集
    iris_data=iris.values[0:150,0:6]
    iris_data=np.array(iris_data[0:150,0:6])
    # 训练集
    iris_train_data=iris_data[range(0,30),0:6]
    iris_train_data=np.vstack((iris_train_data,iris_data[range(50,80),0:6]))
    iris_train_data=np.vstack((iris_train_data,iris_data[range(100,130),0:6]))
    iris_train_data=np.array(iris_train_data)
    iris_train_label=iris_train_data[:,5]
    iris_train_data=iris_train_data[:,0:4]
    iris_train_data=iris_train_data.astype('float64')
    iris_train_label=iris_train_label.astype('float64')
    print(iris_train_data.shape)
    print(iris_train_label.shape)
    
    # 测试集
    iris_test_data=iris_data[range(30,50),0:6]
    iris_test_data=np.vstack((iris_test_data,iris_data[range(80,100),0:6]))
    iris_test_data=np.vstack((iris_test_data,iris_data[range(130,149),0:6]))
    iris_test_data=np.array(iris_test_data)
    iris_test_label=iris_test_data[:,5]
    iris_test_data=iris_test_data[:,0:4]
    iris_test_data=iris_test_data.astype('float64')
    iris_test_label=iris_test_label.astype('float64')
    print(iris_test_data.shape)
    print(iris_test_label.shape)
    b = []
    a = []
    for num in range(1,11):
        clf = svm.SVC(C=num/10, kernel='rbf', decision_function_shape='ovr')
        rf = clf.fit(iris_train_data, iris_train_label)
        #C:惩罚函数,默认是1(相当于惩罚松弛变量)
        #kernel:核函数,默认是rbf高斯核,可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
        #ovr:一对多
        c = clf.score(iris_train_data,iris_train_label)
        print("训练次数:", num, "交叉验证验证准确率:", c)
        a.append(c)   #交叉验证准确率
        c = clf.score(iris_test_data,iris_test_label)
        print("训练次数:", num, "测试集准确率:", c)
    b.append(c)  #测试集准确率
    plt.figure(4)
    plt.subplot(1,2,1)
    plt.plot(range(1,11),a)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    plt.subplot(1,2,2)
    plt.plot(range(1,11),b)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    
    b = []
    a = []
    for num in range(1,11):
        clf = svm.SVC(C=num/10, kernel='linear', decision_function_shape='ovr')
        rf = clf.fit(iris_train_data, iris_train_label)
        #C:惩罚函数,默认是1(相当于惩罚松弛变量)
        #kernel:核函数,默认是rbf高斯核,可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
        #ovr:一对多
        c = clf.score(iris_train_data,iris_train_label)
        print("训练次数:", num, "交叉验证验证准确率:", c)
        a.append(c)   #交叉验证准确率
        c = clf.score(iris_test_data,iris_test_label)
        print("训练次数:", num, "测试集准确率:", c)
    b.append(c)  #测试集准确率
    plt.figure(4)
    plt.subplot(1,2,1)
    plt.plot(range(1,11),a)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    plt.subplot(1,2,2)
    plt.plot(range(1,11),b)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    
    b = []
    a = []
    for num in range(1,11):
        clf = svm.SVC(C=num/10, kernel='poly', decision_function_shape='ovr')
        rf = clf.fit(iris_train_data, iris_train_label)
        #C:惩罚函数,默认是1(相当于惩罚松弛变量)
        #kernel:核函数,默认是rbf高斯核,可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
        #ovr:一对多
        c = clf.score(iris_train_data,iris_train_label)
        print("训练次数:", num, "交叉验证验证准确率:", c)
        a.append(c)   #交叉验证准确率
        c = clf.score(iris_test_data,iris_test_label)
        print("训练次数:", num, "测试集准确率:", c)
    b.append(c)  #测试集准确率
    plt.figure(5)
    plt.subplot(1,2,1)
    plt.plot(range(1,11),a)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    plt.subplot(1,2,2)
    plt.plot(range(1,11),b)
    plt.grid()
    plt.xlabel('C/10')
    plt.ylabel('acc')
    
    展开全文
  • 聚类数据集,mat格式,matlab直接可用
  • 文章目录kmeans,FCM聚类iris和sonar数据集,以及图像分割(更新中)kmeans问题概述kmeans运行效果代码部分结构总览函数1载入数据load_iris(),load_sonar()函数2初始化样本中心点init_kmeans(bool is_iris)函数3 ...

    kmeans,FCM聚类iris和sonar数据集,以及图像分割


    kmeans

    问题概述

    kmeans

    kmeans非常好理解了,本质上其实只有三步(做可视化时候可能需要归一化我们先不说)

    拿iris举例,天气太冷了,120 ( 样 本 个 数 ) _ {(样本个数)} 个小伙伴在操场上站着直哆嗦,这时,学校搬来3 ( 类 别 个 数 ) _(类别个数) ()个大火炉,我们的目的就是在同学都不动的情况下把火炉放到合适的位置,从而使得所有同学都能尽可能感受到火炉的温暖
    首先,学校把火炉随机放在某个地方(当然这个地点坐标可能是二维的也可能是高维,和元素维度保持一致),即中心点初始化。
    第二步,开始循环,让每个同学面向离它们最近的火炉(归类)
    第三步,面向同一个火炉的同学们求出大家坐标的中心,把火炉搬到中间(更新样本中心点)
    然后跳到第二步循环直到中心点啊,轮廓系数什么的收敛,或者循环次数达到某个阈值结束训练

    运行效果

    初始化(白色为火炉)(样本点初始化为深蓝色,颜色偏暗,可能不太容易看清楚)
    在这里插入图片描述迭代一次
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    代码部分

    结构总览

    整形m用于限制算法迭代次数
    bool is_iris用于切换iris和sonar数据集

    int main()
    {
        int m=500;
        bool is_iris=0;
        kmeans k;
        k.load_iris();
        k.load_sonar();
        k.init_kmeans(is_iris);
        while(m--)
        {
            k.sort(is_iris);
            k.reload_z(is_iris);
            cout<<k.load_sc(is_iris)<<endl;
            if(is_iris)
                k.fenxi(2,1);
            if(is_iris)    
                cv::waitKey(0);
    
        }
        return 0;
    }
    
    函数1载入数据load_iris(),load_sonar()

    将iris和sonar数据的信息分别载入到二维数组data_iris和data_sonar中
    其中每一数据的最后一维用于保存聚类后的分类信息,倒数第二维用于保存数据集原来的分类信息(用于可视化处理时作为对照)

    void kmeans::load_iris()
    {
        int i,m=27;
        char ch,ch_1[35];
        int high,low;
        int d[2];
        FILE *f;
        if ((f = fopen("/home/jojo/jason_cpp/iris.data", "rb+")) == NULL)
    	{
    		perror("fail to read");
    	}
         if(f != NULL)
        {
            ch = 'a';
            while(ch != EOF)
            {
                putchar(ch);
                ch = fgetc(f);
                if(ch!='\n')ch_1[tag_a++]=ch;
                else
                {
                    data_iris[tag_b++][0]=(ch_1[0]-'0')+(ch_1[2]-'0')*0.1;
    
                    data_iris[tag_b-1][1]=(ch_1[4]-'0')+(ch_1[6]-'0')*0.1;
    
                    data_iris[tag_b-1][2]=(ch_1[8]-'0')+(ch_1[10]-'0')*0.1;
    
                    data_iris[tag_b-1][3]=(ch_1[12]-'0')+(ch_1[14]-'0')*0.1;
                    //类别看taga(每行长度)大小
                    if(tag_a==27)data_iris[tag_b-1][4]=0;
                    else if(tag_a==31)data_iris[tag_b-1][4]=1;
                    else data_iris[tag_b-1][4]=2;
                    tag_a=0;
                }
            }
        }
        else
            printf("fail to open! \n");
        fclose(f);
        for(tag_b=0;tag_b<4;tag_b++)
        {
            yu_iris[tag_b][0]=500;
            yu_iris[tag_b][1]=-500;
        }    
        for(tag_a=0;tag_a<150;tag_a++)
        for(tag_b=0;tag_b<4;tag_b++)
        {
            if(yu_iris[tag_b][0]>data_iris[tag_a][tag_b])yu_iris[tag_b][0]=data_iris[tag_a][tag_b];
            if(yu_iris[tag_b][1]<data_iris[tag_a][tag_b])yu_iris[tag_b][1]=data_iris[tag_a][tag_b];
        }
    }
    void kmeans::load_sonar()
    {
        int i,m=27;
        char ch,ch_1[500];
        int high,low;
        int d[2];
        FILE *f;
        	if ((f = fopen("/home/jojo/jason_cpp/sonar.txt", "rb+")) == NULL)
    	{
    		perror("fail to read");
    	}
        char data_b[7];
         if(f != NULL)
        {
        for(tag_c=0;tag_c<208;tag_c++)
        {
            for(tag_b=0;tag_b<60;tag_b++)
            {
                    data_sonar[tag_c][tag_b]=0;
                    for(tag_a=0;tag_a<7;tag_a++)
                    {
                        if(ch!=EOF)
                        {
                        putchar(ch);
                        ch = fgetc(f);
                        if(ch=='\n')ch = fgetc(f);
                        data_b[tag_a]=ch;
                        }
                    }
                    data_sonar[tag_c][tag_b]+=(data_b[0]-'0')*1;
                    data_sonar[tag_c][tag_b]+=(data_b[2]-'0')*0.1;
                    data_sonar[tag_c][tag_b]+=(data_b[3]-'0')*0.01;
                    data_sonar[tag_c][tag_b]+=(data_b[4]-'0')*0.001;
                    data_sonar[tag_c][tag_b]+=(data_b[5]-'0')*0.0001;
            }
                            putchar(ch);
                        ch = fgetc(f);
            if(ch=='R')data_sonar[tag_c][60]=0;
            else data_sonar[tag_c][60]=1;
            putchar(ch);
                        ch = fgetc(f);
        }
        }
        else
            printf("fail to open! \n");
        fclose(f);
        for(tag_b=0;tag_b<60;tag_b++)
        {
            yu_sonar[tag_b][0]=500;
            yu_sonar[tag_b][1]=-500;
        }    
        for(tag_a=0;tag_a<118;tag_a++)
        for(tag_b=0;tag_b<60;tag_b++)
        {
            if(yu_sonar[tag_b][0]>data_sonar[tag_a][tag_b])yu_sonar[tag_b][0]=data_sonar[tag_a][tag_b];
            if(yu_sonar[tag_b][1]<data_sonar[tag_a][tag_b])yu_sonar[tag_b][1]=data_sonar[tag_a][tag_b];
        }
    }
    
    函数2初始化样本中心点init_kmeans(bool is_iris)

    iris数据在载入数据过程中计算了样本范围,这里将样本中心点初始化为在样本范围内的随机数,sonar直接取值0.001和0.5

    void kmeans::init_kmeans(bool is_iris)
    {
        if(is_iris)
        {
            point_iris[0][0]=(yu_iris[0][1]-yu_iris[0][0])*((rand()%100)/200+0.5)+yu_iris[0][0];
            point_iris[0][1]=(yu_iris[1][1]-yu_iris[1][0])*((rand()%100)/200+0.5)+yu_iris[1][0];
            point_iris[0][2]=(yu_iris[2][1]-yu_iris[2][0])*((rand()%100)/200+0.5)+yu_iris[2][0];
            point_iris[0][3]=(yu_iris[3][1]-yu_iris[3][0])*((rand()%100)/200+0.5)+yu_iris[3][0];
    
            point_iris[1][0]=(yu_iris[0][1]-yu_iris[0][0])*((rand()%100)/200+0.5)+yu_iris[0][0];
            point_iris[1][1]=(yu_iris[1][1]-yu_iris[1][0])*((rand()%100)/200+0.5)+yu_iris[1][0];
            point_iris[1][2]=(yu_iris[2][1]-yu_iris[2][0])*((rand()%100)/200+0.5)+yu_iris[2][0];
            point_iris[1][3]=(yu_iris[3][1]-yu_iris[3][0])*((rand()%100)/200+0.5)+yu_iris[3][0];
    
            point_iris[2][0]=(yu_iris[0][1]-yu_iris[0][0])*((rand()%100)/200+0.5)+yu_iris[0][0];
            point_iris[2][1]=(yu_iris[1][1]-yu_iris[1][0])*((rand()%100)/200+0.5)+yu_iris[1][0];
            point_iris[2][2]=(yu_iris[2][1]-yu_iris[2][0])*((rand()%100)/200+0.5)+yu_iris[2][0];
            point_iris[2][3]=(yu_iris[3][1]-yu_iris[3][0])*((rand()%100)/200+0.5)+yu_iris[3][0];   
        }
        else
        {
            for(tag_a=0;tag_a<60;tag_a++)
            {
                point_sonar[0][tag_a]=0.001;
                point_sonar[1][tag_a]=0.5;
            }
        }
        
    }
    
    函数3 分类函数sort(bool is_iris)

    计算数据和各类中心点point_iris或point_sonars的距离,进而将数据进行归类(iris给数据第6维赋值,sonar给数据第62维赋值)
    其中dis(double a[],double b[],int add_a,int add_b,int deep_a,int num)
    函数用于计算a数组的第add_a行和b数组的第add_b行的前num列元素的二范数,deep_a是a数组每行拥有的列数

    void kmeans::sort(bool is_iris)
    {
        if(is_iris)
        {
            double(*p)[6]=data_iris;
            double(*p_1)[4]=point_iris;
            for(tag_a=0;tag_a<150;tag_a++)
            {
                if(dis(*p,*p_1,tag_a,0,6,4)<=dis(*p,*p_1,tag_a,1,6,4)&&dis(*p,*p_1,tag_a,0,6,4)<=dis(*p,*p_1,tag_a,2,6,4))
                data_iris[tag_a][5]=0;
                else if(dis(*p,*p_1,tag_a,1,6,4)<=dis(*p,*p_1,tag_a,0,6,4)&&dis(*p,*p_1,tag_a,1,6,4)<=dis(*p,*p_1,tag_a,2,6,4))
                data_iris[tag_a][5]=1;
                else data_iris[tag_a][5]=2;
            }
        }
        else
        {
            double(*p)[62]=data_sonar;
            double(*p_1)[60]=point_sonar;
            for(tag_a=0;tag_a<208;tag_a++)
            {
                //double a=dis(*p,*p_1,tag_a,0,62,60);
                //double b=dis(*p,*p_1,tag_a,1,62,60);
                if(dis(*p,*p_1,tag_a,0,62,60)>=dis(*p,*p_1,tag_a,1,62,60))
                data_sonar[tag_a][61]=0;
                else data_sonar[tag_a][61]=1;
            }
    
        }
        
    }
    
    函数4 更新样本中心点 reload_z(bool is_iris)

    kmeans方法采用求各类均值的方式进行中心点的更新中心分别存放在数组point_iris和point_sonar中

    void kmeans::reload_z(bool is_iris)
    {
        if(is_iris)
        {
            //各类总数
            int number[3]={0,0,0};
            double cent[3][4]={0,0,0,0,0,0,0,0,0,0,0,0};
            for(tag_a=0;tag_a<120;tag_a++)
            {
                for(tag_b=0;tag_b<4;tag_b++)
                cent[int(data_iris[tag_a][5])][tag_b]+=data_iris[tag_a][tag_b];
                number[int(data_iris[tag_a][5])]++;   
            }
            for(tag_a=0;tag_a<3;tag_a++)
            for(tag_b=0;tag_b<4;tag_b++)
                if(number[tag_a]!=0)
                point_iris[tag_a][tag_b]=cent[tag_a][tag_b]/number[tag_a];
            
            
        }
        else
        {
                    int number[2]={0,0};
            double cent[2][60];
            for(tag_a=0;tag_a<60;tag_a++)
            for(tag_b=0;tag_b<2;tag_b++)
            cent[tag_b][tag_a]=0;
            for(tag_a=0;tag_a<208;tag_a++)
            {
                for(tag_b=0;tag_b<60;tag_b++)
                cent[int(data_sonar[tag_a][61])][tag_b]+=data_sonar[tag_a][tag_b];
                number[int(data_sonar[tag_a][61])]++;   
            }
            for(tag_a=0;tag_a<2;tag_a++)
            for(tag_b=0;tag_b<60;tag_b++)
            point_sonar[tag_a][tag_b]=cent[tag_a][tag_b]/number[tag_a];
        }
        
    }
    
    函数5 计算轮廓系数

    轮廓系数公式:
    S ( i ) = b ( i ) − a ( i ) m a x ( b ( i ) , a ( i ) ) S_{(i)}=\frac{b_{(i)}-a_{(i)}}{max(b_{(i)},a_{(i)})} S(i)=max(b(i),a(i))b(i)a(i)
    其中
    a ( i ) a_{(i)} a(i) = average(i向量到所有它属于的簇中其它点的距离)
    b ( i ) b_{(i)} b(i) = min (i向量到与它相邻最近的一簇内的所有点的平均距离)

    double kmeans::load_sc(bool is_iris)
    {
        if(is_iris)
        {
            int b_num=0,a_num=0;
            double data[120][3],dataa;
            for(tag_a=0;tag_a<120;tag_a++)
            for(tag_b=0;tag_b<3;tag_b++)
            data[tag_a][tag_b]=0;
    
            for(tag_a=0;tag_a<120;tag_a++)
            for(tag_b=0;tag_b<120;tag_b++)
            {
                if(tag_b==0)b_num=0;
                if(tag_b==0)a_num=0;
                if(data_iris[tag_a][5]==data_iris[tag_b][5])
                {
                    a_num++;
                    dataa=0;
                    for(tag_c=0;tag_c<3;tag_c++)
                    dataa+=pow((data_iris[tag_a][tag_c]-data_iris[tag_b][tag_c]),2);
                    data[tag_a][0]+=pow(dataa,0.5);
                }
                else
                {
                    b_num++;
                    dataa=0;
                    for(tag_c=0;tag_c<3;tag_c++)
                    dataa+=pow((data_iris[tag_a][tag_c]-data_iris[tag_b][tag_c]),2);
                    data[tag_a][1]+=pow(dataa,0.5);
                }
                if(tag_b==119)
                {
                    data[tag_a][0]/=a_num;
                    data[tag_a][1]/=b_num;            
                }
            }
            for(tag_a=0;tag_a<120;tag_a++)
            {
                if(data[tag_a][1]>data[tag_a][0])
                data[tag_a][2]=(data[tag_a][1]-data[tag_a][0])/data[tag_a][1];
                else
                data[tag_a][2]=(data[tag_a][1]-data[tag_a][0])/data[tag_a][0];
            }
                dataa=0;
                for(tag_a=0;tag_a<120;tag_a++)
                dataa+=data[tag_a][2];
                return dataa/120;
        }
        else
        {
            int b_num=0,a_num=0;
            double data[208][3],dataa;
            for(tag_a=0;tag_a<208;tag_a++)
            for(tag_b=0;tag_b<3;tag_b++)
            data[tag_a][tag_b]=0;
    
            for(tag_a=0;tag_a<208;tag_a++)
            for(tag_b=0;tag_b<208;tag_b++)
            {
                if(tag_b==0)b_num=0;
                if(tag_b==0)a_num=0;
                if(data_sonar[tag_a][61]==data_sonar[tag_b][61])
                {
                    a_num++;
                    dataa=0;
                    for(tag_c=0;tag_c<60;tag_c++)
                    dataa+=pow((data_sonar[tag_a][tag_c]-data_sonar[tag_b][tag_c]),2);
                    data[tag_a][0]+=pow(dataa,0.5);
                }
                else
                {
                    b_num++;
                    dataa=0;
                    for(tag_c=0;tag_c<60;tag_c++)
                    dataa+=pow((data_sonar[tag_a][tag_c]-data_sonar[tag_b][tag_c]),2);
                    data[tag_a][1]+=pow(dataa,0.5);
                }
                if(tag_b==207)
                {
                    if(a_num!=0)
                    data[tag_a][0]/=a_num;
                    if(b_num!=0)
                    data[tag_a][1]/=b_num;            
                }
                
                
            }
    
            for(tag_a=0;tag_a<208;tag_a++)
            {
                if(data[tag_a][1]>data[tag_a][0])
                data[tag_a][2]=(data[tag_a][1]-data[tag_a][0])/data[tag_a][1];
                else
                data[tag_a][2]=(data[tag_a][1]-data[tag_a][0])/data[tag_a][0];
            }
                dataa=0;
                for(tag_a=0;tag_a<208;tag_a++)
                dataa+=data[tag_a][2];
    
                return dataa/208;
        }
           
    }
    
    dis函数
    double kmeans::dis(double a[],double b[],int add_a,int add_b,int deep_a,int num)
    {
        double num_all=0;
        for(int tag_a=0;tag_a<num;tag_a++)
        {
            num_all+=(a[add_a*deep_a+tag_a]-b[add_b*num+tag_a])*(a[add_a*deep_a+tag_a]-b[add_b*num+tag_a]);
        }
        return pow(num_all,0.5);
    }
    

    FCM

    问题概况

    问题同kmeans,步骤如下:
    step1: 对隶属度矩阵U使用(0,1)之间的随机数进行初始化,使其满足约束:

    KaTeX parse error: Can't use function '$' in math mode at position 25: …1}^c{u_{ij}}=1,$̲ $\forall$i=1,.…

    step2: 计算c个聚类中心,j=1,…,c
    z j = ∑ i = 1 m u i j α x i ∑ i = 1 m u i j α z_j=\frac{\sum^m_{i=1}u_{ij}^\alpha x_i}{\sum_{i=1}^mu_{ij}^\alpha} zj=i=1muijαi=1muijαxi

    step3: 计算代价函数。如果他小于某个阈值,或者它与上一次迭代的代价函数值的变化小于某个阈值,则算法停止。
    J ( U , z 1 , . . . , z c ) = ∑ j = 1 c J j = ∑ j = 1 c ∑ i = 1 m u i j α d i j 2 J(U,z_1,...,z_c)=\sum^c_{j=1}J_j=\sum^c_{j=1}\sum^m_{i=1}u^\alpha_{ij}d^2_{ij} J(U,z1,...,zc)=j=1cJj=j=1ci=1muijαdij2
    step4: 计算新的U矩阵。返回step2
    u i j = 1 ∑ k = 1 c ( d i j / d i k ) 2 / ( α − 1 ) u_{ij}=\frac{1}{\sum^c_{k=1}(d_{ij}/d_{ik})^{2/(\alpha-1)}} uij=k=1c(dij/dik)2/(α1)1

    代码

    结构总览
    int main()
    {
        FCM f;
        int m=30;//用于计数
        bool is_iris=0;//切换数据集
        f.load_iris();//载入数据
        f.load_sonar();//载入数据
        f.init_u(is_iris);//初始化u矩阵
        while(m--)
        {
            f.reload_z(is_iris);//更新z矩阵
            f.reload_u(is_iris);//更新u矩阵
            f.sort(is_iris);//归类
            if(is_iris)
            f.fenxi(1,2);//可视化iris数据
            cout<<"cs:"<<f.load_sc(is_iris)<<endl;//输出轮廓系数
            if(is_iris)
            waitKey(0);
        }
        return 0;
    }
    
    函数6 FCM更新中心点 f.reload_z(is_iris);

    根据FCM公式更新样本中心点(step2)

    sum[3]用来存放分母 ∑ i = 1 m u i j α ( j = 1 , . . . , c ) \sum^m_{i=1}u_{ij}^\alpha(j=1,...,c) i=1muijα(j=1,...,c)

    point_iris用来存放聚类中心

    z j = ∑ i = 1 m u i j α x i ∑ i = 1 m u i j α z_j=\frac{\sum^m_{i=1}u_{ij}^\alpha x_i}{\sum_{i=1}^mu_{ij}^\alpha} zj=i=1muijαi=1muijαxi

    void FCM::reload_z(bool is_iris)
    {
        if(is_iris)
        {
            for(tag_b=0;tag_b<4;tag_b++)
            for(tag_c=0;tag_c<3;tag_c++)
            point_iris[tag_b][tag_c]=0;
            double sum[3];
            for(tag_a=0;tag_a<3;tag_a++)
            sum[tag_a]=0;
            for(tag_a=0;tag_a<120;tag_a++)
            for(tag_b=0;tag_b<3;tag_b++)
            sum[tag_b]+=pow(u_iris[tag_a][tag_b],alpha);
            for(tag_a=0;tag_a<120;tag_a++)
            for(tag_b=0;tag_b<4;tag_b++)
            for(tag_c=0;tag_c<3;tag_c++)
            point_iris[tag_c][tag_b]+=pow(u_iris[tag_a][tag_c],alpha)*data_iris[tag_a][tag_b];
            for(tag_c=0;tag_c<3;tag_c++)
            for(tag_b=0;tag_b<4;tag_b++)
            point_iris[tag_c][tag_b]/=sum[tag_c];
        }
        else
        {
            for(tag_b=0;tag_b<2;tag_b++)
            for(tag_c=0;tag_c<60;tag_c++)
            point_sonar[tag_b][tag_c]=0;
            double sum[2];
            for(tag_a=0;tag_a<2;tag_a++)
            sum[tag_a]=0;
            for(tag_a=0;tag_a<208;tag_a++)
            for(tag_b=0;tag_b<2;tag_b++)
            sum[tag_b]+=pow(u_sonar[tag_a][tag_b],alpha);
            for(tag_a=0;tag_a<208;tag_a++)
            for(tag_b=0;tag_b<60;tag_b++)
            for(tag_c=0;tag_c<2;tag_c++)
            point_sonar[tag_c][tag_b]+=pow(u_sonar[tag_a][tag_c],alpha)*data_sonar[tag_a][tag_b];
            for(tag_c=0;tag_c<2;tag_c++)
            for(tag_b=0;tag_b<60;tag_b++)
            point_sonar[tag_c][tag_b]/=sum[tag_c];
        }
    }
    
    函数7 更新隶属度矩阵u函数 reload_u(bool is_iris)step4

    u i j = 1 ∑ k = 1 c ( d i j / d i k ) 2 / ( α − 1 ) u_{ij}=\frac{1}{\sum^c_{k=1}(d_{ij}/d_{ik})^{2/(\alpha-1)}} uij=k=1c(dij/dik)2/(α1)1

    这里的d_iris(int a,int b),d_sonar函数用来求数据集中第a组数据和第b组数据的欧式距离

    void FCM::reload_u(bool is_iris)
    {
    
        if(is_iris)
        {
            for(tag_a=0;tag_a<120;tag_a++)
            for(tag_b=0;tag_b<3;tag_b++)
            {
                        for(tag_c=0;tag_c<3;tag_c++)
                        {
                            u_iris[tag_a][tag_b]+=pow(d_iris(tag_a,tag_b)/d_iris(tag_a,tag_c),2/(alpha-1));
                        }
                        u_iris[tag_a][tag_b]=1/u_iris[tag_a][tag_b];
            }
    
        }
        else
        {
            for(tag_a=0;tag_a<208;tag_a++)
            for(tag_b=0;tag_b<2;tag_b++)
            {
                        for(tag_c=0;tag_c<2;tag_c++)
                        {
                            u_sonar[tag_a][tag_b]+=pow(d_sonar(tag_a,tag_b)/d_sonar(tag_a,tag_c),2/(alpha-1));
                        }
                        u_sonar[tag_a][tag_b]=1/u_sonar[tag_a][tag_b];
            }
        }
    }
    
    函数8 根据隶属度的归类函数 sort(bool is_iris)
    void FCM::sort(bool is_iris)
    {
        double(*p)[3]=u_iris;
        double(*p1)[2]=u_sonar;
        
        if(is_iris)
        {
            for(tag_a=0;tag_a<120;tag_a++)
            data_iris[tag_a][5]=max(*p,tag_a,3);
        }
        else
        {
            for(tag_a=0;tag_a<208;tag_a++)
            data_sonar[tag_a][61]=max(*p1,tag_a,2);
        }
        
    }
    
    d_iris和d_sonar函数
    double FCM::d_iris(int a,int b)
    {
        double fin=0;
        for(int tag=0;tag<4;tag++)
        fin+=(data_iris[a][tag]-point_iris[b][tag])*(data_iris[a][tag]-point_iris[b][tag]);
        return sqrt(fin);
    }
    double FCM::d_sonar(int a,int b)
    {
        double fin=0;
        for(int tag=0;tag<60;tag++)
        fin+=(data_sonar[a][tag]-point_sonar[b][tag])*(data_sonar[a][tag]-point_sonar[b][tag]);
        return sqrt(fin);
    }
    
    iris图片显示函数
    void kmeans::fenxi(int a,int b)
    {
        cv::Mat fra=cv::Mat(cv::Size(800,800), CV_8UC3);
        cv::Mat fra_new=cv::Mat(cv::Size(800,800), CV_8UC3);
            for(tag_a=0;tag_a<800;tag_a++)
                for(tag_b=0;tag_b<800;tag_b++)
                {
                    fra.at<cv::Vec3b>(tag_a,tag_b)[0]=0;
                    fra.at<cv::Vec3b>(tag_a,tag_b)[1]=0;
                    fra.at<cv::Vec3b>(tag_a,tag_b)[2]=0;
                    fra_new.at<cv::Vec3b>(tag_a,tag_b)[0]=0;
                    fra_new.at<cv::Vec3b>(tag_a,tag_b)[1]=0;
                    fra_new.at<cv::Vec3b>(tag_a,tag_b)[2]=0;
                    
                }
                
        for(tag_a=0;tag_a<120;tag_a++)
        {
            fra.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100-1)[data_iris[tag_a][4]]=255;
            fra.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100+1)[data_iris[tag_a][4]]=255;
            fra.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100)[data_iris[tag_a][4]]=255;
            fra.at<cv::Vec3b>(data_iris[tag_a][a]*100-1,data_iris[tag_a][b]*100)[data_iris[tag_a][4]]=255;
            fra.at<cv::Vec3b>(data_iris[tag_a][a]*100+1,data_iris[tag_a][b]*100)[data_iris[tag_a][4]]=255;
            fra_new.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100-1)[data_iris[tag_a][5]]=255;
            fra_new.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100+1)[data_iris[tag_a][5]]=255;
            fra_new.at<cv::Vec3b>(data_iris[tag_a][a]*100,data_iris[tag_a][b]*100)[data_iris[tag_a][5]]=255;
            fra_new.at<cv::Vec3b>(data_iris[tag_a][a]*100-1,data_iris[tag_a][b]*100)[data_iris[tag_a][5]]=255;
            fra_new.at<cv::Vec3b>(data_iris[tag_a][a]*100+1,data_iris[tag_a][b]*100)[data_iris[tag_a][5]]=255;
        
        }
        for(tag_a=0;tag_a<3;tag_a++)
        for(tag_c=0;tag_c<3;tag_c++)
        for(tag_b=-2;tag_b<3;tag_b++)
        for(int tag=-2;tag<3;tag++)
        fra_new.at<cv::Vec3b>(point_iris[tag_a][a]*100+tag,point_iris[tag_a][b]*100+tag_b)[tag_c]=255;
        
        char m[1];
        m[0]=a+'0';
        cv::imshow(m,fra);
            m[0]=a+'3';
        cv::imshow(m,fra_new);
    }
    

    ps kmeans类,FCM类

    class kmeans
    {
    private:
    //计数用
    int tag_a,tag_b,tag_c;
    //数据阈值(初始化中心时用到)
    double yu_iris[4][2],yu_sonar[60][2];
    //载入数据
    double data_iris[120][6],data_sonar[208][62];
    //数据中心z
    //double point_iris[3][4],point_sonar[2][60];
    public:
    double dis(double a[],double b[],int add_a,int add_b,int deep_a,int num);
    public:
    double point_iris[3][4],point_sonar[2][60];
    //载入数据
    void load_iris();
    void load_sonar();
    void init_kmeans(bool is_iris);
    void sort(bool is_iris);
    void reload_z(bool is_iris);
    void show();
    void fenxi(int a,int b);
    double load_sc(bool is_iris);
    };
    
    

    FCM

    class FCM
    {
    private:
    //计数用0
    int tag_a,tag_b,tag_c;
    double alpha=2;
    //数据阈值(初始化中心时用到)
    double yu_iris[4][2],yu_sonar[60][2];
    //载入数据
    double data_iris[120][6],data_sonar[208][62];
    double u_iris[120][3]={
        0.2,0.4,0.4,0.2,
        0.4,0.2,0.4,0.2,
        0.4,0.4,0.2,0.6,
    };
    double u_sonar[208][2];
    //数据中心z
    //double point_iris[3][4],point_sonar[2][60];
    public:
    double d_iris(int a,int b);
    double dis(double a[],double b[],int add_a,int add_b,int deep_a,int num);
    public:
    double point_iris[3][4],point_sonar[2][60];
    //载入数据
    void load_iris();
    void load_sonar();
    void init_u(bool is_iris);
    void sort(bool is_iris);
    void reload_z(bool is_iris);
    void reload_u(bool is_iris);
    int max(double a[],int num,int wide);
    void show();
    void fenxi(int a,int b);
    double load_sc(bool is_iris);
    double d_sonar(int a,int b);
    };
    

    FCM进行图片特征提取

    代码只需将图片信息载入到data[m][4]即可(m是图片像素数,第四维存放分类信息):

    void FCM::load_pic()
    {
    Mat a=imread("2.bmp",1);
    imshow("src",a);
    int tag=0;
    for(tag_a=0;tag_a<a.cols;tag_a++)
    for(tag_b=0;tag_b<a.rows;tag_b++)
    {
        for(tag_c=0;tag_c<3;tag_c++)
        {
            data[tag][tag_c]=a.at<Vec3b>(tag_b,tag_a)[tag_c];
        }
        tag++;
    }
    }
    
    
    

    后面的同上

    效果:

    在这里插入图片描述

    结语

    作者水平有限,若发现问题还望慷慨指正

    展开全文
  • Passivehunter使用枚举子域,该项目使用Rapid7 数据集。 dns.bufferover.run使用DNSGrep快速搜索大型数据集,Passivehunter使用查询https://dns.bufferover.run/dns?q=<hostname>枚举子域。 它使用一些正则表达式...
  • num[1]=(self.all_label.count(2)) num[2]=(self.all_label.count(3)) self.label=np.argmax(num)+1 data = np.loadtxt('sonar.txt', delimiter=',') [row,col]=data.shape #全部数据集特征 feature=(data[:,0:-1]-...
    """
    Created on Tue Oct 19 19:26:28 2021
    直接近邻
    @author: lj
    """
    import numpy as np
    import random
    random.seed(2)
    class k_near:
        def __init__(self):
            self.feature=[]
            
            self.dist=[]
            self.all_label=[]
            self.label=0
            
        def com_dist(self,data):
            [row,col]=data.shape
            diff=np.zeros_like(data)
            for i in range(len(data)):
                diff[i,:]=(self.feature[:]-data[i,:])**2
                self.dist.append(np.sqrt(sum(diff[i,:]))/col)
            
        def find_label(self,label,k):
            self.dist[np.argmin(self.dist)]=2#0*abs(np.max(self.dist))
            for i in range(k):
                self.all_label.append(label[np.argmin(self.dist)])
                self.dist[np.argmin(self.dist)]=2#0*abs(np.max(self.dist))
            num=np.zeros([3])
            num[0]=(self.all_label.count(1))
            num[1]=(self.all_label.count(2))
            num[2]=(self.all_label.count(3))
            
            self.label=np.argmax(num)+1
            
    data = np.loadtxt('sonar.txt', delimiter=',')
    [row,col]=data.shape
    #全部数据集特征
    feature=(data[:,0:-1]-np.min(data[:,0:-1]))/(np.max(data[:,0:-1],axis=0)-np.min(data[:,0:-1]))
    label=data[:,-1]
    
    list_test=range(data.shape[0])
    test=random.sample(list_test, 100)
    #test=range(0,200)
    k=25#近邻数
    
    x=k_near()
    #x.feature=np.zeros([col-1])
    #输入x的特征值
    inputfeature=feature[test,:]
    test_label=[]
    right_label=label[test]
    for i in range(inputfeature.shape[0]):
        x.feature=inputfeature[i,:]
        x.dist=[]
        x.all_label=[]
        x.com_dist(feature)
        x.find_label(label,k)   
        test_label.append(x.label)
        print("数据" + str(test[i])+ "的类别为:",x.label)
    right_rate=1-np.sum(np.abs(test_label-right_label))/len(test_label)
    print("数据正确率:",right_rate)

    本文中作者使用了最为基础的K近邻算法对数据进行分类,其基本思路可以简单总结成以下流程图:

     但是,这种分类方法常常对于分布不均匀的数据有着较差的分类能力,如某些数据临近范围内仅有3、4个点,某些点临近范围内却有着更多的样本,这种情况下,我们需要对不同的点分别进行处理,于是采用了一种新的办法:尝试对搜索临近数据的邻域半径进行限制,将部分超出半径的临近数据剔除,从而有效保证K近邻算法的思想不因为数据分布不均而缺乏体现。

    以下是邻域限制时K近邻的代码:

    """
    Created on Tue Oct 19 19:26:28 2021
    附加邻域k近邻
    @author: lj
    """
    import numpy as np
    import random
    random.seed(2)
    class k_near:
        def __init__(self):
            self.feature=[]
            
            self.dist=[]
            self.all_label=[]
            self.label=0
            
        def com_dist(self,data):
            [row,col]=data.shape
            diff=np.zeros_like(data)
            for i in range(len(data)):
                diff[i,:]=(self.feature[:]-data[i,:])**2
                self.dist.append(np.sqrt(sum(diff[i,:]))/col)
            
        def find_label(self,label,k):
            self.dist[np.argmin(self.dist)]=20*abs(np.max(self.dist))
            limit=0.04*1
            for i in range(k):
                if np.min(self.dist)<limit:
                    self.all_label.append(label[np.argmin(self.dist)])
                    self.dist[np.argmin(self.dist)]=2#0*abs(np.max(self.dist))
                else:
                    self.all_label.append(3)
                    self.dist[np.argmin(self.dist)]=2#0*abs(np.max(self.dist))
            num=np.zeros([2])
            num[0]=(self.all_label.count(1))
            num[1]=(self.all_label.count(2))
            
            self.label=np.argmax(num)+1
            
    data = np.loadtxt('sonar.txt', delimiter=',')
    [row,col]=data.shape
    #全部数据集特征
    feature=(data[:,0:-1]-np.min(data[:,0:-1]))/(np.max(data[:,0:-1],axis=0)-np.min(data[:,0:-1]))
    label=data[:,-1]
    
    list_test=range(data.shape[0])
    test=random.sample(list_test, 100)
    #test=range(0,200)
    k=25
    #近邻数
    
    x=k_near()
    #x.feature=np.zeros([col-1])
    #输入x的特征值
    inputfeature=feature[test,:]
    test_label=[]
    right_label=label[test]
    for i in range(inputfeature.shape[0]):
        x.feature=inputfeature[i,:]
        x.dist=[]
        x.all_label=[]
        x.com_dist(feature)
        x.find_label(label,k)   
        test_label.append(x.label)
        print("数据" + str(test[i])+ "的类别为:",x.label)
    right_rate=1-np.sum(np.abs(test_label-right_label))/len(test_label)
    print("数据正确率:",right_rate)

     由于采用的数据分布较为均匀,两种算法的差距并不是特别明显。不过当K取值25时,附加邻域法的正确率要高出普通K近邻5%以上。

    展开全文
  • 基于libsvm的sonar数据集,无需解压,无需修改,已经直接把sonar数据集修改成符合libsvm调用的格式,可直接使用
  • sonar.all-data

    2020-10-11 16:47:16
    sonar数据集,共两类数据 R和M,共208个样本数据,每个样本数据为60维,其中R类共97各样本数据,M类共111个样本数据。
  • 用于训练或测试的logistic数据集,参考代码可在我的博客中查找
  • RF实践——基于sonar声呐数据集

    千次阅读 2018-07-14 22:59:06
    数据集下载:https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks)  注:下载 sonar.all-data并重命名为sonar.all-data.csv 增加后缀改变文件格式,放到project 用excel打开...
  • 基于Fisher 线性判别方法的数据分类问题 1 Fisher 线性判别方法介绍 1.1 方法总括 把 d 维空间的样本投影到一条直线上,形成一维空间,即通过降维去解决两 分类问题。如何根据实际数据找到一条最好的、最易于分类的...
  • Sonar简介

    2016-10-13 13:51:03
    Sonar简介 Sonar是一个用于代码质量管理的开源平台,用于管理源代码的质量,可以从七个维度检测代码质量 通过插件形式,可以支持包括java,C#,C/C++,PL/SQL,Cobol,JavaScrip,Groovy等等二十几种编程语言的代码质量...
  • 1.使用make_blobs生成样本为200,分类为2的数据集,并绘制成散点图。 import matplotlib.pyplot as plt # 导入数据集 from sklearn.datasets import make_blobs # 导入KNN分类器 from sklearn.neighbors import ...
  • sonar下载地址.txt

    2020-04-24 16:47:56
    代码规范检查工具sonar的完整一套安装包,包括中文插件,可以直接下载运行使用。请测可用,非常好用,有利于提高代码编写质量
  • sonar下载地址&使用-附件资源
  • KNN的MATLAB实现,基于特殊的SONAR数据,M文件,MATLAB源代码。
  • 返回错误信息 获取sonar单个项目结果数据 def get_sonar_list(self, sonar_name): """获取完整sonar结果列表信息""" try: s = SonarSession() # 调用和输出sonar测量指标数据字段 status_code, component = s.func_...
  • #导入boston房价数据集 from sklearn.datasets import load_boston #将数据集赋给boston boston = load_boston() #打印数据维度 print(boston.data.shape) #导入boston房价数据集 from sklearn.datasets import ...

空空如也

空空如也

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

sonar数据集