Example #1
0
		/// <summary> Sets the format of the input instances.
		/// 
		/// </summary>
		/// <param name="instanceInfo">an Instances object containing the input instance
		/// structure (any instances contained in the object are ignored - only the
		/// structure is required).
		/// </param>
		/// <returns> true if the outputFormat may be collected immediately
		/// </returns>
		/// <exception cref="Exception">if the format couldn't be set successfully
		/// </exception>
		public override bool setInputFormat(Instances instanceInfo)
		{
			
			base.setInputFormat(instanceInfo);
			
			m_SelectCols.Upper = instanceInfo.numAttributes() - 1;
			
			// Create the output buffer
			FastVector attributes = new FastVector();
			int outputClass = - 1;
			m_SelectedAttributes = m_SelectCols.Selection;
			int inStrKeepLen = 0;
			int[] inStrKeep = new int[m_SelectedAttributes.Length];
			for (int i = 0; i < m_SelectedAttributes.Length; i++)
			{
				int current = m_SelectedAttributes[i];
				if (instanceInfo.classIndex() == current)
				{
					outputClass = attributes.size();
				}
				Attribute keep = (Attribute) instanceInfo.attribute(current).copy();
				if (keep.type() == Attribute.STRING)
				{
					inStrKeep[inStrKeepLen++] = current;
				}
				attributes.addElement(keep);
			}
			m_InputStringIndex = new int[inStrKeepLen];
			Array.Copy(inStrKeep, 0, m_InputStringIndex, 0, inStrKeepLen);
			Instances outputFormat = new Instances(instanceInfo.relationName(), attributes, 0);
			outputFormat.ClassIndex = outputClass;
			setOutputFormat(outputFormat);
			return true;
		}
Example #2
0
		/// <summary> Calculates the cumulative margin distribution for the set of
		/// predictions, returning the result as a set of Instances. The
		/// structure of these Instances is as follows:<p> <ul> 
		/// <li> <b>Margin</b> contains the margin value (which should be plotted
		/// as an x-coordinate) 
		/// <li> <b>Current</b> contains the count of instances with the current 
		/// margin (plot as y axis)
		/// <li> <b>Cumulative</b> contains the count of instances with margin
		/// less than or equal to the current margin (plot as y axis)
		/// </ul> <p>
		/// 
		/// </summary>
		/// <returns> datapoints as a set of instances, null if no predictions
		/// have been made.  
		/// </returns>
		public virtual Instances getCurve(FastVector predictions)
		{
			
			if (predictions.size() == 0)
			{
				return null;
			}
			
			Instances insts = makeHeader();
			double[] margins = getMargins(predictions);
			int[] sorted = Utils.sort(margins);
			int binMargin = 0;
			int totalMargin = 0;
			insts.add(makeInstance(- 1, binMargin, totalMargin));
			for (int i = 0; i < sorted.Length; i++)
			{
				double current = margins[sorted[i]];
				double weight = ((NominalPrediction) predictions.elementAt(sorted[i])).weight();
				totalMargin = (int) (totalMargin + weight);
				binMargin = (int) (binMargin + weight);
				if (true)
				{
					insts.add(makeInstance(current, binMargin, totalMargin));
					binMargin = 0;
				}
			}
			return insts;
		}
