Пример #1
0
        private void testButton_Click(object sender, EventArgs e)
        {
            var form = Form.ActiveForm as Form1;

            if (readyToTest)
            {
                weka.classifiers.Classifier cl   = classifiers[highestSuccessRate.Key];
                weka.core.Instance          inst = new weka.core.Instance(insts.numAttributes() - 1);
                inst.setDataset(insts);
                for (int i = 0; i < inputObjects.Count; i++)
                {
                    if (inputObjects[i].numeric)
                    {
                        inst.setValue(i, Decimal.ToDouble(inputObjects[i].num.Value));
                    }
                    else
                    {
                        inst.setValue(i, inputObjects[i].nom.SelectedItem.ToString());
                    }
                }


                try
                {
                    string[] values      = insts.attribute(insts.numAttributes() - 1).toString().Split('{', '}')[1].Split(',');
                    double   classOfData = cl.classifyInstance(inst);
                    int      idx         = Convert.ToInt32(classOfData);
                    form.testResult.Text = values[idx];
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("Program is not ready to test, probably needs to process data first.", "Not ready", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
            public int ClassifyInstance(double[] attributes, out double[] percentages)
            {
                double classificationResult = 1.0;

                testInstance.setDataset(dataSet);
                testInstance.setClassMissing();
                dataSet.add(testInstance);
                for (int i = 0; i < attributes.Length; i++)
                {
                    testInstance.setValue(i, attributes[i]);
                }
                classificationResult = m_cl.classifyInstance(testInstance);
                dataSet.delete(0);
                percentages = m_cl.distributionForInstance(testInstance);
                return((int)classificationResult);
            }
        public weka.core.Instance GenerateFeatures(PokerHand hand, int rIdx, int aIdx, weka.core.Instances data, bool generateClass = true)
        {
            // Check that we are using limit betting.
            Debug.Assert(hand.Context.BettingType == BettingType.FixedLimit);

            var results = new weka.core.Instance(data.numAttributes());
            results.setDataset(data);
            int attIdx = 0;
            foreach (var method in typeof(LimitFeatureGenerator).GetMethods())
            {
                // Get all the features of this class.
                var attributes = method.GetCustomAttributes(typeof(Feature), true);
                if (attributes.Length == 0)
                    continue;

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

                // Get the name for this attribute
                string name = attr.Name;
                //Console.WriteLine("Hand: {0} Feature: {1}", hand.Context.ID, name);

                // Get the feature only if it's applicable to this situation.
                object feature = null;
                if(rIdx >= (int)attr.MinRound && rIdx <= (int)attr.MaxRound)
                    feature = method.Invoke(this, new object[] { hand, rIdx, aIdx });

                if (SkipMissingFeatures && (feature == null || feature.ToString() == "?"))
                    continue;

                switch (attr.FType) {
                case FeatureType.Continuous:
                    results.setValue(attIdx, (double)feature);
                    break;
                case FeatureType.Discrete:
                    results.setValue(attIdx, (int)feature);
                    break;
                case FeatureType.Boolean:
                case FeatureType.Nominal:
                case FeatureType.Enum:
                {
                    var attribute = data.attribute(attIdx);
                    var attVal = attribute.indexOfValue(feature.ToString());
                    if(attVal < 0 || attVal > attribute.numValues())
                        throw new Exception(string.Format ("Invalid attribute value: {0} for attribute {1} (idx: {2} total values: {3}", feature.ToString(), name, attVal, attribute.numValues()));
                    results.setValue(attribute, attVal);
                }
                    break;
                case FeatureType.String:
                {
                    var attribute = data.attribute(attIdx);
                    results.setValue(attribute, feature.ToString());
                }
                    break;
                default: throw new Exception("Unspecified feature type for feature: " + method.Name);
                }

                attIdx++;
            }

            if(generateClass)
            {
                var classAttr = data.classAttribute();
                switch (hand.Rounds[rIdx].Actions[aIdx].Type)
                {
                case ActionType.Bet:
                case ActionType.Raise: results.setClassValue(classAttr.indexOfValue("Raise"));
                    break;
                case ActionType.Call:
                case ActionType.Check: results.setClassValue(classAttr.indexOfValue("Call"));
                    break;
                case ActionType.Fold: results.setClassValue(classAttr.indexOfValue("Fold"));;
                    break;
                default:
                    break;
                }
            }

            return results;
        }
Пример #4
0
		/// <summary> Takes string values referenced by an Instance and copies them from a
		/// source dataset to a destination dataset. The instance references are
		/// updated to be valid for the destination dataset. The instance may have the 
		/// structure (i.e. number and attribute position) of either dataset (this
		/// affects where references are obtained from). Only works if the number
		/// of string attributes is the same in both indices (implicitly these string
		/// attributes should be semantically same but just with shifted positions).
		/// 
		/// </summary>
		/// <param name="instance">the instance containing references to strings in the source
		/// dataset that will have references updated to be valid for the destination
		/// dataset.
		/// </param>
		/// <param name="instSrcCompat">true if the instance structure is the same as the
		/// source, or false if it is the same as the destination (i.e. which of the
		/// string attribute indices contains the correct locations for this instance).
		/// </param>
		/// <param name="srcDataset">the dataset for which the current instance string
		/// references are valid (after any position mapping if needed)
		/// </param>
		/// <param name="srcStrAtts">an array containing the indices of string attributes
		/// in the source datset.
		/// </param>
		/// <param name="destDataset">the dataset for which the current instance string
		/// references need to be inserted (after any position mapping if needed)
		/// </param>
		/// <param name="destStrAtts">an array containing the indices of string attributes
		/// in the destination datset.
		/// </param>
		protected internal virtual void  copyStringValues(Instance instance, bool instSrcCompat, Instances srcDataset, int[] srcStrAtts, Instances destDataset, int[] destStrAtts)
		{
			if (srcDataset == destDataset)
			{
				return ;
			}
			if (srcStrAtts.Length != destStrAtts.Length)
			{
				throw new System.ArgumentException("Src and Dest string indices differ in length!!");
			}
			for (int i = 0; i < srcStrAtts.Length; i++)
			{
				int instIndex = instSrcCompat?srcStrAtts[i]:destStrAtts[i];
				Attribute src = srcDataset.attribute(srcStrAtts[i]);
				Attribute dest = destDataset.attribute(destStrAtts[i]);
				if (!instance.isMissing(instIndex))
				{
					//System.err.println(instance.value(srcIndex) 
					//                   + " " + src.numValues()
					//                   + " " + dest.numValues());
					//UPGRADE_WARNING: Data types in Visual C# might be different.  Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
					int valIndex = dest.addStringValue(src, (int) instance.value_Renamed(instIndex));
					// setValue here shouldn't be too slow here unless your dataset has
					// squillions of string attributes
					instance.setValue(instIndex, (double) valIndex);
				}
			}
		}
Пример #5
0
        private void btnDiscover_Click(object sender, EventArgs e)
        {
            string type  = model.GetType().ToString();
            bool   flag  = false;
            bool   flag2 = false;

            //input kontrolleri
            if (nominal != null)
            {
                for (int i = 0; i < nominal.Length; i++)
                {
                    if (nominal[i].SelectedIndex == -1)
                    {
                        flag = true;
                        break;
                    }
                }
            }
            if (numeric != null)
            {
                for (int i = 0; i < numeric.Length; i++)
                {
                    if (String.IsNullOrEmpty(numeric[i].Text))
                    {
                        flag2 = true;
                        break;
                    }
                }
            }
            if (numAtt == numeric.Length && flag2 == true)
            {
                MessageBox.Show("Please select value!", "Error Message!");
            }
            else if (numAtt == nominal.Length && flag == true)
            {
                MessageBox.Show("Please select value!", "Error Message!");
            }
            else if ((nominal.Length + numeric.Length) == numAtt && (flag == true || flag2 == true))
            {
                MessageBox.Show("Please select value!", "Error Message!");
            }
            else
            {
                weka.core.Instance newIns = new weka.core.Instance(numAtt + 1);
                newIns.setDataset(insts);

                int i1 = 0, i2 = 0;
                for (int i = 0; i < numAtt; i++)
                {
                    //nominal
                    if (typeAtt[i])
                    {
                        newIns.setValue(i, nominal[i1].SelectedItem.ToString());
                        i1++;
                    }
                    //numeric
                    else
                    {
                        newIns.setValue(i, double.Parse(numeric[i2].Text));
                        i2++;
                    }
                }

                weka.core.Instances insts2 = new weka.core.Instances(insts);
                insts2.add(newIns);

                if (type == "weka.classifiers.bayes.NaiveBayes")
                {
                    weka.filters.Filter myDiscretize = new weka.filters.unsupervised.attribute.Discretize();
                    myDiscretize.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myDiscretize);
                }

                else if (type == "weka.classifiers.functions.Logistic")
                {
                    weka.filters.Filter myDummy = new weka.filters.unsupervised.attribute.NominalToBinary();
                    myDummy.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myDummy);

                    weka.filters.Filter myNormalize = new weka.filters.unsupervised.instance.Normalize();
                    myNormalize.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myNormalize);
                }

                else if (type == "new weka.classifiers.lazy.IBk")
                {
                    weka.filters.Filter myDummy = new weka.filters.unsupervised.attribute.NominalToBinary();
                    myDummy.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myDummy);

                    weka.filters.Filter myNormalize = new weka.filters.unsupervised.instance.Normalize();
                    myNormalize.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myNormalize);
                }
                else if (type == "weka.classifiers.trees.J48")
                {
                }
                else if (type == "weka.classifiers.trees.RandomForest")
                {
                }
                else if (type == "weka.classifiers.trees.RandomTree")
                {
                }
                else if (type == "weka.classifiers.functions.MultilayerPerceptron")
                {
                    weka.filters.Filter myDummy = new weka.filters.unsupervised.attribute.NominalToBinary();
                    myDummy.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myDummy);

                    weka.filters.Filter myNormalize = new weka.filters.unsupervised.instance.Normalize();
                    myNormalize.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myNormalize);
                }
                else if (type == "weka.classifiers.functions.SMO")
                {
                    weka.filters.Filter myDummy = new weka.filters.unsupervised.attribute.NominalToBinary();
                    myDummy.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myDummy);

                    weka.filters.Filter myNormalize = new weka.filters.unsupervised.instance.Normalize();
                    myNormalize.setInputFormat(insts2);
                    insts2 = weka.filters.Filter.useFilter(insts2, myNormalize);
                }

                double index = model.classifyInstance(insts2.lastInstance());
                //Model okuma kısmı
                weka.classifiers.Classifier cls = (weka.classifiers.Classifier)weka.core.SerializationHelper.read("models/mdl.model");
                lblResult2.Text = "Result= " + insts2.attribute(insts2.numAttributes() - 1).value(Convert.ToInt16(index));
            }
        }