dataset.cs

It s the Naive Bayes algorithm with import function dat-files, realized by the tools of Visual Stu

using System;
using System.Collections;
using System.Text;
using System.Data;

namespace NaiveBayes
{
    class Dataset
    {
        private DataTable dataTable = new DataTable();
        private DataTable digitizedDataTable = new DataTable();

        private DataTable trainingTable = new DataTable();
        private DataTable testTable= new DataTable();

        private ArrayList trainingSamples = new ArrayList();
        private ArrayList testSamples = new ArrayList();

        private ArrayList digitizedTrainingSamples = new ArrayList();
        private ArrayList digitizedTestSamples = new ArrayList();

        private DataTable digitizedTrainingTable = new DataTable();
        private DataTable digitizedTestTable = new DataTable();
        private DataTable digitizedTestTable_ = new DataTable();
        private ArrayList attributes = new ArrayList();
        private ArrayList trainingAttributes = new ArrayList();

        private TargetAttribute targetAttribute;
        private int ratio;
        private int targetIndex;
        private double step;

        public Dataset(DataTable dataTable, int index, double step)
        {
            this.targetIndex = index;
            this.dataTable = dataTable.Clone() as DataTable;
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                this.dataTable.ImportRow(dataTable.Rows[i]);
            }

            initializeAttributes(step);
            initializeTargetAttribute(index);

        }

        public void initializeAttributes(double step)
        {
            this.step = step;
            for (int i = 0; i < this.dataTable.Columns.Count; i++)
            {
                ArrayList column = new ArrayList();
                for (int j = 0; j < this.dataTable.Rows.Count; j++)
                {
                    column.Add(this.dataTable.Rows[j].ItemArray[i]);
                }
                this.attributes.Add(new Attribute(column, step));
            }
        }
        public void initializeTrainingAttributes(double step)
        {
            for (int i = 0; i < this.trainingTable.Columns.Count; i++)
            {
                ArrayList column = new ArrayList();
                for (int j = 0; j < this.trainingTable.Rows.Count; j++)
                {
                    column.Add(this.trainingTable.Rows[j].ItemArray[i]);
                }
                this.trainingAttributes.Add(new Attribute(column, step));
            }
        }

        public void initializeTargetAttribute(int index)
        {
            ArrayList target = new ArrayList();
            for (int i = 0; i < this.dataTable.Rows.Count; i++)
            {
                target.Add(this.dataTable.Rows[i].ItemArray[index]);
            }
            this.targetAttribute = new TargetAttribute(target);
 
        }
        private void initializeDigitizedTestTable_()
        {
            this.digitizedTestTable_ = this.digitizedTestTable.Clone() as DataTable;
            DataRow row = this.digitizedTestTable_.NewRow();
            for (int i = 0; i < this.digitizedTestTable.Rows.Count; i++)
            {                
                this.digitizedTestTable_.ImportRow(this.digitizedTestTable.Rows[i]);
            }
            for (int i = 0; i < this.digitizedTestTable_.Rows.Count; i++)
            {
                this.digitizedTestTable_.Rows[i].ItemArray[this.targetIndex] = "?";
               
            }
        }
        public void digitize()
        {
            this.digitizedDataTable = getDigitizedTable(this.dataTable);
            this.digitizedTrainingTable = getTrainingTable(this.ratio, this.digitizedDataTable);
            this.digitizedTestTable = getTestTable(this.ratio, this.digitizedDataTable);
            initializeDigitizedTestTable_();

        

            initializeDigitizedTrainingSamples();
            intiializeDigitizedTestSamples();
        }

        
        private void initializeDigitizedTrainingSamples()
        {
            for (int i = 0; i < this.digitizedTrainingTable.Rows.Count; i++)
            {
                ArrayList sample = new ArrayList();
                for(int j =0; j<this.digitizedTrainingTable.Columns.Count; j++)
                {
                    sample.Add(this.digitizedTrainingTable.Rows[i].ItemArray[j]);
                }
                this.digitizedTrainingSamples.Add(new Sample(sample, this.targetIndex));
            }
        }

        private void intiializeDigitizedTestSamples()
        {
            for (int i = 0; i < this.digitizedTestTable.Rows.Count; i++)
            {
                ArrayList sample = new ArrayList();
                for (int j = 0; j < this.digitizedTestTable.Columns.Count; j++)
                {
                    sample.Add(this.digitizedTestTable.Rows[i].ItemArray[j]);
                }
                this.digitizedTestSamples.Add(new TestSample(sample, this.targetIndex));
            }
        }

