Classification des documents et séparation des documents par l'IA

L'un des problèmes souvent négligés et vraiment difficiles de l'automatisation des documents, qui est aussi vraiment agaçant au quotidien, est la séparation automatique d'une pile de documents en documents individuels significatifs et leur affectation à une classe de documents. Dans les processus de numérisation traditionnels, on y parvient souvent en préparant manuellement le papier et en apposant un code-barres comme séparateur de documents sur chaque première page. Mais cela demande beaucoup de travail et est source d'erreurs. De plus, comme nous devenons de plus en plus numériques, nous n'avons généralement plus accès au papier, même pour les processus basés sur le papier. L'objectif serait donc simplement de scanner toute la pile et de la séparer par un algorithme intelligent.

Heureusement, cela est déjà disponible aujourd'hui, par exemple à partir de la pile technologique Konfuzio en tant que fonctionnalité intégrée. Mais cela ne veut pas dire que c'est facile. Il faut beaucoup d'expérience et d'infrastructure pour gérer plusieurs étapes interdépendantes de classification et de séparation de manière stable et fiable. C'est précisément ce qu'offre Konfuzio.

Comment fonctionne en principe la structuration des documents ? Eh bien, exactement de la même manière (notre credo !) qu'un être humain le ferait. Parcours la pile page par page, détermine de quel type de page il s'agit, si elle est liée à la page précédente ou si un nouveau sujet/formulaire commence. Vérifie ensuite la sécurité des numéros de page, s'il y en a. En cas de doute, reviens une ou plusieurs pages en arrière pour vérifier, puis prends ta décision de séparation.

Séparation des documents

Dans le cas de la classification AI, ceci est intégré dans une séquence d'algorithmes. Le système est entraîné sur un échantillon qui est déjà correctement séparé. Konfuzio apprend pour chaque page s'il s'agit d'une première, d'une moyenne, d'une dernière ou d'une page unique. L'utilisateur n'a pas besoin de le préciser explicitement, car l'IA de Konfuzio le découvre automatiquement à partir des échantillons et cache cette complexité aux utilisateurs. L'interface de formation exige simplement que les documents individuels soient laissés tomber dans l'ensemble de formation. Il n'est pas nécessaire d'avoir un nombre exact de pages (plage) pour chaque type de document. Konfuzio tient automatiquement compte du fait que cela peut varier pour chaque type de document. Cependant, si tu sais que tu peux aussi limiter les pages autorisées, par exemple pour les formulaires d'une page, qui ont toujours une page.

Konfuzio apprendra ensuite la structure et l'appliquera à l'ensemble de la pile de pages individuelles non séparées pendant l'exécution.

Division des documents - Un guide détaillé pour entraîner une IA

L'automatisation des documents peut souvent être un processus fastidieux et sujet aux erreurs, surtout lorsqu'il s'agit de diviser automatiquement une pile de documents en documents individuels et de les attribuer à une classe de documents. Traditionnellement, les processus de numérisation y parviennent en préparant manuellement le papier et en apposant un code-barres comme séparateur sur chaque première page. Cependant, cela prend beaucoup de temps et est sujet aux erreurs. De plus, les installations de traitement n'ont généralement plus accès au papier, même dans le cas de processus basés sur le papier. L'objectif est donc de scanner simplement l'ensemble de la pile et de la diviser par un algorithme intelligent.

Heureusement, cela est aujourd'hui possible grâce à la technologie Konfuzio. Le SDK Konfuzio propose une classe préfabriquée appelée SplittingAI et une instance d'un ContextAwareFileSplittingModel entraîné, qui utilise une logique sensible au contexte. Sensible au contexte signifie dans ce cas une procédure basée sur des règles qui recherche des chaînes communes entre les premières pages de tous les documents d'une catégorie. Pour prédire si une page est un point de séparation potentiel (c'est-à-dire s'il s'agit d'une première page), l'algorithme compare le contenu de la page à ces chaînes communes aux premières pages. Si au moins une de ces chaînes est présente sur la page, celle-ci est marquée comme première page, ce qui signifie qu'elle est un point de séparation.

Dans cette plongée profonde, nous expliquons comment utiliser le SDK Konfuzio pour entraîner un modèle capable de diviser automatiquement des documents en plusieurs documents. Nous utiliserons la classe SplittingAI et une instance d'un ContextAwareFileSplittingModel entraîné pour diviser automatiquement un fichier en plusieurs documents.

Répartition des fichiers

