online.cs

svm 多类分类 输入多种色点

using System;
using System.Collections.Generic;
using System.Text;

namespace olsvm
{
    class Online
    {
        private double[][] instance;
        private int[] type;
        private int domin;
        private int number;
        private int count;
        private double[] Alpha;
        private double PAlpha;
        private double[] Beta;
        private double[] G;
        private double BetaB;
        private double[][] R;
        private kernal ker;
        private Optimum opt;
        private int useker;
        private double b;
        private double[] Gama;
        private double error;
        private int[] S;
        private int[] E;
        private int[] M;
        private int numS;
        private int numE;
        private int numM;
        private int kind;
        private int index;

        public Online()
        { 
            
        }

        public Online(int use,int dom,int num,double[][] ins,int[] typ,double err)
        {
            opt=new Optimum(use,dom,2,ins,typ,err);
            ker = new kernal(dom, num);
            useker = use;
            domin = dom;
            number = num;
            error = err;
            instance = new double[number][];
            type = new int[number];
            Alpha = new double[number];
            Beta = new double[number];
            S = new int[number];
            E = new int[number];
            M = new int[number];
            Gama = new double[number];
            G = new double[number];
            numS = numE = numM = 0;
            for (int i = 0; i < number; i++)
            {
                instance[i] = new double[domin];
            }
            R = new double[number + 2][];
            for (int i = 0; i < number + 2; i++)
            {
                R[i] = new double[number + 2];
            }
            for (int i = 0; i < number; i++)
            {
                for (int j = 0; j < domin; j++)
                {
                    instance[i][j] = ins[i][j];
                }
                type[i] = typ[i];
                Alpha[i] = 0;
                Beta[i] = 0;
                Gama[i] = 0;
                G[i] = 0;
            }
            for (int i = 0; i < number + 2; i++)
            {
                for (int j = 0; j < number + 2; j++)
                    R[i][j] = 0;
            }
            count = 0;
            b = 0;
        }

        public double xMulte(double[] vect1, double[] vect2)
        {
            double sum = 0;
            for (int i = 0; i < domin; i++)
            {
                sum += vect1[i] * vect2[i];
            }
            return sum;
        }

        public void setB()
        {
            double maxb = 0;
            int maxbpos = 0;
            double sum = 0;
            for (int j = 0; j < count; j++)
            {
                if (Alpha[j] > maxb && Alpha[j] < error)
                {
                    maxb = Alpha[j];
                    maxbpos = j;
                }
            }
            for (int i = 0; i < count; i++)
            {
                switch (useker)
                {
                    case 0:
                        sum += type[i] * Alpha[i] * xMulte(instance[i], instance[maxbpos]);
                        break;
                    case 1:
                        sum += type[i] * Alpha[i] * ker.function_k(instance[i], instance[maxbpos], 4);//
                        break;
                    case 2:
                        sum += type[i] * Alpha[i] * ker.gauss_K(instance[i], instance[maxbpos], 0.618);//
                        break;
                }
            }
            b = type[maxbpos] - sum;
        }

        public void setG()
        {
            for (int i = 0; i < count; i++)
            {
                G[i] = getG(instance[i], type[i]);
            }
        }

        public void setBeta()
        {
            for (int i = 0; i < number; i++)
            {
                Beta[i] = 0;
            }
            for (int i = 0; i < numS; i++)
            {
                double sum = 0;
                sum += R[i + 1][0] * type[count];
                for (int j = 0; j < numS; j++)
                {
                    sum += R[i + 1][j + 1] * getQ(S[j], count);
                }
                Beta[S[i]] = -sum;
            }
            BetaB = 0;
            BetaB = -R[0][0] * type[count];
            for (int i = 0; i < numS; i++)
            {
                BetaB -= R[0][i + 1] * getQ(S[i], count);
            }
        }

        public void setBeta(int k)
        {
            for (int i = 0; i < number; i++)
            {
                Beta[i] = 0;
            }
            for (int i = 0; i < numS; i++)
            {
                double sum = 0;
                sum += R[i + 1][0] * type[k];
                for (int j = 0; j < numS; j++)
                {
                    sum += R[i + 1][j + 1] * getQ(S[j], k);
                }
                Beta[S[i]] = -sum;
            }
            BetaB = 0;
            BetaB = -R[0][0] * type[k];
            for (int i = 0; i < numS; i++)
            {
                BetaB -= R[0][i + 1] * getQ(S[i], k);
            }
        }

