> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Skript zur Dokumentklassifizierung

> Richten Sie in ABBYY FlexiCapture ein Skript zur Dokumentklassifizierung ein, um Klassifikatoren zu kombinieren, eine Kaskadenklassifikation durchzuführen und Klassen anhand des Konfidenzwerts zuzuweisen.

Ein ABBYY FlexiCapture-Klassifikator verarbeitet eingereichte Dokumente und bestimmt ihre Klasse. So können Sie eine Dokumentdefinition auswählen, die für die Feldextraktion verwendet wird.

Jeder Klassifikator entspricht einem bestimmten Klassifikationstraining.

Um mehrere Klassifikatoren für ein einzelnes Batch zu verwenden, müssen Sie ein Klassifizierungsskript einrichten. Das kann nützlich sein, wenn Dokumente zusätzlich klassifiziert werden müssen. In diesem Fall wird zunächst der erste Klassifikator verwendet, um die Dokumente ihrer Klasse zuzuordnen. Anschließend wird je nach Klassifikationsergebnis ein zusätzlicher Klassifikator aus dem Skript ausgewählt. So können Dokumente beispielsweise zunächst in „Rechnungen“ und „Verträge“ klassifiziert werden; anschließend können die Rechnungen weiter nach Firmenname klassifiziert werden.

<Note>
  Dieses Skript kann nur für ein bereits vorhandenes Klassifikationstraining eingerichtet werden und nicht beim Erstellen eines neuen Batch.
</Note>

<div id="set-up-a-classification-script">
  ## Ein Klassifizierungsskript einrichten
</div>

<Steps>
  <Step title="Die Projekteigenschaften öffnen">
    Klicken Sie auf **Project → Projekteigenschaften**.
  </Step>

  <Step title="Die Registerkarte „Recognition“ öffnen">
    Wechseln Sie im Fenster „Projekteigenschaften“ zur Registerkarte **Recognition**.
  </Step>

  <Step title="Den Editor für das Klassifizierungsskript öffnen">
    Klicken Sie im Abschnitt **Classification** rechts neben **Use script** auf **Set**.
  </Step>

  <Step title="Einen Klassifikator hinzufügen">
    Klicken Sie im Dialogfeld auf **Add** und wählen Sie einen Klassifizierungs-Batch aus der Liste aus.
  </Step>

  <Step title="Einen Aliasnamen festlegen">
    Ändern Sie bei Bedarf den **Alias Name** des Klassifikators. Das Skript verweist auf den Namen in der Spalte **Alias Name**, sodass Sie das Skript nicht neu schreiben müssen, wenn sich der Name eines Klassifikators während der Verarbeitung ändert.
  </Step>

  <Step title="Den Skripteditor öffnen">
    Klicken Sie auf **Edit Script**, um das [Skripteditor-Fenster](/de/flexi-capture/interface/script-editor) zu öffnen.
  </Step>
</Steps>

<div id="parameters">
  ## Parameter
</div>

| Name                  | Typ                                                                             | Zugriff          | Beschreibung                                                                                                                                                                                                 |
| --------------------- | ------------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `BatchTypeClassifier` | [IBatchTypeClassifier](/de/flexi-capture/appendix/scripts/ibatchtypeclassifier) | Schreibgeschützt | Ein Klassifikator des Batch-Typs.                                                                                                                                                                            |
| `IsConfident`         | bool                                                                            | Schreibgeschützt | Klassifikations‑Konfidenzwert. Im Gegensatz zu automatischen Klassifikatoren muss dieser Parameter bei Verwendung des Skripts manuell in den Seiteneigenschaften angegeben werden. Siehe folgendes Beispiel. |
| `Page`                | [IPage](/de/flexi-capture/appendix/scripts/ipage)                               | Lesen/Schreiben  | Dokumentseite.                                                                                                                                                                                               |
| `Processing`          | [IProcessingCallback](/de/flexi-capture/appendix/scripts/iprocessingcallback)   | Lesen/Schreiben  | Das Objekt zum Protokollieren von Informationen über die Verarbeitung.                                                                                                                                       |

Im folgenden Beispiel wird `IsConfident` in den Seiteneigenschaften angegeben:

```csharp theme={null}
IClassificationResult result = Classifiers[0].ClassifyPage( Page );
Page.ResultClassName = result.ClassName;
Page.IsResultClassConfident = result.IsConfident;
```

<div id="classify-a-page-and-set-the-class-name">
  ## Eine Seite klassifizieren und den Klassennamen festlegen
</div>

Dieses Skript klassifiziert Seiten und trägt den Namen einer Klasse in ihre Eigenschaften ein:

```csharp theme={null}
IBatchTypeClassifierResult classifierResult = BatchTypeClassifier.ClassifyPage( Page, null );
Page.ResultClassName = classifierResult.ClassName;
```

<div id="get-classification-confidence">
  ## Klassifikations‑Konfidenzwert abrufen
</div>

Dieses Skript ruft Klassifikations‑Konfidenzwerte ab:

```csharp theme={null}
IClassificationResult result = Classifiers[0].ClassifyPage( Page );
FCTools.ShowMessage( "Class: " + result.ClassName );
Page.ResultClassName = result.ClassName;
FCTools.ShowMessage( "IsConfident: " + result.IsConfident );
Page.IsResultClassConfident = result.IsConfident;
```

<div id="combine-multiple-classifiers-for-cascade-classification">
  ## Mehrere Klassifikatoren für die Kaskadenklassifikation kombinieren
</div>

```csharp theme={null}
var res0 = Classifiers.Get ( "Batch" ).ClassifyPage( Page );
IClassConfidences classVars = res0.Classes;
foreach( IClassConfidence c in classVars )
{
    FCTools.ShowMessage( c.Name + " --> " + c.Confidence.ToString() );
}
FCTools.ShowMessage( "Class res0: " + res0.ClassName);
if (res0.ClassName == "Invoice")
{
    var res1 = Classifiers.Get ( "Batch2" ).ClassifyPage( Page );
    IClassConfidences classVars1 = res1.Classes;
    foreach( IClassConfidence d in classVars1 )
    {
        FCTools.ShowMessage( d.Name + " --> " + d.Confidence.ToString() );
    }
    FCTools.ShowMessage( "Class res1: " + res1.ClassName);
    Page.ResultClassName = res1.ClassName;
}
else
{
    Page.ResultClassName = res0.ClassName;
}
FCTools.ShowMessage( "Page.ResultClassName: " +Page.ResultClassName);
```

<div id="assign-the-unknown-class-to-low-confidence-documents">
  ## Weisen Sie Dokumenten mit niedrigem Konfidenzwert die Klasse Unknown zu
</div>

Verwenden Sie dieses Skript, wenn in Ihrem Szenario Dokumenten mit niedrigem Konfidenzwert keine Klasse zugewiesen werden soll, auch wenn bereits eine Klasse für sie festgelegt wurde. Solche Dokumente sollten von einem Operator manuell klassifiziert werden.

<Note>
  Damit das Skript funktioniert, erstellen Sie vorab eine neue Klasse — zum Beispiel "Unknown" — und ordnen Sie sie im Dialogfeld **Class Mapping** der Dokumentdefinition zu. Weitere Informationen finden Sie unter [Zuordnen von Klassen zu Abschnitten der Dokumentdefinition](/de/flexi-capture/classify-mapping-classes).
</Note>

```csharp theme={null}
using System;

IClassificationResult result = Classifiers.Get ( "ClassifierBatch" ).ClassifyPage(Page);
Page.ResultClassName = result.ClassName;
IClassConfidences classVars = result.Classes;
Page.Comment = "";

foreach( IClassConfidence c in classVars )
{
    //FCTools.ShowMessage( c.Name + " -- " + c.Confidence.ToString() ); // Zeichnet den Klassifikations-Konfidenzwert im Ereignisprotokoll auf
    Page.Comment = Page.Comment + c.Name + "-" + c.Confidence.ToString() + "; "; // Zeichnet den Klassifikations-Konfidenzwert in den Seitenkommentaren auf
}

if (classVars.Count>0)
{
    if (classVars[0].Confidence<80) Page.IsResultClassConfident=false; // Konfidenz-Schwellenwert, unterhalb dessen ein Dokument als unsicher klassifiziert wird
    else Page.IsResultClassConfident=true;

    if (classVars[0].Confidence<20) Page.ResultClassName="Unknown"; // Konfidenz-Schwellenwert, unterhalb dessen einem Dokument die Klasse „Unknown" zugewiesen wird
    if (classVars.Count>1) {
        int classesToShow = Math.Min(classVars.Count, 3);
        for(int i=0; i<classesToShow; i++)
        {
            Page.Comment = Page.Comment + classVars[i].Name + "-" + classVars[i].Confidence.ToString() + "; ";
        }
    }
}

FCTools.ShowMessage( "Class: " + Page.ResultClassName );
```

<Note>
  Die Schwellenwerte für den Konfidenzwert in diesem Skript dienen nur zu Demonstrationszwecken. Passen Sie sie an Ihren Workflow an.
</Note>