Extraire des documents individuels d'un fichier Voyons comment nous pouvons utiliser le SDK Konfuzio pour diviser automatiquement un fichier en plusieurs documents. Nous utilisons la classe prédéfinie SplittingAI et une instance d'un ContextAwareFileSplittingModel entraîné. Ce dernier utilise une logique sensible au contexte. Dans ce cas, sensible au contexte signifie une procédure basée sur des règles qui recherche des chaînes communes entre les premières pages de tous les documents d'une catégorie. Pour prédire si une page est un point de séparation potentiel (c'est-à-dire s'il s'agit d'une première page), l'algorithme compare le contenu de la page à ces chaînes communes aux premières pages. Si au moins une de ces chaînes est présente sur la page, celle-ci est marquée comme première page, ce qui signifie qu'elle est un point de séparation.

Ce tutoriel peut également être utilisé avec le MultimodalFileSplittingModel. La seule différence au niveau de l'initialisation réside dans le fait qu'il n'est pas nécessaire de spécifier explicitement un tokenizer.

Comment entraîner une IA de décomposition de documents avec le SDK Konfuzio

L'automatisation des documents est un élément important de l'environnement de travail numérique actuel. Dans ce contexte, la séparation automatique de lots de documents en documents individuels significatifs et leur affectation à une classe de documents est une tâche souvent négligée et difficile, qui peut souvent s'avérer très gênante lors du traitement quotidien des documents. Dans le processus de numérisation traditionnel, on y parvient souvent en préparant manuellement le papier et en apposant un code-barres comme séparateur de documents sur chaque première page. Mais cela prend beaucoup de temps et est source d'erreurs. Avec la numérisation croissante, les équipements de traitement n'ont souvent plus accès au papier. L'objectif serait donc simplement de scanner toute la pile et de la séparer automatiquement grâce à un algorithme intelligent.

Konfuzio propose une solution à ce problème grâce au SDK Python Konfuzio. Le SDK Konfuzio propose une classe pré-entraînée, appelée SplittingAI, qui utilise une instance d'un ContextAwareFileSplittingModel entraîné. Celui-ci utilise une logique consciente du contexte qui recherche des chaînes de caractères communes entre les premières pages de tous les documents d'une catégorie afin de décider si une page est ou non un point de séparation potentiel. S'il y a au moins une chaîne de ce type, nous marquons la page comme étant la première (ce qui signifie qu'il s'agit d'un point de séparation).

Dans ce tutoriel, vous apprendrez à utiliser le SDK Konfuzio pour former et utiliser un ContextAwareFileSplittingModel afin de diviser automatiquement des documents.

Étape 1 : Configurer le projet Konfuzio et créer le document de test

La première chose à faire est de configurer un projet Konfuzio et de choisir un document de test. Vous pouvez le faire en important la bibliothèque Konfuzio SDK dans Python et en initialisant l'objet Konfuzio :

from konfuzio_sdk.data import Page, Category, Project
from konfuzio_sdk.trainer.file_splitting import SplittingAI
from konfuzio_sdk.trainer.file_splitting import ContextAwareFileSplittingModel
from konfuzio_sdk.trainer.information_extraction import load_model
from konfuzio_sdk.tokenizer.regex import ConnectedTextTokenizer
# Initialisieren Sie ein Projekt und rufen Sie ein Testdokument Ihrer Wahl ab
project = Project(id_=IHR_PROJEKT_ID)
test_document = project.get_document_by_id(IHRE_DOKUMENTEN_ID)

Étape 2 : Initialiser et personnaliser le ContextAwareFileSplittingModel

Ensuite, vous devez initialiser et adapter le ContextAwareFileSplittingModel. Pour cela, vous devez indiquer les catégories et le tokenizer pour le modèle. Le tokenizer est utilisé pour charger les textes dans le modèle et les diviser en phrases.

file_splitting_model = ContextAwareFileSplittingModel(categories=project.categories, tokenizer=ConnectedTextTokenizer())

Dans cet exemple, nous utilisons un ConnectedTextTokenizer qui divise le texte en phrases, puis en mots. D'autres tokenizers, tels qu'un tokenizer standard, peuvent également être utilisés. Cependant, le ConnectedTextTokenizer a été spécialement conçu pour le traitement de textes cohérents et peut donc être utile pour identifier les parties séparables du document.

Tout d'abord, nous devons initialiser un projet et sélectionner un document de test. Nous partons du principe que le SDK Konfuzio est déjà installé et que nous avons accès à un système Konfuzio en cours d'exécution.

