> ## 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.

# Dokumentklassifizierung

> Klassifizieren Sie Dokumente mit ABBYY FineReader Engine anhand bildbasierter, textbasierter oder hybrider Klassifizierung in vordefinierte Kategorien — erstellen Sie eine Datenbank aus Beispieldokumenten und wenden Sie sie an.

Ziel der Dokumentklassifizierung ist es, Dokumente verschiedenen vordefinierten Kategorien zuzuordnen. Das ist besonders nützlich, wenn Sie es mit einem Dokumentenfluss zu tun haben, der Dokumente unterschiedlicher Typen enthält, und den Typ jedes Dokuments bestimmen müssen. So möchten Sie beispielsweise Verträge, Rechnungen und Belege in verschiedene Ordner sortieren oder je nach Typ umbenennen. Dies lässt sich mit einem vortrainierten System automatisch erledigen.

Eine der Haupteigenschaften der Dokumentklassifizierung besteht darin, dass Sie die zu unterscheidenden Dokumenttypen im Voraus kennen. ABBYY FineReader Engine kann Dokumente anhand ihres Inhalts oder anhand von Bildmerkmalen klassifizieren oder sowohl die Merkmale des erkannten Textes als auch des Bildes berücksichtigen.

Betrachten wir den Prozess im Detail. Er besteht aus zwei Hauptschritten:

1. Erstellen einer Klassifizierungsdatenbank

   Wählen Sie für jede Kategorie mehrere typische Dokumente oder Seiten aus. Diese werden zum Erstellen der Klassifizierungsdatenbank verwendet.

2. Klassifizieren von Dokumenten

   Die im vorherigen Schritt erstellte Datenbank kann zur Klassifizierung von Dokumenten verwendet werden. Eingehende Dokumente werden einem vortrainierten Klassifizierungssystem zugeführt, das anhand der Klassifizierungsdatenbank die jeweilige Kategorie bestimmt.

Unter Umständen müssen Sie Dokumente auch anhand bestimmter Attribute klassifizieren, z. B. nach Autor oder Barcode-Wert. Dieser Artikel behandelt diese Art der Klassifizierung nicht. Wenn Sie Dokumente anhand ihrer Attribute klassifizieren möchten, sollten Sie eigene Algorithmen implementieren, die zur Datenextraktion [Textextraktion](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-extraction), [Erkennung auf Feldebene](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition) oder [Barcode-Erkennung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition) verwenden können.

