machine-learning
वर्गीकरण का एक परिचय: वीका का उपयोग करके कई मॉडल बनाना

परिचय

आरंभ करना: फ़ाइल से डेटासेट लोड करना

Iris फूल डेटा सेट प्रदर्शन उद्देश्यों के लिए व्यापक रूप से उपयोग किया जाने वाला डेटा सेट है। हम इसे लोड करेंगे, इसका निरीक्षण करेंगे और बाद में उपयोग के लिए इसे थोड़ा संशोधित करेंगे।

import java.io.File;
import java.net.URL;
import weka.core.Instances;
import weka.core.converters.ArffSaver;
import weka.core.converters.CSVLoader;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.RenameAttribute;
import weka.classifiers.evaluation.Evaluation;
import weka.classifiers.rules.ZeroR;
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.lazy.IBk;
import weka.classifiers.trees.J48;
import weka.classifiers.meta.AdaBoostM1;

public class IrisExperiments {
    public static void main(String args[]) throws Exception
     {
        //First we open stream to a data set as provided on http://archive.ics.uci.edu
         CSVLoader loader = new CSVLoader();
         loader.setSource(new URL("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data").openStream());
         Instances data = loader.getDataSet();
         
         //This file has 149 examples with 5 attributes
         //In order:
         //  sepal length in cm
         //  sepal width in cm
         //  petal length in cm 
         //  petal width in cm
         //  class ( Iris Setosa , Iris Versicolour, Iris Virginica)

         //Let's briefly inspect the data
         System.out.println("This file has " + data.numInstances()+" examples.");
         System.out.println("The first example looks like this: ");
         for(int i = 0; i < data.instance(0).numAttributes();i++ ){
             System.out.println(data.instance(0).attribute(i));
         } 
         
         // NOTE that the last attribute is Nominal
         // It is convention to have a nominal variable at the last index as target variable
         
         // Let's tidy up the data a little bit
         // Nothing too serious just to show how we can manipulate the data with filters
         RenameAttribute renamer = new RenameAttribute();
         renamer.setOptions(weka.core.Utils.splitOptions("-R last -replace Iris-type"));
         renamer.setInputFormat(data);                          
         data = Filter.useFilter(data, renamer); 
         
         System.out.println("We changed the name of the target class.");
         System.out.println("And now it looks like this:");
         System.out.println(data.instance(0).attribute(4));
         
         //Now we do this for all the attributes
         renamer.setOptions(weka.core.Utils.splitOptions("-R 1 -replace sepal-length"));
         renamer.setInputFormat(data);                          
         data = Filter.useFilter(data, renamer); 
         
         renamer.setOptions(weka.core.Utils.splitOptions("-R 2 -replace sepal-width"));
         renamer.setInputFormat(data);                          
         data = Filter.useFilter(data, renamer); 
         
         renamer.setOptions(weka.core.Utils.splitOptions("-R 3 -replace petal-length"));
         renamer.setInputFormat(data);                          
         data = Filter.useFilter(data, renamer); 
         
         renamer.setOptions(weka.core.Utils.splitOptions("-R 4 -replace petal-width"));
         renamer.setInputFormat(data);                          
         data = Filter.useFilter(data, renamer); 
         
         //Lastly we save our newly created file to disk
         ArffSaver saver = new ArffSaver();
         saver.setInstances(data);
         saver.setFile(new File("IrisSet.arff"));
         saver.writeBatch();
  }
}

पहले क्लासिफायर ट्रेन करें: ज़ीरो के साथ एक बेसलाइन सेट करना

ZeroR एक साधारण क्लासिफायरियर है। यह कक्षाओं के सामान्य वितरण पर संचालित होने के बजाय प्रति उदाहरण संचालित नहीं होता है। यह वर्ग को सबसे बड़ी प्राथमिकता के साथ चयन करता है। यह इस अर्थ में एक अच्छा क्लासिफायर नहीं है कि यह उम्मीदवार में किसी भी जानकारी का उपयोग नहीं करता है, लेकिन इसका उपयोग अक्सर आधार रेखा के रूप में किया जाता है। नोट: अन्य बेसलाइन का उपयोग aswel के रूप में किया जा सकता है, जैसे: उद्योग मानक क्लासिफायर या दस्तकारी नियम

 // First we tell our data that it's class is hidden in the last attribute
 data.setClassIndex(data.numAttributes() -1);
 // Then we split the data in to two sets
 // randomize first because we don't want unequal distributions
 data.randomize(new java.util.Random(0));
 Instances testset = new Instances(data, 0, 50);
 Instances trainset = new Instances(data, 50, 99);
 
 // Now we build a classifier
 // Train it with the trainset
 ZeroR classifier1 = new ZeroR();
 classifier1.buildClassifier(trainset);
 // Next we test it against the testset
 Evaluation Test = new Evaluation(trainset);
 Test.evaluateModel(classifier1, testset);
 System.out.println(Test.toSummaryString());

सेट में सबसे बड़ा वर्ग आपको 34% सही दर देता है। (149 में से 50)

नोट: ZeroR लगभग 30% प्रदर्शन करता है। ऐसा इसलिए है क्योंकि हमने ट्रेन और परीक्षण सेट में बेतरतीब ढंग से विभाजन किया है। ट्रेन सेट में सबसे बड़ा सेट, इस प्रकार परीक्षण सेट में सबसे छोटा होगा। एक अच्छा परीक्षण / ट्रेन सेट तैयार करना आपके समय के लायक हो सकता है

डेटा के लिए एक महसूस हो रही है। प्रशिक्षण नैवे बे और केएनएन

