private CellDimensions MapBoundingBoxToCell(int x, int y, int box, BoundingBoxDimensions boxDimensions) =>
new CellDimensions
{
X = ((float)x + Sigmoid(boxDimensions.X)) * CELL_WIDTH,
Y = ((float)y + Sigmoid(boxDimensions.Y)) * CELL_HEIGHT,
Width = (float)Math.Exp(boxDimensions.Width) * CELL_WIDTH * anchors[box * 2],
Height = (float)Math.Exp(boxDimensions.Height) * CELL_HEIGHT * anchors[box * 2 + 1],
};
public IList <YoloBoundingBox> ParseOutputs(float[] yoloModelOutputs, float threshold = .3F)
{
uint rowStride = BoxesPerCell * selectedOutput.Dimension * (5 + classCount);
uint columnStride = BoxesPerCell * (classCount + BoxInfoFeatureCount);
var boxes = new List <YoloBoundingBox>();
for (uint row = 0; row < selectedOutput.Dimension; row++)
{
for (uint column = 0; column < selectedOutput.Dimension; column++)
{
for (uint box = 0; box < BoxesPerCell; box++)
{
uint channel = (box * (classCount + BoxInfoFeatureCount));
for (uint i = 0; i < BoxInfoFeatureCount; i++)
{
var index = GetOffset(row, column, channel + i);
}
float confidence = GetConfidence(yoloModelOutputs, row, column, channel);
if (confidence < threshold)
{
continue;
}
BoundingBoxDimensions boundingBoxDimensions = ExtractBoundingBoxDimensions(yoloModelOutputs, row, column, channel);
CellDimensions mappedBoundingBox = MapBoundingBoxToCell(row, column, box, boundingBoxDimensions);
float[] predictedClasses = ExtractClasses(yoloModelOutputs, row, column, channel);
var(topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;
if (topScore < threshold)
{
continue;
}
boxes.Add(new YoloBoundingBox()
{
Dimensions = new BoundingBoxDimensions
{
X = mappedBoundingBox.X,
Y = mappedBoundingBox.Y,
Width = mappedBoundingBox.Width,
Height = mappedBoundingBox.Height,
},
Confidence = topScore,
Label = configuration.Labels[topResultIndex],
BoxColor = classColors[topResultIndex % classColors.Length]
});
}
}
}
return(boxes);
}
public IList <YoloBoundingBox> ParseOutputs(float[] yoloModelOutputs, float threshold = .3F)
{
var boxes = new List <YoloBoundingBox>();
var featuresPerBox = BOX_INFO_FEATURE_COUNT + CLASS_COUNT;
var stride = featuresPerBox * BOXES_PER_CELL;
for (int row = 0; row < ROW_COUNT; row++)
{
for (int column = 0; column < COL_COUNT; column++)
{
for (int box = 0; box < BOXES_PER_CELL; box++)
{
var channel = (box * (CLASS_COUNT + BOX_INFO_FEATURE_COUNT));
BoundingBoxDimensions boundingBoxDimensions = ExtractBoundingBoxDimensions(yoloModelOutputs, row, column, channel);
float confidence = GetConfidence(yoloModelOutputs, row, column, channel);
CellDimensions mappedBoundingBoxes = MapBoundingBoxToCell(row, column, box, boundingBoxDimensions);
if (confidence < threshold)
{
continue;
}
float[] predictedClasses = ExtractClasses(yoloModelOutputs, row, column, channel);
var(topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;
if (topScore < threshold)
{
continue;
}
boxes.Add(new YoloBoundingBox()
{
Dimensions = new BoundingBoxDimensions
{
X = (mappedBoundingBoxes.X - mappedBoundingBoxes.Width / 2),
Y = (mappedBoundingBoxes.Y - mappedBoundingBoxes.Height / 2),
Width = mappedBoundingBoxes.Width,
Height = mappedBoundingBoxes.Height,
},
Confidence = topScore,
Label = labels[topResultIndex],
BoxColor = classColors[topResultIndex]
});
}
}
}
return(boxes);
}
private CellDimensions MapBoundingBoxToCell(uint x, uint y, uint box, BoundingBoxDimensions boxDimensions)
{
var result = new CellDimensions
{
X = ((float)x + Sigmoid(boxDimensions.X)) * cellWidth,
Y = ((float)y + Sigmoid(boxDimensions.Y)) * cellHeight,
Width = (float)Math.Exp(boxDimensions.Width) * selectedOutput.Anchors[box * 2],
Height = (float)Math.Exp(boxDimensions.Height) * selectedOutput.Anchors[box * 2 + 1],
};
return(result);
}
private BoundingBoxDimensions ExtractBoundingBoxDimensions(float[] modelOutput, uint x, uint y, uint channel)
{
var result =
new BoundingBoxDimensions
{
X = modelOutput[GetOffset(x, y, channel)],
Y = modelOutput[GetOffset(x, y, channel + 1)],
Width = modelOutput[GetOffset(x, y, channel + 2)],
Height = modelOutput[GetOffset(x, y, channel + 3)]
};
return(result);
}
/// <summary>
/// для обработки выходных данных, создаваемых моделью
/// </summary>
/// <param name="yoloModelOutputs"></param>
/// <param name="threshold"></param>
/// <returns></returns>
public IList <YoloBoundingBox> ParseOutputs(float[] yoloModelOutputs, float threshold = .3F)
{
var boxes = new List <YoloBoundingBox>();
for (int row = 0; row < ROW_COUNT; row++)
{
for (int column = 0; column < COL_COUNT; column++)
{
for (int box = 0; box < BOXES_PER_CELL; box++)
{
var channel = (box * (CLASS_COUNT + BOX_INFO_FEATURE_COUNT));
BoundingBoxDimensions boundingBoxDimensions = ExtractBoundingBoxDimensions(yoloModelOutputs, row, column, channel);
float confidence = GetConfidence(yoloModelOutputs, row, column, channel);
CellDimensions mappedBoundingBox = MapBoundingBoxToCell(row, column, box, boundingBoxDimensions);
if (confidence < threshold)
{
continue;
}
//получение вероятности распределения прогнозируемых классов для текущего ограничивающего прямоугольника
float[] predictedClasses = ExtractClasses(yoloModelOutputs, row, column, channel);
//получить значение и индекс класса с наибольшей вероятностью для текущего поля и вычислить его оценку
var(topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;
if (topScore < threshold)
{
continue;
}
boxes.Add(new YoloBoundingBox()
{
Dimensions = new BoundingBoxDimensions
{
X = (mappedBoundingBox.X - mappedBoundingBox.Width / 2),
Y = (mappedBoundingBox.Y - mappedBoundingBox.Height / 2),
Width = mappedBoundingBox.Width,
Height = mappedBoundingBox.Height,
},
Confidence = topScore,
Label = labels[topResultIndex],
BoxColor = classColors[topResultIndex]
});
}
}
}
return(boxes);
}
public IList <BoundingBox> ParseOutputs(Tensor modelTensorOutput, float threshold = 0.3F)
{
List <BoundingBox> boxes = new List <BoundingBox> ();
for (int row = 0; row < COL_COUNT; row++)
{
for (int colum = 0; colum < ROW_COUNT; colum++)
{
for (int box = 0; box < BOXES_PER_CELL; box++)
{
int channel = (box * (classCount + BOX_INFO_FEATURE_COUNT));
BoundingBoxDimensions bbd = ExtractBoundingBoxDimensions(modelTensorOutput, colum, row, channel);
float confidence = GetConfidence(modelTensorOutput, colum, row, channel);
CellDimensions mappedBoundingBox = MapBoundingBoxToCell(colum, row, box, bbd);
if (confidence < threshold)
{
continue;
}
float[] predictedClasses = ExtractClasses(modelTensorOutput, colum, row, channel);
var(topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;
if (topScore < threshold)
{
continue;
}
boxes.Add(new BoundingBox {
Dimensions = new BoundingBoxDimensions {
X = (mappedBoundingBox.X - mappedBoundingBox.Width / 2),
Y = (mappedBoundingBox.Y - mappedBoundingBox.Height / 2),
Width = mappedBoundingBox.Width,
Height = mappedBoundingBox.Height,
},
Confidence = topScore,
Label = labels[topResultIndex],
BoxColor = colors[topResultIndex]
});
}
}
}
return(boxes);
}
private static BoundingBoxDimensions MapBoundingBoxToCell(int row, int column, int box, BoundingBoxPrediction boxDimensions)
{
const float cellWidth = ImageSettings.imageWidth / columnCount;
const float cellHeight = ImageSettings.imageHeight / rowCount;
var mappedBox = new BoundingBoxDimensions
{
X = (row + Sigmoid(boxDimensions.X)) * cellWidth,
Y = (column + Sigmoid(boxDimensions.Y)) * cellHeight,
Width = (float)Math.Exp(boxDimensions.Width) * cellWidth * boxAnchors[box].x,
Height = (float)Math.Exp(boxDimensions.Height) * cellHeight * boxAnchors[box].y,
};
// The x,y coordinates from the (mapped) bounding box prediction represent the center
// of the bounding box. We adjust them here to represent the top left corner.
mappedBox.X -= mappedBox.Width / 2;
mappedBox.Y -= mappedBox.Height / 2;
return(mappedBox);
}
public IList <YoloBoundingBox> ParseOutputs(float[] yoloModelOutputs, float threshold = .3F)
{
var boxes = new List <YoloBoundingBox>();
for (int row = 0; row < ROW_COUNT; row++)
{
for (int column = 0; column < COL_COUNT; column++)
{
for (int box = 0; box < BOXES_PER_CELL; box++)
{
//Dentro do loop mais interno, calcule a posição inicial da caixa atual na saída de um modelo unidimensional.
var channel = (box * (CLASS_COUNT + BOX_INFO_FEATURE_COUNT));
//Diretamente abaixo disso, use o método ExtractBoundingBoxDimensions para obter as dimensões da caixa delimitadora atual.
BoundingBoxDimensions boundingBoxDimensions = ExtractBoundingBoxDimensions(yoloModelOutputs, row, column, channel);
//Em seguida, use o método GetConfidence para obter a confiança para a caixa delimitadora atual.
float confidence = GetConfidence(yoloModelOutputs, row, column, channel);
//Depois disso, use o método MapBoundingBoxToCell para mapear a caixa delimitadora atual para a célula atual que está sendo processada.
CellDimensions mappedBoundingBox = MapBoundingBoxToCell(row, column, box, boundingBoxDimensions);
//Antes de efetuar qualquer processamento adicional, verifique se seu valor de confiança é maior que o limite fornecido.
//Se não for, processe a próxima caixa delimitadora.
if (confidence < threshold)
{
continue;
}
//Caso contrário, continue processando a saída.A próxima etapa é obter a distribuição de probabilidade das classes previstas
//para a caixa delimitadora atual usando o método ExtractClasses.
float[] predictedClasses = ExtractClasses(yoloModelOutputs, row, column, channel);
//Em seguida, use o método GetTopResult para obter o valor e o índice da classe com a maior probabilidade para a caixa atual e computar sua pontuação.
var(topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;
//Use o topScore para novamente manter somente as caixas delimitadoras que estão acima do limite especificado.
if (topScore < threshold)
{
continue;
}
//Por fim, se a caixa delimitadora atual exceder o limite, crie um objeto BoundingBox e adicione-o à lista boxes.
boxes.Add(new YoloBoundingBox()
{
Dimensions = new BoundingBoxDimensions
{
X = (mappedBoundingBox.X - mappedBoundingBox.Width / 2),
Y = (mappedBoundingBox.Y - mappedBoundingBox.Height / 2),
Width = mappedBoundingBox.Width,
Height = mappedBoundingBox.Height,
},
Confidence = topScore,
Label = labels[topResultIndex],
BoxColor = classColors[topResultIndex]
});
}
}
}
return(boxes);
}
