Freigeben über

Aktivieren der Dokumentverarbeitung mit Azure Cognitive Services

Verwenden von Azure Cognitive Services

Azure Cognitive Services umfasst eine Reihe von cloudbasierten APIs, die Sie in KI-Anwendungen und Datenflüssen verwenden können. Es bietet vortrainierte Modelle, die in Ihren Anwendungen verwendet werden können und keine Daten und kein Modelltraining ihrerseits erfordern. Sie können einfach über HTTP-REST-Schnittstellen in Anwendungen integriert werden.

Sie haben bereits gelernt, wie Sie Webhooks mit der Anwendung verwenden, um eine Benachrichtigung zu erhalten, wenn eine vorhandene Datei aktualisiert oder eine neue Datei hochgeladen wird, im Tutorial Verwenden von Webhooks. In diesem Tutorial wird beschrieben, wie Sie eine Verbindung mit Azure Cognitive Services herstellen, um Daten aus Rechnungen zu extrahieren.

Um die automatische KI-Verarbeitung mit Ihrer aktuellen SharePoint-Anwendung bei einer Änderung in Ihrem Container einzurichten, müssen Sie using Webhooks (Verwenden von Webhooks ) und dann folgendes ausführen:

  1. Ruft die Deltaänderungen des Containers ab. Sie können derzeit die Benachrichtigung erhalten, wenn es eine Änderung in unserem Container gibt, und sie erhalten nun die Dateien, die hinzugefügt oder aktualisiert werden.
  2. Rufen Sie die Document Intelligence-Dienst-API von Azure Cognitive Services auf. Sie müssen eine Azure KI-Ressource erstellen, um mithilfe der API die Felder aus einem Bild zu extrahieren und die extrahierten Dateien abzurufen. Sie können sie wie in diesem Tutorial gezeigt speichern oder wie sie möchten. Dokumentverarbeitungsschema

Tipp

Weitere Informationen zu den in diesem Tutorial verwendeten Microsoft Graph-APIs finden Sie unter Nachverfolgen von Änderungen für ein Laufwerk, Abrufen einer DriveItem-Ressource und Hochladen oder Ersetzen des Inhalts eines DriveItem-Objekts.

Abrufen der Deltaänderungen eines Containers

Öffnen Sie GraphProvider.ts , und implementieren Sie die -Methode getDriveChanges , um die Liste der geänderten Elemente abzurufen:

public static async getDriveChanges(driveId: string): Promise<any[]> {
  let changedItems: any[] = [];
  const driveDeltaBasePath: string = `/drives/${driveId}/items/root/delta`;
  let driveDeltaTokenParams: string = "";
  let hasMoreChanges: boolean = true;
  try{
    do {
      if (this.changeTokens.has(driveId)) {
        driveDeltaTokenParams = `?token=${this.changeTokens.get(driveId)}`
      }
      const response = await this.graphClient.api(driveDeltaBasePath + driveDeltaTokenParams).get();
      changedItems.push(...response.value);
      if (response['@odata.nextLink']) {
        const token = new URL(response['@odata.nextLink']).searchParams.get('token');
        this.changeTokens.set(driveId, token);
      } else {
        hasMoreChanges = false;
        const token = new URL(response['@odata.deltaLink']).searchParams.get('token');
        this.changeTokens.set(driveId, token);
      }
      console.log(this.changeTokens.get(driveId));
    } while (hasMoreChanges);
  }
  catch(err){
    console.log(err);
  }
  return changedItems;
}

Implementieren Sie die -Methode getDriveItem , um eine Datei aus einem Container abzurufen:

public static async getDriveItem(driveId: string, itemId: string): Promise<any> {
  return await this.graphClient.api(`/drives/${driveId}/items/${itemId}`).get();
}

Erstellen Sie eine neue Datei ReceiptProcessor.ts , und implementieren Sie eine -Methode processDrive:

export abstract class ReceiptProcessor {

