感知机算法的两种表示

 

感知机算法的原始形式

输入:训练数据集T={(x1,y1),(x2,y2),...,(xn,yn)},其中xi属于Rn(n维空间向量)，yi={-1,+1},i=1,2,...,N

学习率t（0<t<=1）;

输出：w,b;感知机模型f(x)=sign(w*x+b)

(1)选取初值w0,b0一般为 0

(2)在训练集中选取数据(xi,yi)

(3)如果yi(w*xi+b)<=0

                          w<---w+tyixi

                           b<----b+tyi

(4)转至（2）,直至训练集中没有误分类点。

算法代码如下

import java.util.Random;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//初始的感知机学习算法
public class ganzhijiOriginal {
    //    数据集中数据的个数
    public static int NCount;
    //    数据中每个数值的维数 不包含y
    public static int N;
    //    学习率  (0,1]
    public static float t;

    //    保存数据
    public static int datas[][];
    //    权重向量
    public static float w[];
    //   偏移数据
    public static float b;

    public static void main(String args[]) {
        Scanner sca = new Scanner(System.in);
//       默认输入的格式为 N-t-b
        System.out.println("输入格式为N-t-b-NCount的数据:");
        String lines = sca.nextLine();
        Pattern pattern = Pattern.compile("(.*)-(.*)-(.*)-(.*)");
        Matcher matcher = pattern.matcher(lines);
        matcher.find();
        N = Integer.parseInt(matcher.group(1));
        t = Float.parseFloat(matcher.group(2));
        b = Float.parseFloat(matcher.group(3));
//        b = Integer.parseInt(matcher.group(3));
        NCount = Integer.parseInt(matcher.group(4));
//        System.out.println("请输入权重向量的初始值格式为格式为x,x,x,x" + N);
//初始化数据集
        w = new float[N];
//        lines = sca.nextLine();
//        String[] str = lines.split(",");
//        for (int i = 0; i < N; i++)
//            w[i] = Float.parseFloat(str[i]);
        datas = new int[NCount][N + 1];
        System.out.println("请输入所有权重向量的初始值");
        for (int i = 0; i < NCount; i++) {
            String line = sca.nextLine();
            String strs[] = line.split(" ");
            for (int j = 0; j <= N; j++)
                datas[i][j] = Integer.parseInt(strs[j]);
        }
        CountTheTimes = 0;
        Random ra = new Random();
        int chooseNumber = ra.nextInt(NCount);
        CalcuteAndUpdatValue(0);
        String strd = "";
        for (int i = 0; i < N; i++)
            strd += w[i] + "*x" + i + "+ ";
        System.out.println("F(x)=sign(" + strd + b + ")");
    }

    public static int CountTheTimes;

    private static void CalcuteAndUpdatValue(int chooseNumber) {
        float f = isPOrN(chooseNumber);
        boolean flages = f * datas[chooseNumber][N] > 0 ? true : false;
        if (!flages) {
            for (int j = 0; j < N; j++) //更新权重w的值
                w[j] = w[j] + t * datas[chooseNumber][N] * datas[chooseNumber][j];
            b = b + t * datas[chooseNumber][N];

            CountTheTimes = 0;//初始化
        } else {
            CountTheTimes++;
            chooseNumber = (chooseNumber + 1) % NCount;
        }
        if (CountTheTimes == NCount) return;
        CalcuteAndUpdatValue(chooseNumber);
    }

    private static float isPOrN(int chooseNumber) {
        float sum = 0;
        for (int i = 0; i < N; i++) sum += datas[chooseNumber][i] * w[i];
        return sum + b;
    }

}

感知机算法的对偶形式

输入：线性可分的数据集T={(x1,y1),(x2,y2),...,(xn,yn)}其中xi属于Rn(n维向量),yi属于{-1，+1}，i，2，。。。，N；学习率为t (0<t<=1)

输出a，b 感知机模型f(x)=sign(j从1 到 ajyjxj*x累加  +b) 其中a=(a1,a2,a3...,an)T

(1)a<---0,b<----0

(2)在训练数据集中选择(xi,yi)

(3)如果 yi(j从1 到 ajyjxj*xi累加  +b)<=0

                  ai<----ai+t

                 b<---b+tyi

(4)转至(2)直到没有误分类点

算法如下

import java.util.Random;
import java.util.Scanner;

//感知机算法的对偶形式
public class ganzhijiOudui {
    //存储数据的Gram矩阵
    public static int gramMatrix[][];
    //    存储初始点集合包括y
    public static int datas[][];
    //感知机中的学习率(0,1]
    public static float t;
    //    存储某个点更新的次数nt
    public static float a[];
    //    点的维度 不包含y
    public static int N;
    //    总点的数
    public static int NCount;
    //偏移量
    public static float b;

    public static int w[];//权重

    public static void main(String args[]) {
        Scanner sca = new Scanner(System.in);
        System.out.println("输入的格式为:N-t-b-NCount");
        String line = sca.nextLine();
        String dt[] = line.split("-");
        N = Integer.parseInt(dt[0]);
        t = Float.parseFloat(dt[1]);
        b = Float.parseFloat(dt[2]);
        NCount = Integer.parseInt(dt[3]);
        InitDatas(sca);


    }

    private static void InitDatas(Scanner sca) {
        datas = new int[NCount][N + 1];
        gramMatrix = new int[NCount][NCount];
        w = new int[N];
//        默认值为零
        a = new float[NCount];
        System.out.println("输入数据点集合格式为x x x ... Y");
        for (int i = 0; i < NCount; i++) {
            String line = sca.nextLine();
            String strs[] = line.split(" ");
            for (int j = 0; j <= N; j++) datas[i][j] = Integer.parseInt(strs[j]);
        }
        System.out.println("初始化Gram矩阵");
        for (int i = 0; i < NCount; i++) {
            for (int j = 0; j < NCount; j++) {
                gramMatrix[i][j] = MultiplyTheDatas(i, j);
            }
        }
//        记录总的循环次数
        TotalTimes = 0;
        Random random = new Random();
        int chooseNumber = random.nextInt(NCount);
        CalculateAndUpdatDatas(0);
        //更新 w
        for (int i = 0; i < N; i++) {
            int sum = 0;
            for (int j = 0; j < NCount; j++) sum += a[j] * datas[j][i]*datas[j][N];
            w[i] = sum;
        }
        String strd = "";
        for (int i = 0; i < N; i++)
            strd += w[i] + "*x" + i + "+ ";
        System.out.println("F(x)=sign(" + strd + b + ")");
    }

    public static int TotalTimes = 0;

    private static void CalculateAndUpdatDatas(int chooseNumber) {

        float sum = CaluteTheFx(chooseNumber);
        boolean flages = sum * datas[chooseNumber][N] > 0 ? true : false;
        if (!flages) {
            TotalTimes = 0;
            a[chooseNumber] = a[chooseNumber] + t;
            b = b + t * datas[chooseNumber][N];
        } else {
            TotalTimes++;
            chooseNumber = (chooseNumber + 1) % NCount;
        }
        if (TotalTimes == NCount) return;
        CalculateAndUpdatDatas(chooseNumber);
    }

    private static float CaluteTheFx(int chooseNumber) {

        float sum = 0;
        for (int i = 0; i <=N; i++) sum += a[i] * datas[i][N] * gramMatrix[i][chooseNumber];
        return sum + b;
    }


    //    计算两个向量的乘积
    private static int MultiplyTheDatas(int i, int j) {
        int sum = 0;
        for (int k = 0; k <N; k++) sum += datas[i][k] * datas[j][k];
        return sum;
    }


}