Пример #1
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            svm_model model  = value as svm_model;
            SVMModel  smodel = new SVMModel(model);

            serializer.Serialize(writer, smodel);
        }
Пример #2
0
        public svm_model initial(List <Dictionary <string, double> > docWordDicList, Dictionary <string, int> dictionary, List <int> trainingAnswer, double c, double gamma)
        {
            Console.WriteLine("==> Starting training...");

            svm_problem   prob  = gen_svm_training_data(docWordDicList, dictionary, trainingAnswer);
            svm_parameter param = new svm_parameter();

            // set the default setting value
            param.svm_type    = svm_parameter.C_SVC;
            param.kernel_type = svm_parameter.RBF;
            param.degree      = 3;
            param.gamma       = gamma;
            param.coef0       = 0;
            param.nu          = 0.5;
            param.cache_size  = 100;
            param.C           = c;
            param.eps         = 1e-3;
            param.p           = 0.1;
            param.shrinking   = 1;
            param.probability = 0;
            param.nr_weight   = 0;

            svm_model model = svm.svm_train(prob, param);

            svm.svm_save_model(SVM_MODEL_FILE_NAME, model);

            Console.WriteLine("==> Training done!!");
            return(model);
        }
Пример #3
0
 SVMClassifier(Dictionary <string, int> identifiersMap, svm_model model)
 {
     /* for serialization */
     svmNetwork          = new ProbabilitySupportVectorMachine(model);
     this.identifiersMap = identifiersMap;
     this.model          = model;
 }
 public SupportVectorMachineModel(svm_model model, RangeTransform rangeTransform, string targetVariable, IEnumerable <string> allowedInputVariables)
     : base(targetVariable)
 {
     this.name                  = ItemName;
     this.description           = ItemDescription;
     this.model                 = model;
     this.rangeTransform        = rangeTransform;
     this.allowedInputVariables = allowedInputVariables.ToArray();
 }
Пример #5
0
        protected void Train(double C, double gamma, List <ISample> trainingSamples, string[] trainingIdentifiers)
        {
            // generate a numeric mapping of our string identifiers to unique numeric values
            identifiersMap = trainingIdentifiers.Select((identifier, index) => new { identifier, index }).ToDictionary(id => id.identifier, id => id.index);

            // don't include imposter samples
            svmNetwork = TrainSVM(C, gamma, trainingSamples, (sample) => identifiersMap[sample.GetIdentifier()]);
            model      = svmNetwork.Model;
        }
Пример #6
0
        public static SVMModel Convert(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
            {
                return(null);
            }

            svm_model x = (svm_model)Marshal.PtrToStructure(ptr, typeof(svm_model));

            return(SVMModel.Convert(x));
        }
 private SupportVectorMachineModel(SupportVectorMachineModel original, Cloner cloner)
     : base(original, cloner)
 {
     // only using a shallow copy here! (gkronber)
     this.model                 = original.model;
     this.rangeTransform        = original.rangeTransform;
     this.allowedInputVariables = (string[])original.allowedInputVariables.Clone();
     if (original.classValues != null)
     {
         this.classValues = (double[])original.classValues.Clone();
     }
 }
Пример #8
0
    public static void  Main(System.String[] argv)
    {
        int i, predict_probability = 0;

        // parse options
        for (i = 0; i < argv.Length; i++)
        {
            if (argv[i][0] != '-')
            {
                break;
            }
            ++i;
            switch (argv[i - 1][1])
            {
            case 'b':
                predict_probability = atoi(argv[i]);
                break;

            default:
                System.Console.Error.Write("unknown option\n");
                exit_with_help();
                break;
            }
        }
        if (i >= argv.Length)
        {
            exit_with_help();
        }
        try
        {
            //UPGRADE_TODO: Expected value of parameters of constructor 'java.io.BufferedReader.BufferedReader' are different in the equivalent in .NET. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"'
            System.IO.StreamReader input  = new System.IO.StreamReader(argv[i]);                                                          // Input file
            System.IO.BinaryWriter output = new System.IO.BinaryWriter(new System.IO.FileStream(argv[i + 2], System.IO.FileMode.Create)); // Output file

            TextReader reader = File.OpenText(argv[i + 1]);
            reader.ReadToEnd();
            System.Text.UnicodeEncoding unicodeEncoding = new System.Text.UnicodeEncoding();
            byte[] sBytes = unicodeEncoding.GetBytes(reader.ToString());

            svm_model model = svm.svm_load_model(sBytes); // Model file
            predict(input, output, model, predict_probability);
        }
        catch (System.IO.FileNotFoundException e)
        {
            string message = e.Message;
            exit_with_help();
        }
        catch (System.IndexOutOfRangeException e)
        {
            string message = e.Message;
            exit_with_help();
        }
    }