Example #3
0
		/// <summary> Calculates the performance stats for the desired class and return 
		/// results as a set of Instances.
		/// 
		/// </summary>
		/// <param name="classIndex">index of the class of interest.
		/// </param>
		/// <returns> datapoints as a set of instances.
		/// </returns>
		public virtual Instances getCurve(FastVector predictions, int classIndex)
		{
			
			if ((predictions.size() == 0) || (((NominalPrediction) predictions.elementAt(0)).distribution().Length <= classIndex))
			{
				return null;
			}
			
			ThresholdCurve tc = new ThresholdCurve();
			Instances threshInst = tc.getCurve(predictions, classIndex);
			
			Instances insts = makeHeader();
			int fpind = threshInst.attribute(ThresholdCurve.FP_RATE_NAME).index();
			int tpind = threshInst.attribute(ThresholdCurve.TP_RATE_NAME).index();
			int threshind = threshInst.attribute(ThresholdCurve.THRESHOLD_NAME).index();
			
			double[] vals;
			double fpval, tpval, thresh;
			for (int i = 0; i < threshInst.numInstances(); i++)
			{
				fpval = threshInst.instance(i).value_Renamed(fpind);
				tpval = threshInst.instance(i).value_Renamed(tpind);
				thresh = threshInst.instance(i).value_Renamed(threshind);
				vals = new double[3];
				vals[0] = 0; vals[1] = fpval; vals[2] = thresh;
				insts.add(new Instance(1.0, vals));
				vals = new double[3];
				vals[0] = 1; vals[1] = 1.0 - tpval; vals[2] = thresh;
				insts.add(new Instance(1.0, vals));
			}
			
			return insts;
		}
        public void WriteFile(List <List <string> > numericDataset, string file, List <string> atrNames, List <string> targetValues, bool isTargetNumeric)
        {
            weka.core.FastVector targetVals = new weka.core.FastVector();

            weka.core.Instances dataRel;

            for (int i = 0; i < targetValues.Count; i++)
            {
                targetVals.addElement(targetValues[i]);
            }

            weka.core.Instances  data;
            weka.core.FastVector atts = new weka.core.FastVector();

            // fill and prepare the dataset for the arrf file
            for (int j = 0; j < insts.numAttributes(); j++)
            {
                if (j == insts.numAttributes() - 1 && isTargetNumeric == false) // target value can be nominal
                {
                    atts.addElement(new weka.core.Attribute(atrNames[j], targetVals));
                }
                else
                {
                    atts.addElement(new weka.core.Attribute(atrNames[j]));
                }
            }

            data = new weka.core.Instances("MyRelation", atts, 0);

            for (int i = 0; i < insts.numInstances(); i++)
            {
                double[] vals = new double[insts.numAttributes()];

                for (int j = 0; j < insts.numAttributes(); j++)
                {
                    if (j == insts.numAttributes() - 1 && isTargetNumeric == false) // target value can be nominal
                    {
                        vals[j] = targetVals.indexOf(numericDataset[j][i]);
                    }
                    else
                    {
                        vals[j] = Convert.ToDouble(numericDataset[j][i]);
                    }
                }

                data.add(new weka.core.DenseInstance(1.0, vals));
            }

            if (File.Exists(file))
            {
                File.Delete(file);
            }

            var saver = new weka.core.converters.ArffSaver();

            saver.setInstances(data);
            saver.setFile(new java.io.File(file));
            // files are saved into {AppFolder}/bin/Debug folder. You can find two files in this path.
            saver.writeBatch();
        }
Example #5
0
		/// <summary> Calculates the performance stats for the default class and return 
		/// results as a set of Instances. The
		/// structure of these Instances is as follows:<p> <ul> 
		/// <li> <b>Probability Cost Function </b>
		/// <li> <b>Normalized Expected Cost</b>
		/// <li> <b>Threshold</b> contains the probability threshold that gives
		/// rise to the previous performance values. 
		/// </ul> <p>
		/// 
		/// </summary>
		/// <seealso cref="TwoClassStats">
		/// </seealso>
		/// <param name="classIndex">index of the class of interest.
		/// </param>
		/// <returns> datapoints as a set of instances, null if no predictions
		/// have been made.
		/// </returns>
		public virtual Instances getCurve(FastVector predictions)
		{
			
			if (predictions.size() == 0)
			{
				return null;
			}
			return getCurve(predictions, ((NominalPrediction) predictions.elementAt(0)).distribution().Length - 1);
		}