from konfuzio_sdk.data import Page, Category, Project
from konfuzio_sdk.trainer.file_splitting import ContextAwareFileSplittingModel
from konfuzio_sdk.tokenizer.regex import ConnectedTextTokenizer
# initialize a Project and fetch a test Document of your choice
project = Project(id_=YOUR_PROJECT_ID)
test_document = project.get_document_by_id(YOUR_DOCUMENT_ID)

Ensuite, nous initialisons une instance du ContextAwareFileSplittingModel et l'adaptons aux catégories de notre projet. Nous devons également indiquer le tokenizer utilisé. Dans ce cas, nous utilisons le ConnectedTextTokenizer.

# initialize a Context Aware File Splitting Model and fit it
file_splitting_model = ContextAwareFileSplittingModel(categories=project.categories, tokenizer=ConnectedTextTokenizer())
# fit the model
file_splitting_model.fit(allow_empty_categories=True)

Nous pouvons maintenant utiliser le modèle entraîné pour diviser un document d'entrée en plusieurs documents. Nous partons du principe que nous avons un document qui est composé de plusieurs documents et qui doit donc être séparé.

# run the prediction with the Context Aware File Splitting Model
new_documents = []
current_document = None
for page in test_document.pages():
    pred = file_splitting_model.predict(page)
    if pred.is_first_page:
        # create a new Document when a first Page is found
        if current_document is not None:
            new_documents.append(current_document)
        current_document = project.create_document(category_id=YOUR_CATEGORY_ID)
        current_document.add_page(page)
    else:
        # add the Page to the current Document
        current_document.add_page(page)
# add the last Document to the list
new_documents.append(current_document)

La variable new_documents contient maintenant une liste de documents distincts extraits du document d'entrée original.

Validation par Human-in-the-Loop UI

Le traitement des documents est une composante importante dans différents secteurs, tels que la banque, les assurances et le secteur juridique. Le processus de numérisation et de classement de plusieurs documents peut prendre beaucoup de temps et il existe souvent un besoin d'une solution automatisée capable de diviser et d'organiser ces documents. Cependant, les solutions automatisées ne sont pas toujours impeccables et peuvent négliger des détails importants ou mal identifier un type de document. C'est là qu'intervient une interface avec l'homme, l'interface de validation de documents (DV UI).

DV UI est un outil qui permet aux personnes d'interagir avec un système de traitement automatisé des documents afin de valider et de corriger sa sortie. DV UI offre une interface permettant aux utilisateurs de vérifier et de valider la division automatique des documents et l'organisation des fichiers, et d'apporter des corrections si nécessaire. L'utilisateur peut également entraîner le système d'IA à reconnaître de nouveaux types de documents afin de garantir l'exactitude des futures répartitions et organisations.

L'utilisation de DV UI pour affiner l'IA qui divise automatiquement les numérisations et les fichiers peut améliorer considérablement la précision et l'efficacité du traitement des documents. Le système d'IA peut apprendre des corrections de l'utilisateur et mettre à jour ses algorithmes afin de mieux reconnaître les types de documents et de les diviser en conséquence. Plus le système d'IA reçoit de données de l'utilisateur, plus il devient précis, de sorte qu'au fil du temps, moins d'interventions manuelles sont nécessaires.

En outre, l'utilisation de DV UI pour le traitement des documents permet aux entreprises d'économiser du temps et de l'argent, car le système peut traiter plus de documents en moins de temps et avec moins d'erreurs. Cela signifie que les entreprises peuvent concentrer leurs ressources sur d'autres tâches importantes, comme l'analyse des données extraites des documents traités, au lieu de les organiser et de les diviser manuellement.

En résumé, DV UI est un outil indispensable pour affiner l'IA qui divise automatiquement les numérisations et les fichiers contenant plusieurs documents. Son utilisation peut améliorer considérablement la précision et l'efficacité du traitement des documents, réduire le besoin d'interventions manuelles et permettre aux entreprises de se concentrer sur d'autres tâches importantes.

Conclusion Séparation des documents et classification des documents

Dans cet exemple, nous avons montré comment utiliser le SDK Konfuzio pour utiliser un modèle entraîné afin de diviser un document d'entrée en plusieurs documents séparés. La division automatique de documents est particulièrement utile pour le traitement de lots de documents papier ou de fichiers PDF contenant plusieurs documents séparés. Grâce au SDK Konfuzio, les développeurs peuvent rapidement et facilement entraîner leurs propres modèles et les appliquer à de nouveaux documents.

Registre ou visitez notre documentation technique to learn more