Пример #9
0
        public static void Free(svm_model x)
        {
            Marshal.FreeHGlobal(x.rho);
            x.rho = IntPtr.Zero;

            Marshal.FreeHGlobal(x.probA);
            x.probA = IntPtr.Zero;

            Marshal.FreeHGlobal(x.probB);
            x.probB = IntPtr.Zero;

            Marshal.FreeHGlobal(x.sv_indices);
            x.sv_indices = IntPtr.Zero;

            Marshal.FreeHGlobal(x.label);
            x.label = IntPtr.Zero;

            Marshal.FreeHGlobal(x.nSV);
            x.nSV = IntPtr.Zero;

            SVMParameter.Free(x.param);

            IntPtr i_ptr_sv = x.SV;

            for (int i = 0; i < x.l; i++)
            {
                IntPtr ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_sv, typeof(IntPtr));
                SVMNode.Free(ptr_nodes);

                i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr)));
            }

            Marshal.FreeHGlobal(x.SV);
            x.SV = IntPtr.Zero;

            IntPtr i_ptr_svcoef = x.sv_coef;

            for (int i = 0; i < x.nr_class - 1; i++)
            {
                IntPtr temp = (IntPtr)Marshal.PtrToStructure(i_ptr_svcoef, typeof(IntPtr));
                Marshal.FreeHGlobal(temp);
                temp = IntPtr.Zero;

                i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr)));
            }

            Marshal.FreeHGlobal(x.sv_coef);
            x.sv_coef = IntPtr.Zero;
        }
Пример #10
0
        public static void Free(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
            {
                return;
            }

            svm_model x = (svm_model)Marshal.PtrToStructure(ptr, typeof(svm_model));

            SVMModel.Free(x);

            Marshal.DestroyStructure(ptr, typeof(svm_model));
            Marshal.FreeHGlobal(ptr);
            ptr = IntPtr.Zero;
        }
Пример #11
0
        /// <summary>
        /// Construct a SVM from a model.
        /// </summary>
        ///
        /// <param name="theModel">The model.</param>
        public SupportVectorMachine(svm_model theModel)
        {
            _model      = theModel;
            _paras      = _model.param;
            _inputCount = 0;

            // determine the input count
            foreach (var element in _model.SV)
            {
                foreach (svm_node t in element)
                {
                    _inputCount = Math.Max(t.index, _inputCount);
                }
            }

            //
        }
Пример #12
0
 public MaltLibsvmModel(svm_model model, svm_problem problem)
 {
     param    = model.param;
     nr_class = model.nr_class;
     l        = model.l;
     SV       = model.SV;
     sv_coef  = model.sv_coef;
     rho      = model.rho;
     label    = model.label;
     nSV      = model.nSV;
     start    = new int[nr_class];
     start[0] = 0;
     for (int i = 1; i < nr_class; i++)
     {
         start[i] = start[i - 1] + nSV[i - 1];
     }
 }
        public bool LoadFromFile(string fileName)
        {
            if (File.Exists(fileName))
            {
                FileStream fs = new FileStream(fileName, FileMode.Open);
                using (BinaryReader r = new BinaryReader(fs))
                {
                    this.model = new svm_model();

                    svm_parameter p = new svm_parameter();
                    p.C            = r.ReadDouble();
                    p.cache_size   = r.ReadDouble();
                    p.coef0        = r.ReadDouble();
                    p.degree       = r.ReadDouble();
                    p.eps          = r.ReadDouble();
                    p.gamma        = r.ReadDouble();
                    p.kernel_type  = r.ReadInt32();
                    p.nr_weight    = r.ReadInt32();
                    p.nu           = r.ReadDouble();
                    p.p            = r.ReadDouble();
                    p.probability  = r.ReadInt32();
                    p.shrinking    = r.ReadInt32();
                    p.svm_type     = r.ReadInt32();
                    p.weight       = ReadDoubleArray(r);
                    p.weight_label = ReadIntArray(r);

                    this.model.param    = p;
                    this.model.nr_class = r.ReadInt32();
                    this.model.l        = r.ReadInt32();
                    this.model.SV       = ReadSvmNodeArray(r);
                    this.model.sv_coef  = ReadDouble2DArray(r);
                    this.model.rho      = ReadDoubleArray(r);
                    this.model.probA    = ReadDoubleArray(r);
                    this.model.probB    = ReadDoubleArray(r);
                    this.model.label    = ReadIntArray(r);
                    this.model.nSV      = ReadIntArray(r);

                    return(true);
                }
            }

            this.model = null;
            return(false);
        }
Пример #14
0
        static void Main(string[] args)
        {
            List <Dictionary <string, double> > docWordDicList = new List <Dictionary <string, double> >();
            Dictionary <string, int>            dictionary     = new Dictionary <string, int>();
            List <int> trainingAnswer = new List <int>();
            Dictionary <string, double> wordIDFDictionary = new Dictionary <string, double>();
            Hashtable     stopWordTable    = genStopwordTable(STOP_WORD_PATH);
            List <string> testFileNameList = new List <string>();
            int           dicSize          = 100;

            Console.WriteLine("==> Starting prepare data...");
            NLPAdapter nlpAdapter = new NLPAdapter(NLP_MODEL_PATH);

            trainModel(TRAINING_DATA_DIR,
                       LOG_DIR,
                       ref docWordDicList,
                       ref dictionary,
                       dicSize,
                       ref trainingAnswer,
                       ref wordIDFDictionary,
                       stopWordTable,
                       nlpAdapter
                       );
#if KNN_MODE
            KNN knn = new KNN();
            knn.set(dicSize, docWordDicList.Count());
            knn.initial(docWordDicList, dictionary, trainingAnswer);
            knn.train(3, 20);
            knn.getAveDistance();

            //knn.genLog(@"D:\work\KPMG\learning\classification\project1_0422\log");
            List <KeyValuePair <int, int> > testAnswer = runKnnTest(knn, TEST_DATA_DIR, TEST_LOG_DIR, dictionary, wordIDFDictionary, stopWordTable, ref testFileNameList, nlpAdapter);
#else
            Console.WriteLine("==> Starting get model...");
            SVMAdapter svmAdapter = new SVMAdapter();
            svm_model  model      = svmAdapter.getSVMModel(docWordDicList, dictionary, trainingAnswer, SVMAdapter.SVM_C_DEFAULT, SVMAdapter.SVM_GAMMA_DEFAULT);

            Console.WriteLine("==> Starting SVM test...");
            List <KeyValuePair <int, int> > testAnswer = runSVMTest(svmAdapter, TEST_DATA_DIR, TEST_LOG_DIR, dictionary, wordIDFDictionary, stopWordTable, ref testFileNameList, model, nlpAdapter);
            Console.WriteLine("==> Starting SVM test done!!");
#endif
            Console.WriteLine("==> Starting saving result...");
            genStatistic(testAnswer, testFileNameList, LOG_DIR);
        }
        public void TrainModel(double[] labels, double[][] mlArray)
        {
            SvmProblemBuilder builder = new SvmProblemBuilder(labels, mlArray);
            svm_problem       problem = builder.CreateProblem();

            svm_parameter param = new svm_parameter()
            {
                svm_type     = 0,
                kernel_type  = 0,
                cache_size   = 512,
                eps          = 0.1,
                C            = 10,
                nr_weight    = 0,
                weight_label = null,
                weight       = null
            };

            this.model = svm.svm_train(problem, param);
        }