        public DataTable getDigitizedTable(DataTable table)
        {
            DataTable tempDigitizedTable = new DataTable();
            for (int i = 0; i < table.Columns.Count; i++)
            {
                tempDigitizedTable.Columns.Add();
                tempDigitizedTable.Columns[i].ColumnName = ("Attribute" + (i + 1).ToString());
            }

            for (int i = 0; i < (this.attributes[0] as Attribute).getDigitizedValues().Count; i++)
            {
                DataRow row = tempDigitizedTable.NewRow();
                for (int j = 0; j < tempDigitizedTable.Columns.Count - 1; j++)
                {
                    row[j] = (this.attributes[j] as Attribute).getDigitizedValues()[i];
                }
                row[tempDigitizedTable.Columns.Count - 1] = this.targetAttribute.getDigitizedValues()[i];
                tempDigitizedTable.Rows.Add(row);

            }

            return tempDigitizedTable;
        }

        public void Devide(double index)
        {
            this.ratio = Convert.ToInt32(this.targetAttribute.getValues().Count * index);
            
            this.trainingTable = getTrainingTable(this.ratio, this.dataTable);
            this.testTable = getTestTable(this.ratio, this.dataTable);

            initializeTrainingSamples();
            initializeTestSamples();

            initializeTrainingAttributes(this.step);
            
        }
        public void initializeTrainingSamples()
        {
            for (int i = 0; i < this.trainingTable.Rows.Count; i++)
            {
                ArrayList sample = new ArrayList();
                for (int j = 0; j < this.trainingTable.Columns.Count; j++)
                {
                    sample.Add(this.trainingTable.Rows[i].ItemArray[j]); 
                }
                this.trainingSamples.Add(new Sample(sample, this.targetIndex));
            }
        }

        public void initializeTestSamples()
        {
            for (int i = 0; i < this.testTable.Rows.Count; i++)
            {
                ArrayList sample = new ArrayList();
                for (int j = 0; j < this.testTable.Columns.Count; j++)
                {
                    sample.Add(this.testTable.Rows[i].ItemArray[j]);
                }
                this.testSamples.Add(new TestSample(sample, this.targetIndex));
            }
        }


        public DataTable getTrainingTable(int num, DataTable initialTable)
        {
            DataTable tempTable = initialTable.Clone() as DataTable;

            for (int i = 0; i < this.ratio; i++)
            {
                tempTable.ImportRow(initialTable.Rows[i]);
            }

            return tempTable;
        }
        public DataTable getTestTable(int num, DataTable initialTable)
        {
            DataTable tempTestTable = new DataTable();
            tempTestTable = initialTable.Clone() as DataTable;
            for (int i = 0; i < initialTable.Rows.Count - num; i++)
            {
                tempTestTable.ImportRow(initialTable.Rows[initialTable.Rows.Count - 1 - i]);
            }
            return tempTestTable;
        }
        public void randomize()
        {
            Random rnd = new Random();
            int count = this.dataTable.Rows.Count;

            for (int i = 0; i < 4 * count; i++)
            {
                DataRow row = this.dataTable.NewRow();
                int rownum = rnd.Next(0, count - 1);

                row.ItemArray = this.dataTable.Rows[rownum].ItemArray;
                this.dataTable.Rows.RemoveAt(rownum);
                this.dataTable.Rows.Add(row);
            }
        }

        public void update()
        {
            this.digitizedTestSamples.Clear();
            this.digitizedTrainingSamples.Clear();
            this.digitizedTestTable.Clear();
            this.digitizedTrainingTable.Clear();
            this.trainingAttributes.Clear();
            this.trainingSamples.Clear();
            this.trainingTable.Clear();
            this.testTable.Clear();
            this.testSamples.Clear();
        }
        //----------------------------------------------------------------------------------------------------------------

        public DataTable getDigitizedTestTable_()
        {
            return this.digitizedTestTable_;
        }
        public TargetAttribute getTargetAttribute()
        {
            return this.targetAttribute;
        }
        public DataTable getDataTable()
        {
            return this.dataTable;
        }
        public DataTable getDigitizedDataTable()
        {
            return this.digitizedDataTable;
        }
        public DataTable getTrainingTable()
        {
            return this.trainingTable;
        }
        public DataTable getTestTable()
        {
            return this.testTable;
        }
        public DataTable getDigitizedTrainingTable()
        {
            return this.digitizedTrainingTable;
        }
        public DataTable getDigitizedTestTable()
        {
            return this.digitizedTestTable;
        }
        public ArrayList getDigitizedTestSamples()
        {
            return this.digitizedTestSamples;
        }
        public ArrayList getDigitizedTrainingSamples()
        {
            return this.digitizedTrainingSamples;
        }
        public ArrayList getAttributes()
        {
            return this.attributes;
        }
        public ArrayList getTrainingAttributes()
        {
            return this.trainingAttributes;
        }
     
    }
}