public void ScorePeptideSets(PeakScoringContext context, IList <IPeakFeatureCalculator> detailFeatureCalculators)
{
var modelCalcs = ScoringModel.PeakFeatureCalculators;
var detailFeatures = new float [detailFeatureCalculators.Count];
var modelFeatures = new float [modelCalcs.Count];
// Here we score both the detailFeatureCalculators (for storage)
// and the peak calculators of the legacy model (for import-stage peak scoring)
// This will cause some scores to be calculated multiple times, but score
// caching should make this fast.
var allFeatureCalculators = detailFeatureCalculators.Union(modelCalcs);
// Calculate summary data once for all scores
var summaryData = new PeptidePeakDataConverter <IDetailedPeakData>(this);
foreach (var calc in allFeatureCalculators)
{
float feature;
var summaryCalc = calc as SummaryPeakFeatureCalculator;
if (summaryCalc != null)
{
feature = summaryCalc.Calculate(context, summaryData);
}
else
{
feature = calc.Calculate(context, this);
}
int detailIndex = detailFeatureCalculators.IndexOf(calc);
if (detailIndex != -1)
{
detailFeatures[detailIndex] = feature;
}
int modelIndex = modelCalcs.IndexOf(calc);
if (modelIndex != -1)
{
modelFeatures[modelIndex] = double.IsNaN(feature) ? 0 : feature;
}
}
CombinedScore = ScoringModel.Score(modelFeatures);
foreach (var peak in this.Where(peak => peak.PeakGroup != null))
{
peak.PeakGroup.DetailScores = detailFeatures;
}
}
public void ScoreFeatures(IProgressMonitor progressMonitor = null)
{
if (_features == null)
{
_features = Document.GetPeakFeatures(_calcs, progressMonitor);
}
if (ScoringModel == null)
{
return;
}
var bestTargetPvalues = new List <double>();
var targetIds = new List <PeakTransitionGroupIdKey>();
foreach (var transitionGroupFeatures in _features)
{
var mProphetScoresGroup = new List <double>();
foreach (var peakGroupFeatures in transitionGroupFeatures.PeakGroupFeatures)
{
mProphetScoresGroup.Add(ScoringModel.Score(peakGroupFeatures.Features));
}
var pValuesGroup = mProphetScoresGroup.Select(score => 1 - Statistics.PNorm(score)).ToList();
int bestIndex = mProphetScoresGroup.IndexOf(mProphetScoresGroup.Max());
double bestPvalue = pValuesGroup[bestIndex];
var featureStats = new PeakFeatureStatistics(transitionGroupFeatures, mProphetScoresGroup, pValuesGroup, bestIndex, null);
_featureDictionary.Add(transitionGroupFeatures.Id.Key, featureStats);
if (!transitionGroupFeatures.Id.NodePep.IsDecoy)
{
bestTargetPvalues.Add(bestPvalue);
targetIds.Add(transitionGroupFeatures.Id.Key);
}
}
_qValues = new Statistics(bestTargetPvalues).Qvalues(MProphetPeakScoringModel.DEFAULT_R_LAMBDA, MProphetPeakScoringModel.PI_ZERO_MIN).ToList();
for (int i = 0; i < _qValues.Count; ++i)
{
var newFeatureStats = _featureDictionary[targetIds[i]].SetQValue(_qValues[i]);
_featureDictionary[targetIds[i]] = newFeatureStats;
}
}
public void ScoreFeatures(IProgressMonitor progressMonitor = null, bool releaseRawFeatures = false, TextWriter output = null)
{
if (_features == null)
{
_features = Document.GetPeakFeatures(_calcs, progressMonitor);
}
if (ScoringModel == null)
{
return;
}
var bestTargetPvalues = new List <double>(_features.TargetCount);
var targetIds = new List <PeakTransitionGroupIdKey>(_features.TargetCount);
foreach (var transitionGroupFeatures in _features.Features)
{
int bestIndex = 0;
float bestScore = float.MinValue;
float bestPvalue = float.NaN;
var peakGroupFeatures = transitionGroupFeatures.PeakGroupFeatures;
IList <float> mProphetScoresGroup = null, pvalues = null;
if (!releaseRawFeatures)
{
mProphetScoresGroup = new float[peakGroupFeatures.Count];
}
if (!releaseRawFeatures)
{
pvalues = new float[peakGroupFeatures.Count];
}
for (int i = 0; i < peakGroupFeatures.Count; i++)
{
double score = ScoringModel.Score(peakGroupFeatures[i].Features);
if (double.IsNaN(bestScore) || score > bestScore)
{
bestIndex = i;
bestScore = (float)score;
bestPvalue = (float)(1 - Statistics.PNorm(score));
}
if (mProphetScoresGroup != null)
{
mProphetScoresGroup[i] = (float)score;
}
if (pvalues != null)
{
pvalues[i] = (float)(1 - Statistics.PNorm(score));
}
}
if (bestScore == float.MinValue)
{
bestScore = float.NaN;
}
var featureStats = new PeakFeatureStatistics(transitionGroupFeatures,
mProphetScoresGroup, pvalues, bestIndex, bestScore, null);
_featureDictionary.Add(transitionGroupFeatures.Key, featureStats);
if (!transitionGroupFeatures.IsDecoy)
{
bestTargetPvalues.Add(bestPvalue);
targetIds.Add(transitionGroupFeatures.Key);
}
}
_qValues = new Statistics(bestTargetPvalues).Qvalues(MProphetPeakScoringModel.DEFAULT_R_LAMBDA, MProphetPeakScoringModel.PI_ZERO_MIN);
for (int i = 0; i < _qValues.Length; ++i)
{
_featureDictionary[targetIds[i]].QValue = (float)_qValues[i];
}
if (releaseRawFeatures)
{
_features = null; // Done with this memory
}
}
public ScoringModel Score_Driving_Of_User(IList <User_Driving_Events> eventList, string SessionId)
{
foreach (var evnt in eventList)
{
if (evnt.Event_Type_Id == (int)(EventType.Agressive_Lane_Change))
{
LaneChangeCount++;
}
else if (evnt.Event_Type_Id == (int)(EventType.Agressive_Turning))
{
AggressiveTurningCount++;
}
else if (evnt.Event_Type_Id == (int)(EventType.Sudden_Braking))
{
SuddenBrakingCount++;
}
else if (evnt.Event_Type_Id == (int)(EventType.Sudden_Acceleration))
{
SuddenAccelerationCount++;
}
else if (evnt.Event_Type_Id == (int)(EventType.Speeding_Event))
{
SpeedingCount++;
}
}
SpeedingAndAccelerationCount = SuddenBrakingCount + SuddenAccelerationCount + SpeedingCount;
if (LaneChangeCount > 0)
{
score = "High Risk";
}
else if (AggressiveTurningCount > 0)
{
score = "Medium Risk";
}
else if (SpeedingAndAccelerationCount > 0)
{
score = "Moderate Risk";
}
else
{
score = "No Risk";
}
var scoringModel = new ScoringModel();
scoringModel.Agressive_Lane_Change_Count = LaneChangeCount;
scoringModel.Agressive_Turning_Count = AggressiveTurningCount;
scoringModel.Sudden_Acceleration_Count = SuddenAccelerationCount;
scoringModel.Sudden_Braking_Count = SuddenBrakingCount;
scoringModel.Speeding_Event_Count = SpeedingCount;
scoringModel.Session_Score = score;
if (!eventList.Equals(null))
{
var factory = new DbConnectionFactory("testDatabase");
var context = new DbContext(factory);
var repo = new Session_HistoryRepository(context);
var sessionHistory = new Session_History();
sessionHistory.Agressive_Lane_Change_Count = LaneChangeCount;
sessionHistory.Agressive_Turning_Count = AggressiveTurningCount;
sessionHistory.Sudden_Acceleration_Count = SuddenAccelerationCount;
sessionHistory.Sudden_Braking_Count = SuddenBrakingCount;
sessionHistory.Speeding_Event_Count = SpeedingCount;
sessionHistory.Session_Score = score;
sessionHistory.Session_Id = SessionId;
repo.UpdateWithScores(sessionHistory);
}
return(scoringModel);
}