Пример #16
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            SVMModel  dmodel = serializer.Deserialize <SVMModel>(reader);
            svm_model model  = new svm_model()
            {
                SV = dmodel.SV
            };

            model.SV = dmodel.SV;
            DataHelpers.SetFieldValue <int>(model, "l", dmodel.l);
            DataHelpers.SetFieldValue <int[]>(model, "label", dmodel.label);
            DataHelpers.SetFieldValue <int>(model, "nr_class", dmodel.nr_class);
            DataHelpers.SetFieldValue <int[]>(model, "nSV", dmodel.nSV);
            DataHelpers.SetFieldValue <double[]>(model, "probA", dmodel.probA);
            DataHelpers.SetFieldValue <double[]>(model, "probB", dmodel.probB);
            DataHelpers.SetFieldValue <double[]>(model, "rho", dmodel.rho);
            DataHelpers.SetFieldValue <double[][]>(model, "sv_coef", dmodel.sv_coef);
            DataHelpers.SetFieldValue <svm_parameter>(model, "param", dmodel.param);
            return(model);
        }
Пример #17
0
        /// <summary>
        /// Load the models.
        /// </summary>
        /// <param name="xmlin">Where to read the models from.</param>
        /// <param name="network">Where the models are read into.</param>
        private void HandleModels(ReadXML xmlin, SVMNetwork network)
        {
            int index = 0;

            while (xmlin.ReadToTag())
            {
                if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODEL, true))
                {
                    svm_parameter param = new svm_parameter();
                    svm_model     model = new svm_model();
                    model.param           = param;
                    network.Models[index] = model;
                    HandleModel(xmlin, network.Models[index]);
                    index++;
                }
                else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODELS, false))
                {
                    break;
                }
            }
        }
Пример #18
0
    private void  run(System.String[] argv)
    {
        parse_command_line(argv);
        read_problem();
        error_msg = svm.svm_check_parameter(prob, param);

        if ((System.Object)error_msg != null)
        {
            System.Console.Error.Write("Error: " + error_msg + "\n");
            System.Environment.Exit(1);
        }

        if (cross_validation != 0)
        {
            do_cross_validation();
        }
        else
        {
            model = svm.svm_train(prob, param);
            svm.svm_save_model(model_file_name, model);
        }
    }
Пример #19
0
        /// <summary>
        /// Load the data from a model.
        /// </summary>
        /// <param name="xmlin">Where to read the data from.</param>
        /// <param name="model">The model to load data into.</param>
        private void HandleData(ReadXML xmlin, svm_model model)
        {
            int i = 0;
            int m = model.nr_class - 1;
            int l = model.l;

            model.sv_coef = EngineArray.AllocateDouble2D(m, l);
            model.SV      = new svm_node[l][];

            while (xmlin.ReadToTag())
            {
                if (xmlin.IsIt(SVMNetworkPersistor.TAG_ROW, true))
                {
                    String line = xmlin.ReadTextToTag();

                    String[] st = xmlin.ReadTextToTag().Split(',');

                    for (int k = 0; k < m; k++)
                    {
                        model.sv_coef[k][i] = Double.Parse(st[i]);
                    }
                    int n = st.Length / 2;
                    model.SV[i] = new svm_node[n];
                    int idx = 0;
                    for (int j = 0; j < n; j++)
                    {
                        model.SV[i][j]               = new svm_node();
                        model.SV[i][j].index         = int.Parse(st[idx++]);
                        model.SV[i][j].value_Renamed = Double.Parse(st[idx++]);
                    }
                    i++;
                }
                else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DATA, false))
                {
                    break;
                }
            }
        }
