optimum.cs

svm 多类分类 输入多种色点

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

namespace olsvm
{
    class Optimum : Frank
    {
        protected int dimension;
        protected int satistics;
        protected double[][] coordinate;
        protected int[] category;
        protected double cc;
        protected int useKernal;
        protected kernal Ker;
        protected int ker_d;

        public double[] slope;
        public double intercept;
        public double[] optimalValue;

        public Optimum(int diman, int satics, double[][] instance, int[] type, double err)
            : base(2 * satics, satics + 1)
        {
            useKernal = 0;
            dimension = diman;
            satistics = satics;
            coordinate = new double[satistics][];
            for (int i = 0; i < satistics; i++)
            {
                coordinate[i] = new double[dimension];
            }
            category = new int[satistics];
            optimalValue = new double[satistics];
            slope = new double[dimension];
            cc = err;
            for (int i = 0; i < satistics; i++)
            {
                for (int j = 0; j < dimension; j++)
                {
                    coordinate[i][j] = instance[i][j];
                }
                category[i] = type[i];
            }
        }


        public Optimum(int kernum, int diman, int satics, double[][] instance, int[] type, double err)
            : base(2 * satics, satics + 1)
        {
            Ker = new kernal(diman, satics);
            useKernal = kernum;
            dimension = diman;
            satistics = satics;
            ker_d = 4;
            coordinate = new double[satistics][];
            for (int i = 0; i < satistics; i++)
            {
                coordinate[i] = new double[dimension];
            }
            category = new int[satistics];
            optimalValue = new double[satistics];
            slope = new double[dimension];
            cc = err;
            for (int i = 0; i < satistics; i++)
            {
                for (int j = 0; j < dimension; j++)
                {
                    coordinate[i][j] = instance[i][j];
                }
                category[i] = type[i];
            }
        }

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

        public void FindOptimalValue()
        { 
            int nn=2*satistics;
	        int	mm=1+satistics;
	        double pre=0.001;
	        int K=1;
	        double[][] h;
	        h=new double[nn][];
	        for(int i=0;i<nn;i++)
	        {
		        h[i]=new double[nn];
	        }
	        double[] c;
	        c=new double[nn];
	        double[] b;
	        b=new double[mm];
	        double[][] a;
	        a=new double[mm][];
	        for(int i=0;i<mm;i++)
	        {
		        a[i]=new double[nn];
	        }
	        double[] x;
	        x=new double[nn];
	        double[] xbasic;
	        xbasic=new double[nn];
	        double[] y;
	        y=new double[nn];
	        double[] gra;
	        gra=new double[nn];
	        for(int i=0;i<nn;i++)
	        {
		        xbasic[i]=0;
		        y[0]=0;
		        gra[0]=0;
	        }
	        double STEP=0;
	        for(int i=0;i<nn;i++){
		        for(int j=0;j<nn;j++){
			        if(i<satistics&&j<satistics)
			        {
				        switch(useKernal)
				        {
				        case 0:
					        h[i][j]=category[i]*category[j]*xMulte(coordinate[i],coordinate[j]);
					        break;
				        case 1:
					        h[i][j]=category[i]*category[j]*Ker.function_k(coordinate[i],coordinate[j],ker_d);//
					        break;
				        case 2:
					        h[i][j]=category[i]*category[j]*Ker.gauss_K(coordinate[i],coordinate[j],0.618);
					        break;
				        }
			        }
			        else
				        h[i][j]=0;
		        }
		        if(i<satistics)
			        c[i]=-1;
		        else
			        c[i]=0;
	        }
	        for(int i=0;i<mm;i++){
		        for(int j=0;j<nn;j++){
			        if(i==0){
				        if(j<satistics)
					        a[i][j]=category[j];
				        else
					        a[i][j]=0;
			        }
			        else{
				        if(i-1==j||i-1==j-satistics)
					        a[i][j]=1;
				        else
					        a[i][j]=0;
			        }
		        }
		        if(i==0)
			        b[i]=0;
		        else
			        b[i]=cc;
	        }
	        base.master(pre,K,h,c,b,a,x,xbasic,y,gra,STEP);
	        for(int i=0;i<satistics;i++){
		        optimalValue[i]=base.X[i];
	        }
        }

        public void setSlope()
        {
            for (int i = 0; i < dimension; i++)
            {
                slope[i] = 0;
                for (int j = 0; j < satistics; j++)
                {
                    slope[i] += category[j] * optimalValue[j] * coordinate[j][i];
                }
            }
        }

        public void setIntercept()
        {
            double maxb = 0;
            int maxbpos = 0;
            double sum = 0;
            for (int j = 0; j < satistics; j++)
            {
                if (optimalValue[j] > maxb && optimalValue[j] < cc)
                {
                    maxb = optimalValue[j];
                    maxbpos = j;
                }
            }
            for (int i = 0; i < satistics; i++)
            {
                switch (useKernal)
                {
                    case 0:
                        sum += category[i] * optimalValue[i] * xMulte(coordinate[i], coordinate[maxbpos]);
                        break;
                    case 1:
                        sum += category[i] * optimalValue[i] * Ker.function_k(coordinate[i], coordinate[maxbpos], ker_d);//
                        break;
                    case 2:
                        sum += category[i] * optimalValue[i] * Ker.gauss_K(coordinate[i], coordinate[maxbpos], 0.618);//
                        break;
                }
            }
            intercept = category[maxbpos] - sum;
        }

        public void run()
        {
            FindOptimalValue();
            setSlope();
            setIntercept();
        }

        public int getsign(double[] x)
        {
            double sum = 0;
            int i = 0;
            switch (useKernal)
            {
                case 0:
                    for (i = 0; i < satistics; i++)
                    {
                        sum += category[i] * optimalValue[i] * xMulte(coordinate[i], x);
                    }
                    break;
                case 1:
                    for (i = 0; i < satistics; i++)
                    {
                        sum += category[i] * optimalValue[i] * Ker.function_k(coordinate[i], x, ker_d);
                    }
                    break;
                case 2:
                    for (i = 0; i < satistics; i++)
                    {
                        sum += category[i] * optimalValue[i] * Ker.gauss_K(coordinate[i], x, 0.618);
                    }
                    break;
            }
            sum += intercept;
            if (sum > 0)
                return 1;
            else if (sum < 0)
                return -1;
            else
                return 0;
        }
    }
}