Example #6
0
		/// <summary> Pulls all the margin values out of a vector of NominalPredictions.
		/// 
		/// </summary>
		/// <param name="predictions">a FastVector containing NominalPredictions
		/// </param>
		/// <returns> an array of margin values.
		/// </returns>
		private double[] getMargins(FastVector predictions)
		{
			
			// sort by predicted probability of the desired class.
			double[] margins = new double[predictions.size()];
			for (int i = 0; i < margins.Length; i++)
			{
				NominalPrediction pred = (NominalPrediction) predictions.elementAt(i);
				margins[i] = pred.margin();
			}
			return margins;
		}
        public void TestCreationOfEnums()
        {
            // Arrange
            var values = new weka.core.FastVector();
            values.addElement("beech");
            values.addElement("oak");
            values.addElement("ash");

            var attribute = new weka.core.Attribute("trees", values);
            var repo = new EnumRepository();

            // Act
            var enumValue = repo.GetEnumValue(attribute, 0);

            // Assert
            var fields = enumValue.GetType().GetFields();
            Assert.AreEqual(3, fields.Length);
            Assert.AreEqual("beech", fields[0].Name);
        }
            public int InitializeClassifier(string[] atributes, string[] gestures, string classAttribute, string modelLocation)
            {
                java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new java.io.FileInputStream(modelLocation));


                m_cl = (weka.classifiers.Classifier)ois.readObject();

                //Declare the feature vector
                weka.core.FastVector fvWekaFeatureVector = new weka.core.FastVector(atributes.Length + 1);
                for (int i = 0; i < atributes.Length; i++)
                {
                    weka.core.Attribute aux = new weka.core.Attribute(atributes[i]);
                    fvWekaFeatureVector.addElement(aux);
                }


                //Declare the class weka.core.Attribute along with its values
                weka.core.FastVector fvClassValues = new weka.core.FastVector(gestures.Length);
                for (int i = 0; i < gestures.Length; i++)
                {
                    weka.core.Attribute z1 = new weka.core.Attribute(atributes[i]);
                    fvClassValues.addElement(gestures[i]);
                }
                //fvClassValues.addElement("yes");
                //fvClassValues.addElement("no");

                weka.core.Attribute ClassAttribute = new weka.core.Attribute(classAttribute, fvClassValues);

                fvWekaFeatureVector.addElement(ClassAttribute);

                dataSet = new weka.core.Instances("TestRel", fvWekaFeatureVector, 10);
                dataSet.setClassIndex(atributes.Length);

                testInstance = new weka.core.Instance(atributes.Length + 1);

                return(1);
            }
		/// <summary> Sets the format of the input instances.
		/// 
		/// </summary>
		/// <param name="instanceInfo">an Instances object containing the input instance
		/// structure (any instances contained in the object are ignored - only the
		/// structure is required).
		/// </param>
		/// <exception cref="UnsupportedAttributeTypeException">if the specified attribute
		/// is neither numeric or nominal.
		/// </exception>
		public override bool setInputFormat(Instances instanceInfo)
		{
			
			base.setInputFormat(instanceInfo);
			
			m_AttIndex.Upper=instanceInfo.numAttributes() - 1;
			if (!Numeric && !Nominal)
			{
				throw new Exception("Can only handle numeric " + "or nominal attributes.");
			}
			m_Values.Upper=instanceInfo.attribute(m_AttIndex.Index).numValues() - 1;
			if (Nominal && m_ModifyHeader)
			{
				instanceInfo = new Instances(instanceInfo, 0); // copy before modifying
				Attribute oldAtt = instanceInfo.attribute(m_AttIndex.Index);
				int[] selection = m_Values.Selection;
				FastVector newVals = new FastVector();
				for (int i = 0; i < selection.Length; i++)
				{
					newVals.addElement(oldAtt.value_Renamed(selection[i]));
				}
				instanceInfo.deleteAttributeAt(m_AttIndex.Index);
				instanceInfo.insertAttributeAt(new Attribute(oldAtt.name(), newVals), m_AttIndex.Index);
				m_NominalMapping = new int[oldAtt.numValues()];
				for (int i = 0; i < m_NominalMapping.Length; i++)
				{
					bool found = false;
					for (int j = 0; j < selection.Length; j++)
					{
						if (selection[j] == i)
						{
							m_NominalMapping[i] = j;
							found = true;
							break;
						}
					}
					if (!found)
					{
						m_NominalMapping[i] = - 1;
					}
				}
			}
			setOutputFormat(instanceInfo);
			return true;
		}
        private weka.core.FastVector generateStateAttributes(int rIdx)
        {
            var atts = new weka.core.FastVector();

            // Get all the features of this class.
            foreach (var method in typeof(LimitFeatureGenerator).GetMethods())
            {
                var attributes = method.GetCustomAttributes(typeof(Feature), true);
                if (attributes.Length == 0)
                    continue;

                // Get the feature attribute on this method.
                var attr = ((Feature)attributes[0]);

                if(rIdx < (int)attr.MinRound || rIdx > (int)attr.MaxRound)
                    continue;

                // Get the name for this column in the CSV file.
                string name = attr.Name;

                switch (attr.FType) {
                case FeatureType.Boolean:
                {
                    var attVals = new weka.core.FastVector();
                    attVals.addElement(Boolean.FalseString);
                    attVals.addElement(Boolean.TrueString);
                    atts.addElement(new weka.core.Attribute(name, attVals));
                }break;
                case FeatureType.Enum:
                {
                    var attVals = new weka.core.FastVector();
                    var vals = Enum.GetNames(attr.EnumType);
                    for(int i = 0; i < vals.Length; i++)
                        attVals.addElement(vals[i]);
                    atts.addElement(new weka.core.Attribute(name, attVals));
                }break;
                case FeatureType.Nominal:
                {
                    var attVals = new weka.core.FastVector();
                    var vals = attr.NominalValues;
                    for(int i = 0; i < vals.Length; i++)
                        attVals.addElement(vals[i]);
                    atts.addElement(new weka.core.Attribute(name, attVals));
                }break;
                case FeatureType.String:
                {
                    atts.addElement(new weka.core.Attribute(name, (weka.core.FastVector)null));
                }break;
                case FeatureType.Discrete:
                case FeatureType.Continuous:
                {
                    atts.addElement(new weka.core.Attribute(name));
                }break;
                default: throw new Exception("Unknown attribute type: " + attr.FType.ToString());
                }
            }

            return atts;
        }
        public weka.core.Instances GenerateClassifierInstances(int rIdx)
        {
            var atts = generateStateAttributes(rIdx);

            var classVals = new weka.core.FastVector();
            classVals.addElement("Fold");
            classVals.addElement("Call");
            classVals.addElement("Raise");
            atts.addElement(new weka.core.Attribute("Action", classVals));

            var data = new weka.core.Instances(((Rounds)rIdx).ToString().ToLower() + "_data", atts, 0);

            data.setClassIndex(data.numAttributes() - 1);

            return data;
        }
