public PredictionResult Test(IArffDataSet testingSet) { Guard.NotNull(() => testingSet, testingSet); var problemSource = problemFactory.Construct(testingSet); return(Prediction.Predict(problemSource.GetProblem(), trainedModel, false)); }
private double testMulticlassModel(int numberOfClasses, int count, SvmType svm, KernelType kernel, bool probability = false, string outputFile = null) { Problem train = SVMUtilities.CreateMulticlassProblem(numberOfClasses, count); Parameter param = new Parameter(); RangeTransform transform = RangeTransform.Compute(train); Problem scaled = transform.Scale(train); param.Gamma = 1.0 / 3; param.SvmType = svm; param.KernelType = kernel; param.Probability = probability; if (svm == SvmType.C_SVC) { for (int i = 0; i < numberOfClasses; i++) { param.Weights[i] = 1; } } Model model = Training.Train(scaled, param); Problem test = SVMUtilities.CreateMulticlassProblem(numberOfClasses, count, false); scaled = transform.Scale(test); return(Prediction.Predict(scaled, outputFile, model, false)); }
static void Main(string[] args) { Stopwatch sw = new Stopwatch(); sw.Start(); var csvHelper = new CSVFormatter(); var trainingArray = File.ReadAllLines("ExcelFiles/trainingsample.csv"); var recordsList = csvHelper.FormatToRecordList(trainingArray); var validationArray = File.ReadAllLines("ExcelFiles/validationsample.csv"); var validationrecordsList = csvHelper.FormatToRecordList(validationArray); var results = Prediction.Predict(recordsList, validationrecordsList); int accuracy = 0; for (var i = 0; i < results.ToArray().Length; i++) { if (results[i].Number.Equals(validationrecordsList[i].Number)) { accuracy++; } //Console.WriteLine($" The closest match for{i}-th record is {results[i].Number} || {validationrecordsList[i].Number} distance of {results[i].DistanceToNumber}"); } Console.WriteLine($"Accuracy is {accuracy} out of {validationArray.Length}"); sw.Stop(); Console.WriteLine(sw.Elapsed); Console.ReadLine(); }
//PREDICTION public void SetTransform(Vector3 position, Quaternion rotation) { startPos = transform.position; startRot = transform.rotation; interpolationTime = predition.Predict(position, rotation, out endPos, out endRot, out speed); time = 0; updateTransform = true; }
public void ReceiveTransform(Vector3 pos, Quaternion rot) //USED BY MOVEMENTMANAGER { // Debug.Log("Enemy: " + this.GetComponent<GameNetworkObject>().NetworkId + "Position is: " + pos); startPos = myTransform.position; startRot = myTransform.rotation; interpolationTime = prediction.Predict(pos, rot, out endPos, out endRot, out speed); Vector3 normalizedSpeed = speed.normalized; animController.Animation(normalizedSpeed.x, normalizedSpeed.z); time = 0; }
public void Classify() { Problem train = Problem.Read(@"e:\ocr\ProcessedImages\train.txt"); Problem test = Problem.Read(@"e:\ocr\input\feature.txt"); Parameter param = new Parameter(); double C; double Gamma; param.C = 64; param.Gamma = 16; Model model = Training.Train(train, param); Prediction.Predict(test, @"E:\ocr\results.txt", model, false); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////// int PredictSVM(String binaryStringSVM, Model model) { //sử dụng SVM để nhận dạng ký tự String kytu = ""; string temp = Path.GetTempFileName(); File.WriteAllText(temp, "0 " + binaryStringSVM); Problem test = Problem.Read(temp); Prediction.Predict(test, temp, model, false); kytu = File.ReadAllText(temp); return(int.Parse(kytu.Trim())); }
private void sVMToolStripMenuItem_Click(object sender, EventArgs e) { Problem train = Problem.Read(@"D:\AI.txt"); Problem test = Problem.Read(@"D:\test.txt"); Parameter parameters = new Parameter(); double C; double Gamma; parameters.C = 32; parameters.Gamma = 8; Model model = Training.Train(train, parameters); Prediction.Predict(test, @"D:\result.txt", model, false); }
private void button3_Click(object sender, EventArgs e) { OpenFileDialog openDialog = new OpenFileDialog(); if (openDialog.ShowDialog() == DialogResult.OK) { Bitmap img = new Bitmap(openDialog.FileName); pictureBox1.Image = img; img = preProcess((Bitmap)img.Clone()); HOEF hoefObj = new HOEF(); float[] featureVector = hoefObj.Apply(img); List <float[]> features = new List <float[]>(); features.Add(featureVector); FileStream fs = new FileStream("Test", FileMode.Create, FileAccess.Write); StreamWriter sw = new StreamWriter(fs); WriteToFile(features, 50, ref sw); sw.Flush(); sw.Close(); fs.Close(); Problem test = Problem.Read("Test"); Prediction.Predict(test, "result", model, false); FileStream fsRead = new FileStream("result", FileMode.Open, FileAccess.Read); StreamReader sr = new StreamReader(fsRead); string result = sr.ReadLine(); sr.Close(); fsRead.Close(); int iResult = Int32.Parse(result); char[] lookupTable = { 'A', 'B', 'C', 'D' }; string output = lookupTable[iResult].ToString(); label3.Text = output; } }
public void Test() { int datasetSize = _dataMgr.count; int dimension = _dataMgr.inputNum; Node[][] inputs = new Node[datasetSize][]; int[] labels = new int[datasetSize]; for (int i = 0; i < datasetSize; i++) { int index = _rnd.Next(datasetSize - 1); inputs[i] = new Node[dimension]; double[] input = _dataMgr.GetInputData(index); for (int j = 0; j < dimension; j++) { inputs[i][j] = new Node(); inputs[i][j].Index = j; inputs[i][j].Value = input[j]; } if (_dataMgr.GetLabelData(index) < 0.5) { labels[i] = -1; } else { labels[i] = 1; } } int successCnt = 0; for (int i = 0; i < datasetSize; i++) { double value = Prediction.Predict(_model, inputs[i]); if ((int)value == (int)labels[i]) { successCnt++; } Console.WriteLine("compare " + labels[i] + " and " + value); } Console.WriteLine("success rate:" + (double)successCnt / (double)datasetSize); }
public void ReceiveTransform(Vector3 pos, Quaternion rot) //USED BY MOVEMENTMANAGER { //Debug.Log("Enemy: " + gnObject.NetworkId + "Position is: " + pos); //oldDestination = nextDestination; //oldQuatenion = nextQuaternion; //nextDestination = pos; //nextQuaternion = rot; startPos = transform.position; startRot = transform.rotation; interpolationTime = prediction.Predict(pos, rot, out endPos, out endRot, out speed); Vector3 normalizedSpeed = speed.normalized; animController.Animation(normalizedSpeed.x, normalizedSpeed.z); time = 0; }
public override double Forecast(double[] vector) { double result = 0; if (TrainedModel != null && vector != null) { Node[] node = new Node[vector.Length]; for (int i = 0; i < vector.Length; i++) { node[i] = new Node(); node[i].Index = i + 1; node[i].Value = vector[i]; } node = mRange.Transform(node); result = Prediction.Predict(TrainedModel, node); } return(result); }
public void ReceiveTransform(Vector3 pos, Quaternion rot) { Debug.Log("Enemy: " + this.GetComponent <GameNetworkObject>().NetworkId + "Position is: " + pos); //oldDestination = nextDestination; //oldQuatenion = nextQuaternion; //nextDestination = pos; //nextQuaternion = rot; startPos = transform.position; startRot = transform.rotation; interpolationTime = prediction.Predict(pos, rot, out endPos, out endRot, out speed); Vector3 normalizedSpeed = speed.normalized; animController.Animation(normalizedSpeed.x, normalizedSpeed.z); time = 0; }
private double testRegressionModel(int count, SvmType svm, KernelType kernel, string outputFile = null) { Problem train = SVMUtilities.CreateRegressionProblem(count); Parameter param = new Parameter(); RangeTransform transform = RangeTransform.Compute(train); Problem scaled = transform.Scale(train); param.Gamma = 1.0 / 2; param.SvmType = svm; param.KernelType = kernel; param.Degree = 2; Model model = Training.Train(scaled, param); Problem test = SVMUtilities.CreateRegressionProblem(count, false); scaled = transform.Scale(test); return(Prediction.Predict(scaled, outputFile, model, false)); }
private void InnerLoop(int n) { List <Seed> newGeneration = initialSeeds; for (int iterations = 0; iterations < n; iterations++) { List <Seed> selectedSeeds = selection.Select(newGeneration); //Console.WriteLine("The average SSE of generation: " + iterations); Console.WriteLine(selectedSeeds.Average(seed => seed.GetSSE())); for (int i = 0; i < selectedSeeds.Count - 1; i += 2) { Tuple <Seed, Seed> children = crossover.Crossover(selectedSeeds[i], selectedSeeds[i + 1]); currentSeeds.Add(children.Item1); currentSeeds.Add(children.Item2); } for (int i = 0; i < currentSeeds.Count; i++) { mutation.Mutate(currentSeeds[i]); } for (int i = 0; i < currentSeeds.Count; i++) { List <double> predictions = fitnessEvaluator.GeneratePredictions(currentSeeds[i]); currentSeeds[i].SetSSE(fitnessEvaluator.EvaluateFitness(predictions)); } // Console.WriteLine("The lowest SSE of generation: " + iterations); //Console.WriteLine(currentSeeds.Min(seed => seed.GetSSE())); newGeneration = elitism.Preserve(currentSeeds); currentSeeds = new List <Seed>(); } List <double> list = new List <double>() { 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; /*List<double> coefficients = new List<double>() { -0.1, -0.03, -0.03, -0.01, 0.22, -0.27, -0.24, 0.35, 0.29, 0.33, 0.19, 0.23, 0.15, 0.16, -0.16, 0.16, 0.19, -0.21, -0.24, 0.48 }; * Prediction prediction = new Prediction(new Seed(coefficients), list);*/ Prediction prediction = new Prediction(elitism.GetBestSeed(), list); prediction.Predict(); }
private double TrainAndTest(string trainSet, string testSet, string resultFile) { Problem train = Problem.Read(trainSet); Problem test = Problem.Read(testSet); Parameter parameters = new Parameter(); if (chClassification.Checked) { parameters.SvmType = SvmType.C_SVC; parameters.C = 0.03; parameters.Gamma = 0.008; } else { parameters.SvmType = SvmType.EPSILON_SVR; parameters.C = 8; parameters.Gamma = 0.063; parameters.P = 0.5; } Model model = Training.Train(train, parameters); return(Prediction.Predict(test, resultFile, model, true)); }
private double testTwoClassModel(int count, SvmType svm, KernelType kernel, bool probability = false, string outputFile = null) { Problem train = SVMUtilities.CreateTwoClassProblem(count); Parameter param = new Parameter(); RangeTransform transform = RangeTransform.Compute(train); Problem scaled = transform.Scale(train); param.Gamma = .5; param.SvmType = svm; param.KernelType = kernel; param.Probability = probability; if (svm == SvmType.C_SVC) { param.Weights[-1] = 1; param.Weights[1] = 1; } Model model = Training.Train(scaled, param); Problem test = SVMUtilities.CreateTwoClassProblem(count, false); scaled = transform.Scale(test); return(Prediction.Predict(scaled, outputFile, model, false)); }
//Function checks if the game has not ended when the mouse is down along with if the player ball is touching floor and if so will freeze the gameobject before it will fire it private void Update() { if (lM.GetDistance() <= 1.2f && Input.GetMouseButtonDown(0) && lM.gameState == 0) { lM.NowFiring(false); if (currentProjectile <= projectiles.Length - 1) { switch (projectiles[currentProjectile].GetComponent <Projectile>().GetProjectileType()) { //BluePotion case 0: temporaryPower = defaultPower * 6; break; //Brick case 1: temporaryPower = defaultPower * 4; break; //Bullet case 2: temporaryPower = defaultPower * 11; break; //Cannon ball case 3: temporaryPower = defaultPower * 4.25f; break; //Cone case 4: temporaryPower = defaultPower * 9f; break; //GreenPotion case 5: temporaryPower = defaultPower * 6; break; //HolyGrenade case 6: temporaryPower = defaultPower * 6.5f; break; //MagmaBall case 7: temporaryPower = defaultPower * 3.5f; break; //PurplePotion case 8: temporaryPower = defaultPower * 6; break; //RedPotion case 9: temporaryPower = defaultPower * 6; break; //Skull case 10: temporaryPower = defaultPower * 7; break; //Wing case 11: temporaryPower = defaultPower * 10f; break; } //Turn on the update frame mouse direction preparing = true; } } if (preparing) { //Get camera's negatize z axis pos (or distance from camera to our target) float z = -Camera.main.transform.position.z; //Screen to world point converts our X and Y screen position into world space 'Z' distance away from our camera //As our camera is -z from 0, this will end up on the XY plane (or where Z is equal to 0) Vector3 mousePositionInWorldSpace = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, z)); //Calculate the distance from the plater position from the mouse position in world space Vector3 differenceDistance = transform.position - mousePositionInWorldSpace; //Draw the mouse line Debug.DrawLine(mousePositionInWorldSpace, transform.position, Color.white); distance = Vector3.Distance(Camera.main.ScreenToWorldPoint(Input.mousePosition), transform.position); if (distance < 1.18f && distance > 1f) { velocity = differenceDistance * temporaryPower; priorVelocity = velocity; } else { priorVelocity = differenceDistance * temporaryPower; velocity = Vector3.Lerp(transform.position, priorVelocity, 0.9f - (distance * 0.1f)); } if (Input.GetMouseButtonUp(0) && cannon == null) { preparing = false; Fire(velocity); bTouchedStageFloor = false; } else if (cannon == null || currentProjectile == 0) { //transform.right = new Vector3(transform.position.x - 180, transform.position.y, transform.position.z); if (prediction != null /*&& lM.enablePrediction*/) { prediction.Predict(velocity); } if (GetComponent <LineRenderer>().positionCount >= 1) { transform.right = GetComponent <LineRenderer>().GetPosition(1) - transform.position; } } } }
static void Main(string[] args) { SpamDSClass sds = new SpamDSClass(); FireFlyAlgorithm ff = new FireFlyAlgorithm(); ParameterSelection ps = new ParameterSelection(); //reading the phishing emails and the test Datas string testFileFolderName = "TrainTestDataSpam"; string trainTestDataPath = String.Format(Environment.CurrentDirectory + "\\{0}", testFileFolderName); //filepath for the training and test dataset string[] trainTestFileURL = System.IO.Directory.GetFileSystemEntries(trainTestDataPath); string extractedVectorsFolderName = "ExtractedFeatures"; string extractedVectorsFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", extractedVectorsFolderName); string[] evFileURL = System.IO.Directory.GetFileSystemEntries(extractedVectorsFilePath); string outputEvaluationFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "OutputEvaluations.txt"); string outpuVectorFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "OutputVectors.txt"); PDSClass pds = new PDSClass(); //string SVAccuracyFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "SVAccuracy.txt"); /** * //extract and format spam words * string spamWordsFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "StopWords.txt"); * sds.ExtractFormatSpamWords(spamWordsFilePath); **/ /** * //Extract UCI dataset * string UCIInputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "SpamDataset.txt"); * sds.ExtractFormatUCIDataset(UCIInputFilePath); * string UCIOutputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "SpamDatasetOutput.txt"); * sds.ExtractVectorUCIDataset(UCIOutputFilePath); ***/ /** * //Extract UCI Card dataset * string outputFileName = "ZooOutput.txt"; * string CreditCardInputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "Zoo.txt"); * sds.ExtractFormatUCIDataset(CreditCardInputFilePath, outputFileName); //extract, format and write vectors to file * string UCIOutputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", outputFileName); * sds.ExtractVectorUCIDataset(UCIOutputFilePath, outputFileName); ***/ /** * //extract and format credit card dataset * string outputFileName = "CreditCardDSOutput.txt"; * //string CreditCardInputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "CreditCardDS.txt"); * //sds.ExtractFormatUCIDataset(CreditCardInputFilePath, outputFileName); //extract, format and write vectors to file * string OutputFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", outputFileName); * sds.ExtractVectorCreditCard(OutputFilePath, outputFileName); * //sds.ReadVectorFromFile(OutputFilePath); //read vector values from file **/ File.WriteAllText(ps.SVAccuracyFilePath, string.Empty); File.WriteAllText(outputEvaluationFilePath, string.Empty); //deleting the contents of the file holding the results for new results File.WriteAllText(ps.filePath, string.Empty); //deleting the contents of the file holding the extracted C,Gamma and CV values File.WriteAllText(sds.extractedFeaturesFilePathTrainDS, string.Empty); File.WriteAllText(ps.filePath2, string.Empty); File.WriteAllText(ps.filePath3, string.Empty); //File.WriteAllText(outpuVectorFilePath, string.Empty); //deleting the contents of the file holding the results for new results //int NumofFeatures = 17; double DatasetEntropy = 0.0; int TotalMails = 0; //string[] features = sds.Features(); //saving the features in the string array int[,] HamSpamCount = new int[, ] { }; //count for the total number of ham and phish emails string[] testTrainFolderFiles = new string[] { }; string folderFiles; //double[] informationGain = new double[NumofFeatures]; //Dictionary<string, double> feat_infoGain = sds.Feature_InfoGain(features, informationGain); //saving the information gain for all the individual features Dictionary <string, double> feat_infoGain = new Dictionary <string, double>(); //saving the information gain for all the individual features double classficatnAccuracySum = 0.0; //cummulative classification accuracy double classficatnAccuracy = 0; //classification accuracy for each iteration DateTime start = DateTime.Now; double totalPhishing = 0, totalHam = 0; int mailGrandTotal = 0; //initializing all the variables that will used for evaluating the performance of the classifier double FP = 0.0, FN = 0.0, TP = 0.0, TN = 0.0, P = 0.0, F_M = 0.0, sumFP = 0.0, sumF_M = 0.0, sumFN = 0.0, sumTP = 0.0, sumTN = 0.0, sumP = 0.0, sumTime = 0.0; double storagePercentage = 0.0, sumStoragePercentage = 0.0; int N_Fold = 10; //number of folds int n_Runs = 1; //number of runs double[,] NormalizedVector = new double[, ] { }; //normalized vector values for each features Program p = new Program(); double avgRuns = 0.0, avgFP = 0.0, avgFN = 0.0, avgR = 0.0, avgPr = 0.0, avgFM = 0.0, avgTime = 0.0, avgStoragePercentage = 0.0; //avg=> average double globalBest = double.MinValue; //change the boolean value appropriately to choose the task you want to perform (either vector value extraction or email classification) //Note: Both values must not be true! This is to reduce processing time bool extractVectorValues = false; //switch for extract bool Emailclassification = true; //switch for classification double C = new double(); double Gamma = new double(); //double[] CV = new double[2]; List <double> CV1 = new List <double>(); //Save the CV accuracy, C and Gamma for comparison List <double> CV2 = new List <double>(); //Save the CV accuracy, C and Gamma for comparison List <int[, ]> vectorList = new List <int[, ]>(); //save the list of vectors for each fold List <Dictionary <string, int> > trainMailList = new List <Dictionary <string, int> >(); //save training mails for each fold List <Dictionary <string, int> > testMailList = new List <Dictionary <string, int> >(); //save test emails for each fold List <string[]> featList = new List <string[]>(); int NumofFeatures = 0; int[,] vector = new int[, ] { }; Dictionary <string, int> trainMail_Class = new Dictionary <string, int>(); //variable containing the emails and classes of all the training emails Dictionary <string, int> testMail_Class = new Dictionary <string, int>(); //variable containing the emails and classes of all the test emails string[] features = new string[] { }; List <Dictionary <string, double> > feat_infoGainList = new List <Dictionary <string, double> >(); //for (int aa = 0; aa < n_Runs; aa++) //{ // classficatnAccuracySum = 0.0; // sumFP = 0.0; // sumTP = 0.0; //Recall // sumFN = 0.0; // sumF_M = 0.0; // sumP = 0.0; // sumTime = 0.0; //for (int a = 0; a < N_Fold; a++) //{ if (extractVectorValues == true) //if the value of ExtractVectorValues is true, only extract email vector values and dont perform classification { for (int a = 0; a < N_Fold; a++) { n_Runs = 1; // change number of runs from its default value (i.e 10) to 1 (to avoid repeating the extraction process 10 times) since we wanna do is to extract the vector values from each emails string[] trainFileURLs = new string[] { }; //urls for the train emails (i.e. the emails used for training the classifier) string[] testFileURLs = new string[] { }; //urls for the test emails (i.e. the emails used for testing the classifier) trainMail_Class = new Dictionary <string, int>(); testMail_Class = new Dictionary <string, int>(); string[] trainMailFileNames = new string[trainMail_Class.Count]; //the file names for all the emails in the training dataset string[] testMailFileNames = new string[] { }; //the file names for all the emails in the test dataset string trainMailLabel; int spamCount = 0, hamCount = 0; double phishPercentage, hamPercentage; features = new string[] { }; //processing the training dataset for the each fold for (int i = 0; i < trainTestFileURL.Length; i++) { if (i.Equals(a)) { continue; //skipping one email folder, which is to be used for testing the trained classifier (i.e. the current test dataset) } testTrainFolderFiles = System.IO.Directory.GetFiles(trainTestFileURL[i]); //getting the filenames of all the emails in the training dataset trainFileURLs = trainFileURLs.Concat(testTrainFolderFiles).ToArray(); //get all the urls for the test emails trainMailFileNames = sds.getFileNames(trainFileURLs); //get the file names for all the test mails for (int j = 0; j < testTrainFolderFiles.Length; j++) //processing all the emails in the current training dataset for classification { trainMailLabel = trainMailFileNames[j].Substring(0, 2); //getting the label for each email, HM(for Ham Mails) and PM(for Phish Mails) //folderFiles = File.ReadAllText(testTrainFolderFiles[j]); //extracting the content of each email in each email folder //trainMail_Class[sds.ProcessMails(folderFiles)] = (trainMailLabel.Equals("SM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. trainMail_Class[testTrainFolderFiles[j]] = (trainMailLabel.Equals("SM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. if (trainMail_Class.ElementAt(j).Value == 1) { spamCount++; //counting the total number of ham and phishing to get their percentage } else { hamCount++; } } } //processing the test dataset for each fold for (int i = a; i < a + 1; i++) { testTrainFolderFiles = System.IO.Directory.GetFiles(trainTestFileURL[i]); testFileURLs = testFileURLs.Concat(testTrainFolderFiles).ToArray(); testMailFileNames = sds.getFileNames(testFileURLs); for (int j = 0; j < testTrainFolderFiles.Length; j++) { trainMailLabel = testMailFileNames[j].Substring(0, 2); //folderFiles = File.ReadAllText(testTrainFolderFiles[j]); //testMail_Class[sds.ProcessMails(folderFiles)] = (trainMailLabel.Equals("SM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. testMail_Class[testTrainFolderFiles[j]] = (trainMailLabel.Equals("SM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. if (testMail_Class.ElementAt(j).Value == 1) { spamCount++; } else { hamCount++; } } } //calculating the percentage of spam and ham email in the dataset phishPercentage = (double)spamCount / (double)(trainMail_Class.Count + testMail_Class.Count); hamPercentage = (double)hamCount / (double)(trainMail_Class.Count + testMail_Class.Count); mailGrandTotal = spamCount + hamCount; totalHam = hamCount; totalPhishing = spamCount; //Information Gain features = pds.Features(); NumofFeatures = features.Count(); TotalMails = trainMail_Class.Count; vector = new int[TotalMails, NumofFeatures]; double[] informationGainn = new double[NumofFeatures]; pds.processVector(vector, trainMail_Class, features, trainFileURLs, NumofFeatures); //extracting the vector values of all the features int[,] HamPhishCount = new int[NumofFeatures, 4]; pds.FeatureVectorSum(NumofFeatures, TotalMails, vector, trainMail_Class, HamPhishCount); // calculating the total number of zeros and ones for both phishing and ham emails DatasetEntropy = pds.Entropy(trainMail_Class); //calculating the entropy for the entire dataset pds.CalInformationGain(NumofFeatures, HamPhishCount, informationGainn, TotalMails, DatasetEntropy); //calculating information gain for each feature feat_infoGain = pds.Feature_InfoGain(features, informationGainn); //assisgning the calculated information gain to each feature //process vector for training Dataset int NumofFeatures2 = NumofFeatures - 9; string[] newFeatures = new string[NumofFeatures2]; for (int i = 0; i < NumofFeatures2; i++) { newFeatures[i] = feat_infoGain.ElementAt(i).Key; //copying the best 8 features with the highest information gain } vector = new int[TotalMails, NumofFeatures2]; pds.processVector(vector, trainMail_Class, newFeatures, trainFileURLs, NumofFeatures2); //extract vectors of the training data pds.extractVectors(vector, trainMail_Class, NumofFeatures2, "trainingDS", a); //process vector for testing Dataset TotalMails = testMail_Class.Count; vector = new int[TotalMails, NumofFeatures2]; pds.processVector(vector, testMail_Class, newFeatures, testFileURLs, NumofFeatures2); NormalizedVector = ff.Normalize(vector); //normalize the all vector values for test data //extract vectors of the test data pds.extractVectors(vector, testMail_Class, NumofFeatures2, "testDS", a); /*** * vector = sds.processTrainVector(trainMail_Class, ref features); //extracting the vector values of all the features * * TotalMails = trainMail_Class.Count; * NumofFeatures = vector.GetLength(1); * double[] informationGain = new double[NumofFeatures]; * HamSpamCount = new int[NumofFeatures, 4]; * sds.FeatureVectorSum(NumofFeatures, TotalMails, vector, trainMail_Class, HamSpamCount); // calculating the total number of zeros and ones for both phishing and ham emails * DatasetEntropy = sds.Entropy(trainMail_Class, NumofFeatures); //calculating the entropy for the entire dataset * * sds.CalInformationGain(NumofFeatures, HamSpamCount, informationGain, TotalMails, DatasetEntropy);//calculating information gain for each feature * feat_infoGain = sds.Feature_InfoGain(features, informationGain, NumofFeatures); //assisgning the calculated information gain to each feature * * //extract features with information gain greater than zero * List<string> topFeat = new List<string>(); * foreach (KeyValuePair<string, double> feat in feat_infoGain) * { * if (feat.Value > 0) * topFeat.Add(feat.Key); * } * * NumofFeatures = topFeat.Count; //update number of features to number of features with high information gain * vector = sds.processVector(trainMail_Class, topFeat.ToArray(), NumofFeatures); //extracting the vector values of all the features * * vectorList.Add(vector); //save vectors for each fold * trainMailList.Add(trainMail_Class); //save training mails for each fold * testMailList.Add(testMail_Class); //save test mails for each fold * featList.Add(topFeat.ToArray()); * feat_infoGainList.Add(feat_infoGain); * } * * * //get the feature with the lowest count * NumofFeatures = vectorList[0].GetLength(1); //get the number of features for each fold * foreach (int[,] vec in vectorList) * { * int NumofFeat = vec.GetLength(1); * if (NumofFeat < NumofFeatures) * NumofFeatures = NumofFeat; //get the feature with the lowest count * } * * if (NumofFeatures >= 40) //retrict number of features to 100, if number of selected features is greater than 100 * NumofFeatures = 40; * * //For each fold, process the extracted vectors * for (int a = 0; a < N_Fold; a++) * { * //extract vectors of the training data * sds.extractVectors(vectorList[a], trainMailList[a], NumofFeatures, "trainingDS", a); * * //process vector for testing Dataset * TotalMails = testMailList[a].Count; * vector = new int[TotalMails, NumofFeatures]; * vector = sds.processVector(testMailList[a], featList[a], NumofFeatures); //extracting the vector values of all the features * sds.extractVectors(vector, testMailList[a], NumofFeatures, "testDS", a); //extract vectors of the test data * * if (a.Equals(9)) * { * Console.Write("Extraction Completed...."); * Console.ReadKey(); * } ***/ } } else //perform email classification - don't extract! { n_Runs = 1; for (int r = 0; r < n_Runs; r++) { classficatnAccuracySum = 0.0; sumFP = 0.0; sumTP = 0.0; sumFN = 0.0; sumF_M = 0.0; sumP = 0.0; sumTime = 0.0; sumStoragePercentage = 0.0; for (int a = 0; a < N_Fold; a++) { if (Emailclassification == true) //if the value of EmailClassification is true, perform email classification and dont extract emails { //SVM Classfication begins here DateTime start1 = DateTime.Now; //First, read in the training and test data. Problem train = Problem.Read(string.Format("ExtractedFeaturesTrain{0}.{1}", (a + 1).ToString(), "txt")); Problem test = Problem.Read(string.Format("ExtractedFeaturesTest{0}.{1}", (a + 1).ToString(), "txt")); //scalling the data GaussianTransform gt = GaussianTransform.Compute(train); Problem trainScaledProblem = gt.Scale(train); Problem testScaledProblem = gt.Scale(test); /** * //count total number of positives and negative instances * int trp = trainScaledProblem.Y.Count(s => s == 1); * int trN = trainScaledProblem.Y.Count(s => s == -1); * int tep = testScaledProblem.Y.Count(s => s == 1); * int teN = testScaledProblem.Y.Count(s => s == -1); * int totp = trp + tep; * int totN = trN + teN; **/ //For this example (and indeed, many scenarios), the default parameters will suffice. Parameter parameters = new Parameter(); //double C = new double(); //double Gamma = new double(); Console.WriteLine("\nClassification Number {0} Step: {1}...............................\n", a + 1, r + 1); //This will do a grid optimization to find the best parameters and store them in C and Gamma, outputting the entire //search to params.txt. /* * if (a == 0) * { * ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); * CV1.Add(ParameterSelection.CVAccuracy); * CV1.Add(C); * CV1.Add(Gamma); * } * else if (a == 1) * { * ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); * CV2.Add(ParameterSelection.CVAccuracy); * CV2.Add(C); * CV2.Add(Gamma); * * if (CV1[0] > CV2[0]) //if the previous CV rate is greater than the present, then, discard the present and use the C and Gamma of the previous. * { * C = CV1[1]; * Gamma = CV1[2]; * } * * }*/ /** * //Standard SVM (i.e. SVM without instance selection) * ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(trainScaledProblem, parameters); **/ //Bootstrap Sampling Method //Training.samplingGellingPoint(trainScaledProblem, testScaledProblem); //int subsetNumber = 5; //int samplesPerSubset = 30; //Problem subsets = new Problem(); //Parameter bestPara = new Parameter(); //subsets = Training.BootstrapSampling(trainScaledProblem, parameters, subsetNumber, samplesPerSubset, testScaledProblem, out bestPara); //select subsets using boothtrap sampling method //parameters.C = C; //parameters.Gamma = Gamma; /** * //KNN-Based boundary instance Selection * KNNInstanceSelectionAlgorithm knn = new KNNInstanceSelectionAlgorithm(); * int k = 50; * int numberOfSubset = 300; //subset to select for training * Problem dataSubset = knn.computeNearestNeighbour(k, trainScaledProblem, numberOfSubset); * //Problem dataSubset = knn.computeNearestNeighbour(k, trainScaledProblem, numberOfSubset); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(dataSubset, parameters); **/ /** * AntColonyOptimizationBoundarySelection aco = new AntColonyOptimizationBoundarySelection(); * int numberOfSubset = 500; //subset to select for training * int kNum = 300; * //Problem dataSubset = aco.ACOBoundarySelection(train, numberOfSubset, kNum); * Problem dataSubset = aco.ACOBoundarySelection(trainScaledProblem, numberOfSubset, kNum); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(dataSubset, parameters); **/ /** * //FFA_Based Instance Selection * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(trainScaledProblem, out storagePercentage); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); */ /** * //Flower Pollination Algorithm (FPA) Based Instance Selection * FlowerPollinationAlgorithm fpa = new FlowerPollinationAlgorithm(); * //Problem subP = fpa.FlowerPollination(trainScaledProblem); * Problem subP = fpa.BinaryFlowerPollination(trainScaledProblem, out storagePercentage); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); **/ /** * //Cuckoo Search Algorithm * CuckooSearchAlgorithm csa = new CuckooSearchAlgorithm(); * Problem subP = csa.CuckooSearch(trainScaledProblem, out storagePercentage); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); **/ //Social Spider Algorithms SocialSpiderAlgorithm ss = new SocialSpiderAlgorithm(); Problem subP = ss.SocialSpider(trainScaledProblem, out storagePercentage); ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); parameters.C = C; parameters.Gamma = Gamma; Model model = Training.Train(subP, parameters); /** * //Bat Algorithm (BA) Based Instance Selection * BatAlgorithm bat = new BatAlgorithm(); * Problem subP = bat.BinaryBat(trainScaledProblem, out storagePercentage); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); */ /** * //Clustering-Based Instance Selection Algorithm * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * ParameterSelection.Grid(boundaryInstance, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(boundaryInstance, parameters); **/ /** * //Edge Instance Selection * Problem edgeNN = Training.EdgeInstanceSelection(trainScaledProblem); * ParameterSelection.Grid(edgeNN, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(edgeNN, parameters); **/ /** * //Hybrid: Clustering + FFA + EISA * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(boundaryInstance); * Problem edgeNN = Training.EdgeInstanceSelection(subP); * ParameterSelection.Grid(edgeNN, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(edgeNN, parameters); */ /** * //Hybrid: FFA + EISA * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(trainScaledProblem); * Problem edgeNN = Training.EdgeInstanceSelection(subP); * ParameterSelection.Grid(edgeNN, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(edgeNN, parameters); **/ /** * //Hybrid: KNN-based based + FFA-Based * //Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(trainScaledProblem); * int k = 50; * int numberOfSubset = 100; //subset to select for training * Problem dataSubset = Training.computeNearestNeighbour(k, subP, numberOfSubset); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); */ /** * //Hybrid: Clustering-Based + FFA-Based * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(boundaryInstance); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(boundaryInstance, parameters); **/ /** * //Hybrid: Clustering-Based + Flower Pollination Algorithm * FlowerPollinationAlgorithm fpa = new FlowerPollinationAlgorithm(); * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * Problem subP = fpa.FlowerPollination(trainScaledProblem); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(boundaryInstance, parameters); **/ /* //Hybrid: Clustering based + FFA-Based + KNN-Based * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(boundaryInstance); * int k = 50; * int numberOfSubset = 100; //subset to select for training * Problem dataSubset = Training.computeNearestNeighbour(k, boundaryInstance, numberOfSubset); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(dataSubset, parameters); */ //Train the model using the optimal parameters. //Model model = Training.Train(trainScaledProblem, parameters); //removing support vectors that contributes less to the decision surface //Model submod = Training.performSupportVectorReduction(model, trainScaledProblem); //Perform classification on the test data, putting the results in results.txt. //classficatnAccuracySum += Prediction.Predict(testScaledProblem, "ClassificationResults.txt", model, false); //classficatnAccuracy = Prediction.Predict(test, "ClassificationResults.txt", model, false); //classfication accuracy for each iteration ->for the purpose of outputting to the text file classficatnAccuracy = Prediction.Predict(testScaledProblem, "ClassificationResults.txt", model, false); //classfication accuracy for each iteration ->for the purpose of outputting to the text file classficatnAccuracySum += classficatnAccuracy; Console.WriteLine("\nClassification Accuracy: {0}%", 100 * classficatnAccuracy); PerformanceEvaluator pp = new PerformanceEvaluator("ClassificationResults.txt", test, out TP, out TN, out FP, out FN, out P, out F_M); DateTime end1 = DateTime.Now; TimeSpan duration1 = end1 - start1; double time1 = duration1.Minutes * 60.0 + duration1.Seconds + duration1.Milliseconds / 1000.0; sumTP += TP; sumTN += TN; sumFP += FP; sumFN += FN; sumP += P; sumF_M += F_M; sumTime += time1; sumStoragePercentage += storagePercentage; //saving all the output to a file string outpt = string.Format("Cross Validation: {0}, Run number {1}, CAccuracy: {2:0.0000} FP: {3:0.0000}, FN: {4:0.0000}, Recall: {5:0.0000}, Precision: {6:0.0000}, FMeasure: {7:0.0000}, Time: {8} Seconds, Storage Percentage: {9}", a + 1, r + 1, (classficatnAccuracy * 100), (FP * 100), (FN * 100), (TP * 100), (P * 100), (F_M * 100), time1, storagePercentage); File.AppendAllText(outputEvaluationFilePath, outpt); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); } if (classficatnAccuracy * 100 > globalBest) { globalBest = classficatnAccuracy * 100; } } classficatnAccuracySum = (classficatnAccuracySum * 100) / N_Fold; //converting to percentage and dividing by the number of folds sumFP = (sumFP * 100) / N_Fold; //calculating the average cross validation for False Positive over 10 folds sumTP = (sumTP * 100) / N_Fold; //calculating the average cross validation for Recall over 10 folds sumFN = (sumFN * 100) / N_Fold; //calculating the average cross validation for False Negative over 10 folds sumF_M = (sumF_M * 100) / N_Fold; //calculating the average cross validation for F Measure over 10 folds sumP = (sumP * 100) / N_Fold; //calculating the average cross validation for Precision over 10 folds sumStoragePercentage = sumStoragePercentage / N_Fold; avgRuns += classficatnAccuracySum; avgFP += sumFP; avgFN += sumFN; avgR += sumTP; avgPr += sumP; avgFM += sumF_M; avgTime += sumTime; avgStoragePercentage += sumStoragePercentage; //saving all the outputs to a file File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, string.Format("Average Calculations....Run Number: {0}", r + 1)); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); string outpt2 = string.Format("Run number {0}, Average CAccuracy: {1:0.0000} FP: {2:0.0000}, FN: {3:0.0000}, Recall: {4:0.0000}, Precision: {5:0.0000}, FMeasure: {6:0.0000}, Time: {7}, Storage Percentage: {8}", r + 1, classficatnAccuracySum, sumFP, sumFN, sumTP, sumP, sumF_M, sumTime, sumStoragePercentage); File.AppendAllText(outputEvaluationFilePath, outpt2); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); Console.WriteLine("\nStep {0}...............................\n", r + 1); } } //} DateTime end = DateTime.Now; TimeSpan duration = end - start; double time = duration.Minutes * 60.0 + duration.Seconds + duration.Milliseconds / 1000.0; Console.WriteLine("\nAverage processing time {0:########.00} seconds\n", avgTime / n_Runs); //Console.WriteLine("\nTotal processing time {0:########.00} seconds\n", time); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, "Average processing time:\n" + avgTime / n_Runs + " Seconds"); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); //sending all the outputs to the screen Console.WriteLine("\nOverall Average Accuracy: {0:0.00}% \nGlobal Best: {1:0.00}%", avgRuns / n_Runs, globalBest); Console.WriteLine("\n\nTotal False Positive: {0:0.00}%\nTotal False Negative: {1:0.00}%\nRecall: {2:0.00}%\nPrecision: {3:0.00}%\nF_Measure: {4:0.00}% \nStorage Percentage: {5:0.00}%", (avgFP / n_Runs), (avgFN / n_Runs), (avgR / n_Runs), (avgPr / n_Runs), (avgFM / n_Runs), (avgStoragePercentage / n_Runs)); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, "Overall Average Calculations......."); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); string outpt3 = string.Format("Overall Average CAccuracy: {0:0.0000} FP: {1:0.0000}, FN: {2:0.0000}, Recall: {3:0.0000}, Precision: {4:0.0000}, FMeasure: {5:0.0000}, Storage Percentage: {6:0.0000}", avgRuns / n_Runs, avgFP / n_Runs, avgFN / n_Runs, avgR / n_Runs, avgPr / n_Runs, avgFM / n_Runs, avgStoragePercentage / n_Runs); File.AppendAllText(outputEvaluationFilePath, outpt3); Console.ReadKey(); }
static void Main(string[] args) { PDSClass pds = new PDSClass(); FireFlyAlgorithm ff = new FireFlyAlgorithm(); ParameterSelection ps = new ParameterSelection(); //reading the phishing emails and the test Datas string testFileFolderName = "TrainTestData"; string trainTestDataPath = String.Format(Environment.CurrentDirectory + "\\{0}", testFileFolderName); //filepath for the training and test dataset string[] trainTestFileURL = System.IO.Directory.GetFileSystemEntries(trainTestDataPath); string extractedVectorsFolderName = "ExtractedFeatures"; string extractedVectorsFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", extractedVectorsFolderName); string[] evFileURL = System.IO.Directory.GetFileSystemEntries(extractedVectorsFilePath); string outputEvaluationFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "OutputEvaluations.txt"); //string SVAccuracyFilePath = String.Format(Environment.CurrentDirectory + "\\{0}", "SVAccuracy.txt"); File.WriteAllText(ps.SVAccuracyFilePath, string.Empty); File.WriteAllText(outputEvaluationFilePath, string.Empty); //deleting the contents of the file holding the results for new results File.WriteAllText(ps.filePath, string.Empty); //deleting the contents of the file holding the extracted C,Gamma and CV values File.WriteAllText(pds.extractedFeaturesFilePathTrainDS, string.Empty); File.WriteAllText(ps.filePath2, string.Empty); File.WriteAllText(ps.filePath3, string.Empty); int NumofFeatures = 17; double DatasetEntropy = 0.0; int TotalMails; string[] features = pds.Features(); //saving the features in the string array int[,] HamPhishCount = new int[, ] { }; //count for the total number of ham and phish emails string[] testTrainFolderFiles = new string[] { }; string folderFiles; double[] informationGain = new double[NumofFeatures]; Dictionary <string, double> feat_infoGain = pds.Feature_InfoGain(features, informationGain); //saving the information gain for all the individual features double classficatnAccuracySum = 0.0; //cummulative classification accuracy double classficatnAccuracy = 0; //classification accuracy for each iteration DateTime start = DateTime.Now; double totalPhishing = 0, totalHam = 0; int mailGrandTotal = 0; //initializing all the variables that will used for evaluating the performance of the classifier double FP = 0.0, FN = 0.0, TP = 0.0, TN = 0.0, P = 0.0, F_M = 0.0, sumFP = 0.0, sumF_M = 0.0, sumFN = 0.0, sumTP = 0.0, sumTN = 0.0, sumP = 0.0; int N_Fold = 10; //number of folds int n_Runs = 1; //number of runs double[,] NormalizedVector = new double[, ] { }; //normalized vector values for each features Program p = new Program(); double avgRuns = 0.0, avgFP = 0.0, avgFN = 0.0, avgR = 0.0, avgPr = 0.0, avgFM = 0.0; //avg=> average double globalBest = double.MinValue; //change the boolean value appropriately to choose the task you want to perform (either vector value extraction or email classification) //both values should not be true. This is to reduce processing time bool extractVectorValues = true; bool Emailclassification = false; double C = new double(); double Gamma = new double(); //double[] CV = new double[2]; List <double> CV1 = new List <double>(); //Save the CV accuracy, C and Gamma for comparison List <double> CV2 = new List <double>(); //Save the CV accuracy, C and Gamma for comparison for (int aa = 0; aa < n_Runs; aa++) { classficatnAccuracySum = 0.0; sumFP = 0.0; sumTP = 0.0; //Recall sumFN = 0.0; sumF_M = 0.0; sumP = 0.0; for (int a = 0; a < N_Fold; a++) { if (extractVectorValues == true) //if the value of ExtractVectorValues is true, only extract email vector values and dont perform classification { n_Runs = 1; // change number of runs from its default value (i.e 10) to 1 (to avoid repeating the extraction process 10 times) since we wanna do is to extract the vector values from each emails string[] trainFileURLs = new string[] { }; //urls for the train emails (i.e. the emails used for training the classifier) string[] testFileURLs = new string[] { }; //urls for the test emails (i.e. the emails used for testing the classifier) Dictionary <string, int> trainMail_Class = new Dictionary <string, int>(); //variable containing the emails and classes of all the training emails Dictionary <string, int> testMail_Class = new Dictionary <string, int>(); //variable containing the emails and classes of all the test emails string[] trainMailFileNames = new string[trainMail_Class.Count]; //the file names for all the emails in the training dataset string[] testMailFileNames = new string[] { }; //the file names for all the emails in the test dataset string trainMailLabel; int phishCount = 0, hamCount = 0; double phishPercentage, hamPercentage; //processing the training dataset for the each fold for (int i = 0; i < trainTestFileURL.Length; i++) { if (i.Equals(a)) { continue; //skipping one email folder, which is to be used for testing the trained classifier (i.e. the current test dataset) } testTrainFolderFiles = System.IO.Directory.GetFiles(trainTestFileURL[i]); //getting the filenames of all the emails in the training dataset trainFileURLs = trainFileURLs.Concat(testTrainFolderFiles).ToArray(); //get all the urls for the test emails trainMailFileNames = pds.getFileNames(trainFileURLs); //get the file names for all the test mails for (int j = 0; j < testTrainFolderFiles.Length; j++) //processing all the emails in the current training dataset for classification { trainMailLabel = trainMailFileNames[j].Substring(0, 2); //getting the label for each email, HM(for Ham Mails) and PM(for Phish Mails) folderFiles = File.ReadAllText(testTrainFolderFiles[j]); //extracting the content of each email in each email folder trainMail_Class[pds.ProcessMails(folderFiles)] = (trainMailLabel.Equals("PM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. if (trainMail_Class.ElementAt(j).Value == 1) { phishCount++; //counting the total number of ham and phishing to get their percentage } else { hamCount++; } } } //processing the test dataset for each fold for (int i = a; i < a + 1; i++) { testTrainFolderFiles = System.IO.Directory.GetFiles(trainTestFileURL[i]); testFileURLs = testFileURLs.Concat(testTrainFolderFiles).ToArray(); testMailFileNames = pds.getFileNames(testFileURLs); for (int j = 0; j < testTrainFolderFiles.Length; j++) { trainMailLabel = testMailFileNames[j].Substring(0, 2); folderFiles = File.ReadAllText(testTrainFolderFiles[j]); testMail_Class[pds.ProcessMails(folderFiles)] = (trainMailLabel.Equals("PM")) ? 1 : 0; //processing each email and assigning label to the emails based on the folders each emails come from. if (testMail_Class.ElementAt(j).Value == 1) { phishCount++; } else { hamCount++; } } } //calculating the percentage of phishing and ham email in the dataset phishPercentage = (double)phishCount / (double)(trainMail_Class.Count + testMail_Class.Count); hamPercentage = (double)hamCount / (double)(trainMail_Class.Count + testMail_Class.Count); mailGrandTotal = phishCount + hamCount; totalHam = hamCount; totalPhishing = phishCount; //Information Gain TotalMails = trainMail_Class.Count; int[,] vector = new int[TotalMails, NumofFeatures]; pds.processVector(vector, trainMail_Class, features, trainFileURLs, NumofFeatures); //extracting the vector values of all the features HamPhishCount = new int[NumofFeatures, 4]; pds.FeatureVectorSum(NumofFeatures, TotalMails, vector, trainMail_Class, HamPhishCount); // calculating the total number of zeros and ones for both phishing and ham emails DatasetEntropy = pds.Entropy(trainMail_Class); //calculating the entropy for the entire dataset pds.CalInformationGain(NumofFeatures, HamPhishCount, informationGain, TotalMails, DatasetEntropy); //calculating information gain for each feature feat_infoGain = pds.Feature_InfoGain(features, informationGain); //assisgning the calculated information gain to each feature //process vector for training Dataset int NumofFeatures2 = NumofFeatures - 8; string[] newFeatures = new string[NumofFeatures2]; for (int i = 0; i < NumofFeatures2; i++) { newFeatures[i] = feat_infoGain.ElementAt(i).Key; //copying the best 8 features with the highest information gain } TotalMails = trainMail_Class.Count; vector = new int[TotalMails, NumofFeatures2]; pds.processVector(vector, trainMail_Class, newFeatures, trainFileURLs, NumofFeatures2); NormalizedVector = ff.Normalize(vector); //normalize the all vector values for train data //extract vectors of the training data pds.extractVectors(vector, trainMail_Class, NumofFeatures2, "trainingDS", a); //process vector for testing Dataset TotalMails = testMail_Class.Count; vector = new int[TotalMails, NumofFeatures2]; pds.processVector(vector, testMail_Class, newFeatures, testFileURLs, NumofFeatures2); NormalizedVector = ff.Normalize(vector); //normalize the all vector values for test data //extract vectors of the test data pds.extractVectors(vector, testMail_Class, NumofFeatures2, "testDS", a); } if (Emailclassification == true) //if the value of EmailClassification is true, perform email classification and dont extract emails { //SVM Classfication begins here //First, read in the training and test data. Problem train = Problem.Read(string.Format("ExtractedFeaturesTrain{0}.{1}", (a + 1).ToString(), "txt")); Problem test = Problem.Read(string.Format("ExtractedFeaturesTest{0}.{1}", (a + 1).ToString(), "txt")); //scalling the data GaussianTransform gt = GaussianTransform.Compute(train); Problem trainScaledProblem = gt.Scale(train); Problem testScaledProblem = gt.Scale(test); //For this example (and indeed, many scenarios), the default parameters will suffice. Parameter parameters = new Parameter(); //double C = new double(); //double Gamma = new double(); Console.WriteLine("\nClassification Number {0} Step: {1}...............................\n", a + 1, aa + 1); //This will do a grid optimization to find the best parameters and store them in C and Gamma, outputting the entire //search to params.txt. /* * if (a == 0) * { * ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); * CV1.Add(ParameterSelection.CVAccuracy); * CV1.Add(C); * CV1.Add(Gamma); * } * else if (a == 1) * { * ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); * CV2.Add(ParameterSelection.CVAccuracy); * CV2.Add(C); * CV2.Add(Gamma); * * if (CV1[0] > CV2[0]) //if the previous CV rate is greater than the present, then, discard the present and use the C and Gamma of the previous. * { * C = CV1[1]; * Gamma = CV1[2]; * } * * }*/ //Bootstrap Sampling Method //Training.samplingGellingPoint(trainScaledProblem, testScaledProblem); //int subsetNumber = 5; //int samplesPerSubset = 30; //Problem subsets = new Problem(); //Parameter bestPara = new Parameter(); //subsets = Training.BootstrapSampling(trainScaledProblem, parameters, subsetNumber, samplesPerSubset, testScaledProblem, out bestPara); //select subsets using boothtrap sampling method //parameters.C = C; //parameters.Gamma = Gamma; //KNN-Based boundary instance Selection int k = 50; int numberOfSubset = 300; //subset to select for training Problem dataSubset = Training.computeNearestNeighbour(k, trainScaledProblem, numberOfSubset); ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); parameters.C = C; parameters.Gamma = Gamma; //Model model = Training.buildModel(dataSubset, parameters); Model model = Training.Train(dataSubset, parameters); //ParameterSelection.Grid(boundaryInstance, parameters, "params.txt", out C, out Gamma); //ParameterSelection.Grid(trainScaledProblem, parameters, "params.txt", out C, out Gamma); /* //FFA_Based Instance Selection * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(trainScaledProblem); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); */ /* * //Clustering-Based Instance Selection Algorithm * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * ParameterSelection.Grid(boundaryInstance, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(boundaryInstance, parameters); */ /* //Edge Instance Selection * Problem edgeNN = Training.EdgeInstanceSelection(trainScaledProblem); * ParameterSelection.Grid(edgeNN, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(edgeNN, parameters); */ /* * //Hybrid: KNN-based based + FFA-Based * //Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(trainScaledProblem); * int k = 50; * int numberOfSubset = 100; //subset to select for training * Problem dataSubset = Training.computeNearestNeighbour(k, subP, numberOfSubset); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(subP, parameters); */ /* * //Hybrid: Clustering-Based + FFA-Based * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(boundaryInstance); * ParameterSelection.Grid(subP, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(boundaryInstance, parameters); */ /* //Hybrid: Clustering based + FFA-Based + KNN-Based * Problem boundaryInstance = Training.ClusteringBoundaryInstance(trainScaledProblem); * FireflyInstanceSelection fi = new FireflyInstanceSelection(); * Problem subP = fi.firefly_simple(boundaryInstance); * int k = 50; * int numberOfSubset = 100; //subset to select for training * Problem dataSubset = Training.computeNearestNeighbour(k, boundaryInstance, numberOfSubset); * ParameterSelection.Grid(dataSubset, parameters, "params.txt", out C, out Gamma); * parameters.C = C; * parameters.Gamma = Gamma; * Model model = Training.Train(dataSubset, parameters); */ //Train the model using the optimal parameters. //Model model = Training.Train(trainScaledProblem, parameters); //removing support vectors that contributes less to the decision surface //Model submod = Training.performSupportVectorReduction(model, trainScaledProblem); //Perform classification on the test data, putting the results in results.txt. //classficatnAccuracySum += Prediction.Predict(testScaledProblem, "ClassificationResults.txt", model, false); classficatnAccuracy = Prediction.Predict(testScaledProblem, "ClassificationResults.txt", model, false); //classfication accuracy for each iteration ->for the purpose of outputting to the text file classficatnAccuracySum += classficatnAccuracy; Console.WriteLine("\nClassification Accuracy: {0}%", 100 * classficatnAccuracy); PerformanceEvaluator pp = new PerformanceEvaluator("ClassificationResults.txt", test, out TP, out TN, out FP, out FN, out P, out F_M); sumTP += TP; sumTN += TN; sumFP += FP; sumFN += FN; sumP += P; sumF_M += F_M; //saving all the output to a file string outpt = string.Format("Cross Validation: {0}, Run number {1}, CAccuracy: {2:0.0000} FP: {3:0.0000}, FN: {4:0.0000}, Recall: {5:0.0000}, Precision: {6:0.0000}, FMeasure: {7:0.0000}", a + 1, aa + 1, (classficatnAccuracy * 100), (FP * 100), (FN * 100), (TP * 100), (P * 100), (F_M * 100)); File.AppendAllText(outputEvaluationFilePath, outpt); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); } if (classficatnAccuracy * 100 > globalBest) { globalBest = classficatnAccuracy * 100; } } classficatnAccuracySum = (classficatnAccuracySum * 100) / N_Fold; //converting to percentage and dividing by the number of folds sumFP = (sumFP * 100) / N_Fold; //calculating the average cross validation for False Positive over 10 folds sumTP = (sumTP * 100) / N_Fold; //calculating the average cross validation for Recall over 10 folds sumFN = (sumFN * 100) / N_Fold; //calculating the average cross validation for False Negative over 10 folds sumF_M = (sumF_M * 100) / N_Fold; //calculating the average cross validation for F Measure over 10 folds sumP = (sumP * 100) / N_Fold; //calculating the average cross validation for Precision over 10 folds avgRuns += classficatnAccuracySum; avgFP += sumFP; avgFN += sumFN; avgR += sumTP; avgPr += sumP; avgFM += sumF_M; //saving all the outputs to a file File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, string.Format("Average Calculations....Run Number: {0}", aa + 1)); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); string outpt2 = string.Format("Run number {0}, Average CAccuracy: {1:0.0000} FP: {2:0.0000}, FN: {3:0.0000}, Recall: {4:0.0000}, Precision: {5:0.0000}, FMeasure: {6:0.0000}", aa + 1, classficatnAccuracySum, sumFP, sumFN, sumTP, sumP, sumF_M); File.AppendAllText(outputEvaluationFilePath, outpt2); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); Console.WriteLine("\nStep {0}...............................\n", aa + 1); } DateTime end = DateTime.Now; TimeSpan duration = end - start; double time = duration.Minutes * 60.0 + duration.Seconds + duration.Milliseconds / 1000.0; Console.WriteLine("\nTotal processing time {0:########.00} seconds\n", time); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, "Total processing time:\n" + time + " Seconds"); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); //sending all the outputs to the screen Console.WriteLine("\nOverall Average Accuracy: {0:0.00}% \nGlobal Best: {1:0.00}%", avgRuns / n_Runs, globalBest); Console.WriteLine("\n\nTotal False Positive: {0:0.00}%\nTotal False Negative: {1:0.00}%\nRecall: {2:0.00}%\nPrecision: {3:0.00}%\nF_Measure: {4:0.00}%", (avgFP / n_Runs), (avgFN / n_Runs), (avgR / n_Runs), (avgPr / n_Runs), (avgFM / n_Runs)); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, "Overall Average Calculations......."); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); File.AppendAllText(outputEvaluationFilePath, Environment.NewLine); string outpt3 = string.Format("Overall Average CAccuracy: {0:0.0000} FP: {1:0.0000}, FN: {2:0.0000}, Recall: {3:0.0000}, Precision: {4:0.0000}, FMeasure: {5:0.0000}", avgRuns / n_Runs, avgFP / n_Runs, avgFN / n_Runs, avgR / n_Runs, avgPr / n_Runs, avgFM / n_Runs); File.AppendAllText(outputEvaluationFilePath, outpt3); Console.ReadKey(); }
/// <summary> /// Возвращает тип класса к которому относится вектор /// </summary> /// <param name="testVector">Вектор</param> /// <returns></returns> public double Test(Node[] testVector) { double assignment = Prediction.Predict(model, testVector); return(assignment); }
private void TestClassifier() { Problem test = Problem.Read("test_samples"); Prediction.Predict(test, "result", model_svm, false); }
public double predict(Node[] test) { double preRes = Prediction.Predict(model, test); return(preRes); }
private void button2_Click(object sender, EventArgs e) { pictureBox2.Image = (Bitmap)pictureBox1.Image.Clone(); Bitmap src = new Bitmap(pictureBox2.Image); Bitmap res = new Bitmap(pictureBox2.Image); SaveFileDialog saveDialog = new SaveFileDialog(); src = resize(src, new Size(200, 200)); res = resize(res, new Size(200, 200)); pictureBox2.Image = src; srcImg = src; pictureBox2.Image = res; Bitmap sampleImage = new Bitmap(pictureBox2.Image); var rect = new Rectangle(0, 0, sampleImage.Width, sampleImage.Height); var data = sampleImage.LockBits(rect, ImageLockMode.ReadWrite, sampleImage.PixelFormat); var depth = Bitmap.GetPixelFormatSize(data.PixelFormat) / 8; //bytes per pixel var buffer = new byte[data.Width * data.Height * depth]; //copy pixels to buffer Marshal.Copy(data.Scan0, buffer, 0, buffer.Length); System.Threading.Tasks.Parallel.Invoke( () => { //upper-left Process(buffer, 0, 0, data.Width / 2, data.Height / 2, data.Width, depth); }, () => { //upper-right Process(buffer, data.Width / 2, 0, data.Width, data.Height / 2, data.Width, depth); }, () => { //lower-left Process(buffer, 0, data.Height / 2, data.Width / 2, data.Height, data.Width, depth); }, () => { //lower-right Process(buffer, data.Width / 2, data.Height / 2, data.Width, data.Height, data.Width, depth); } ); //Copy the buffer back to image Marshal.Copy(buffer, 0, data.Scan0, buffer.Length); sampleImage.UnlockBits(data); pictureBox2.Image = sampleImage; dstImg = sampleImage; void Process(byte[] buffer1, int x, int y, int endx, int endy, int width, int depth1) { for (int i = x; i < endx; i++) { for (int j = y; j < endy; j++) { var offset = ((j * width) + i) * depth; var B = buffer[offset + 0]; var G = buffer[offset + 1]; var R = buffer[offset + 2]; var a = Math.Max(R, Math.Max(B, G)); var b = Math.Min(R, Math.Min(B, G)); if (!(((R > 95) && (G > 40) && (B > 20) && ((a - b) > 15) && (Math.Abs(R - G) > 15) && (R > G) && (R > B)) || ((R > 220) && (G > 210) && (B > 170) && ((a - b) > 15) && (Math.Abs(R - G) > 15) && (R > G) && (G > B)))) { buffer[offset + 0] = buffer[offset + 1] = buffer[offset + 2] = 0; } else { buffer[offset + 0] = buffer[offset + 1] = buffer[offset + 2] = 255; } } } } //Graysacle GrayscaleBT709 filter = new GrayscaleBT709(); pictureBox2.Image = filter.Apply((Bitmap)pictureBox2.Image); dstImg = filter.Apply(dstImg); //Dilatation try { Dilatation filter1 = new Dilatation(); pictureBox2.Image = filter1.Apply((Bitmap)pictureBox2.Image); dstImg = filter1.Apply(dstImg); } catch (Exception) { System.Windows.Forms.MessageBox.Show("Apply Grayscale"); } //Biggest Blob Extraction ExtractBiggestBlob filter2 = new ExtractBiggestBlob(); pictureBox2.Image = filter2.Apply((Bitmap)pictureBox2.Image); dstImg = filter2.Apply(dstImg); blob = filter2.BlobPosition; Bitmap newBmp = new Bitmap(dstImg.Width, dstImg.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); using (Graphics gfx = Graphics.FromImage(newBmp)) { gfx.DrawImage(dstImg, 0, 0); } //newBmp = dstImg; for (int i = 0; i < dstImg.Width; i++) { for (int j = 0; j < dstImg.Height; j++) { System.Drawing.Color srcColor = srcImg.GetPixel(i + blob.X, j + blob.Y); System.Drawing.Color dstColor = dstImg.GetPixel(i, j); if (!(dstColor.R >= 0 && dstColor.R <= 10 && dstColor.G >= 0 && dstColor.G <= 10 && dstColor.B >= 0 && dstColor.B <= 10)) { newBmp.SetPixel(i, j, srcColor); } } } dstImg = newBmp; pictureBox2.Image = newBmp; List <double> edgeCount = new List <double>(); List <double> ratio = new List <double>(); int pixelCount = 0; Bitmap hoefImage = new Bitmap(pictureBox2.Image); GrayscaleBT709 grayFilter = new GrayscaleBT709(); hoefImage = grayFilter.Apply((Bitmap)pictureBox2.Image); CannyEdgeDetector cannyFilter = new CannyEdgeDetector(0, 0, 1.4); hoefImage = cannyFilter.Apply(hoefImage); pictureBox2.Image = hoefImage; var imgarray = new System.Drawing.Image[36]; for (int i = 0; i < 6; i++) { for (int j = 0; j < 6; j++) { pixelCount++; var index = i * 6 + j; imgarray[index] = new Bitmap(40, 40); var graphics = Graphics.FromImage(imgarray[index]); graphics.DrawImage(hoefImage, new Rectangle(0, 0, 40, 40), new Rectangle(i * 40, j * 40, 40, 40), GraphicsUnit.Pixel); graphics.Dispose(); } } for (int n = 0; n < 36; n++) { int counter = 0; Bitmap bufferImage = new Bitmap(imgarray[n]); for (int i = 0; i < 40; i++) { for (int j = 0; j < 40; j++) { System.Drawing.Color hoefColor = bufferImage.GetPixel(i, j); if (!(hoefColor.R == 0 && hoefColor.G == 0 && hoefColor.B == 0)) { counter++; } } } edgeCount.Add(counter); } double Total = edgeCount.Sum(); foreach (double x in edgeCount) { var a = x / Total; ratio.Add(a); } FileStream fs = new FileStream(@"E:\test.txt", FileMode.Create, FileAccess.Write); StreamWriter sw = new StreamWriter(fs); int no = 0; sw.Write((++no) + " "); for (int i = 0; i < ratio.Count; ++i) { sw.Write(i + ":" + ratio[i].ToString() + " "); } sw.WriteLine(); sw.Close(); fs.Close(); //Support Vector Machine Problem train = Problem.Read(@"E:\AI.txt"); Problem test = Problem.Read(@"E:\test.txt"); Parameter parameters = new Parameter(); double C; double Gamma; parameters.C = 32; parameters.Gamma = 8; Model model = Training.Train(train, parameters); Prediction.Predict(test, @"E:\result.txt", model, false); FileStream fs1 = new FileStream(@"E:\result.txt", FileMode.Open, FileAccess.Read); StreamReader sw1 = new StreamReader(fs1); string w = sw1.ReadLine(); if (w == "1") { MessageBox.Show("A"); } else if (w == "2") { MessageBox.Show("B"); } else if (w == "3") { MessageBox.Show("C"); } else if (w == "4") { MessageBox.Show("D"); } else if (w == "5") { MessageBox.Show("E"); } else if (w == "6") { MessageBox.Show("F"); } else if (w == "7") { MessageBox.Show("G"); } else if (w == "8") { MessageBox.Show("H"); } else if (w == "9") { MessageBox.Show("I"); } else if (w == "10") { MessageBox.Show("J"); } else if (w == "11") { MessageBox.Show("K"); } //else { MessageBox.Show("L"); } }
private void resultGestureToolStripMenuItem_Click(object sender, EventArgs e) { int dir; int no; List <string> filedir = new List <string>(Directory.GetDirectories(path)); for (dir = 0, no = 0; (dir < filedir.Count && no <= 26); dir++, no++) { string[] filePaths = Directory.GetFiles(filedir[dir].ToString()); List <Bitmap> y = new List <Bitmap>(); foreach (var iI in filePaths) { Bitmap Image = new Bitmap(iI); y.Add(Image); } foreach (Bitmap img in y) { pictureBox1.Image = img; srcImg = img; dstImg = img; Bitmap skin = new Bitmap(pictureBox1.Image); var rect = new Rectangle(0, 0, skin.Width, skin.Height); var data = skin.LockBits(rect, ImageLockMode.ReadWrite, skin.PixelFormat); var depth = Bitmap.GetPixelFormatSize(data.PixelFormat) / 8; //bytes per pixel var buffer = new byte[data.Width * data.Height * depth]; //copy pixels to buffer Marshal.Copy(data.Scan0, buffer, 0, buffer.Length); System.Threading.Tasks.Parallel.Invoke( () => { //upper-left Process(buffer, 0, 0, data.Width / 2, data.Height / 2, data.Width, depth); }, () => { //upper-right Process(buffer, data.Width / 2, 0, data.Width, data.Height / 2, data.Width, depth); }, () => { //lower-left Process(buffer, 0, data.Height / 2, data.Width / 2, data.Height, data.Width, depth); }, () => { //lower-right Process(buffer, data.Width / 2, data.Height / 2, data.Width, data.Height, data.Width, depth); } ); //Copy the buffer back to image Marshal.Copy(buffer, 0, data.Scan0, buffer.Length); skin.UnlockBits(data); pictureBox2.Image = skin; Bitmap src = new Bitmap(pictureBox1.Image); Bitmap res = new Bitmap(pictureBox2.Image); src = resize(src, new Size(200, 200)); res = resize(res, new Size(200, 200)); pictureBox1.Image = src; pictureBox2.Image = res; GrayscaleBT709 grayoject = new GrayscaleBT709(); pictureBox2.Image = grayoject.Apply((Bitmap)pictureBox2.Image); Dilatation filter = new Dilatation(); // apply the filter pictureBox2.Image = filter.Apply((Bitmap)pictureBox2.Image); ExtractBiggestBlob filter1 = new ExtractBiggestBlob(); pictureBox2.Image = filter.Apply((Bitmap)pictureBox2.Image); blob = filter1.BlobPosition; Bitmap src1 = new Bitmap(pictureBox1.Image); Bitmap res1 = new Bitmap(pictureBox2.Image); Bitmap newBmp = new Bitmap(src1.Width, res1.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); //Threshold t = new Threshold(); //pictureBox2.Image = t.Apply((Bitmap)pictureBox2.Image); for (int i = 0; i < res1.Width; i++) { for (int j = 0; j < res1.Height; j++) { System.Drawing.Color srcColor = src1.GetPixel(i + blob.X, j + blob.Y); System.Drawing.Color dstColor = res1.GetPixel(i, j); if (!(dstColor.R >= 0 && dstColor.R <= 10 && dstColor.G >= 0 && dstColor.G <= 10 && dstColor.B >= 0 && dstColor.B <= 10)) { newBmp.SetPixel(i, j, srcColor); } else { newBmp.SetPixel(i, j, Color.Black); } } } res1 = newBmp; pictureBox2.Image = newBmp; List <double> edgeCount = new List <double>(); List <double> ratio = new List <double>(); int pixelCount = 0; Bitmap Destimg = new Bitmap(pictureBox2.Image); GrayscaleBT709 go = new GrayscaleBT709(); pictureBox2.Image = go.Apply((Bitmap)pictureBox2.Image); Destimg = go.Apply(Destimg); CannyEdgeDetector filter2 = new CannyEdgeDetector(0, 0, 1.4); pictureBox2.Image = filter2.Apply((Bitmap)pictureBox2.Image); Destimg = filter2.Apply(Destimg); var imgarray = new System.Drawing.Image[36]; for (int i = 0; i < 6; i++) { for (int j = 0; j < 6; j++) { pixelCount++; var index = i * 6 + j; imgarray[index] = new Bitmap(40, 40); var graphics = Graphics.FromImage(imgarray[index]); graphics.DrawImage(Destimg, new Rectangle(0, 0, 40, 40), new Rectangle(i * 40, j * 40, 40, 40), GraphicsUnit.Pixel); graphics.Dispose(); } } for (int n = 0; n < 36; n++) { int counter = 0; Bitmap bufferImage = new Bitmap(imgarray[n]); for (int i = 0; i < 40; i++) { for (int j = 0; j < 40; j++) { System.Drawing.Color hoefColor = bufferImage.GetPixel(i, j); //if(hoefColor.R<=255 && hoefColor.R>=230 && hoefColor.G <= 255 && hoefColor.G >= 230 && hoefColor.B <= 255 && hoefColor.B >= 230) if (!(hoefColor.R == 0 && hoefColor.G == 0 && hoefColor.B == 0)) { counter++; } } } edgeCount.Add(counter); } double total = edgeCount.Sum(); foreach (double x in edgeCount) { var a = (float)x / total; ratio.Add(a); } FileStream fs = new FileStream(@"D:\AI.txt", FileMode.Append, FileAccess.Write); StreamWriter sw = new StreamWriter(fs); sw.Write((no) + " "); for (int i = 0; i < ratio.Count; ++i) { sw.Write(i + ":" + ratio[i].ToString() + " "); } sw.WriteLine(); sw.Close(); fs.Close(); Problem train = Problem.Read(@"D:\AI.txt"); Problem test = Problem.Read(@"D:\test.txt"); Parameter parameters = new Parameter(); double C; double Gamma; parameters.C = 32; parameters.Gamma = 8; Model model = Training.Train(train, parameters); Prediction.Predict(test, @"D:\result.txt", model, false); } } }
private void Detection() { var watch = System.Diagnostics.Stopwatch.StartNew(); if (Video.Image != null) { if (ModeList.selectedIndex == 0) { training = 1; int prev = AlphabetList.selectedIndex; if (AlphabetList.selectedIndex == 26 || prev == 26) { label = 67; } else if (AlphabetList.selectedIndex == -1) { label = prev; } else { label = AlphabetList.selectedIndex; } } else { training = 0; } ProgressBar.Visible = true; ProgressBar.Value = 0; ProgressBar.Maximum_Value = 9; ProgressBar.Value += 1; CapturedBox.Image = (Bitmap)Video.Image.Clone(); Bitmap src = new Bitmap(CapturedBox.Image); //skin detection var image = new Rectangle(0, 0, src.Width, src.Height); var value = src.LockBits(image, ImageLockMode.ReadWrite, src.PixelFormat); var size = Bitmap.GetPixelFormatSize(value.PixelFormat) / 8; var buffer = new byte[value.Width * value.Height * size]; Marshal.Copy(value.Scan0, buffer, 0, buffer.Length); System.Threading.Tasks.Parallel.Invoke( () => { Skin_process(buffer, 0, 0, value.Width / 2, value.Height / 2, value.Width, size); }, () => { Skin_process(buffer, 0, value.Height / 2, value.Width / 2, value.Height, value.Width, size); }, () => { Skin_process(buffer, value.Width / 2, 0, value.Width, value.Height / 2, value.Width, size); }, () => { Skin_process(buffer, value.Width / 2, value.Height / 2, value.Width, value.Height, value.Width, size); } ); Marshal.Copy(buffer, 0, value.Scan0, buffer.Length); src.UnlockBits(value); SkinBox.Image = src; if (Skin == 1) { ProgressBar.Value += 1; //Dilation & Erosion src = Grayscale.CommonAlgorithms.BT709.Apply(src); BinaryDilation3x3 dilatation = new BinaryDilation3x3(); BinaryErosion3x3 erosion = new BinaryErosion3x3(); for (int a = 1; a <= 10; a++) { src = dilatation.Apply(src); } for (int a = 1; a <= 10; a++) { src = erosion.Apply(src); } ProgressBar.Value += 1; NoiseBox.Image = src; //Blob try { ExtractBiggestBlob blob = new ExtractBiggestBlob(); src = blob.Apply(src); x = blob.BlobPosition.X; y = blob.BlobPosition.Y; ProgressBar.Value += 1; } catch { this.Show(); //MessageBox.Show("Lightning conditions are not good for detecting the gestures", "Bad Lights", MessageBoxButtons.OK, MessageBoxIcon.Information); } //Merge Bitmap srcImage = new Bitmap(CapturedBox.Image); Bitmap dstImage = new Bitmap(src); var srcrect = new Rectangle(0, 0, srcImage.Width, srcImage.Height); var dstrect = new Rectangle(0, 0, dstImage.Width, dstImage.Height); var srcdata = srcImage.LockBits(srcrect, ImageLockMode.ReadWrite, srcImage.PixelFormat); var dstdata = dstImage.LockBits(dstrect, ImageLockMode.ReadWrite, dstImage.PixelFormat); var srcdepth = Bitmap.GetPixelFormatSize(srcdata.PixelFormat) / 8; var dstdepth = Bitmap.GetPixelFormatSize(dstdata.PixelFormat) / 8; //bytes per pixel var srcbuffer = new byte[srcdata.Width * srcdata.Height * srcdepth]; var dstbuffer = new byte[dstdata.Width * dstdata.Height * dstdepth]; //copy pixels to buffer Marshal.Copy(srcdata.Scan0, srcbuffer, 0, srcbuffer.Length); Marshal.Copy(dstdata.Scan0, dstbuffer, 0, dstbuffer.Length); System.Threading.Tasks.Parallel.Invoke( () => { //upper-left Merge_process(srcbuffer, dstbuffer, x, 0, y, 0, x + (dstdata.Width / 2), dstdata.Width / 2, y + (dstdata.Height / 2), dstdata.Height / 2, srcdata.Width, dstdata.Width, srcdepth, dstdepth); }, () => { //upper-right Merge_process(srcbuffer, dstbuffer, x + (dstdata.Width / 2), dstdata.Width / 2, y, 0, x + (dstdata.Width), dstdata.Width, y + (dstdata.Height / 2), dstdata.Height / 2, srcdata.Width, dstdata.Width, srcdepth, dstdepth); }, () => { //lower-left Merge_process(srcbuffer, dstbuffer, x, 0, y + (dstdata.Height / 2), dstdata.Height / 2, x + (dstdata.Width / 2), dstdata.Width / 2, y + (dstdata.Height), dstdata.Height, srcdata.Width, dstdata.Width, srcdepth, dstdepth); }, () => { //lower-right Merge_process(srcbuffer, dstbuffer, x + (dstdata.Width / 2), dstdata.Width / 2, y + (dstdata.Height / 2), dstdata.Height / 2, x + (dstdata.Width), dstdata.Width, y + (dstdata.Height), dstdata.Height, srcdata.Width, dstdata.Width, srcdepth, dstdepth); } ); //Copy the buffer back to image Marshal.Copy(srcbuffer, 0, srcdata.Scan0, srcbuffer.Length); Marshal.Copy(dstbuffer, 0, dstdata.Scan0, dstbuffer.Length); srcImage.UnlockBits(srcdata); dstImage.UnlockBits(dstdata); src = dstImage; ProgressBar.Value += 1; CropBox.Image = src; //Resize ResizeBilinear resize = new ResizeBilinear(200, 200); src = resize.Apply(src); ProgressBar.Value += 1; //Edges src = Grayscale.CommonAlgorithms.BT709.Apply((Bitmap)src); SobelEdgeDetector edges = new SobelEdgeDetector(); src = edges.Apply(src); ProgressBar.Value += 1; EdgeDetectorBox.Image = src; //HOEF Bitmap block = new Bitmap(src); int[] edgescount = new int[50]; double[] norm = new double[200]; String text = null; int sum = 0; int z = 1; for (int p = 1; p <= 6; p++) { for (int q = 1; q <= 6; q++) { for (int x = (p - 1) * block.Width / 6; x < (p * block.Width / 6); x++) { for (int y = (q - 1) * block.Height / 6; y < (q * block.Height / 6); y++) { Color colorPixel = block.GetPixel(x, y); int r = colorPixel.R; int g = colorPixel.G; int b = colorPixel.B; if (r != 0 & g != 0 & b != 0) { edgescount[z]++; } } } z++; } } for (z = 1; z <= 36; z++) { sum = sum + edgescount[z]; } for (z = 1; z <= 36; z++) { norm[z] = (double)edgescount[z] / sum; text = text + " " + z.ToString() + ":" + norm[z].ToString(); } if (training == 1) { File.AppendAllText(@"D:\train.txt", label.ToString() + text + Environment.NewLine); ProgressBar.Value += 1; } else { File.WriteAllText(@"D:\test.txt", label.ToString() + text + Environment.NewLine); ProgressBar.Value += 1; //SVM Problem train = Problem.Read(@"D:\train.txt"); Problem test = Problem.Read(@"D:\test.txt"); Parameter parameter = new Parameter() { C = 32, Gamma = 8 }; Model model = Training.Train(train, parameter); Prediction.Predict(test, @"D:\result.txt", model, false); int value1 = Convert.ToInt32(File.ReadAllText(@"D:\result.txt")); String alphabet = null; if (value1 == 27) { alphabet += "Welcome "; } else if (value1 == 28) { alphabet += "Good Morning"; } else if (value1 == 29) { alphabet += "Thank You"; } else { alphabet += (char)(65 + value1); } OutputText.Text = alphabet; SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(); speechSynthesizer.SetOutputToDefaultAudioDevice(); speechSynthesizer.Volume = 100; speechSynthesizer.Rate = -2; speechSynthesizer.SelectVoiceByHints(VoiceGender.Female, VoiceAge.Child); speechSynthesizer.SpeakAsync(alphabet); if (alphabet == " ") { speechSynthesizer.SpeakAsync(OutputText.Text); } ProgressBar.Value += 1; } } else { this.Show(); } watch.Stop(); var time = (watch.ElapsedMilliseconds); float secs = (float)time / 1000; ExecutionTimeBox.Text = Convert.ToString(secs) + " " + "Seconds"; } }
private void button2_Click(object sender, EventArgs e) { if (FinalFrame.IsRunning == true) { pictureBox2.Image = (Bitmap)pictureBox1.Image.Clone(); } Bitmap InputImage = (Bitmap)pictureBox2.Image; Rectangle Tile = new Rectangle(0, 0, InputImage.Width, InputImage.Height); BitmapData bitmapdata = InputImage.LockBits(Tile, ImageLockMode.ReadWrite, InputImage.PixelFormat); int formatsize = Bitmap.GetPixelFormatSize(bitmapdata.PixelFormat) / 8; var tempreg = new byte[bitmapdata.Width * bitmapdata.Height * formatsize]; Marshal.Copy(bitmapdata.Scan0, tempreg, 0, tempreg.Length); System.Threading.Tasks.Parallel.Invoke( () => { multithread1(tempreg, 0, 0, bitmapdata.Width / 2, bitmapdata.Height / 2, bitmapdata.Width, formatsize); }, () => { multithread1(tempreg, 0, bitmapdata.Height / 2, bitmapdata.Width / 2, bitmapdata.Height, bitmapdata.Width, formatsize); }, () => { multithread1(tempreg, bitmapdata.Width / 2, 0, bitmapdata.Width, bitmapdata.Height / 2, bitmapdata.Width, formatsize); }, () => { multithread1(tempreg, bitmapdata.Width / 2, bitmapdata.Height / 2, bitmapdata.Width, bitmapdata.Height, bitmapdata.Width, formatsize); } ); Marshal.Copy(tempreg, 0, bitmapdata.Scan0, tempreg.Length); InputImage.UnlockBits(bitmapdata); Grayscale grayfilter = new Grayscale(0.2125, 0.7154, 0.0721);//GrayscaleBT709 grayfilter=new GrayscaleBT709(); Dilatation dilatefilter = new Dilatation(); Erosion erodefilter = new Erosion(); InputImage = grayfilter.Apply((Bitmap)InputImage); InputImage = dilatefilter.Apply((Bitmap)InputImage); InputImage = erodefilter.Apply((Bitmap)InputImage); //Opening openfilter = new Opening(); //InputImage=openfilter.Apply((Bitmap)InputImage); //Closing closefilter = new Closing(); //InputImage=closefilter.Apply((Bitmap)InputImage); ExtractBiggestBlob blob = new ExtractBiggestBlob(); InputImage = blob.Apply(InputImage); int cordx = blob.BlobPosition.X; int cordy = blob.BlobPosition.Y; Bitmap source = new Bitmap(pictureBox1.Image); Bitmap destination = new Bitmap(InputImage); var sourcerectangle = new Rectangle(0, 0, source.Width, source.Height); var destinationrectangle = new Rectangle(0, 0, destination.Width, destination.Height); var sourcedata = source.LockBits(sourcerectangle, ImageLockMode.ReadWrite, source.PixelFormat); var destinationdata = destination.LockBits(destinationrectangle, ImageLockMode.ReadWrite, destination.PixelFormat); var sourcedepth = Bitmap.GetPixelFormatSize(sourcedata.PixelFormat) / 8; var destinationdepth = Bitmap.GetPixelFormatSize(destinationdata.PixelFormat) / 8; var source1 = new byte[sourcedata.Width * sourcedata.Height * sourcedepth]; var destination1 = new byte[destinationdata.Width * destinationdata.Height * destinationdepth]; Marshal.Copy(sourcedata.Scan0, source1, 0, source1.Length); Marshal.Copy(destinationdata.Scan0, destination1, 0, destination1.Length); System.Threading.Tasks.Parallel.Invoke( () => { multithread2(source1, destination1, cordx, 0, cordy, 0, cordx + (destinationdata.Width / 2), destinationdata.Width / 2, cordy + (destinationdata.Height / 2), destinationdata.Height / 2, sourcedata.Width, destinationdata.Width, sourcedepth, destinationdepth); }, () => { multithread2(source1, destination1, cordx + (destinationdata.Width / 2), destinationdata.Width / 2, cordy, 0, cordx + (destinationdata.Width), destinationdata.Width, cordy + (destinationdata.Height / 2), destinationdata.Height / 2, sourcedata.Width, destinationdata.Width, sourcedepth, destinationdepth); }, () => { multithread2(source1, destination1, cordx, 0, cordy + (destinationdata.Height / 2), destinationdata.Height / 2, cordx + (destinationdata.Width / 2), destinationdata.Width / 2, cordy + (destinationdata.Height), destinationdata.Height, sourcedata.Width, destinationdata.Width, sourcedepth, destinationdepth); }, () => { multithread2(source1, destination1, cordx + (destinationdata.Width / 2), destinationdata.Width / 2, cordy + (destinationdata.Height / 2), destinationdata.Height / 2, cordx + (destinationdata.Width), destinationdata.Width, cordy + (destinationdata.Height), destinationdata.Height, sourcedata.Width, destinationdata.Width, sourcedepth, destinationdepth); } ); Marshal.Copy(source1, 0, sourcedata.Scan0, source1.Length); Marshal.Copy(destination1, 0, destinationdata.Scan0, destination1.Length); source.UnlockBits(sourcedata); destination.UnlockBits(destinationdata); InputImage = destination; InputImage = grayfilter.Apply((Bitmap)InputImage); CannyEdgeDetector edgesoutline = new CannyEdgeDetector(); InputImage = edgesoutline.Apply(InputImage); pictureBox2.Image = InputImage; Bitmap blocks = new Bitmap(InputImage); int[] numofedges = new int[100]; double[] normalized = new double[400]; String alphabet = null; int total = 0; int sq = 1; for (int p = 1; p <= 8; p++) { for (int q = 1; q <= 8; q++) { for (int x = (p - 1) * blocks.Width / 8; x < (p * blocks.Width / 8); x++) { for (int y = (q - 1) * blocks.Height / 8; y < (q * blocks.Height / 8); y++) { Color colorPixel = blocks.GetPixel(x, y); int r = colorPixel.R; int g = colorPixel.G; int b = colorPixel.B; if (r != 0 & g != 0 & b != 0) { numofedges[sq]++; } } } sq++; } } for (sq = 1; sq <= 64; sq++) { total = total + numofedges[sq]; } for (sq = 1; sq <= 64; sq++) { normalized[sq] = (double)numofedges[sq] / total; alphabet = alphabet + " " + sq.ToString() + ":" + normalized[sq].ToString(); } File.WriteAllText(@"datasets\testalpha.txt", label.ToString() + alphabet + Environment.NewLine); Problem train = Problem.Read(@"datasets\trainedset.txt"); Problem test = Problem.Read(@"datasets\testalpha.txt"); Parameter parameter = new Parameter(); parameter.C = 32; parameter.Gamma = 8; Model model = Training.Train(train, parameter); Prediction.Predict(test, @"datasets\result.txt", model, false); int value = Convert.ToInt32(File.ReadAllText(@"datasets\result.txt")); String res = null; res = res + (char)(value + 65); label1.Text = res; }
public void svmproject(Dictionary <int, Characteristic> Characteristics) { Dictionary <int, Characteristic> _characteristics = new Dictionary <int, Characteristic>(); _characteristics = Characteristics; Model model; RangeTransform range; double C; double gamma; // default values Parameter parameters = new Parameter(); //parameters.SvmType = SvmType.C_SVC; //parameters.KernelType = KernelType.RBF; //parameters.Degree = 3; //parameters.Gamma = 0; //parameters.Coefficient0 = 0; //parameters.Nu = 0.5; //parameters.CacheSize = 40; //parameters.C = 1000; //parameters.EPS = 1e-3; //parameters.P = 0.1; //parameters.Shrinking = true; //parameters.WeightCount = 0; //parameters.WeightLabels = new int[0]; //parameters.Weights = new double[0]; //parameters.C = 5; //parameters.Gamma = 1; string str = null; for (int i = 1; i < _characteristics.Count(); i++) { if (_characteristics[i].IsQualifiedColony == false && _characteristics[i].IsInvalidColony == true) { str = str + "0"; str = str + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() + " 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString() + " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n"; } if (_characteristics[i].IsQualifiedColony == true && _characteristics[i].IsInvalidColony == false) { str = str + "1"; str = str + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() + " 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString() + " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n"; } } if (str != null) { byte[] array = Encoding.ASCII.GetBytes(str); MemoryStream stream = new MemoryStream(array); //convert stream 2 string Problem train = new Problem(); train = Problem.Read(stream); range = Scaling.DetermineRange(train); train = Scaling.Scale(train, range); //String outfile001="D:\\parameters.txt"; ParameterSelection.Grid(train, parameters, @"D:\\parameters.txt", out C, out gamma); parameters.C = C; parameters.Gamma = gamma; model = Training.Train(train, parameters); //MessageBox.Show("学习完毕"); //stream.Dispose(); stream.Close(); } else { MessageBox.Show("无学习数据"); model = null; range = null; } string str1 = null; for (int i = 1; i < _characteristics.Count(); i++) { str1 = str1 + "0"; str1 = str1 + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() + " 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString() + " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n"; } if (str1 != null) { byte[] array = Encoding.ASCII.GetBytes(str1); MemoryStream stream = new MemoryStream(array); //convert stream 2 string Problem pre = new Problem(); pre = Problem.Read(stream); pre = Scaling.Scale(pre, range); Prediction.Predict(pre, @"D:\result.txt", model, false); MessageBox.Show("筛选完毕"); //stream.Dispose(); stream.Close(); } else { MessageBox.Show("无筛选数据"); } //svm_problem prob = new svm_problem(); //prob.l = point_list.Count; //prob.y = new double[prob.l]; // if(param.svm_type == svm_parameter.EPSILON_SVR || // param.svm_type == svm_parameter.NU_SVR) //{ // if(param.gamma == 0) param.gamma = 1; // prob.x = new svm_node[prob.l][]; // for(int i=0;i<prob.l;i++) // { // point p = (point)point_list[i]; // prob.x[i][0] = new svm_node(); // prob.x[i][0].index = 1; // prob.x[i][0].value_Renamed = p.x; // prob.y[i] = p.y; // } // svm_model model = svm.svm_train(prob, param); // svm_node[] x = new svm_node[1]; // x[0] = new svm_node(); // x[0].index = 1; // int[] j = new int[XLEN]; //C = Convert.ToInt16(numericUpDown8.Value); //gamma = Convert.ToInt16(numericUpDown9.Value); //StudyAlgorithm study = new StudyAlgorithm(); //study.GetModel(AllColony, C, gamma, out model, out range); //ScreenAlgorithm screenAlgorithm = new ScreenAlgorithm(); //screenAlgorithm.ScreenTheColony(CharacteristicsValue, model, range); }