Пример #20
0
        public static IntPtr Allocate(SVMModel x)
        {
            if (x == null || x.ClassCount < 1 || x.Labels == null || x.Labels.Length < 1 || x.Parameter == null ||
                x.Rho == null || x.Rho.Length < 1 || x.SVCoefs == null || x.SVCoefs.Count < 1 || x.TotalSVCount < 1 ||
                x.SVCounts == null || x.SVCounts.Length < 1)
            {
                return(IntPtr.Zero);
            }

            svm_model y = new svm_model();

            y.nr_class = x.ClassCount;
            y.l        = x.TotalSVCount;
            y.free_sv  = (int)x.Creation;

            // Allocate model.parameter
            IntPtr ptr_param = SVMParameter.Allocate(x.Parameter);

            y.param = (svm_parameter)Marshal.PtrToStructure(ptr_param, typeof(svm_parameter));

            // Allocate model.rho
            y.rho = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.Rho.Length);
            Marshal.Copy(x.Rho, 0, y.rho, x.Rho.Length);

            // Allocate model.probA
            y.probA = IntPtr.Zero;
            if (x.ProbabilityA != null)
            {
                y.probA = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.ProbabilityA.Length);
                Marshal.Copy(x.ProbabilityA, 0, y.probA, x.ProbabilityA.Length);
            }

            // Allocate model.probB
            y.probB = IntPtr.Zero;
            if (x.ProbabilityB != null)
            {
                y.probB = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.ProbabilityB.Length);
                Marshal.Copy(x.ProbabilityB, 0, y.probB, x.ProbabilityB.Length);
            }

            // Allocate model.label
            y.label = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.Labels.Length);
            Marshal.Copy(x.Labels, 0, y.label, x.Labels.Length);

            // Allocate model.nSV
            y.nSV = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.SVCounts.Length);
            Marshal.Copy(x.SVCounts, 0, y.nSV, x.SVCounts.Length);

            // Allocate model.sv_coef
            y.sv_coef = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)) * x.SVCoefs.Count);
            IntPtr i_ptr_svcoef = y.sv_coef;

            for (int i = 0; i < x.SVCoefs.Count; i++)
            {
                IntPtr temp = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.SVCoefs[i].Length);
                Marshal.Copy(x.SVCoefs[i], 0, temp, x.SVCoefs[i].Length);
                Marshal.StructureToPtr(temp, i_ptr_svcoef, true);
                i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr)));
            }

            // Allocate model.sv_indices
            y.sv_indices = IntPtr.Zero;
            if (x.SVIndices != null)
            {
                y.sv_indices = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.SVIndices.Length);
                Marshal.Copy(x.SVIndices, 0, y.sv_indices, x.SVIndices.Length);
            }

            // Allocate model.SV
            y.SV = IntPtr.Zero;
            if (x.SV != null)
            {
                y.SV = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)) * x.SV.Count);
                IntPtr i_ptr_sv = y.SV;
                for (int i = 0; i < x.SV.Count; i++)
                {
                    // Prepare each node array
                    // 1) All nodes containing zero value is removed
                    // 2) A node which index is -1 is added to the end
                    List <SVMNode> temp = x.SV[i].Where(a => a.Value != 0).ToList();
                    temp.Add(new SVMNode(-1, 0));
                    SVMNode[] nodes = temp.ToArray();

                    // Allocate node array
                    IntPtr ptr_nodes = SVMNode.Allocate(nodes);
                    Marshal.StructureToPtr(ptr_nodes, i_ptr_sv, true);

                    i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr)));
                }
            }

            // Allocate the model
            int    size = Marshal.SizeOf(y);
            IntPtr ptr  = Marshal.AllocHGlobal(size);

            Marshal.StructureToPtr(y, ptr, true);

            return(ptr);
        }
Пример #21
0
 /// <summary>
 /// Handle a model.
 /// </summary>
 /// <param name="xmlin">Where to read the model from.</param>
 /// <param name="model">Where to load the model into.</param>
 private void HandleModel(ReadXML xmlin, svm_model model)
 {
     while (xmlin.ReadToTag())
     {
         if (xmlin.IsIt(SVMNetworkPersistor.TAG_TYPE_SVM, true))
         {
             int i = EngineArray.FindStringInArray(
                 SVMNetworkPersistor.svm_type_table, xmlin.ReadTextToTag());
             model.param.svm_type = i;
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DEGREE, true))
         {
             model.param.degree = int.Parse(xmlin.ReadTextToTag());
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_GAMMA, true))
         {
             model.param.gamma = double.Parse(xmlin.ReadTextToTag());
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_COEF0, true))
         {
             model.param.coef0 = double.Parse(xmlin.ReadTextToTag());
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_NUMCLASS, true))
         {
             model.nr_class = int.Parse(xmlin.ReadTextToTag());
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_TOTALSV, true))
         {
             model.l = int.Parse(xmlin.ReadTextToTag());
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_RHO, true))
         {
             int n = model.nr_class * (model.nr_class - 1) / 2;
             model.rho = new double[n];
             String[] st = xmlin.ReadTextToTag().Split(',');
             for (int i = 0; i < n; i++)
             {
                 model.rho[i] = double.Parse(st[i]);
             }
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_LABEL, true))
         {
             int n = model.nr_class;
             model.label = new int[n];
             String[] st = xmlin.ReadTextToTag().Split(',');
             for (int i = 0; i < n; i++)
             {
                 model.label[i] = int.Parse(st[i]);
             }
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_PROB_A, true))
         {
             int n = model.nr_class * (model.nr_class - 1) / 2;
             model.probA = new double[n];
             String[] st = xmlin.ReadTextToTag().Split(',');
             for (int i = 0; i < n; i++)
             {
                 model.probA[i] = Double.Parse(st[i]);
             }
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_PROB_B, true))
         {
             int n = model.nr_class * (model.nr_class - 1) / 2;
             model.probB = new double[n];
             String[] st = xmlin.ReadTextToTag().Split(',');
             for (int i = 0; i < n; i++)
             {
                 model.probB[i] = Double.Parse(st[i]);
             }
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_NSV, true))
         {
             int n = model.nr_class;
             model.nSV = new int[n];
             String[] st = xmlin.ReadTextToTag().Split(',');
             for (int i = 0; i < n; i++)
             {
                 model.nSV[i] = int.Parse(st[i]);
             }
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_TYPE_KERNEL, true))
         {
             int i = EngineArray.FindStringInArray(
                 SVMNetworkPersistor.kernel_type_table, xmlin
                 .ReadTextToTag());
             model.param.kernel_type = i;
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DATA, true))
         {
             HandleData(xmlin, model);
         }
         else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODEL, false))
         {
             break;
         }
     }
 }