        public void setGama()
        {
            for (int i = 0; i < number; i++)
            {
                if (!isInS(i))
                {
                    Gama[i] = getQ(i, count);
                    for (int j = 0; j < numS; j++)
                    {
                        Gama[i] += getQ(i, S[j]) * Beta[S[j]];
                    }
                    Gama[i] += type[i] * BetaB;
                }
                else
                {
                    Gama[i] = 0;
                }
            }
        }

        public void setGama(int k)
        {
            for (int i = 0; i < number; i++)
            {
                if (!isInS(i))
                {
                    Gama[i] = getQ(i, k);
                    for (int j = 0; j < numS; j++)
                    {
                        Gama[i] += getQ(i, S[j]) * Beta[S[j]];
                    }
                    Gama[i] += type[i] * BetaB;
                }
                else
                {
                    Gama[i] = 0;
                }
            }
        }

        public double getF(double[] x)
        {
            double sum = 0;
            int i = 0;
            switch (useker)
            {
                case 0:
                    for (i = 0; i < count; i++)
                    {
                        sum += type[i] * Alpha[i] * xMulte(instance[i], x);
                    }
                    break;
                case 1:
                    for (i = 0; i < count; i++)
                    {
                        sum += type[i] * Alpha[i] * ker.function_k(instance[i], x, 4);
                    }
                    break;
                case 2:
                    for (i = 0; i < count; i++)
                    {
                        sum += type[i] * Alpha[i] * ker.gauss_K(instance[i], x, 0.618);
                    }
                    break;
            }
            sum += b;
            return sum;
        }

        public double getG(double[] x, int y)
        {
            return y * getF(x) - 1;
        }

        public double getQ(int s, int t)
        {
            double v=0;
            switch (useker)
            {
                case 0:
                    v = type[s] * type[t] * xMulte(instance[s], instance[t]);
                    break;
                case 1:
                    v = type[s] * type[t] * ker.function_k(instance[s], instance[t], 4);//
                    break;
                case 2:
                    v = type[s] * type[t] * ker.gauss_K(instance[s], instance[t], 0.618);//
                    break;
            }
            return v;
        }

        public void Matrix_ni(double[][] Mni, double[][] M, int n)
        {
            int i, j;
            double temp;
            double[][] I;       //构造单位矩阵
            I = new double[n][];
            for (i = 0; i < n; i++)
            {
                I[i] = new double[n];
            }
            for (i = 0; i < n; i++)
                for (j = 0; j < n; j++)
                {
                    if (i == j) I[i][j] = 1;
                    else I[i][j] = 0;
                }
            for (i = 0; i < n; i++)
            {
                int k = i;
                while (M[k][i] == 0 && k <= n)
                    k++;
                if (i != k)
                {
                    for (j = 0; j < n; j++)
                    {
                        temp = M[i][j]; M[i][j] = M[k][j];
                        M[k][j] = temp;
                        temp = I[i][j]; I[i][j] = I[k][j];
                        I[k][j] = temp;
                    }
                }
                temp = M[i][i];
                for (k = 0; k < n; k++)
                {

                    M[i][k] = M[i][k] / temp;
                    I[i][k] = I[i][k] / temp;
                }
                for (k = 0; k < n; k++)
                {
                    if (k != i)
                    {
                        temp = M[k][i];
                        for (j = 0; j < n; j++)
                        {

                            M[k][j] = M[k][j] - M[i][j] * temp;
                            I[k][j] = I[k][j] - I[i][j] * temp;
                        }
                    }
                }
            }
            for (i = 0; i < n; i++)
                for (j = 0; j < n; j++)
                {
                    Mni[i][j] = I[i][j];
                }
        }

        public void setR()
        { 
            double[][] Q;
	        Q=new double [3][];
	        for(int k=0;k<3;k++)
	        {
		        Q[k]=new double [3];
	        }
	        Q[0][0]=0;
	        for(int i=1;i<3;i++)
	        {
		        Q[0][i]=type[i-1];
		        Q[i][0]=type[i-1];
	        }
	        for(int i=0;i<2;i++)
	        {
		        for(int j=0;j<2;j++)