Example #1
0
        ////MLGE parameters:
        //static readonly List<double> PPM_TOLERANCE_LIST = new List<double>(new double[] { 10.0 / 1000000.0 });
        //static readonly List<double> RETENTION_TIME_WINDOW_LIST = new List<double>(new double[] { 0.75, 1.0, 2.0 });
        //static readonly List<double> LR_PROBABILITY_THRESHOLD_LIST = new List<double>(new double[] { 0.3, 0.5, 0.7, 0.9 });

        ////Nora parameters:
        //static readonly List<double> XCORR_THRESHOLD_LIST = new List<double>(new double[] { 1.5, 2, 2.5 });
        ////static readonly List<double> XCORR_THRESHOLD_LIST = new List<double>(new double[] {1.5, 2.0 });
        //static readonly List<int> NUM_DB_THRESHOLD_LIST = new List<int>(new int[] { 2 });

        public static void RunExclusionExplorer(ExclusionProfileEnum exclusionType)
        {
            PreExperimentSetUp();
            WriterClass.writeln(new PerformanceEvaluator().getHeader());
            int experimentNumber = 0;

            if (exclusionType == ExclusionProfileEnum.MACHINE_LEARNING_GUIDED_EXCLUSION_PROFILE)
            {
                foreach (double ppmTol in GlobalVar.PPM_TOLERANCE_LIST)
                {
                    foreach (double rtWin in GlobalVar.RETENTION_TIME_WINDOW_LIST)
                    {
                        foreach (double prThr in GlobalVar.LR_PROBABILITY_THRESHOLD_LIST)
                        {
                            experimentNumber++;
                            double startTime = getCurrentTime();
                            GlobalVar.ppmTolerance            = ppmTol;
                            GlobalVar.retentionTimeWindowSize = rtWin;
                            GlobalVar.AccordThreshold         = prThr;

                            ExclusionProfile exclusionProfile = new MachineLearningGuidedExclusion(InputFileOrganizer.AccordNet_LogisticRegressionClassifier_WeightAndInterceptSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
                            String           experimentName   = "EXP_" + experimentNumber + GlobalVar.experimentName + String.Format("_MachineLearningGuidedExclusion:ppmTol_{0}_rtWin_{1}_prThr_{2}", ppmTol, rtWin, prThr);
                            Experiment       experiment       = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                            RunSimulationAndPostProcess(experiment);
                        }
                    }
                }
            }
            else if (exclusionType == ExclusionProfileEnum.NORA_EXCLUSION_PROFILE)
            {
                foreach (double xCorr in GlobalVar.XCORR_THRESHOLD_LIST)
                {
                    foreach (int numDB in GlobalVar.NUM_DB_THRESHOLD_LIST)
                    {
                        foreach (double ppmTol in GlobalVar.PPM_TOLERANCE_LIST)
                        {
                            foreach (double rtWin in GlobalVar.RETENTION_TIME_WINDOW_LIST)
                            {
                                experimentNumber++;
                                double startTime = getCurrentTime();
                                GlobalVar.ppmTolerance            = ppmTol;
                                GlobalVar.retentionTimeWindowSize = rtWin;
                                GlobalVar.XCorr_Threshold         = xCorr;
                                GlobalVar.NumDBThreshold          = numDB;

                                ExclusionProfile exclusionProfile = new NoraExclusion(database, GlobalVar.XCorr_Threshold, GlobalVar.ppmTolerance, GlobalVar.NumDBThreshold, GlobalVar.retentionTimeWindowSize);
                                String           experimentName   = "EXP_" + experimentNumber + GlobalVar.experimentName + String.Format("_HeuristicExclusion:xCorr_{0}_numDB_{1}_ppmTol_{2}_rtWin_{3}", xCorr, numDB, ppmTol, rtWin) + "_expNum" + experimentNumber;
                                Experiment       experiment       = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                                RunSimulationAndPostProcess(experiment);
                            }
                        }
                    }
                }
            }
            else if (exclusionType == ExclusionProfileEnum.COMBINED_EXCLUSION)
            {
                foreach (double rtWin in GlobalVar.RETENTION_TIME_WINDOW_LIST)
                {
                    foreach (double prThr in GlobalVar.LR_PROBABILITY_THRESHOLD_LIST)
                    {
                        foreach (int numDB in GlobalVar.NUM_DB_THRESHOLD_LIST)
                        {
                            foreach (double xCorr in GlobalVar.XCORR_THRESHOLD_LIST)
                            {
                                foreach (double ppmTol in GlobalVar.PPM_TOLERANCE_LIST)
                                {
                                    experimentNumber++;
                                    double startTime = getCurrentTime();
                                    GlobalVar.ppmTolerance            = ppmTol;
                                    GlobalVar.retentionTimeWindowSize = rtWin;
                                    GlobalVar.AccordThreshold         = prThr;
                                    GlobalVar.XCorr_Threshold         = xCorr;
                                    GlobalVar.NumDBThreshold          = numDB;

                                    ExclusionProfile exclusionProfile = new CombinedExclusion(InputFileOrganizer.AccordNet_LogisticRegressionClassifier_WeightAndInterceptSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize, xCorr, numDB);
                                    String           experimentName   = "EXP_" + experimentNumber + GlobalVar.experimentName + String.Format("_CombinedExclusion:xCorr_{0}_numDB_{1}_ppmTol_{2}_rtWin_{3}_prThr_{4}",
                                                                                                                                             xCorr, numDB, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize, GlobalVar.AccordThreshold);
                                    Experiment experiment = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                                    RunSimulationAndPostProcess(experiment);
                                }
                            }
                        }
                    }
                }
            }
            else if (exclusionType == ExclusionProfileEnum.SVMEXCLUSION)
            {
                foreach (double ppmTol in GlobalVar.PPM_TOLERANCE_LIST)
                {
                    foreach (double rtWin in GlobalVar.RETENTION_TIME_WINDOW_LIST)
                    {
                        experimentNumber++;
                        double startTime = getCurrentTime();
                        GlobalVar.ppmTolerance            = ppmTol;
                        GlobalVar.retentionTimeWindowSize = rtWin;

                        ExclusionProfile exclusionProfile = new SVMExclusion(InputFileOrganizer.SVMSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
                        String           experimentName   = "EXP_" + experimentNumber + GlobalVar.experimentName + String.Format("_SVM:ppmTol_{0}_rtWin_{1}", ppmTol, rtWin);
                        Experiment       experiment       = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                        RunSimulationAndPostProcess(experiment);
                    }
                }
            }
            else if (exclusionType == ExclusionProfileEnum.NO_EXCLUSION_PROFILE)
            {
                foreach (double rtWin in GlobalVar.RETENTION_TIME_WINDOW_LIST)
                {
                    experimentNumber++;
                    double startTime = getCurrentTime();
                    GlobalVar.ppmTolerance            = 0;
                    GlobalVar.retentionTimeWindowSize = rtWin;

                    ExclusionProfile exclusionProfile = new NoExclusion(database, GlobalVar.retentionTimeWindowSize);
                    String           experimentName   = "EXP_" + experimentNumber + GlobalVar.experimentName + String.Format("_NoExclusion:ppmTol_rtWin_{0}", rtWin);
                    Experiment       experiment       = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                    RunSimulationAndPostProcess(experiment);

                    if (exclusionType == ExclusionProfileEnum.NO_EXCLUSION_PROFILE)
                    {
                        List <ObservedPeptideRtTrackerObject> peptideIDRT = ((NoExclusion)exclusionProfile).peptideIDRT;

                        //actual arrival time, xcorr, rtCalc predicted RT, corrected RT, offset
                        //WriterClass.writeln("pepSeq\tarrivalTime\txcorr\trtPeak\tcorrectedRT\toffset\trtCalcPredicted\tisPredicted1", writerClassOutputFile.peptideRTTime);
                        //foreach (ObservedPeptideRtTrackerObject observedPeptracker in peptideIDRT)
                        //{

                        //	WriterClass.writeln(observedPeptracker.ToString(), writerClassOutputFile.peptideRTTime);
                        //}
                        WriterClass.writeln("peptideSequence\tObservedRetentionTime", writerClassOutputFile.peptideRTTime);
                        foreach (ObservedPeptideRtTrackerObject observedPeptracker in peptideIDRT)
                        {
                            WriterClass.writeln(String.Format("{0}\t{1}", observedPeptracker.peptideSequence, observedPeptracker.arrivalTime), writerClassOutputFile.peptideRTTime);
                        }
                    }
                    break;
                }
            }
            else if (exclusionType == ExclusionProfileEnum.RANDOM_EXCLUSION_PROFILE)
            {
                List <ExperimentResult> resultList = ParseExperimentResult(InputFileOrganizer.SummaryFileForRandomExclusion);
                foreach (ExperimentResult expResult in resultList)
                {
                    //Do 5 random experiments per normal experiment
                    for (int i = 0; i < GlobalVar.randomRepeatsPerExperiment; i++)
                    {
                        experimentNumber++;
                        double startTime = getCurrentTime();
                        String originalExperimentName = expResult.experimentName;
                        int    numExcluded            = expResult.numSpectraExcluded;
                        int    numAnalyzed            = expResult.numSpectraAnalyzed;

                        ExclusionProfile exclusionProfile = new RandomExclusion_Fast(database, ms2SpectraList, numExcluded, numAnalyzed, 12);
                        String           experimentName   = "EXP_" + experimentNumber + String.Format("Random:originalExperiment_{0}", originalExperimentName);

                        Experiment experiment = new Experiment(exclusionProfile, experimentName, experimentNumber, exclusionType, startTime);
                        RunSimulationAndPostProcess(experiment);
                    }
                }
            }
        }
Example #2
0
        public static ExclusionProfile SingleSimulationRun(ExclusionProfileEnum expType)
        {
            PreExperimentSetUp();
            int    experimentNumber = 1;
            double startTime        = getCurrentTime();

            //parameters:
            //GlobalVar.ppmTolerance = 5.0 / 1000000.0;
            //GlobalVar.retentionTimeWindowSize = 1.0;
            //GlobalVar.AccordThreshold = 0.5;
            //GlobalVar.XCorr_Threshold = 1.5;
            //GlobalVar.NumDBThreshold = 2;
            if (GlobalVar.isSimulationForFeatureExtraction == false)
            {
                GlobalVar.ppmTolerance            = GlobalVar.PPM_TOLERANCE_LIST[0];
                GlobalVar.retentionTimeWindowSize = GlobalVar.RETENTION_TIME_WINDOW_LIST[0];
                GlobalVar.AccordThreshold         = GlobalVar.LR_PROBABILITY_THRESHOLD_LIST[0];
                GlobalVar.XCorr_Threshold         = GlobalVar.XCORR_THRESHOLD_LIST[0];
                GlobalVar.NumDBThreshold          = GlobalVar.NUM_DB_THRESHOLD_LIST[0];
            }
            //random
            int numExcluded = 14826;
            int numAnalyzed = 22681;

            //end parameters

            ExclusionProfile exclusionProfile = null;

            switch (expType)
            {
            case ExclusionProfileEnum.NORA_EXCLUSION_PROFILE:
                exclusionProfile = new NoraExclusion(database, GlobalVar.XCorr_Threshold, GlobalVar.ppmTolerance, GlobalVar.NumDBThreshold, GlobalVar.retentionTimeWindowSize);
                break;

            case ExclusionProfileEnum.MACHINE_LEARNING_GUIDED_EXCLUSION_PROFILE:
                exclusionProfile = new MachineLearningGuidedExclusion(InputFileOrganizer.AccordNet_LogisticRegressionClassifier_WeightAndInterceptSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
                break;

            case ExclusionProfileEnum.RANDOM_EXCLUSION_PROFILE:

                exclusionProfile = new RandomExclusion_Fast(database, ms2SpectraList, numExcluded, numAnalyzed, 12);

                break;

            case ExclusionProfileEnum.NO_EXCLUSION_PROFILE:
                exclusionProfile = new NoExclusion(database, GlobalVar.retentionTimeWindowSize);
                break;

            case ExclusionProfileEnum.MLGE_SEQUENCE_EXCLUSION_PROFILE:
                exclusionProfile = new MLGESequenceExclusion(InputFileOrganizer.AccordNet_LogisticRegressionClassifier_WeightAndInterceptSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
                break;

            case ExclusionProfileEnum.NORA_SEQUENCE_EXCLUSION_PROFILE:
                exclusionProfile = new NoraSequenceExclusion(database, GlobalVar.XCorr_Threshold, GlobalVar.ppmTolerance, GlobalVar.NumDBThreshold, GlobalVar.retentionTimeWindowSize);
                break;

            case ExclusionProfileEnum.SVMEXCLUSION:
                exclusionProfile = new SVMExclusion(InputFileOrganizer.SVMSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
                break;
            }

            WriterClass.writeln(exclusionProfile.GetPerformanceEvaluator().getHeader());
            String     experimentName = "EXP_" + experimentNumber + GlobalVar.experimentName;
            Experiment experiment     = new Experiment(exclusionProfile, experimentName, 1, expType, startTime);

            new DataReceiverSimulation().DoJob(exclusionProfile, ms2SpectraList);
            double analysisTime = getCurrentTime() - startTime;

            //WriteScanArrivalProcessedTime(DataProcessor.scanArrivalAndProcessedTimeList);
            //WriteExcludedProteinList(exclusionProfile.getDatabase().getExcludedProteins());

#if IGNORE
            WriteScanArrivalProcessedTime(DataProcessor.spectraNotAdded);

            foreach (double[] ignoredSpectra in DataProcessor.spectraNotAdded)
            {
                int scanNum = ms2SpectraList[(int)ignoredSpectra[0] - 1].getScanNum();
                exclusionProfile.getSpectraUsed().Add(scanNum);
            }
#endif

            //if (expType == ExclusionProfileEnum.NO_EXCLUSION_PROFILE)
            //{
            //	List<ObservedPeptideRtTrackerObject> peptideIDRT = ((NoExclusion)exclusionProfile).peptideIDRT;

            //	//actual arrival time, xcorr, rtCalc predicted RT, corrected RT, offset
            //	WriterClass.writeln("pepSeq\tarrivalTime\txcorr\trtPeak\tcorrectedRT\toffset\trtCalcPredicted\tisPredicted1", writerClassOutputFile.peptideRTTime);
            //	foreach (ObservedPeptideRtTrackerObject observedPeptracker in peptideIDRT)
            //	{

            //		WriterClass.writeln(observedPeptracker.ToString(), writerClassOutputFile.peptideRTTime);
            //	}
            //}
            //if (expType == ExclusionProfileEnum.MACHINE_LEARNING_GUIDED_EXCLUSION_PROFILE)
            //{
            //	List<double[]> peptideIDRT = ((MachineLearningGuidedExclusion)exclusionProfile).peptideIDRT;

            //	//actual arrival time, xcorr, rtCalc predicted RT, corrected RT, offset
            //	WriterClass.writeln("arrivalTime\txcorr\trtPeak\tcorrectedRT\toffset\trtCalcPredicted\tisPredicted1", writerClassOutputFile.peptideRTTime);
            //	foreach(double[] id in peptideIDRT)
            //	{
            //		String str = "";
            //		foreach(double d in id)
            //		{
            //			str = str + "\t" + d;
            //		}
            //		str= str.Trim();
            //		WriterClass.writeln(str, writerClassOutputFile.peptideRTTime);
            //	}
            //}

#if TRACKEXCLUDEDPROTEINFEATURE
            if (expType == ExclusionProfileEnum.MACHINE_LEARNING_GUIDED_EXCLUSION_PROFILE)
            {
                List <object[]> excludedProteinFeatures = ((MachineLearningGuidedExclusion)exclusionProfile).excludedProteinFeatureList;
                WriterClass.writeln("Accession\tCardinality\tHighestXCorr\tMeanXCorr\tMedianXCorr\tStDev", writerClassOutputFile.ExcludedSpectraScanNum);
                foreach (object[] feature in excludedProteinFeatures)
                {
                    String featureStr = "";
                    foreach (object o in feature)
                    {
                        featureStr = featureStr + o.ToString() + "\t";
                    }
                    featureStr = featureStr.Trim();
                    WriterClass.writeln(featureStr, writerClassOutputFile.ExcludedSpectraScanNum);
                }
            }
#endif
            //WriteUnusedSpectra(exclusionProfile);
            //WriteUsedSpectra(exclusionProfile);
            PostExperimentProcessing(experiment);
            //WriteUnusedSpectra(exclusionProfile);

            return(exclusionProfile);
        }