Пример #22
0
        private static List <KeyValuePair <int, int> > runSVMTest(SVMAdapter svmAdapter, string testPath, string logPath, Dictionary <string, int> dictionary, Dictionary <string, double> wordIDFDictionary, Hashtable stopWordTable, ref List <string> testFileNameList, svm_model model, NLPAdapter nlpAdapter)
        {
            string[] categories = Directory.GetDirectories(testPath);
            List <KeyValuePair <int, int> > testAnswer = new List <KeyValuePair <int, int> >();

            for (int i = 0; i < categories.Length; i++) //traverse Categories
            {
                Console.WriteLine(categories[i]);
                string[] files = Directory.GetFiles(categories[i]);
                for (int j = 0; j < files.Length; j++)
                {
                    int testResult = -1;
                    testFileNameList.Add(Path.GetFileName(files[j]));
                    testResult = svmAdapter.runSVMTest(readDoc(files[j], stopWordTable, nlpAdapter), dictionary, wordIDFDictionary, model);
                    testAnswer.Add(new KeyValuePair <int, int>(testResult, i));
                    Console.WriteLine(testResult + "," + i);
                }
            }

            return(testAnswer);
        }
Пример #23
0
        public static SVMModel Convert(svm_model x)
        {
            SVMModel y = new SVMModel();

            y.Creation     = (CreationType)x.free_sv;
            y.ClassCount   = x.nr_class;
            y.TotalSVCount = x.l;

            if (y.Creation == CreationType.LOAD_MODEL)
            {
                y.Parameter        = new SVMParameter();
                y.Parameter.Type   = (SVMType)x.param.svm_type;
                y.Parameter.Kernel = (SVMKernelType)x.param.kernel_type;
                switch (y.Parameter.Kernel)
                {
                case SVMKernelType.LINEAR:
                    break;

                case SVMKernelType.POLY:
                    y.Parameter.Gamma  = x.param.gamma;
                    y.Parameter.Coef0  = x.param.coef0;
                    y.Parameter.Degree = x.param.degree;
                    break;

                case SVMKernelType.RBF:
                    y.Parameter.Gamma = x.param.gamma;
                    break;

                case SVMKernelType.SIGMOID:
                    y.Parameter.Gamma = x.param.gamma;
                    y.Parameter.Coef0 = x.param.coef0;
                    break;
                }
            }
            else
            {
                y.Parameter = SVMParameter.Convert(x.param);
            }

            int problemCount = (int)(y.ClassCount * (y.ClassCount - 1) * 0.5);

            y.Rho = new double[problemCount];
            Marshal.Copy(x.rho, y.Rho, 0, y.Rho.Length);

            y.ProbabilityA = null;
            if (x.probA != IntPtr.Zero)
            {
                y.ProbabilityA = new double[problemCount];
                Marshal.Copy(x.probA, y.ProbabilityA, 0, y.ProbabilityA.Length);
            }

            y.ProbabilityB = null;
            if (x.probB != IntPtr.Zero)
            {
                y.ProbabilityB = new double[problemCount];
                Marshal.Copy(x.probB, y.ProbabilityB, 0, y.ProbabilityB.Length);
            }

            y.SVCounts = new int[y.ClassCount];
            Marshal.Copy(x.nSV, y.SVCounts, 0, y.SVCounts.Length);

            y.Labels = new int[y.ClassCount];
            Marshal.Copy(x.label, y.Labels, 0, y.Labels.Length);

            y.SVCoefs = new List <double[]>(y.ClassCount - 1);
            IntPtr i_ptr_svcoef = x.sv_coef;

            for (int i = 0; i < y.ClassCount - 1; i++)
            {
                y.SVCoefs.Add(new double[y.TotalSVCount]);
                IntPtr coef_ptr = (IntPtr)Marshal.PtrToStructure(i_ptr_svcoef, typeof(IntPtr));
                Marshal.Copy(coef_ptr, y.SVCoefs[i], 0, y.SVCoefs[i].Length);
                i_ptr_svcoef = IntPtr.Add(i_ptr_svcoef, Marshal.SizeOf(typeof(IntPtr)));
            }

            y.SVIndices = null;
            if (x.sv_indices != IntPtr.Zero)
            {
                y.SVIndices = new int[y.TotalSVCount];
                Marshal.Copy(x.sv_indices, y.SVIndices, 0, y.SVIndices.Length);
            }

            y.SV = new List <SVMNode[]>();
            IntPtr i_ptr_sv = x.SV;

            for (int i = 0; i < x.l; i++)
            {
                IntPtr    ptr_nodes = (IntPtr)Marshal.PtrToStructure(i_ptr_sv, typeof(IntPtr));
                SVMNode[] nodes     = SVMNode.Convert(ptr_nodes);
                y.SV.Add(nodes);
                i_ptr_sv = IntPtr.Add(i_ptr_sv, Marshal.SizeOf(typeof(IntPtr)));
            }

            return(y);
        }
