private void addParameterToIdentificationParameter(ParameterSelection parameterSelection) { _identificationParameter.AddLinkedParameter(parameterSelection); ParameterLinkedToIdentificationParameter(this, new ParameterInIdentificationParameterEventArgs(_identificationParameter, parameterSelection)); }
public IdentificationParameter CreateFor(ParameterSelection parameterSelection, ParameterIdentification parameterIdentification) { return(CreateFor(new[] { parameterSelection }, parameterIdentification)); }
protected override void Context() { base.Context(); sut.ParameterLinkedToIdentificationParameter += (o, e) => { _newLinkedParameter = e.LinkedParameter; }; }
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); }
protected override void Context() { _modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>(); _residualCalculatorFactory = A.Fake <IResidualCalculatorFactory>(); _timeGridUpdater = A.Fake <ITimeGridUpdater>(); _simModelBatchFactory = A.Fake <ISimModelBatchFactory>(); _optimizationAlgorithmMapper = A.Fake <IParameterIdentificationAlgorithmToOptmizationAlgorithmMapper>(); _outputSelectionUpdater = A.Fake <IOutputSelectionUpdater>(); _coreUserSettings = A.Fake <ICoreUserSettings>(); _jacobianMatrixCalculator = A.Fake <IJacobianMatrixCalculator>(); _coreUserSettings.MaximumNumberOfCoresToUse = 2; sut = new ParameterIdentificationRun(_residualCalculatorFactory, _timeGridUpdater, _simModelBatchFactory, _modelCoreSimulationMapper, _optimizationAlgorithmMapper, _outputSelectionUpdater, _coreUserSettings, _jacobianMatrixCalculator); _simulation = A.Fake <ISimulation>(); _parameter1 = A.Fake <IParameter>(); _parameter1.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _parameter1.Value = 15; _parameter2 = A.Fake <IParameter>(); _parameter2.Value = 35; _parameter2.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.Configuration.LLOQMode = LLOQModes.OnlyObservedData; _parameterIdentification.Configuration.RemoveLLOQMode = RemoveLLOQModes.NoTrailing; _parameterIdentification.AddSimulation(_simulation); _parameterSelection1 = ParameterSelectionFor(_parameter1, "ParameterPath1"); _parameterSelection2 = ParameterSelectionFor(_parameter2, "ParameterPath2"); _identificationParameter = DomainHelperForSpecs.IdentificationParameter("IdParam", min: 10, max: 20, startValue: 15); _identificationParameter.AddLinkedParameter(_parameterSelection1); _identificationParameter.AddLinkedParameter(_parameterSelection2); _modelCoreSimulation = A.Fake <IModelCoreSimulation>(); A.CallTo(() => _modelCoreSimulationMapper.MapFrom(_simulation, true)).Returns(_modelCoreSimulation); _outputMapping = A.Fake <OutputMapping>(); A.CallTo(() => _outputMapping.UsesSimulation(_simulation)).Returns(true); A.CallTo(() => _outputMapping.WeightedObservedData.ObservedData).Returns(DomainHelperForSpecs.ObservedData()); _parameterIdentification.AddOutputMapping(_outputMapping); _simModelBatch = A.Fake <ISimModelBatch>(); A.CallTo(() => _simModelBatchFactory.Create()).Returns(_simModelBatch); _parameterIdentification.AddIdentificationParameter(_identificationParameter); _residualCalculator = A.Fake <IResidualCalculator>(); A.CallTo(_residualCalculatorFactory).WithReturnType <IResidualCalculator>().Returns(_residualCalculator); _algorithm = A.Fake <IOptimizationAlgorithm>(); A.CallTo(() => _optimizationAlgorithmMapper.MapFrom(_parameterIdentification.AlgorithmProperties)).Returns(_algorithm); _cancellationTokenSource = new CancellationTokenSource(); _cancellationToken = _cancellationTokenSource.Token; _runInitializer = A.Fake <IParameterIdentifcationRunInitializer>(); A.CallTo(() => _runInitializer.InitializeRun()).ReturnsAsync(_parameterIdentification); PerformExtraInitializationSteps(); sut.InitializeWith(_runInitializer); }
public virtual bool Analyzes(ParameterSelection parameterSelection) { return(Equals(ParameterSelection, parameterSelection)); }
private static bool isNonFormulaParameter(ParameterSelection parameterSelection) { var parameter = parameterSelection.Parameter; return(parameter.IsFixedValue || !parameter.Formula.IsExplicit()); }
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(); }
private static bool isConstantParameter(ParameterSelection parameterSelection) => parameterSelection.Parameter.IsConstantParameter();
public double OptimizedParameterValueFor(OptimizedParameterValue optimizedParameterValue, ParameterSelection linkedParameter) { return(OptimizedParameterValueFor(optimizedParameterValue.Value, linkedParameter)); }
public ParameterInIdentificationParameterEventArgs(IdentificationParameter identificationParameter, ParameterSelection linkedParameter) : base(identificationParameter) { LinkedParameter = linkedParameter; }
public bool LinksParameter(ParameterSelection parameterSelection) { return(parameterSelection.Simulation != null && _allLinkedParameters.Contains(parameterSelection)); }
protected override void ActionForLinkedParameterIsNotInSimulation(ParameterIdentification parameterIdentification, ISimulation newSimulation, ParameterSelection linkedParameter, IdentificationParameter identificationParameter) { identificationParameter.RemovedLinkedParameter(linkedParameter); }
public virtual bool IdentifiesParameter(ParameterSelection parameterSelection) { return(_allIdentificationParameters.Any(x => x.LinksParameter(parameterSelection))); }
//context shoud represent use case defined in 47-7990 Management of Jacobi Matrix protected override void Context() { _parameterIdentification = A.Fake <ParameterIdentification>(); _runResult = A.Fake <OptimizationRunResult>(); _simModelBatches = new Dictionary <ISimulation, ISimModelBatch>(); _allOutputMappings = new List <OutputMapping>(); _allVariableIdentificationParameters = new List <IdentificationParameter>(); A.CallTo(() => _parameterIdentification.AllOutputMappings).Returns(_allOutputMappings); A.CallTo(() => _parameterIdentification.AllVariableIdentificationParameters).Returns(_allVariableIdentificationParameters); sut = new JacobianMatrixCalculator(); _output1 = A.Fake <OutputMapping>(); _simulation1 = A.Fake <ISimulation>(); _simModelBatch1 = A.Fake <ISimModelBatch>(); _simModelBatches.Add(_simulation1, _simModelBatch1); A.CallTo(() => _output1.Simulation).Returns(_simulation1); A.CallTo(() => _output1.FullOutputPath).Returns("S1|OutputPath1"); A.CallTo(() => _output1.OutputPath).Returns("OutputPath1"); _allOutputMappings.Add(_output1); _output2 = A.Fake <OutputMapping>(); _simulation2 = A.Fake <ISimulation>(); _simModelBatch2 = A.Fake <ISimModelBatch>(); A.CallTo(() => _output2.Simulation).Returns(_simulation2); A.CallTo(() => _output2.FullOutputPath).Returns("S2|OutputPath2"); A.CallTo(() => _output2.OutputPath).Returns("OutputPath2"); _simModelBatches.Add(_simulation2, _simModelBatch2); _allOutputMappings.Add(_output2); _identificationParameter1 = new IdentificationParameter().WithName("IP1"); _identificationParameter2 = new IdentificationParameter().WithName("IP2"); _ps1 = A.Fake <ParameterSelection>(); _ps1.Parameter.Value = 100; A.CallTo(() => _ps1.FullQuantityPath).Returns("S1|ParameterPath1"); A.CallTo(() => _ps1.Path).Returns("ParameterPath1"); A.CallTo(() => _ps1.Simulation).Returns(_simulation1); _identificationParameter1.AddLinkedParameter(_ps1); _ps2 = A.Fake <ParameterSelection>(); _ps2.Parameter.Value = 200; A.CallTo(() => _ps2.FullQuantityPath).Returns("S2|ParameterPath2"); A.CallTo(() => _ps2.Path).Returns("ParameterPath2"); A.CallTo(() => _ps2.Simulation).Returns(_simulation2); A.CallTo(() => _ps2.Dimension).Returns(_ps1.Dimension); _identificationParameter1.AddLinkedParameter(_ps2); _ps3 = A.Fake <ParameterSelection>(); _ps3.Parameter.Value = 300; A.CallTo(() => _ps3.FullQuantityPath).Returns("S2|ParameterPath3"); A.CallTo(() => _ps3.Path).Returns("ParameterPath3"); A.CallTo(() => _ps3.Simulation).Returns(_simulation2); _identificationParameter2.AddLinkedParameter(_ps3); _allVariableIdentificationParameters.Add(_identificationParameter1); _allVariableIdentificationParameters.Add(_identificationParameter2); A.CallTo(() => _runResult.AllResidualsFor(_output1.FullOutputPath)).Returns(new[] { new Residual(1, 11, 1), new Residual(2, 21, 2), new Residual(3, 31, 0) }); A.CallTo(() => _runResult.AllResidualsFor(_output2.FullOutputPath)).Returns(new[] { new Residual(1, 12, 3), new Residual(3, 32, 4), new Residual(4, 42, 5) }); A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps1.Path)).Returns(new[] { 11d, 21d, 31d, 41d, 51d }); A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps2.Path)).Throws(new OSPSuiteException()); A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps3.Path)).Throws(new OSPSuiteException()); A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps1.Path)).Throws(new OSPSuiteException()); A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps2.Path)).Returns(new[] { 12d, 22d, 32d, 42d, 52d, 62d }); A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps3.Path)).Returns(new[] { 13d, 23d, 33d, 43d, 53d, 63d }); _simResults1 = new DataColumn { BaseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs()) { Values = new[] { 1f, 2f, 3f, 4f, 5f } }, Values = new[] { 10f, 20f, 30f, 40f, 50f } }; A.CallTo(() => _runResult.SimulationResultFor(_output1.FullOutputPath)).Returns(_simResults1); _simResults2 = new DataColumn { BaseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs()) { Values = new[] { 1f, 2f, 3f, 4f, 5f, 6f } }, Values = new[] { 10f, 20f, 30f, 40f, 50f, 60f } }; A.CallTo(() => _runResult.SimulationResultFor(_output2.FullOutputPath)).Returns(_simResults2); }
private void addParameterSelectionToParameterIdentification(ParameterIdentification parameterIdentification, ParameterSelection parameterSelection) { var identificationParameter = parameterIdentification.IdentificationParameterByLinkedPath(parameterSelection.Path); if (identificationParameter != null) { identificationParameter.AddLinkedParameter(parameterSelection); } else { parameterIdentification.AddIdentificationParameter(_identificationParameterFactory.CreateFor(parameterSelection, parameterIdentification)); } }
public override void GlobalContext() { base.GlobalContext(); _observedData = DomainHelperForSpecs.ObservedData(); _sim1 = new IndividualSimulation { Id = "Sim1", Name = "Sim1", IsLoaded = true, Model = new Model { Root = new Container() } }; _sim1.Model.Root.Add(new Container { new Parameter().WithName("P") }.WithName("Liver")); _sim2 = new IndividualSimulation { Id = "Sim2", Name = "Sim2", IsLoaded = true, Model = new Model { Root = new Container() } }; _sim2.Model.Root.Add(new Container { new Parameter().WithName("P") }.WithName("Liver")); _objectBaseRepository = IoC.Resolve <IWithIdRepository>(); var workspace = IoC.Resolve <IWorkspace>(); _project = IoC.Resolve <IPKSimProject>(); workspace.Project = _project; _objectBaseRepository.Register(_sim1); _objectBaseRepository.Register(_sim2); _project.AddObservedData(_observedData); _project.AddBuildingBlock(_sim1); _project.AddBuildingBlock(_sim2); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.AddSimulation(_sim1); _parameterIdentification.AddSimulation(_sim2); _outputMapping = new OutputMapping { WeightedObservedData = new WeightedObservedData(_observedData), OutputSelection = new SimulationQuantitySelection(_sim1, new QuantitySelection("A|B", QuantityType.Metabolite)), Weight = 5, Scaling = Scalings.Log }; _outputMapping.WeightedObservedData.Weights[1] = 10; _parameterIdentification.AddOutputMapping(_outputMapping); _identificationParameter = DomainHelperForSpecs.IdentificationParameter(min: 1, max: 10, startValue: 5); _parameterSelection1 = new ParameterSelection(_sim1, new QuantitySelection("Liver|P", QuantityType.Parameter)); _parameterSelection2 = new ParameterSelection(_sim2, new QuantitySelection("Liver|P", QuantityType.Parameter)); _identificationParameter.AddLinkedParameter(_parameterSelection1); _identificationParameter.AddLinkedParameter(_parameterSelection2); _parameterIdentification.AddIdentificationParameter(_identificationParameter); _identificationParameter.Scaling = Scalings.Linear; _parameterIdentification.Configuration.AlgorithmProperties = new OptimizationAlgorithmProperties("AA"); _parameterIdentification.AlgorithmProperties.Add(new ExtendedProperty <double> { Name = "Toto", Value = 5 }); _runResult = new ParameterIdentificationRunResult(); _parameterIdentification.AddResult(_runResult); _parameterIdentification.AddAnalysis(new ParameterIdentificationPredictedVsObservedChart()); _parameterIdentification.AddAnalysis(new ParameterIdentificationTimeProfileChart()); _parameterIdentification.AddAnalysis(new ParameterIdentificationResidualHistogram()); _parameterIdentification.AddAnalysis(new ParameterIdentificationResidualVsTimeChart()); GlobalBecause(); }
protected override void Context() { base.Context(); _linkedParameter = A.Fake <ParameterSelection>(); _identificationParameter = new IdentificationParameter(); }
public virtual void UpdateSimulation(ISimulation newSimulation) { ParameterSelection.UpdateSimulation(newSimulation); }
protected override void ActionForLinkedParameterIsNotInSimulation(ParameterIdentification parameterIdentification, ISimulation newSimulation, ParameterSelection linkedParameter, IdentificationParameter identificationParameter) { _validationResult.AddMessage( NotificationType.Warning, parameterIdentification, Captions.ParameterIdentification.SimulationDoesNotContainParameterWithPath(newSimulation.Name, linkedParameter.Path)); }