Oblix/yolov8x-doclaynet_ONNX

Para usar este modelo, primero se debe instalar la librería de Transformers.js desde NPM utilizando:

npm i @xenova/transformers

Ejemplo: Realizar detección de objetos con Oblix/yolov8x-doclaynet_ONNX.

import { AutoModel, AutoProcessor, RawImage } from '@xenova/transformers';

const model = await AutoModel.from_pretrained(
  "Oblix/yolov8x-doclaynet_ONNX",
  {
    quantized: false,
  }
);
const processor = await AutoProcessor.from_pretrained("Oblix/yolov8x-doclaynet_ONNX");

const url = 'https://huggingface.co/DILHTWD/documentlayoutsegmentation_YOLOv8_ondoclaynet/resolve/main/sample1.png';
const rawImage = await RawImage.fromURL(url);
const { pixel_values } = await processor(rawImage);
const output = await model({ images: pixel_values });

// Post-process:
const permuted = output.output0[0].transpose(1, 0);
// `permuted` es un Tensor de forma [ 8400, 15 ]:
// - 8400 cuadros delimitadores potenciales
// - 15 parámetros para cada cuadro:
//   - los primeros 4 son las coordenadas de los cuadros delimitadores (x-center, y-center, ancho, alto)
//   - los 11 restantes son las probabilidades para cada clase

// Código de ejemplo para formatearlo correctamente:
const results = [];
const threshold = 0.5; // Ajuste el umbral según sea necesario
const [scaledHeight, scaledWidth] = pixel_values.dims.slice(-2);
for (const [xc, yc, w, h, ...scores] of permuted.tolist()) {
  // Obtener valores de píxeles, teniendo en cuenta el tamaño original de la imagen
  const x1 = (xc - w / 2) / scaledWidth * rawImage.width;
  const y1 = (yc - h / 2) / scaledHeight * rawImage.height;
  const x2 = (xc + w / 2) / scaledWidth * rawImage.width;
  const y2 = (yc + h / 2) / scaledHeight * rawImage.height;

  // Obtener la mejor clase
  const argmax = scores.reduce((maxIndex, currentVal, currentIndex, arr) => currentVal > arr[maxIndex] ? currentIndex : maxIndex, 0);
  const score = scores[argmax];
  if (score < threshold) continue; // No es lo suficientemente confiable

  const label = model.config.id2label[argmax];
  results.push({
    x1, x2, y1, y2, score, label, index: argmax,
  });
}

const iouThreshold = 0.5; // Ajuste el umbral según sea necesario
const filteredResults = removeDuplicates(results, iouThreshold);
console.log(filteredResults);

function removeDuplicates(detections, iouThreshold) {
  const filteredDetections = [];

  for (const detection of detections) {
    let isDuplicate = false;
    let duplicateIndex = -1;
    let maxIoU = 0;

    for (let i = 0; i < filteredDetections.length; i++) {
      const filteredDetection = filteredDetections[i];
      const iou = calculateIoU(detection, filteredDetection);
      if (iou > iouThreshold) {
        isDuplicate = true;
        if (iou > maxIoU) {
          maxIoU = iou;
          duplicateIndex = i;
        }
      }
    }

    if (!isDuplicate) {
      filteredDetections.push(detection);
    } else if (duplicateIndex !== -1) {
      if (detection.score > filteredDetections[duplicateIndex].score) {
        filteredDetections[duplicateIndex] = detection;
      }
    }
  }

  return filteredDetections;
}

function calculateIoU(detection1, detection2) {
  const xOverlap = Math.max(0, Math.min(detection1.x2, detection2.x2) - Math.max(detection1.x1, detection2.x1));
  const yOverlap = Math.max(0, Math.min(detection1.y2, detection2.y2) - Math.max(detection1.y1, detection2.y1));
  const overlapArea = xOverlap * yOverlap;

  const area1 = (detection1.x2 - detection1.x1) * (detection1.y2 - detection1.y1);
  const area2 = (detection2.x2 - detection2.x1) * (detection2.y2 - detection2.y1);
  const unionArea = area1 + area2 - overlapArea;

  return overlapArea / unionArea;
}