Пример #24
0
	private static void  predict(System.IO.StreamReader input, System.IO.BinaryWriter output, svm_model model, int predict_probability)
	{
		int correct = 0;
		int total = 0;
		double error = 0;
		double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
		
		int svm_type = svm.svm_get_svm_type(model);
		int nr_class = svm.svm_get_nr_class(model);
		int[] labels = new int[nr_class];
		double[] prob_estimates = null;
		
		if (predict_probability == 1)
		{
			if (svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR)
			{
				System.Console.Out.Write("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + svm.svm_get_svr_probability(model) + "\n");
			}
			else
			{
				svm.svm_get_labels(model, labels);
				prob_estimates = new double[nr_class];
				//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
				output.Write("labels");
				for (int j = 0; j < nr_class; j++)
				{
					//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
					output.Write(" " + labels[j]);
				}
				//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
				output.Write("\n");
			}
		}
		while (true)
		{
			System.String line = input.ReadLine();
			if ((System.Object) line == null)
				break;
			
			SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:");
			
			double target = atof(st.NextToken());
			int m = st.Count / 2;
			svm_node[] x = new svm_node[m];
			for (int j = 0; j < m; j++)
			{
				x[j] = new svm_node();
				x[j].index = atoi(st.NextToken());
				x[j].value = atof(st.NextToken());
			}
			
			double v;
			if (predict_probability == 1 && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC))
			{
				v = svm.svm_predict_probability(model, x, prob_estimates);
				//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
				output.Write(v + " ");
				for (int j = 0; j < nr_class; j++)
				{
					//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
					output.Write(prob_estimates[j] + " ");
				}
				//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
				output.Write("\n");
			}
			else
			{
				v = svm.svm_predict(model, x);
				//UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"'
				output.Write(v + "\n");
			}
			
			if (v == target)
				++correct;
			error += (v - target) * (v - target);
			sumv += v;
			sumy += target;
			sumvv += v * v;
			sumyy += target * target;
			sumvy += v * target;
			++total;
		}
		System.Console.Out.Write("Accuracy = " + (double) correct / total * 100 + "% (" + correct + "/" + total + ") (classification)\n");
		System.Console.Out.Write("Mean squared error = " + error / total + " (regression)\n");
		System.Console.Out.Write("Squared correlation coefficient = " + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv * sumy)) / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy * sumy)) + " (regression)\n");
	}
Пример #25
0
        /// <inheritdoc/>
        public Object Read(Stream mask0)
        {
            var result = new SupportVectorMachine();
            var ins0   = new EncogReadHelper(mask0);
            EncogFileSection section;

            while ((section = ins0.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("SVM") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    IDictionary <String, String> paras = section.ParseParams();
                    EngineArray.PutAll(paras, result.Properties);
                }
                if (section.SectionName.Equals("SVM") &&
                    section.SubSectionName.Equals("SVM-PARAM"))
                {
                    IDictionary <String, String> p = section.ParseParams();
                    result.InputCount = EncogFileSection.ParseInt(p,
                                                                  PersistConst.InputCount);
                    result.Params.C = EncogFileSection.ParseDouble(p,
                                                                   ParamC);
                    result.Params.cache_size = EncogFileSection.ParseDouble(
                        p, ParamCacheSize);
                    result.Params.coef0 = EncogFileSection.ParseDouble(p,
                                                                       ParamCoef0);
                    result.Params.degree = EncogFileSection.ParseDouble(p,
                                                                        ParamDegree);
                    result.Params.eps = EncogFileSection.ParseDouble(p,
                                                                     ParamEps);
                    result.Params.gamma = EncogFileSection.ParseDouble(p,
                                                                       ParamGamma);
                    result.Params.kernel_type = EncogFileSection.ParseInt(
                        p, ParamKernelType);
                    result.Params.nr_weight = EncogFileSection.ParseInt(
                        p, ParamNumWeight);
                    result.Params.nu = EncogFileSection.ParseDouble(p,
                                                                    ParamNu);
                    result.Params.p = EncogFileSection.ParseDouble(p,
                                                                   ParamP);
                    result.Params.probability = EncogFileSection.ParseInt(
                        p, ParamProbability);
                    result.Params.shrinking = EncogFileSection.ParseInt(
                        p, ParamShrinking);

                    /*result.Params.statIterations = Encog.Persist.EncogFileSection.ParseInt(
                     *                                  params_0, PersistSVM.PARAM_START_ITERATIONS);*/
                    result.Params.svm_type = EncogFileSection.ParseInt(p,
                                                                       ParamSVMType);
                    result.Params.weight = EncogFileSection.ParseDoubleArray(
                        p, ParamWeight);
                    result.Params.weight_label = EncogFileSection
                                                 .ParseIntArray(p, ParamWeightLabel);
                }
                else if (section.SectionName.Equals("SVM") &&
                         section.SubSectionName.Equals("SVM-MODEL"))
                {
                    try
                    {
#if !SILVERLIGHT
                        var rdr = new StringReader(
                            section.LinesAsString);
                        TextReader br    = rdr;
                        svm_model  model = svm.svm_load_model(rdr);
                        result.Model = model;
                        br.Close();
                        rdr.Close();
#endif
                    }
                    catch (IOException ex)
                    {
                        throw new PersistError(ex);
                    }
                }
            }

            return(result);
        }
