Iris Class 
Namespace: Accord.DataSets
The Iris type exposes the following members.
Name  Description  

ClassLabels 
Gets the class labels associated with each instance
in Fisher's Iris flower dataset.
 
ClassNames 
Gets the class labels in Fisher's Iris flower dataset:
"Iris  setosa", "Iris  versicolor", and "Iris  virginica".
 
Instances 
Gets the data instances contained in Fisher's Iris flower dataset.
 
VariableNames 
Gets the variable names in Fisher's Iris flower dataset:
"Sepal length", "Sepal width", "Petal length", and "Petal width".

Name  Description  

Equals  Determines whether the specified object is equal to the current object. (Inherited from Object.)  
Finalize  Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)  
GetHashCode  Serves as the default hash function. (Inherited from Object.)  
GetType  Gets the Type of the current instance. (Inherited from Object.)  
MemberwiseClone  Creates a shallow copy of the current Object. (Inherited from Object.)  
ToString  Returns a string that represents the current object. (Inherited from Object.) 
Name  Description  

HasMethod 
Checks whether an object implements a method with the given name.
(Defined by ExtensionMethods.)  
IsEqual 
Compares two objects for equality, performing an elementwise
comparison if the elements are vectors or matrices.
(Defined by Matrix.)  
To(Type)  Overloaded.
Converts an object into another type, irrespective of whether
the conversion can be done at compile time or not. This can be
used to convert generic types to numeric types during runtime.
(Defined by ExtensionMethods.)  
ToT  Overloaded.
Converts an object into another type, irrespective of whether
the conversion can be done at compile time or not. This can be
used to convert generic types to numeric types during runtime.
(Defined by ExtensionMethods.) 
The Iris flower data set or Fisher's Iris data set is a multivariate data set introduced by Ronald Fisher in his 1936 paper The use of multiple measurements in taxonomic problems as an example of linear discriminant analysis. It is sometimes called Anderson's Iris data set because Edgar Anderson collected the data to quantify the morphologic variation of Iris flowers of three related species. Two of the three species were collected in the Gaspé Peninsula "all from the same pasture, and picked on the same day and measured at the same time by the same person with the same apparatus".
The data set consists of 50 samples from each of three species of Iris(Iris setosa, Iris virginica and Iris versicolor). Four features were measured from each sample: the length and the width of the sepals and petals, in centimetres. Based on the combination of these four features, Fisher developed a linear discriminant model to distinguish the species from each other.
References:
The following example shows how to download and train a classifier (SVM) in the Iris dataset:
// Generate always same random numbers Accord.Math.Random.Generator.Seed = 0; // Let's say we would like to learn a classifier for the famous Iris // dataset, and measure its performance using a GeneralConfusionMatrix // Download and load the Iris dataset var iris = new Iris(); double[][] inputs = iris.Instances; int[] outputs = iris.ClassLabels; // Create the multiclass learning algorithm for the machine var teacher = new MulticlassSupportVectorLearning<Linear>() { // Configure the learning algorithm to use SMO to train the // underlying SVMs in each of the binary class subproblems. Learner = (param) => new SequentialMinimalOptimization<Linear>() { // If you would like to use other kernels, simply replace // the generic parameter to the desired kernel class, such // as for example, Polynomial or Gaussian: Kernel = new Linear() // use the Linear kernel } }; // Estimate the multiclass support vector machine using onevsone method MulticlassSupportVectorMachine<Linear> ovo = teacher.Learn(inputs, outputs); // Compute classification error GeneralConfusionMatrix cm = GeneralConfusionMatrix.Estimate(ovo, inputs, outputs); double error = cm.Error; // should be 0.066666666666666652 double accuracy = cm.Accuracy; // should be 0.93333333333333335 double kappa = cm.Kappa; // should be 0.9 double chiSquare = cm.ChiSquare; // should be 248.52216748768473
The next example shows how to learn a minibatch classifier for the Iris dataset:
// In this example, we will learn a multiclass SVM using the onevsone (OvO) // approach. The OvO approacbh can decompose decision problems involving multiple // classes into a series of binary ones, which can then be solved using SVMs. // Ensure we have reproducible results Accord.Math.Random.Generator.Seed = 0; // We will try to learn a classifier // for the Fisher Iris Flower dataset var iris = new Iris(); double[][] inputs = iris.Instances; // get the flower characteristics int[] outputs = iris.ClassLabels; // get the expected flower classes // We will use minibatches of size 32 to learn a SVM using SGD var batches = MiniBatches.Create(batchSize: 32, maxIterations: 1000, shuffle: ShuffleMethod.EveryEpoch, input: inputs, output: outputs); // Now, we can create a multiclass teaching algorithm for the SVMs var teacher = new MulticlassSupportVectorLearning<Linear, double[]> { // We will use SGD to learn each of the binary problems in the multiclass problem Learner = (p) => new AveragedStochasticGradientDescent<Linear, double[], LogisticLoss>() { LearningRate = 1e3, MaxIterations = 1 // so the gradient is only updated once after each minibatch } }; // The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism) // Now, we can start training the model on minibatches: foreach (var batch in batches) { teacher.Learn(batch.Inputs, batch.Outputs); } // Get the final model: var svm = teacher.Model; // Now, we should be able to use the model to predict // the classes of all flowers in Fisher's Iris dataset: int[] prediction = svm.Decide(inputs); // And from those predictions, we can compute the model accuracy: var cm = new GeneralConfusionMatrix(expected: outputs, predicted: prediction); double accuracy = cm.Accuracy; // should be approximately 0.973