Example #12
0
		private double[] getProbabilities(FastVector predictions, int classIndex)
		{
			
			// sort by predicted probability of the desired class.
			double[] probs = new double[predictions.size()];
			for (int i = 0; i < probs.Length; i++)
			{
				NominalPrediction pred = (NominalPrediction) predictions.elementAt(i);
				probs[i] = pred.distribution()[classIndex];
			}
			return probs;
		}
Example #13
0
		/// <summary> Creates an Instances object with the attributes we will be calculating.
		/// 
		/// </summary>
		/// <returns> the Instances structure.
		/// </returns>
		private Instances makeHeader()
		{
			
			FastVector fv = new FastVector();
			fv.addElement(new Attribute("Margin"));
			fv.addElement(new Attribute("Current"));
			fv.addElement(new Attribute("Cumulative"));
			return new Instances("MarginCurve", fv, 100);
		}
Example #14
0
		/// <summary> Calculates the performance stats for the desired class and return 
		/// results as a set of Instances.
		/// 
		/// </summary>
		/// <param name="classIndex">index of the class of interest.
		/// </param>
		/// <returns> datapoints as a set of instances.
		/// </returns>
		public virtual Instances getCurve(FastVector predictions, int classIndex)
		{
			
			if ((predictions.size() == 0) || (((NominalPrediction) predictions.elementAt(0)).distribution().Length <= classIndex))
			{
				return null;
			}
			
			double totPos = 0, totNeg = 0;
			double[] probs = getProbabilities(predictions, classIndex);
			
			// Get distribution of positive/negatives
			for (int i = 0; i < probs.Length; i++)
			{
				NominalPrediction pred = (NominalPrediction) predictions.elementAt(i);
				if (pred.actual() == weka.classifiers.evaluation.Prediction_Fields.MISSING_VALUE)
				{
					System.Console.Error.WriteLine(GetType().FullName + " Skipping prediction with missing class value");
					continue;
				}
				if (pred.weight() < 0)
				{
					System.Console.Error.WriteLine(GetType().FullName + " Skipping prediction with negative weight");
					continue;
				}
				if (pred.actual() == classIndex)
				{
					totPos += pred.weight();
				}
				else
				{
					totNeg += pred.weight();
				}
			}
			
			Instances insts = makeHeader();
			int[] sorted = Utils.sort(probs);
			TwoClassStats tc = new TwoClassStats(totPos, totNeg, 0, 0);
			double threshold = 0;
			double cumulativePos = 0;
			double cumulativeNeg = 0;
			for (int i = 0; i < sorted.Length; i++)
			{
				
				if ((i == 0) || (probs[sorted[i]] > threshold))
				{
					tc.TruePositive = tc.TruePositive - cumulativePos;
					tc.FalseNegative = tc.FalseNegative + cumulativePos;
					tc.FalsePositive = tc.FalsePositive - cumulativeNeg;
					tc.TrueNegative = tc.TrueNegative + cumulativeNeg;
					threshold = probs[sorted[i]];
					insts.add(makeInstance(tc, threshold));
					cumulativePos = 0;
					cumulativeNeg = 0;
					if (i == sorted.Length - 1)
					{
						break;
					}
				}
				
				NominalPrediction pred = (NominalPrediction) predictions.elementAt(sorted[i]);
				
				if (pred.actual() == weka.classifiers.evaluation.Prediction_Fields.MISSING_VALUE)
				{
					System.Console.Error.WriteLine(GetType().FullName + " Skipping prediction with missing class value");
					continue;
				}
				if (pred.weight() < 0)
				{
					System.Console.Error.WriteLine(GetType().FullName + " Skipping prediction with negative weight");
					continue;
				}
				if (pred.actual() == classIndex)
				{
					cumulativePos += pred.weight();
				}
				else
				{
					cumulativeNeg += pred.weight();
				}
				
				/*
				System.out.println(tc + " " + probs[sorted[i]] 
				+ " " + (pred.actual() == classIndex));
				*/
				/*if ((i != (sorted.length - 1)) &&
				((i == 0) ||  
				(probs[sorted[i]] != probs[sorted[i - 1]]))) {
				insts.add(makeInstance(tc, probs[sorted[i]]));
				}*/
			}
			return insts;
		}