Пример #26
0
        /// <summary>
        /// Save a model.
        /// </summary>
        /// <param name="xmlout">Where to save a model to.</param>
        /// <param name="model">The model to save to.</param>
        public static void SaveModel(WriteXML xmlout, svm_model model)
        {
            if (model != null)
            {
                xmlout.BeginTag(SVMNetworkPersistor.TAG_MODEL);

                svm_parameter param = model.param;

                xmlout.AddProperty(SVMNetworkPersistor.TAG_TYPE_SVM,
                                   svm_type_table[param.svm_type]);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_TYPE_KERNEL,
                                   kernel_type_table[param.kernel_type]);

                if (param.kernel_type == svm_parameter.POLY)
                {
                    xmlout.AddProperty(SVMNetworkPersistor.TAG_DEGREE, param.degree);
                }

                if (param.kernel_type == svm_parameter.POLY ||
                    param.kernel_type == svm_parameter.RBF ||
                    param.kernel_type == svm_parameter.SIGMOID)
                {
                    xmlout.AddProperty(SVMNetworkPersistor.TAG_GAMMA, param.gamma);
                }

                if (param.kernel_type == svm_parameter.POLY ||
                    param.kernel_type == svm_parameter.SIGMOID)
                {
                    xmlout.AddProperty(SVMNetworkPersistor.TAG_COEF0, param.coef0);
                }

                int nr_class = model.nr_class;
                int l        = model.l;

                xmlout.AddProperty(SVMNetworkPersistor.TAG_NUMCLASS, nr_class);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_TOTALSV, l);

                xmlout.AddProperty(SVMNetworkPersistor.TAG_RHO, model.rho, nr_class
                                   * (nr_class - 1) / 2);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_LABEL, model.label,
                                   nr_class);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_PROB_A, model.probA,
                                   nr_class * (nr_class - 1) / 2);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_PROB_B, model.probB,
                                   nr_class * (nr_class - 1) / 2);
                xmlout.AddProperty(SVMNetworkPersistor.TAG_NSV, model.nSV, nr_class);

                xmlout.BeginTag(SVMNetworkPersistor.TAG_DATA);

                double[][]   sv_coef = model.sv_coef;
                svm_node[][] SV      = model.SV;

                StringBuilder line = new StringBuilder();
                for (int i = 0; i < l; i++)
                {
                    line.Length = 0;
                    for (int j = 0; j < nr_class - 1; j++)
                    {
                        line.Append(sv_coef[j][i] + " ");
                    }

                    svm_node[] p = SV[i];
                    //if (param.kernel_type == svm_parameter.PRECOMPUTED)
                    //{
                    //  line.Append("0:" + (int) (p[0].value));
                    //}
                    //else
                    for (int j = 0; j < p.Length; j++)
                    {
                        line.Append(p[j].index + ":" + p[j].value_Renamed + " ");
                    }
                    xmlout.AddProperty(SVMNetworkPersistor.TAG_ROW, line.ToString());
                }

                xmlout.EndTag();
                xmlout.EndTag();
            }
        }
Пример #27
0
        public int runSVMTest(Dictionary <string, double> docWord, Dictionary <string, int> dictionary, Dictionary <string, double> wordIDFDictionary, svm_model model)
        {
            List <KeyValuePair <int, int> > result = new List <KeyValuePair <int, int> >();

            // generate svm nodes
            List <KeyValuePair <string, string> > nodeList = new List <KeyValuePair <string, string> >();
            List <svm_node> nodes = new List <svm_node>();

            foreach (string word in docWord.Keys)
            {
                if (dictionary.ContainsKey(word))
                {
                    int    index = dictionary[word];
                    double TF    = docWord[word];
                    double IDF   = wordIDFDictionary[word];
                    double value = TF * IDF;
                    nodes.Add(new svm_node() // svm node
                    {
                        index = index,
                        value = value,
                    });
                    nodeList.Add(new KeyValuePair <string, string>(System.Convert.ToString(index), System.Convert.ToString(value)));
                    //trainStr = trainStr + "\t" + index + ":" + value;
                }
            }

            if (nodeList.Count > 0)
            {
                // sort the list by feature index at first
                nodeList.Sort(
                    delegate(KeyValuePair <string, string> firstPair,
                             KeyValuePair <string, string> nextPair)
                {
                    int a = int.Parse(firstPair.Key);
                    int b = int.Parse(nextPair.Key);

                    return(a.CompareTo(b));
                }
                    );

                for (int k = 0; k < nodeList.Count; k++)
                {
                    KeyValuePair <string, string> node = nodeList[k];
                    String index = node.Key;
                    String value = node.Value;
                }
            }

            int resValue = (int)svm.svm_predict(model, nodes.ToArray());

            return(resValue);
        }
