Résultat Split

Documentation de référence sur le traitement d’un résultat Split à l’aide des SDK Mindee.

Vous devrez disposer d'un objet de réponse comme décrit dans la Traitement des réponses section.

Accéder aux plages Split

Un SplitRange décrit un sous-document logique identifié dans le fichier source.

`SplitRange` Attributs

Chaque SplitRange instance aura ces propriétés.

Type de document

La catégorie de document attribuée au sous-document. Elle est toujours renseignée.

Elle est renvoyée sous forme de chaîne et est identique à la valeur saisie sur la plateforme Mindee — casse, espaces et ponctuation compris.

Plage de pages

Un tableau à deux éléments de à base 0 indices de page, où le premier entier indique la page de début et le second entier indique la page de fin. Elle est toujours renseignée.

Une valeur de plage de pages de (0,2) signifierait de la première page à la troisième page.

Réponse d'extraction

Réponse d'extraction facultative associée au Split. Elle n'est renseignée que si l'enchaînement d'extraction est activé pour le modèle.

Parcourir les plages Split

Vous voudrez généralement parcourir toutes les plages Split, car le nombre de plages dépend du document.

from mindee import SplitResponse

def handle_response(response: SplitResponse) -> None:
    splits = response.inference.result.splits

    for split in splits:
        # plage [start_page, end_page] à base 0
        page_range = split.page_range

        print(f"Type détecté : {split.document_type}")
        print(f"Sur les pages : {page_range[0]} - {page_range[1]}")

        # Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        extraction_response = split.extraction_response

        if extraction_response is not None:
            # Accédez aux champs extraits à partir du résultat d'inférence du Split
            fields = extraction_response.inference.result.fields
            print(f"Champs d'extraction : {fields}")

handleResponse(response) {
  const splits = response.inference.result.splits;

  for (const split of splits) {
    // plage [startPage, endPage] à base 0
    const pageRange = split.pageRange;

    // Type de document identifié pour ce Split
    const documentType = split.documentType;

    console.log(`Type détecté : ${documentType}`);
    console.log(`Sur les pages : ${pageRange[0]} - ${pageRange[1]}`);
    
    // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    const extractionResponse = split.extractionResponse;

    if (extractionResponse) {
      // Accédez aux champs extraits à partir du résultat d'inférence du Split
      const fields = extractionResponse.inference.result.fields;
      console.log("Champs d'extraction :", fields.toString());
    }
  }
}

use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        // plage [startPage, endPage] à base 0
        $pageRange = $split->pageRange;

        // Type de document identifié pour ce Split
        $documentType = $split->documentType;

        echo "Type détecté : $documentType\n";
        echo "Sur les pages : {$pageRange[0]} - {$pageRange[1]}\n";

        // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        $extractionResponse = $split->extractionResponse;

        if ($extractionResponse !== null) {
            // Accédez aux champs extraits à partir du résultat d'inférence du Split
            $fields = $extractionResponse->inference->result->fields;
            echo "Champs d'extraction : " . $fields->toString() . "\n";
        }
    }
}

def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    # plage [start_page, end_page] à base 0
    page_range = split.page_range

    # Type de document identifié pour ce Split
    document_type = split.document_type

    puts "Type détecté : #{document_type}"
    puts "Sur les pages : #{page_range[0]} - #{page_range[1]}"

    # Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    extraction_response = split.extraction_response

    if extraction_response
      # Accédez aux champs extraits à partir du résultat d'inférence du Split
      fields = extraction_response.inference.result.fields
      puts "Champs d'extraction : #{fields}"
    end
  end

import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(SplitResponse response) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    // plage [startPage, endPage] à base 0
    var pageRange = split.getPageRange();

    // Type de document identifié pour ce Split
    String documentType = split.getDocumentType();

    System.out.println("Type détecté : " + documentType);
    System.out.println(
      "Sur les pages : " + pageRange.get(0) + " - " + pageRange.get(1)
    );

    // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    var extractionResponse = split.getExtractionResponse();

    if (extractionResponse != null) {
      // Accédez aux champs extraits à partir du résultat d'inférence du Split
      var fields = extractionResponse.getInference().getResult().getFields();
      System.out.println("Champs d'extraction : " + fields.toString());
    }
  }
}

using System;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        // plage [startPage, endPage] à base 0
        var pageRange = split.PageRange;

        // Type de document identifié pour ce Split
        string documentType = split.DocumentType;

        Console.WriteLine($"Type détecté : {documentType}");
        Console.WriteLine($"Sur les pages : {pageRange[0]} - {pageRange[1]}");

        // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        var extractionResponse = split.ExtractionResponse;

        if (extractionResponse != null)
        {
            // Accédez aux champs extraits à partir du résultat d'inférence du Split
            var fields = extractionResponse.Inference.Result.Fields;
            Console.WriteLine($"Champs d'extraction : {fields}");
        }
    }
}

Les résultats de l'extraction en chaîne seront un ExtractionResponse objet. Cet objet est identique à la réponse d’un modèle d'extraction.

Reportez-vous à la Résultat d’extraction section pour plus de détails sur le traitement de l'extraction.

Extraire les plages Split depuis le fichier d'entrée

Les SDK offrent la prise en charge de l'extraction de chaque plage Split sous forme de fichiers PDF distincts.

from mindee import SplitResponse

def handle_response(response: SplitResponse, input_source) -> None:
    splits = response.inference.result.splits

    for split in splits:
      extracted_split = split.extract_from_input_source(input_source)

async handleResponse(response, inputSource) {
  const splits = response.inference.result.splits;

  for (const split of splits) {
    const extractedSplit = await split.extractFromInputSource(inputSource);
  }
}

use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response, $inputSource)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        $extractedSplit = $split->extractFromInputSource($inputSource)
    }
}

def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    extracted_split = split.extract_from_input_source(input_source)
  end

import com.mindee.input.LocalInputSource;
import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(
  SplitResponse response,
  LocalInputSource inputSource
) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    var extractedSplit = split.extractFromInputSource(inputSource);
  }
}

using System;
using Mindee.Input;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response, LocalInputSource inputSource)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        var extractedSplit = split.ExtractFromInputSource(inputSource);
    }
}

Seules les méthodes documentées ici sont prêtes pour la production.

C'est parce que nous améliorons encore les SDK, veuillez patienter !

PrécédentDémarrage rapide Split SuivantAperçu du modèle Crop

Mis à jour il y a 15 jours

Ce contenu vous a-t-il été utile ?