  public static async processDrive(driveId: string): Promise<void> {
    const changedItems = await GraphProvider.getDriveChanges(driveId);
    for (const changedItem of changedItems) {
      try {
        const item = await GraphProvider.getDriveItem(driveId, changedItem.id);
        const extension = this.getFileExtension(item.name);
        if (this.SUPPORTED_FILE_EXTENSIONS.includes(extension.toLowerCase())) {
          console.log(item.name);
          const url = item["@microsoft.graph.downloadUrl"];
          const receipt = await this.analyzeReceiptStream(await this.getDriveItemStream(url));
          const receiptString = JSON.stringify(receipt, null, 2)
          const fileName = this.getFileDisplayName(item.name) + "-extracted-fields.json";
          const parentId = item.parentReference.id;
          await GraphProvider.addDriveItem(driveId, parentId, fileName, receiptString);
        }
      } catch (error) {
        console.log(error);
      }
    }
  }
}

Wenn Sie die App jetzt zusammen mit Tunneling und Abonnement neu starten, sollten die zuletzt hinzugefügten/aktualisierten Dateien in der Konsole aufgeführt werden.

Aufrufen der Document Intelligence-Dienst-API von Azure Cognitive Services

Um die Document Intelligence-APIs von Azure Cognitive Services verwenden zu können, müssen Sie eine Multi-Service- oder Document Intelligence-Ressource für Azure AI Service erstellen. Informationen zum Erstellen der Ressource finden Sie in den folgenden Tutorials:

Nach diesem Schritt sollten Sie über einen Endpunkt und einen Schlüssel verfügen, der zur Verwendung bereit ist.

Öffnen Sie nun ReceiptProcessor.ts , um eine Methode dac zum Speichern der Azure Cognitive Services-Anmeldeinformationen zu erstellen:

private static dac = new DocumentAnalysisClient(
  `${process.env["DAC_RESOURCE_ENDPOINT"]}`,
  new AzureKeyCredential(`${process.env["DAC_RESOURCE_KEY"]}`)
);

Erstellen Sie die Methode getDriveItemStream.

private static async getDriveItemStream(url: string): Promise<Readable> {
  const token = GraphProvider.graphAccessToken;
  const config: AxiosRequestConfig = {
    method: "get",
    url: url,
    headers: {
      "Authorization": `Bearer ${token}`
    },
    responseType: 'stream'
  };
  const response = await axios.get<Readable>(url, config);
  return response.data;
}

Erstellen Sie eine Methode analyzeReceiptStream , um die OCR-Felder über die Azure Cognitive Services-Verarbeitung abzurufen. Hier nehmen wir das prebuilt-invoice Modell, aber es können andere Modelle ausgewählt werden:

private static async analyzeReceiptStream(stream: Readable): Promise<any> {
  const poller = await this.dac.beginAnalyzeDocument("prebuilt-invoice", stream, {
    onProgress: ({ status }) => {
      console.log(`status: ${status}`);
    },
  });

  const {
    documents: [result] = [],
  } = await poller.pollUntilDone();

  const fields = result?.fields;
  this.removeUnwantedFields(fields);
  return fields;
}

Erstellen Sie eine Methode removeUnwantedFields , um die unerwünschten Felder in der Antwort von Azure Cognitive Services zu entfernen:

private static removeUnwantedFields(fields: any) {
  for (const prop in fields) {
    if (prop === 'boundingRegions' || prop === 'content' || prop === 'spans') {
      delete fields[prop];
    }
    if (typeof fields[prop] === 'object') {
      this.removeUnwantedFields(fields[prop]);
    }
  }
}

Öffnen Sie schließlich GraphProvider.ts , um die addDriveItem -Methode am Ende der GraphProvider Klasse hinzuzufügen.

public static async addDriveItem(driveId: string, parentId: any, fileName: string, receiptString: string) {
  await this.graphClient.api(`/drives/${driveId}/items/${parentId}:/${fileName}:/content`).put(receiptString);
}

Starten Sie nun die Demo-App neu, und richten Sie das Tunneling mit ngrok und delta change subscription für den Container erneut ein.

Wenn Sie eine Beliebige Datei (unterstützte Formate: JPEG, JPG, PNG, BMP, TIFF, PDF) in diesem Container hinzufügen/aktualisieren, sollte eine neue JSON-Datei erstellt werden, die die aus der Datei extrahierten Felder enthält.

  • Last updated on