} /* ExploreMatrixCell */ public void MakePrediction(PicesClass knownClass, PicesClass predictedClass, double predProb, PicesFeatureVector fv, TrainingModel2 trainModel ) { bool partOfOriginalClassifier = ClassInClassifierClasses(knownClass); if (!partOfOriginalClassifier) { String notPartClassName = "(V)" + knownClass.Name; knownClass = PicesClassList.GetUniqueClass(notPartClassName, ""); } int x = classes.LookUpIndex(knownClass); if (x < 0) { classes.Add(knownClass); } x = classes.LookUpIndex(predictedClass); if (x < 0) { classes.Add(predictedClass); } Prediction p = new Prediction(knownClass, predictedClass, predProb, fv, trainModel, partOfOriginalClassifier); predictions.Add(p); } /* featureVector */
} /* UpdateButton_Click */ private void LoadTrainingModelNames() { string[] modelNames = TrainingModel2.GetListOfTrainingModels();; if (modelNames == null) { TrainingLibrary1.Items.Add("None"); TrainingLibrary2.Items.Add("None"); } else { foreach (string s in modelNames) { TrainingLibrary1.Items.Add(s); TrainingLibrary2.Items.Add(s); } } if (!String.IsNullOrEmpty(activeTrainingModel1Name)) { SetTrainingLibrarySelected(activeTrainingModel1Name, TrainingLibrary1); } if (!String.IsNullOrEmpty(activeTrainingModel2Name)) { SetTrainingLibrarySelected(activeTrainingModel2Name, TrainingLibrary2); } } /* LoadTrainingModelNames */
} /* LoadTrainingModels */ private void LoadData() { loadingThreadRunning = true; if (trainingModel != null) { BlockStart(); trainingModel = null; BlockEnd(); } if (groundTruth != null) { BlockStart(); groundTruth = null; BlockEnd(); } if (crossValidation) { GradeAgainstCrossValidationRun(); } else { GradeAgainstGroundTruth(); } if (!cancelProcessing) { displayConfusionMatrix = true; } loadingThreadRunning = false; } /* LoadData */
public ClassifierProcess(PicesDataBaseServer _dbServer, int _processorNum, String _classifierName, bool _reClassify, bool _validatedTrumps, bool _excludeNoise, Queue <PredictionResult> _predictionUpdateQueue, Queue <PicesFeatureVector> _featureVectorQueue, DateTime _midPoint, Queue <String> _errorMsgs ) { errorMsgs = _errorMsgs; processorNum = _processorNum; classifier = null; classifierName = _classifierName; reClassify = _reClassify; validatedTrumps = _validatedTrumps; excludeNoise = _excludeNoise; predictionUpdateQueue = _predictionUpdateQueue; featureVectorQueue = _featureVectorQueue; dbServer = _dbServer; midPoint = _midPoint; classifierWeOwnIt = false; ClassInitialization(); }
public ConfusionMatrix(PicesTrainingConfigManaged _config, PicesClassList _classifierClasses, /**< List of classes in origianl Classifier before reduction due to training level. */ TrainingModel2 _trainingModel, String _modelName, String _groundTruthRootDir, uint _trainLevel, uint _predLevel ) { config = _config; trainingModel = _trainingModel; groundTruthRootDir = _groundTruthRootDir; trainLevel = _trainLevel; predLevel = _predLevel; classifierClasses = _classifierClasses; if (config != null) { otherClass = config.OtherClass(); } InitializeComponent(); classes = new PicesClassList(); classes.Clear(); ModelName.Text = _modelName; GroundTruth.Text = _groundTruthRootDir; }
public PredictionBreakDownDisplay(PicesDataBase _dbConn, PicesDataBaseImage _image, PicesRaster _raster, TrainingModel2 _trainingModel, PicesInstrumentData _instrumentData, /*!< Instrument data that goes with image, if null will read from database. */ PicesRunLog _runLog ) { if (_runLog == null) { runLog = new PicesRunLog(); } else { runLog = _runLog; } if (_image == null) { return; } fileName = _image.ImageFileName; instrumentData = _instrumentData; trainingModel = _trainingModel; PicesRaster raster = _raster; if (_dbConn != null) { if (raster == null) { raster = _dbConn.ImageFullSizeFind(fileName); } if (instrumentData == null) { instrumentData = _dbConn.InstrumentDataGetByScanLine(_image.SipperFileName, _image.TopLeftRow); } dbFeatureVector = _dbConn.FeatureDataRecLoad(fileName); } if (raster == null) { return; } //raster = raster.ConnectedComponent (); featureCalcImages = new PicesRasterList(); featureVector = new PicesFeatureVector(raster, fileName, featureCalcImages, runLog); if (instrumentData != null) { featureVector.AddInstrumentData(instrumentData); } InitializeComponent(); }
public void SetTrainingModel(TrainingModel2 _trainingModel) { trainingModel = _trainingModel; if (otherClass == null) { otherClass = PicesClassList.GetUniqueClass("Other", ""); } }
public static TrainingModel2 Model2() { TrainingModel2 model = null; BlockStart(); model = model2; BlockEnd(); return(model); }
public ImageListDisplay(String _rootDir, Dictionary <String, Prediction> _predictions, TrainingModel2 _trainingModel ) { predictions = _predictions; rootDir = _rootDir; trainingModel = _trainingModel; InitializeComponent(); }
public PredictionBreakDownDisplayDual(PicesDataBase _dbConn, String _fileName, TrainingModel2 _trainingModel, PicesInstrumentData _instrumentData, /**< Instrument data that goes with image, if null will read from dtabase. */ PicesRunLog _runLog ) { if (_runLog == null) { runLog = new PicesRunLog(); } else { runLog = _runLog; } fileName = _fileName; instrumentData = _instrumentData; trainingModel = _trainingModel; PicesDataBase dbConn = PicesDataBase.GetGlobalDatabaseManagerNewInstance(runLog); PicesRaster raster = dbConn.ImageFullSizeFind(fileName); if (raster == null) { return; } if (_dbConn != null) { dbFeatureVector = _dbConn.FeatureDataRecLoad(_fileName); if (instrumentData == null) { PicesDataBaseImage image = dbConn.ImageLoad(fileName); if (image != null) { instrumentData = dbConn.InstrumentDataGetByScanLine(image.SipperFileName, image.TopLeftRow); } } } featureVector = new PicesFeatureVector(raster, fileName, null, runLog); if (instrumentData != null) { featureVector.AddInstrumentData(instrumentData); } dbConn.Close(); dbConn = null; GC.Collect(); InitializeComponent(); }
} /* SetConfigurationFileName */ public static void LoadConfiguration() { BlockStart(); SetConfigurationFileName(); model1 = null; model2 = null; StreamReader sr = null; try { sr = new StreamReader(configFileName); } catch (Exception) { sr = null; } if (sr != null) { String line = ""; while ((line = sr.ReadLine()) != null) { String[] fields = line.Split('\t', '='); if (fields.Length < 2) { continue; } String fieldName = fields[0].ToLower(); if (fieldName == "model1name") { model1Name = fields[1]; } else if (fieldName == "model2name") { model2Name = fields[1]; } } sr.Close(); sr = null; //if (!String.IsNullOrEmpty (model1Name)) // SetModel1 (model1Name, false, null); //if (!String.IsNullOrEmpty (model2Name)) // SetModel2 (model2Name, false, null); } configLoaded = true; BlockEnd(); } /* LoadConfiguration */
Prediction(PicesClass _knownClass, PicesClass _predClass, double _prob, PicesFeatureVector _fv, TrainingModel2 _trainModel, bool _partOfClassifier ) { knowClass = _knownClass; predClass = _predClass; prob = _prob; fv = _fv; trainModel = _trainModel; partOfClassifier = _partOfClassifier; }
private void CreateFeatureSelectionDataSets_Load(object sender, EventArgs e) { modelNames = TrainingModel2.GetListOfTrainingModels(); if (modelNames != null) { foreach (String s in modelNames) { ModelName.Items.Add(s); } } ModelName.Text = initialModelName; UpdatePercentageFields(); DestinationDirectory.Text = OSservices.AddSlash(PicesSipperVariables.DataFilesDirectory()) + "FeatureSelection"; }
} /* Model1LoadCompletion */ static private void Model2LoadCompletion(TrainingModelStatus sender) { if (!sender.ValidModel()) { model2 = null; } else { model2 = sender.TrainiedModel(); } model2LoadStatus = null; if (doneLoadingModel2Event != null) { doneLoadingModel2Event(model2); } } /* Model2LoadCompletion */
} /* LoadConfiguration */ public static void SetModel1(String _model1Name, bool _forceRebuild, DoneLoadingEvent _doneLoadingEvent ) { bool model1CurentlyLoading = false; BlockStart(); if (model1LoadStatus != null) { model1CurentlyLoading = true; } else { if ((model1 != null) && (model1Name == _model1Name) && (!_forceRebuild)) { // We already have this model loaded; there is nothing to do. // But we still have to the call back to let it know that the model is loaded. if (_doneLoadingEvent != null) { _doneLoadingEvent(model1); } } else { if (model1 != null) { model1 = null; GC.Collect(); } GC.Collect(); Model1LoadStart(_model1Name, _forceRebuild, _doneLoadingEvent); SaveConfiguration(); } } BlockEnd(); if (model1CurentlyLoading) { MessageBox.Show("Can not set a new Model; one is currently loading now."); return; } } /* SetModel1 */
private void LoadTrainingModel() { trainingModelRunning = true; PicesDataBase.ThreadInit(); if (trainingModel != null) { trainingModel = null; GC.Collect(); } trainingModel = new TrainingModel2(runLog, trainingModelName); trainingModelLogFileName = trainingModel.RunLogFileName; trainingModel.AttachMsgQueueToRunLog(logMessages); if (forceRebuild) { trainingModel.LoadTrainigLibrary(true); // true = Force Rebuild of Model } else { trainingModel.LoadExistingModelOtherwiseBuild(null); } trainingModel.AttachMsgQueueToRunLog(null); if (trainingModel.Valid) { validModel = true; } else { List <String> errMsgs = trainingModel.ErrorMsgs; if (errMsgs != null) { logMessages.AddMsgs(errMsgs); } validModel = false; trainingModel = null; } PicesDataBase.ThreadEnd(); trainingModelRunning = false; } /* LoadTrainingModel */
} /* LoadPlanktonImage */ private void AddImageToTraningLibraries() { if (!ActiveTrainingLibraries.ModelsAreAvailable()) { MessageBox.Show("There are no selected Training Models to add Image to."); return; } if (image.ValidatedClass == null) { MessageBox.Show("No Validated Class Selected."); return; } TrainingModel2 tm1 = ActiveTrainingLibraries.Model1(); if (tm1 == null) { tm1 = ActiveTrainingLibraries.Model2(); } if (tm1 == null) { MessageBox.Show("No active training library specified."); return; } if (!tm1.IncludesClass(image.ValidatedClass)) { MessageBox.Show("Training Model[" + tm1.ModelName + "] does not include a definition for class[" + image.ValidatedClass.Name + "].", "ImageViewer.AddImageToTraningLibraries"); } else { try { tm1.AddImageToTrainingLibray(image.ImageFileName, raster, image.ValidatedClass, true); } catch (Exception e) { MessageBox.Show("Error adding image to TrainingModel2[" + tm1.ModelName + "]" + "\n\n" + e.ToString(), "ImageViewer.AddImageToTraningLibraries"); } } } /* AddImageToTraningLibraries */
} /* GetNextFeatureVector*/ private void ThreadProcess() { threadRunning = true; PicesDataBase.ThreadInit(); if ((classifier == null) && (!String.IsNullOrEmpty(classifierName))) { PicesRunLog log = new PicesRunLog(); classifier = new TrainingModel2(log, classifierName); classifier.LoadExistingModelOtherwiseBuild(null); classifierWeOwnIt = true; } while (!cancelFlag) { PicesFeatureVector fv = GetNextFeatureVector(); if (fv != null) { ProcessOneFeatureVector(fv); } else { if (threadTerminate) { break; } Thread.Sleep(10); } } if (dbConn != null) { dbConn.Close(); dbConn = null; GC.Collect(); } PicesDataBase.ThreadEnd(); threadRunning = false; threadDone = true; } /* ThreadProcess */
} /* BlockEnd */ private void CleanUpMemory() { if (loadingThreadRunning) { CancelProcessing(); } if (confusionMatrix != null) { confusionMatrix.Close(); confusionMatrix = null; } if (trainingModel != null) { BlockStart(); trainingModel = null; BlockEnd(); } } /* CleanUpMemory */
private void SaveActiveTrainingModelFeatureData_Load(object sender, EventArgs e) { modelNames = TrainingModel2.GetListOfTrainingModels(); if (modelNames != null) { foreach (String s in modelNames) { ModelName.Items.Add(s); } } ModelName.Text = OSservices.GetRootName(initialModelName); String[] fileFormats = PicesFeatureFileIO.RegisteredDriverNames(false, true); if (fileFormats != null) { foreach (String ff in fileFormats) { FileFormat.Items.Add(ff); } } FileFormat.Text = "Pices"; DestinationFileName.Text = OSservices.AddSlash(PicesSipperVariables.TempDirectory()) + ModelName.Text + ".data"; }
} /* GradeAgainstCrossValidationRun */ void CrossValidate(PicesFeatureVectorList testExamples, PicesFeatureVectorList trainingExamples, int foldNum ) { msgQueue.AddMsg("\n\n" + "Starting Fold[" + (foldNum + 1).ToString() + "] of Fold[" + numOfFolds + "]" + "\n"); if (trainingModel != null) { trainingModel = null; } msgQueue.AddMsg("Building Classifier"); try { trainingModel = new TrainingModel2(runLog, curSelModel); trainingModel.BuildTrainingModel(trainingExamples); } catch (Exception e) { msgQueue.AddMsg("\n\n\n" + "Exception occur building training model" + "\n" + e.ToString() + "\n\n"); MessageBox.Show(this, "Exception Occurred Building Training Model." + "\n" + e.ToString(), "CrossValidate", MessageBoxButtons.OK); trainingModel = null; return; } if (cancelProcessing) { trainingModel = null; return; } if (!trainingModel.Valid) { MessageBox.Show(this, "Training Model is Invalid.", "Ground Thruthing", MessageBoxButtons.OK); } else { msgQueue.AddMsg("\n" + "Predictions for fold[" + (foldNum + 1).ToString() + "]"); PicesClass knownClass = null; foreach (PicesFeatureVector example in testExamples) { if (cancelProcessing) { break; } knownClass = example.MLClass; PicesPrediction prediction = trainingModel.PredictClass(example); if ((otherClass != null) && (prediction.MLClass == noAgreementClass)) { prediction.MLClass = otherClass; } /**@todo Add code for "NoAgreement:" to be treeted as a Other Class when there is "NoAgreement". */ confusionMatrix.MakePrediction(knownClass, prediction.MLClass, prediction.Probability, example, trainingModel); } } trainingModel.CleanUp(); trainingModel = null; } /* CrossValidate */
} /* PerformPredictions*/ private void GradeAgainstGroundTruth() { if (!cancelProcessing) { if (trainingModel != null) { trainingModel = null; } trainingModel = new TrainingModel2(runLog, trainingModelName); if (trainingModel.Valid) { if (trainingLevel < maxLevel) { trainingModel.LoadTrainingModelForGivenLevel(trainingLevel, msgQueue); } else { trainingModel.LoadExistingModelOtherwiseBuild(msgQueue); } } } if (!cancelProcessing) { groundTruth = new PicesFeatureVectorList(); groundTruth.LoadInSubDirectoryTree(GroundTruth.Text, true, // true = useDirectoryNameForClassName, runLog, false // false = Don't rewiteRootFeatureFile ); numGroundTruthImages = groundTruth.Count; numGroundTruthImagesProcessed = 0; } if (cancelProcessing) { if (trainingModel != null) { BlockStart(); trainingModel = null; BlockEnd(); } } else { if (!trainingModel.Valid) { MessageBox.Show("Error Loading Training Model; refer to dialog box"); cancelProcessing = true; } else if (!cancelProcessing) { confusionMatrix.SetTrainingModel(trainingModel); PerformPredictions(); } } if (groundTruth != null) { BlockStart(); groundTruth = null; BlockEnd(); } } /* GradeAgainstGroundTruth */
} /* GradeAgainstGroundTruth */ private void GradeAgainstCrossValidationRun() { if (curSelModel == null) { curSelModel = new PicesTrainingConfigManaged(configFileName, runLog); } if (!curSelModel.Valid()) { MessageBox.Show("Configuration File[" + configFileName + "] is not valid"); return; } bool changesMade = false; PicesFeatureVectorList data = curSelModel.LoadFeatureDataFromTrainingLibraries(changesMade); if (cancelProcessing) { data = null; return; } if (data == null) { MessageBox.Show("No data was loaded from Configuration File[" + configFileName + "] is not valid"); return; } PicesFeatureVectorList examples = data.StratifyAmoungstClasses(numOfFolds); int imageCount = examples.Count; int numImagesPerFold = (imageCount + numOfFolds - 1) / numOfFolds; int firstInGroup = 0; int foldNum; for (foldNum = 0; foldNum < numOfFolds; foldNum++) { int lastInGroup; // If We are doing the last Fold Make sure that we are including all the examples // that have not been tested. if (foldNum == (numOfFolds - 1)) { lastInGroup = imageCount; } else { lastInGroup = firstInGroup + numImagesPerFold - 1; } PicesFeatureVectorList trainingImages = new PicesFeatureVectorList(); PicesFeatureVectorList testImages = new PicesFeatureVectorList(); for (int x = 0; (x < imageCount) && (!cancelProcessing); x++) { PicesFeatureVector newImage = new PicesFeatureVector(examples[x]); if ((x >= firstInGroup) && (x <= lastInGroup)) { testImages.Add(newImage); } else { trainingImages.Add(newImage); } } if (cancelProcessing) { break; } CrossValidate(testImages, trainingImages, foldNum); firstInGroup = firstInGroup + numImagesPerFold; } if (!cancelProcessing) { if (trainingModel != null) { trainingModel = null; } msgQueue.AddMsg("\n" + "Building Final Classifier for User Query"); trainingModel = new TrainingModel2(runLog, curSelModel); trainingModel.BuildTrainingModel(data); } if ((!cancelProcessing) && (trainingModel != null) && (!trainingModel.Valid)) { MessageBox.Show("Error Loading Training Model; refer to dialog box"); cancelProcessing = true; } else if (!cancelProcessing) { confusionMatrix.SetTrainingModel(trainingModel); } // We no longer need the Training Model or Ground Truth loaded BlockStart(); data = null; BlockEnd(); } /* GradeAgainstCrossValidationRun */