Example #15
0
		private Instances makeHeader()
		{
			
			FastVector fv = new FastVector();
			fv.addElement(new Attribute(TRUE_POS_NAME));
			fv.addElement(new Attribute(FALSE_NEG_NAME));
			fv.addElement(new Attribute(FALSE_POS_NAME));
			fv.addElement(new Attribute(TRUE_NEG_NAME));
			fv.addElement(new Attribute(FP_RATE_NAME));
			fv.addElement(new Attribute(TP_RATE_NAME));
			fv.addElement(new Attribute(PRECISION_NAME));
			fv.addElement(new Attribute(RECALL_NAME));
			fv.addElement(new Attribute(FALLOUT_NAME));
			fv.addElement(new Attribute(FMEASURE_NAME));
			fv.addElement(new Attribute(THRESHOLD_NAME));
			return new Instances(RELATION_NAME, fv, 100);
		}
Example #16
0
		/// <summary> Includes a whole bunch of predictions in the confusion matrix.
		/// 
		/// </summary>
		/// <param name="predictions">a FastVector containing the NominalPredictions
		/// to include
		/// </param>
		/// <exception cref="Exception">if no valid prediction was made (i.e. 
		/// unclassified).
		/// </exception>
		public virtual void  addPredictions(FastVector predictions)
		{
			
			for (int i = 0; i < predictions.size(); i++)
			{
				addPrediction((NominalPrediction) predictions.elementAt(i));
			}
		}
Example #17
0
		private Instances makeHeader()
		{
			
			FastVector fv = new FastVector();
			fv.addElement(new Attribute(PROB_COST_FUNC_NAME));
			fv.addElement(new Attribute(NORM_EXPECTED_COST_NAME));
			fv.addElement(new Attribute(THRESHOLD_NAME));
			return new Instances(RELATION_NAME, fv, 100);
		}