एक अच्छा क्लासिफायरियर बनाने के लिए हमें अक्सर इस बात का अंदाजा लगाना होगा कि फीचर स्पेस में डेटा को कैसे संरचित किया जाता है। वीका एक दृश्य मॉड्यूल प्रदान करता है जो मदद कर सकता है।

कुछ आयाम पहले से ही कक्षाओं को काफी अच्छी तरह से अलग करते हैं। पंखुड़ी-चौड़ाई अवधारणा को बड़े करीने से आदेश देती है, जब उदाहरण के लिए पंखुड़ी-चौड़ाई की तुलना में।

प्रशिक्षण सरल क्लासिफायरियर डेटा की संरचना के बारे में काफी कुछ प्रकट कर सकते हैं। मैं आमतौर पर उस उद्देश्य के लिए नियरेस्ट नेबर और नैवे बे का उपयोग करना पसंद करता हूं। Naive Bayes स्वतंत्रता को मानता है, यह अच्छा प्रदर्शन एक संकेत है कि आयाम अपने आप में जानकारी रखते हैं। k- निकटतम-पड़ोसी सुविधा स्थान में k निकटतम (ज्ञात) उदाहरणों के वर्ग को असाइन करके काम करता है। इसका उपयोग अक्सर स्थानीय भौगोलिक निर्भरता की जांच करने के लिए किया जाता है, हम इसका उपयोग यह जांचने के लिए करेंगे कि क्या हमारी अवधारणा को स्थानीय रूप से फीचर स्पेस में परिभाषित किया गया है।

 //Now we build a Naive Bayes classifier
 NaiveBayes classifier2 = new NaiveBayes();
 classifier2.buildClassifier(trainset);
 // Next we test it against the testset
 Test = new Evaluation(trainset);
 Test.evaluateModel(classifier2, testset);
 System.out.println(Test.toSummaryString());
 
//Now we build a kNN classifier
IBk classifier3 = new IBk();
// We tell the classifier to use the first nearest neighbor as example 
classifier3.setOptions(weka.core.Utils.splitOptions("-K 1"));
classifier3.buildClassifier(trainset);
// Next we test it against the testset
Test = new Evaluation(trainset);
Test.evaluateModel(classifier3, testset);
System.out.println(Test.toSummaryString());

Naive Bayes हमारे हौसले से स्थापित बेसलाइन की तुलना में बहुत बेहतर प्रदर्शन करता है, यह संकेत देते हुए कि स्वतंत्र सुविधाएँ सूचना को याद रखती हैं (याद रखें पेटल-चौड़ाई?)।

1NN अच्छा प्रदर्शन करता है (वास्तव में इस मामले में थोड़ा बेहतर), यह दर्शाता है कि हमारी कुछ जानकारी स्थानीय है। बेहतर प्रदर्शन यह संकेत दे सकता है कि कुछ दूसरे आदेश प्रभाव भी जानकारी रखते हैं (यदि वर्ग z की तुलना में x और y) ।

इसे एक साथ रखना: एक पेड़ को प्रशिक्षित करना

पेड़ ऐसे मॉडल बना सकते हैं जो स्वतंत्र सुविधाओं पर और दूसरे क्रम के प्रभावों पर काम करते हैं। इसलिए वे इस डोमेन के लिए अच्छे उम्मीदवार हो सकते हैं। पेड़ नियम हैं जो एक साथ जकड़ते हैं, एक नियम ऐसे उदाहरणों को विभाजित करता है जो उप-समूहों में एक नियम पर पहुंचते हैं, जो नियम के तहत नियमों से गुजरते हैं।

ट्री लर्नर नियम बनाते हैं, उन्हें एक साथ चेन करते हैं और जब वे नियमों को बहुत विशिष्ट मानते हैं, तो ओवरफिटिंग से बचने के लिए पेड़ों का निर्माण बंद कर देते हैं। ओवरफिटिंग का मतलब उस मॉडल का निर्माण करना है जो उस अवधारणा के लिए बहुत जटिल है जिसे हम खोज रहे हैं। ओवरफिटेड मॉडल ट्रेन डेटा पर अच्छा प्रदर्शन करते हैं, लेकिन नए डेटा पर खराब

हम J4 का उपयोग करते हैं, C4.5 का एक JAVA कार्यान्वयन एक लोकप्रिय एल्गोरिथ्म है।

//We train a tree using J48
//J48 is a JAVA implementation of the C4.5 algorithm
J48 classifier4 = new J48();
//We set it's confidence level to 0.1
//The confidence level tell J48 how specific a rule can be before it gets pruned
classifier4.setOptions(weka.core.Utils.splitOptions("-C 0.1"));
classifier4.buildClassifier(trainset);
// Next we test it against the testset
Test = new Evaluation(trainset);
Test.evaluateModel(classifier4, testset);
System.out.println(Test.toSummaryString());

System.out.print(classifier4.toString());

//We set it's confidence level to 0.5
//Allowing the tree to maintain more complex rules
classifier4.setOptions(weka.core.Utils.splitOptions("-C 0.5"));
classifier4.buildClassifier(trainset);
// Next we test it against the testset
Test = new Evaluation(trainset);
Test.evaluateModel(classifier4, testset);
System.out.println(Test.toSummaryString());
     
System.out.print(classifier4.toString());

उच्चतम विश्वास के साथ प्रशिक्षित पेड़ सीखने वाला सबसे विशिष्ट नियम बनाता है, और परीक्षण सेट पर सबसे अच्छा प्रदर्शन होता है, विशेष रूप से विशिष्टता का वारंट होता है।

नोट: दोनों शिक्षार्थी पंखुड़ी-चौड़ाई पर एक नियम से शुरू करते हैं। याद रखें कि हमने दृश्य में इस आयाम को कैसे देखा?