Пример #28
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void trainInternal(java.util.LinkedHashMap<String, String> libOptions) throws org.maltparser.core.exception.MaltChainedException
        protected internal override void trainInternal(LinkedHashMap <string, string> libOptions)
        {
            try
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
                svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_parameter param = getLibSvmParameters(libOptions);
                svm_parameter param = getLibSvmParameters(libOptions);
                if (svm.svm_check_parameter(prob, param) != null)
                {
                    throw new LibException(svm.svm_check_parameter(prob, param));
                }
                Configuration config = Configuration;

                if (config.LoggerInfoEnabled)
                {
                    config.logInfoMessage("Creating LIBSVM model " + getFile(".moo").Name + "\n");
                }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.PrintStream out = System.out;
                PrintStream @out = System.out;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.PrintStream err = System.err;
                PrintStream err = System.err;
                System.Out = NoPrintStream.NO_PRINTSTREAM;
                System.Err = NoPrintStream.NO_PRINTSTREAM;
                svm_model model = svm.svm_train(prob, param);
                System.Out = err;
                System.Out = @out;
                ObjectOutputStream output = new ObjectOutputStream(new BufferedOutputStream(new FileStream(getFile(".moo").AbsolutePath, FileMode.Create, FileAccess.Write)));
                try
                {
                    output.writeObject(new MaltLibsvmModel(model, prob));
                }
                finally
                {
                    output.close();
                }
                bool saveInstanceFiles = ((bool?)Configuration.getOptionValue("lib", "save_instance_files")).Value;
                if (!saveInstanceFiles)
                {
                    getFile(".ins").delete();
                }
            }
            catch (OutOfMemoryException e)
            {
                throw new LibException("Out of memory. Please increase the Java heap size (-Xmx<size>). ", e);
            }
            catch (ArgumentException e)
            {
                throw new LibException("The LIBSVM learner was not able to redirect Standard Error stream. ", e);
            }
            catch (SecurityException e)
            {
                throw new LibException("The LIBSVM learner cannot remove the instance file. ", e);
            }
            catch (IOException e)
            {
                throw new LibException("The LIBSVM learner cannot save the model file '" + getFile(".mod").AbsolutePath + "'. ", e);
            }
        }
Пример #29
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void trainExternal(String pathExternalTrain, java.util.LinkedHashMap<String, String> libOptions) throws org.maltparser.core.exception.MaltChainedException
        protected internal override void trainExternal(string pathExternalTrain, LinkedHashMap <string, string> libOptions)
        {
            try
            {
                binariesInstances2SVMFileFormat(getInstanceInputStreamReader(".ins"), getInstanceOutputStreamWriter(".ins.tmp"));
                Configuration config = Configuration;

                if (config.LoggerInfoEnabled)
                {
                    config.logInfoMessage("Creating learner model (external) " + getFile(".mod").Name);
                }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
                svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String[] params = getLibParamStringArray(libOptions);
                string[] @params       = getLibParamStringArray(libOptions);
                string[] arrayCommands = new string[@params.Length + 3];
                int      i             = 0;
                arrayCommands[i++] = pathExternalTrain;
                for (; i <= @params.Length; i++)
                {
                    arrayCommands[i] = @params[i - 1];
                }
                arrayCommands[i++] = getFile(".ins.tmp").AbsolutePath;
                arrayCommands[i++] = getFile(".mod").AbsolutePath;

                if (verbosity == Verbostity.ALL)
                {
                    config.logInfoMessage('\n');
                }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Process child = Runtime.getRuntime().exec(arrayCommands);
                Process child = Runtime.Runtime.exec(arrayCommands);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.InputStream in = child.getInputStream();
                Stream @in = child.InputStream;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.InputStream err = child.getErrorStream();
                Stream err = child.ErrorStream;
                int    c;
                while ((c = @in.Read()) != -1)
                {
                    if (verbosity == Verbostity.ALL)
                    {
                        config.logInfoMessage((char)c);
                    }
                }
                while ((c = err.Read()) != -1)
                {
                    if (verbosity == Verbostity.ALL || verbosity == Verbostity.ERROR)
                    {
                        config.logInfoMessage((char)c);
                    }
                }
                if (child.waitFor() != 0)
                {
                    config.logErrorMessage(" FAILED (" + child.exitValue() + ")");
                }
                @in.Close();
                err.Close();
                svm_model          model  = svm.svm_load_model(getFile(".mod").AbsolutePath);
                MaltLibsvmModel    xmodel = new MaltLibsvmModel(model, prob);
                ObjectOutputStream output = new ObjectOutputStream(new BufferedOutputStream(new FileStream(getFile(".moo").AbsolutePath, FileMode.Create, FileAccess.Write)));
                try
                {
                    output.writeObject(xmodel);
                }
                finally
                {
                    output.close();
                }
                bool saveInstanceFiles = ((bool?)Configuration.getOptionValue("lib", "save_instance_files")).Value;
                if (!saveInstanceFiles)
                {
                    getFile(".ins").delete();
                    getFile(".mod").delete();
                    getFile(".ins.tmp").delete();
                }
                if (config.LoggerInfoEnabled)
                {
                    config.logInfoMessage('\n');
                }
            }
            catch (InterruptedException e)
            {
                throw new LibException("Learner is interrupted. ", e);
            }
            catch (ArgumentException e)
            {
                throw new LibException("The learner was not able to redirect Standard Error stream. ", e);
            }
            catch (SecurityException e)
            {
                throw new LibException("The learner cannot remove the instance file. ", e);
            }
            catch (IOException e)
            {
                throw new LibException("The learner cannot save the model file '" + getFile(".mod").AbsolutePath + "'. ", e);
            }
            catch (OutOfMemoryException e)
            {
                throw new LibException("Out of memory. Please increase the Java heap size (-Xmx<size>). ", e);
            }
        }
 public SupportVectorMachineModel(svm_model model, RangeTransform rangeTransform, string targetVariable, IEnumerable <string> allowedInputVariables, IEnumerable <double> classValues)
     : this(model, rangeTransform, targetVariable, allowedInputVariables)
 {
     this.classValues = classValues.ToArray();
 }