public override PrositRTInput.PrositPeptideInput CreatePrositInputRow(SrmSettings settings, PeptideDocNodeWrapper skylineInput,
out PrositException exception)
{
var sequence = PrositHelpers.EncodeSequence(settings, (PeptideDocNode)skylineInput, IsotopeLabelType.light, out exception);
if (sequence == null)
{
return(null);
}
return(new PrositRTInput.PrositPeptideInput(sequence));
}
public override PrositIntensityInput.PrositPrecursorInput CreatePrositInputRow(SrmSettings settings, PeptidePrecursorNCE skylineInput, out PrositException exception)
{
var peptideSequence = PrositHelpers.EncodeSequence(settings, skylineInput.NodePep, IsotopeLabelType.light, out exception);
if (peptideSequence == null) // equivalently, exception != null
{
return(null);
}
var precursorCharge = PrositHelpers.OneHotEncode(skylineInput.NodeGroup.PrecursorCharge - 1, PrositConstants.PRECURSOR_CHARGES);
return(new PrositIntensityInput.PrositPrecursorInput(peptideSequence, precursorCharge, skylineInput.NCE.Value / 100.0f));
}
public FragmentIonIntensity(TensorProto tensor, ref int index)
{
if (index + PrositConstants.PRECURSOR_CHARGES > tensor.FloatVal.Count)
{
throw new ArgumentException();
}
Intensities = new float[PrositConstants.PRECURSOR_CHARGES];
// Copy intensities
for (var i = 0; i < PrositConstants.PRECURSOR_CHARGES; ++i)
{
Intensities[i] = PrositHelpers.ReLU(tensor.FloatVal[index++]);
}
}
/// <summary>
/// Constructs batches and makes predictions in parallel
/// </summary>
/// <param name="predictionClient">Client to use for prediction</param>
/// <param name="progressMonitor">Monitor to show progress in UI</param>
/// <param name="progressStatus"/>
/// <param name="settings">Settings to use for constructing inputs and outputs</param>
/// <param name="inputs">List of inputs to predict</param>
/// <param name="token">Token for cancelling prediction</param>
/// <returns>Predictions from Prosit</returns>
public TSkylineOutput PredictBatches(PredictionService.PredictionServiceClient predictionClient,
IProgressMonitor progressMonitor, ref IProgressStatus progressStatus, SrmSettings settings, IList <TSkylineInputRow> inputs, CancellationToken token)
{
const int CONSTRUCTING_INPUTS_FRACTION = 50;
progressMonitor.UpdateProgress(progressStatus = progressStatus
.ChangeMessage(PrositResources.PrositModel_BatchPredict_Constructing_Prosit_inputs)
.ChangePercentComplete(0));
inputs = inputs.Distinct().ToArray();
var processed = 0;
var totalCount = inputs.Count;
var inputLock = new object();
var inputsList =
new List <TPrositIn>();
var validInputsList =
new List <List <TSkylineInputRow> >();
// Construct batch inputs in parallel
var localProgressStatus = progressStatus;
ParallelEx.ForEach(PrositHelpers.EnumerateBatches(inputs, PrositConstants.BATCH_SIZE),
batchEnumerable =>
{
var batch = batchEnumerable.ToArray();
var batchInputs = new List <TPrositInputRow>(batch.Length);
var validSkylineInputs = new List <TSkylineInputRow>(batch.Length);
foreach (var singleInput in batch)
{
var input = CreatePrositInputRow(settings, singleInput, out _);
if (input != null)
{
batchInputs.Add(input);
validSkylineInputs.Add(singleInput);
}
}
lock (inputLock)
{
inputsList.Add(CreatePrositInput(batchInputs));
validInputsList.Add(validSkylineInputs);
// ReSharper disable AccessToModifiedClosure
processed += batch.Length;
progressMonitor.UpdateProgress(localProgressStatus.ChangePercentComplete(CONSTRUCTING_INPUTS_FRACTION * processed / totalCount));
// ReSharper enable AccessToModifiedClosure
}
});
processed = 0;
totalCount = inputsList.Sum(pi => pi.InputRows.Count);
const int REQUESTING_INPUTS_FRACTION = 100 - CONSTRUCTING_INPUTS_FRACTION;
progressStatus = progressStatus
.ChangeMessage(PrositResources.PrositModel_BatchPredict_Requesting_predictions_from_Prosit)
.ChangePercentComplete(CONSTRUCTING_INPUTS_FRACTION);
progressMonitor.UpdateProgress(progressStatus);
// Make predictions batch by batch in sequence and merge the outputs
var prositOutputAll = new TPrositOut();
foreach (var prositIn in inputsList)
{
var prositOutput = Predict(predictionClient, prositIn, token);
prositOutputAll = prositOutputAll.MergeOutputs(prositOutput);
processed += prositIn.InputRows.Count;
progressStatus = progressStatus.ChangeMessage(TextUtil.SpaceSeparate(
PrositResources.PrositModel_BatchPredict_Requesting_predictions_from_Prosit,
processed.ToString(), @"/", totalCount.ToString()))
.ChangePercentComplete(CONSTRUCTING_INPUTS_FRACTION +
REQUESTING_INPUTS_FRACTION * processed / totalCount);
progressMonitor.UpdateProgress(progressStatus);
}
return(CreateSkylineOutput(settings, validInputsList.SelectMany(i => i).ToArray(), prositOutputAll));
}