Das unten beschriebene Verfahren wird außerdem durch das Demo-Tool [Classification](/de/fine-reader/engine/guided-tour/samples#classification) für Windows und das Codebeispiel [Classification](/de/fine-reader/engine/guided-tour/samples#classification_unix) für Linux und macOS veranschaulicht.

<div id="scenario-implementation">
  ## Implementierung des Szenarios
</div>

<Note>
  Die in diesem Thema bereitgestellten Codebeispiele sind spezifisch für Windows.
</Note>

Im Folgenden wird die empfohlene Methode zur Verwendung von ABBYY FineReader Engine zur Dokumentklassifizierung ausführlich beschrieben.

<Accordion title="Schritt 1. ABBYY FineReader Engine laden">
  Um mit ABBYY FineReader Engine zu beginnen, müssen Sie das Objekt [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface) erstellen. Das Engine-Objekt ist das oberste Objekt in der Hierarchie der ABBYY FineReader Engine-Objekte und stellt verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zum Erstellen anderer Objekte bereit.

  Zum Erstellen des Engine-Objekts können Sie die Funktion [InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function) verwenden. Siehe auch [andere Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) (Win).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      public EngineLoader()
      {
          // Initialisieren Sie diese Variablen mit dem vollständigen Pfad zu FREngine.dll, Ihrer Customer Project ID
          // und gegebenenfalls mit dem Pfad zu Ihrer Online License-Token-Datei und dem Online License-Passwort
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // FREngine.dll-Bibliothek laden
          dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
             
          try
          {
              if (dllHandle == IntPtr.Zero)
              {
                  throw new Exception("Can't load " + enginePath);
              }
              IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
              if (initializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find InitializeEngine function");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DeinitializeEngine function");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DllCanUnloadNow function");
              }
              // Zeiger in Delegaten konvertieren
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // Funktion InitializeEngine aufrufen 
              // und dabei den Pfad zur Online License-Datei und das Online License-Passwort übergeben
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // FREngine.dll-Bibliothek freigeben
              engine = null;
              // Alle Objekte vor dem Aufruf von FreeLibrary löschen
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // Funktionen aus Kernel32.dll
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // Funktionen aus FREngine.dll
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine(string customerProjectId, string licensePath, 
          string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
          ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<Accordion title="Schritt 2. ClassificationEngine erstellen">
  Erstellen Sie ein [ClassificationEngine](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine)-Objekt, das als Factory für andere Objekte der Classification API dient. Verwenden Sie dafür die Methode [CreateClassificationEngine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Engine-Objekts.

  ### C\#

  ```csharp theme={null}
  FREngine.IEngine engine;
  FREngine.IClassificationEngine classEngine = engine.CreateClassificationEngine();
  ```
</Accordion>

<Accordion title="Schritt 3. Die Klassifizierungsobjekte vorbereiten">
  Die Trainings- und Klassifizierungsmethoden arbeiten mit einem speziellen Objekttyp, der aus einem Dokument oder einer Seite erstellt wird: [ClassificationObject](/de/fine-reader/engine/api-reference/classification-related-objects/classificationobject), das alle für die Klassifizierung relevanten Informationen enthält.

  Gehen Sie wie folgt vor, um ein Dokument für die Verwendung in einem Klassifizierungsszenario vorzubereiten:

  1. Laden Sie die zu verarbeitenden Bilder. Dafür gibt es mehrere Möglichkeiten: Sie können beispielsweise das Objekt [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) mithilfe der Methode [CreateFRDocument](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Engine-Objekts erstellen und dann mit der Methode [AddImageFile](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method) Bilder aus einer Datei zum erstellten FRDocument-Objekt hinzufügen.

  2. Wenn Sie einen Klassifikator trainieren oder verwenden möchten, der Textmerkmale berücksichtigt ([CT\_Combined](/de/fine-reader/engine/api-reference/enumerations/classifiertypeenum#ct_combined), [CT\_Text](/de/fine-reader/engine/api-reference/enumerations/classifiertypeenum#ct_text)), erkennen Sie das Dokument zunächst mit einer geeigneten Methode. Wir verwenden die Methoden [Analyze](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method) und [Recognize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument). Eine Dokumentensynthese ist für die Klassifizierung nicht erforderlich.

  <Note>
    Obwohl die Parallelverarbeitung für die Klassifizierung selbst nicht unterstützt wird, benötigen Sie sie möglicherweise für die vorbereitende Erkennung von Dokumenten unter Windows und Linux. Wenn Sie eine große Anzahl von Dokumenten klassifizieren möchten, empfehlen wir die Verwendung von Batch Processor oder anderen Methoden zur Parallelverarbeitung, die unter [Parallel Processing with ABBYY FineReader Engine](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing) beschrieben sind.
  </Note>

  3. Verwenden Sie die Methode [CreateObjectFromDocument](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine/createobjectfromdocument-method) des Objekts [ClassificationEngine](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine), um ein ClassificationObject zu erstellen, das die Informationen der ersten Seite des Dokuments enthält. Wenn Sie eine andere Seite des Dokuments verwenden möchten, rufen Sie die Methode [CreateObjectFromPage](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine/createobjectfrompage-method) auf.

  4. Die Eigenschaft [Description](/de/fine-reader/engine/api-reference/classification-related-objects/classificationobject#description) des ClassificationObject ist standardmäßig leer. Geben Sie diese Eigenschaft an, wenn Sie eine aussagekräftige Beschreibung benötigen.

  <Note>
    Es kann gelegentlich vorkommen, dass das erkannte Dokument oder die erkannte Seite dennoch keinen erkannten Text enthält (zum Beispiel, wenn versehentlich eine leere Seite verwendet wurde). In diesem Fall kann das ClassificationObject nicht für Klassifikatoren verwendet werden, die Textmerkmale erfordern. Sie können die Eigenschaft [SuitableClassifiers](/de/fine-reader/engine/api-reference/classification-related-objects/classificationobject#suitableclassifiers) zur zusätzlichen Überprüfung verwenden.
  </Note>

  ### C\#

  ```csharp theme={null}
  // Das FRDocument-Objekt erstellen
  FREngine.IFRDocument frDocument = engine.CreateFRDocument();
  // Die Bilder hinzufügen
  frDocument.AddImageFile( "C:\\MyImage.tif", null, null );
  // Optional: das Dokument analysieren und erkennen
  frDocument.Analyze( null, null, null );
  frDocument.Recognize( null, null );
  // Das Klassifizierungsobjekt erstellen
  FREngine.IClassificationObject clObject = classEngine.CreateObjectFromDocument( frDocument );
  // Die Kategorie, zu der das Objekt gehört, in die Beschreibung eintragen
  clObject.Description = "CategoryA_Object1";
  ```
</Accordion>

<Accordion title="Schritt 4. Erstellen eines Trainingsdatensatzes">
  Um einen Klassifikator zu trainieren, der zwischen mehreren Dokumenttypen unterscheiden kann, benötigen Sie einen kategorisierten Datensatz, der Beispiele für jeden Typ enthält. Verwenden Sie das Objekt [TrainingData](/de/fine-reader/engine/api-reference/classification-related-objects/trainingdata), um diesen Datensatz aufzubauen und zu verwalten:

  1. Erstellen Sie mithilfe der Methode [CreateTrainingData](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine/createtrainingdata-method) des ClassificationEngine-Objekts ein leeres Objekt.
  2. Greifen Sie über die Eigenschaft [Categories](/de/fine-reader/engine/api-reference/classification-related-objects/trainingdata#categories) auf die Kategoriensammlung zu.
  3. Verwenden Sie die Methode [AddNew](/de/fine-reader/engine/api-reference/classification-related-objects/categories/addnew-method) des Objekts Categories mehrmals, um für jeden Dokumenttyp, den Sie klassifizieren möchten, eine Kategorie hinzuzufügen. Die Methode erwartet als Eingabeparameter einen string mit der Kategorienbezeichnung. Diese Bezeichnung wird von den Klassifizierungsmethoden zurückgegeben und muss daher innerhalb der Kategoriensammlung eindeutig sein.
  4. Öffnen Sie für jedes neu hinzugefügte Objekt [Category](/de/fine-reader/engine/api-reference/classification-related-objects/category) über die Eigenschaft [Objects](/de/fine-reader/engine/api-reference/classification-related-objects/category#objects) die Sammlung der Klassifizierungsobjekte. Fügen Sie mithilfe der Methode [IClassificationObjects::Add](/de/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/add-method) die Klassifizierungsobjekte hinzu, die zu dieser Kategorie gehören.<br />Keine Kategorie darf leer bleiben. Aus offensichtlichen Gründen sind für das Training mindestens zwei Kategorien erforderlich.
  5. Nachdem Sie den Trainingsdatensatz eingerichtet haben, können Sie ihn zur späteren Verwendung in einer Datei auf der Festplatte speichern, etwa wenn sich die Genauigkeit des trainierten Modells als unzureichend erweist und Sie zur Verbesserung der Qualität Daten hinzufügen oder korrigieren möchten. Das Objekt TrainingData stellt dazu die Methode [SaveToFile](/de/fine-reader/engine/api-reference/supplementary-objects-and-methods/savetofile-method) bereit.

  ### C\#

  ```csharp theme={null}
  FREngine.ITrainingData trainingData = classEngine.CreateTrainingData();
  FREngine.ICategories categories = trainingData.Categories;
  // Die erste Kategorie hinzufügen
  FREngine.ICategory category = categories.AddNew( "CategoryA" );
  // Die in Schritt 3 vorbereiteten Klassifizierungsobjekte hinzufügen
  category.Objects.Add( clObject ); // für alle Objekte aus dieser Kategorie wiederholen
  ...
  // Für alle Kategorien wiederholen
  ...
  // Nachdem alle Kategorien hinzugefügt wurden, den Trainingsdatensatz speichern
  trainingData.SaveToFile( "C:\\trainingData.dat" );
  ```
</Accordion>

<Accordion title="Schritt 5. Das Klassifizierungsmodell trainieren">
  Die Funktionalität für das Modelltraining wird vom [Trainer](/de/fine-reader/engine/api-reference/classification-related-objects/trainer)-Objekt bereitgestellt. Verwenden Sie die [CreateTrainer](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine/createtrainer-method)-Methode des ClassificationEngine-Objekts, um es zu erstellen.

  Es enthält alle Einstellungen für den Klassifikatortyp und das Trainingsverfahren in zwei Unterobjekten: [TrainingParams](/de/fine-reader/engine/api-reference/classification-related-objects/trainingparams) und [ValidationParams](/de/fine-reader/engine/api-reference/classification-related-objects/validationparams). Legen Sie fest, welche Einstellungen Sie benötigen, und passen Sie die entsprechenden Eigenschaften an:

  * Der Typ des Klassifikators ([ITrainingParams::ClassifierType](/de/fine-reader/engine/api-reference/classification-related-objects/trainingparams#classifiertype)). Diese Einstellung legt fest, welche Merkmale des Dokuments bei der Kategorisierung berücksichtigt werden: Bildeigenschaften, der Inhalt des erkannten Textes oder beides. Wenn Sie einen Typ auswählen möchten, der den Textinhalt nutzt, müssen Sie sicherstellen, dass alle Klassifizierungsobjekte im Trainingsdatensatz aus zuvor erkannten Dokumenten erstellt wurden.
  * Der Trainingsmodus ([ITrainingParams::TrainingMode](/de/fine-reader/engine/api-reference/classification-related-objects/trainingparams#trainingmode)). Diese Einstellung legt fest, ob der Trainingsprozess auf hohe Präzision (wie viele der ausgewählten Elemente korrekt sind), hohe Trefferquote (wie viele der korrekten Elemente ausgewählt werden) oder ein ausgewogenes Verhältnis zwischen beiden ausgerichtet sein soll.
  * Ob eine k-fache Kreuzvalidierung verwendet werden soll ([IValidationParams::ShouldPerformValidation](/de/fine-reader/engine/api-reference/classification-related-objects/validationparams#shouldperformvalidation)). Wir empfehlen, die Kreuzvalidierung zu verwenden, wenn Ihre Trainingsstichprobe nicht groß ist, da Sie damit mehrere Modelle auf den verschiedenen Partitionen derselben Stichprobe trainieren und das beste auswählen können. Wenn Ihnen eine große Menge kategorisierter Daten zur Verfügung steht, ist es möglicherweise besser, die Validierung zu deaktivieren, das Modell mit der gesamten Trainingsstichprobe zu trainieren und anschließend die Klassifizierungsmethoden (Schritt 6) zu verwenden, um das Modell an einer anderen Stichprobe zu testen und die Leistungskennzahlen selbst zu berechnen.
  * Die Parameter der k-fachen Kreuzvalidierung: die Anzahl der Teile, in die die Trainingsmenge aufgeteilt wird ([IValidationParams::FoldsCount](/de/fine-reader/engine/api-reference/classification-related-objects/validationparams#foldscount)), und die Anzahl der Iterationen ([IValidationParams::RepeatCount](/de/fine-reader/engine/api-reference/classification-related-objects/validationparams#repeatcount)). Beachten Sie, dass die erforderliche Anzahl von Objekten in der Trainingsmenge bei jeder Iteration für den [Textklassifikator](/de/fine-reader/engine/api-reference/enumerations/classifiertypeenum#ct_text) mindestens 4 und für den [kombinierten Klassifikator](/de/fine-reader/engine/api-reference/enumerations/classifiertypeenum#ct_combined) mindestens 8 betragen muss. Stellen Sie sicher, dass Ihre Trainingsmenge genügend Objekte enthält.

  Jetzt können Sie ein Modell trainieren. Übergeben Sie das in Schritt 4 konfigurierte TrainingData-Objekt an die Methode [TrainModel](/de/fine-reader/engine/api-reference/classification-related-objects/trainer/trainmodel-method) des Trainer-Objekts. Diese gibt eine [TrainingResults](/de/fine-reader/engine/api-reference/classification-related-objects/trainingresults)-Sammlung zurück, die mit der derzeit verfügbaren Funktionalität nur ein einziges [TrainingResult](/de/fine-reader/engine/api-reference/classification-related-objects/trainingresult) enthält. Wenn Sie eine Kreuzvalidierung durchgeführt haben, überprüfen Sie die Leistungswerte im zugehörigen Unterobjekt [ValidationResult](/de/fine-reader/engine/api-reference/classification-related-objects/validationresult).

  <Note>
    Modelltraining und -klassifizierung werden unter Linux und Windows unabhängig vom Wert von [IMultiProcessingParams::MultiProcessingMode](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams#multiprocessingmode) im sequenziellen Modus durchgeführt.
  </Note>

  Die Eigenschaft [ITrainingResult::Model](/de/fine-reader/engine/api-reference/classification-related-objects/trainingresult#model) ermöglicht den Zugriff auf das trainierte Klassifizierungsmodell. Sie können es mithilfe der Methode [SaveToFile](/de/fine-reader/engine/api-reference/classification-related-objects/model/savetofile-method) in einer Datei speichern oder es direkt zur Klassifizierung von Dokumenten verwenden (weiter zu Schritt 6).

  ### C\#

  ```csharp theme={null}
  // Trainer-Objekt erstellen und Parameter einrichten
  FREngine.ITrainer trainer = classEngine.CreateTrainer();
  trainer.TrainingParams.ClassifierType = (int)FREngine.ClassifierTypeEnum.CT_Image; // der Klassifikator verwendet ausschließlich die Bildmerkmale
  // Die übrigen Einstellungen bleiben auf den Standardwerten; das Modell wird direkt trainiert
  FREngine.ITrainingResults results = trainer.TrainModel ( trainingData );
  // F1-Score des Modells prüfen
  double F1 = results[0].ValidationResult.FMeasure;
  // Klassifikationsmodell abrufen
  FREngine.IModel model = results[0].Model;
  // Modell zur späteren Verwendung speichern
  model.SaveToFile( "C:\\model.dat" );
  ```
</Accordion>

<Accordion title="Schritt 6. Dokumente klassifizieren">
  Um das trainierte Modell für die Klassifizierung zu verwenden:

  1. Wenn das Modell derzeit nicht geladen ist, rufen Sie die Methode [CreateModelFromFile](/de/fine-reader/engine/api-reference/classification-related-objects/classificationengine/createmodelfromfile-method) des Objekts ClassificationEngine auf, um es aus einer Datei auf dem Datenträger zu laden.
  2. Bereiten Sie die Klassifizierungsobjekte aus den Dokumenten vor, die Sie klassifizieren möchten, wie in Schritt 3 beschrieben.
  3. Rufen Sie für jedes Klassifizierungsobjekt die Methode [Classify](/de/fine-reader/engine/api-reference/classification-related-objects/model/classify-method) des Objekts Model auf und übergeben Sie das ClassificationObject als Eingabeparameter. Die Methode gibt eine Sammlung von [ClassificationResult](/de/fine-reader/engine/api-reference/classification-related-objects/classificationresult)-Objekten zurück, die jeweils die Kategorienbezeichnung und die Wahrscheinlichkeit für diese Kategorie enthalten. Die Ergebnisse sind nach Wahrscheinlichkeit vom besten zum schlechtesten sortiert. Rufen Sie das Ergebnis ab und prüfen Sie, ob die Wahrscheinlichkeit für Sie akzeptabel ist.<br />Wenn der Klassifikator keine Kategorie zuweisen konnte, wird anstelle der Ergebnissammlung null zurückgegeben.

  <Note>
    Das Modelltraining und die Klassifizierung werden unter Linux und Windows unabhängig vom Wert von [IMultiProcessingParams::MultiProcessingMode](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams#multiprocessingmode) im sequenziellen Modus durchgeführt.
  </Note>

  ### C\#

  ```csharp theme={null}
  // Open the trained model
  FREngine.IModel model = classEngine.CreateModelFromFile( "C:\\model.dat" );
  // Classify the object
  FREngine.IClassificationResults classResults = model.Classify( clObject );
  // Access the best result and its probability
  string label = classResults[0].CategoryLabel;
  double probability = classResults[0].Probability;
  ```
</Accordion>

<Accordion title="Schritt 7. ABBYY FineReader Engine entladen">
  Nachdem Sie Ihre Arbeit mit ABBYY FineReader Engine abgeschlossen haben, müssen Sie das Objekt [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface) entladen. Verwenden Sie dazu die exportierte Funktion [DeinitializeEngine](/de/fine-reader/engine/api-reference/functions/deinitializeengine-function).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // Unload FineReader Engine
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine was not loaded
              return;
          }
          engine = null;
          // Deleting all objects before FreeLibrary call
          GC.Collect();
          GC.WaitForPendingFinalizers();
          GC.Collect();
          int hresult = deinitializeEngine();
   
          hresult = dllCanUnloadNow();
          if (hresult == 0)
          {
              FreeLibrary(dllHandle);
          }
          dllHandle = IntPtr.Zero;
          initializeEngine = null;
          deinitializeEngine = null;
          dllCanUnloadNow = null;
          // throwing exception after cleaning up
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Kernel32.dll functions
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // FREngine.dll functions
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // private variables
      private FREngine.IEngine engine = null;
      // Handle to FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Erforderliche Ressourcen
</div>

Sie können die Datei [FREngineDistribution.csv](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) verwenden, um automatisch eine Liste der Dateien zu erstellen, die für die Ausführung Ihrer Anwendung erforderlich sind. Wählen Sie für die Verarbeitung in diesem Szenario in Spalte 5 (RequiredByModule) die folgenden Werte aus:

Core

Core.Resources

Opening

Opening, Processing

Processing

Processing.Classification

Processing.Classification.NaturalLanguages

Processing.OCR

Processing.OCR, Processing.ICR

Processing.OCR.NaturalLanguages

Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages

Wenn Sie das Standardszenario ändern, passen Sie die erforderlichen Module entsprechend an. Sie müssen außerdem die Oberflächensprachen, Erkennungssprachen und alle zusätzlichen Funktionen angeben, die Ihre Anwendung verwendet (z. B. Opening.PDF, wenn Sie PDF-Dateien öffnen müssen, oder Processing.OCR.CJK, wenn Sie Texte in [CJK-Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk) erkennen müssen). Weitere Informationen finden Sie unter [Working with the FREngineDistribution.csv File](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization">
  ## Zusätzliche Optimierung
</div>

Weitere Informationen zum Einrichten der verschiedenen Verarbeitungsphasen finden Sie in diesen Artikeln:

* Laden der Engine - nur für Windows
  * [Verschiedene Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)<br />Beschreibt die verschiedenen Möglichkeiten zum Laden des Engine-Objekts im Detail.
  * [Verwenden von ABBYY FineReader Engine in Multithread-Serveranwendungen](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications)<br />Behandelt die Besonderheiten bei der Verwendung von FineReader Engine in Serveranwendungen.
* Erkennung - für Linux und Windows
  * [Parallelverarbeitung mit ABBYY FineReader Engine](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing)<br />Um die erkannten Dokumente oder Seiten schnell für einen Klassifikator mit Textmerkmalen vorzubereiten, verwenden Sie für die Erkennung die Parallelverarbeitung und deaktivieren Sie anschließend Multiprocessing für die Klassifizierung.

<div id="see-also">
  ## Siehe auch
</div>

[Implementierung grundlegender Anwendungsszenarien](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)