Betriebsüberwachung bringt mehr Daten als ein Kunde jemals sehen sollte. Ein einzelner Ausfall kann zu fehlgeschlagenen Checks, Latenzperzentilen, Fehlerratenwarnungen, Abhängigkeitsereignissen, Protokollen, Ablaufverfolgungen und Dutzenden von Benachrichtigungen von separaten Systemen führen. Die direkte Veröffentlichung dieses Streams würde zu Lärm und nicht zu Transparenz führen.

Kunden benötigen ein kleineres und stabileres Datenprodukt. Sie möchten wissen, welche Funktion betroffen ist, wie der Vorfall ihre Arbeit verändert, was der Anbieter tut und wann das nächste Replace verfügbar ist. Der Aufbau dieser Sichtweise erfordert eine Übersetzungsebene zwischen Maschinentelemetrie und öffentlicher Kommunikation.

Die Herausforderung besteht nicht darin, eine weitere Kennzahl zu erfassen. Es geht darum, zu entscheiden, welche Beobachtungen zuverlässig genug sind, um zu einer öffentlichen Behauptung zu werden, und den Kontext zu wahren, der die Behauptung nützlich macht.

Überwachungsbeobachtungen sind keine Vorkommnisse

Ein Überwachungsereignis beschreibt, was ein System zu einem bestimmten Zeitpunkt beobachtet hat. Eine HTTP-Prüfung hat einen Fehler zurückgegeben. Eine Anfrage hat den Latenzschwellenwert überschritten. Eine Warteschlange hat ihre Tiefenbegrenzung überschritten. Keine dieser Beobachtungen allein beweist, dass es bei Kunden zu einem Vorfall kommt.

Betrachten Sie eine fehlgeschlagene Prüfung an einem Standort. Der Endpunkt ist möglicherweise ausgefallen, aber das Probe selbst könnte ein Routing-Drawback haben. Ein globaler Durchschnitt kann gesund bleiben, während eine Kundenregion unbrauchbar ist. Ein interner Integritätsendpunkt kann 200 zurückgeben, obwohl eine nachgelagerte Abhängigkeit Benutzer daran hindert, einen Kauf abzuschließen.

Bevor die Telemetrie zum öffentlichen Standing wird, bedarf sie einer Bestätigung und eines Kontexts. Ein nützliches Ereignissignal vereint mehrere Dimensionen:

• Umfang: ein Endpunkt, eine Area, ein Kontosegment oder der gesamte Dienst
• Dauer: ein vorübergehender Fehler oder ein anhaltender Zustand
• Benutzereffekt: langsamere Antworten, fehlgeschlagene Anfragen, verzögerte Verarbeitung oder völlige Nichtverfügbarkeit
• Vertrauen: eine Beobachtung oder Übereinstimmung über unabhängige Signale hinweg
• Eigentum: das Workforce oder die Abteilung, die für die Untersuchung verantwortlich ist

Diese angereicherte Aufzeichnung kommt einer Vorfalltatsache näher. Es kann die Kommunikation unterstützen, ohne rohe interne Particulars preiszugeben oder zu überbewerten, was die Daten beweisen.

Erstellen Sie ein stabiles Vorfallmodell

Überwachungstools verwenden ihr eigenes Vokabular. Einer berichtet möglicherweise von „kritisch“, ein anderer von „Entlassung“ und ein dritter von „fehlgeschlagen“. Öffentliche Kommunikation braucht ein konsistentes Modell, das Veränderungen der dahinter stehenden Instrumente übersteht.

Eine kompakte Vorfallaufzeichnung kann Folgendes umfassen:

• Vorfall-ID
• betroffene kundenseitige Komponenten
• Begin- und Endzeitstempel
• aktuelle Part
• Wirkungszusammenfassung
• geografischer oder Kontobereich
• Vertrauensniveau
• nächstes geplantes Replace
• Quellsignale und deren Zeitstempel

Die Quellsignale stehen den Antwortenden weiterhin zur Verfügung, aber die öffentliche Ebene liest die normalisierten Felder. Diese Trennung verhindert, dass sich der Wortlaut auf einer Statusseite ändert, nur weil das Überwachungsteam einen Alarmierungsanbieter ersetzt.

Es unterstützt auch klare Zustandsübergänge. Die meisten Vorfälle mit Kundenkontakt durchlaufen einen kleinen Ablauf: Untersuchung, Identifizierung, Überwachung und Lösung. Die interne Antwort kann Dutzende von Teilaufgaben enthalten, aber Kunden benötigen keinen Ticket-für-Ticket-Feed. Sie müssen wissen, wie sicher das Workforce von der Ursache ist und ob sich der Dienst erholt.

Versionieren Sie das Vorfallschema wie jeden anderen gemeinsam genutzten Datenvertrag. Eine neue Überwachungsquelle sollte sich auf bestehende Felder abbilden oder eine überprüfte Erweiterung einführen und nicht ihr privates Vokabular an Kunden weitergeben.

Ordnen Sie technische Signale den Fähigkeiten des Kunden zu

Infrastrukturtopologie und Kundenerlebnis sind unterschiedliche Modelle desselben Techniques. Ein Datenbankreplikat, ein Nachrichtenkonsument oder ein Edge-Knoten können die technische Fehlerquelle sein. Der öffentliche Vorfall sollte die Fähigkeit beschreiben, die Kunden erkennen.

Diese Zuordnung sollte vor einem Ausfall entworfen werden. Groups können einen Servicekatalog verwalten, der interne Ressourcen mit öffentlichen Komponenten wie Anmeldung, API, Dashboard, Abrechnung, Suche und Webhooks verbindet. Wenn ein Sign ausgelöst wird, kann das Vorfallsystem die mögliche Kundenoberfläche identifizieren, ohne dass der Antwortende diese Beziehung aus dem Gedächtnis neu aufbauen muss.

Die Zuordnung ist viele-zu-viele. Ein ausgefallener Identitätsanbieter kann sich auf die Anmeldung, die Kontoerstellung und administrative Aktionen auswirken. Eine verzögerte Warteschlange kann sich auf Webhooks und Berichte auswirken, während synchrone API-Aufrufe fehlerfrei bleiben. Eine öffentliche Komponente kann von mehreren internen Diensten abhängen und ein interner Dienst kann mehrere Komponenten unterstützen.

Die explizite Beibehaltung dieser Beziehung verbessert sowohl die Kommunikation als auch die Analyse. Damit kann das Workforce eine Frage beantworten, die rohe Überwachungsdaten nicht beantworten können: „Was können Kunden noch tun?“

Nutzen Sie vor der Veröffentlichung Vertrauens-Gates

Automatisierung beschleunigt die Kommunikation von Vorfällen, allerdings nur, wenn sie Sicherheitsmaßnahmen beinhaltet. Durch die Veröffentlichung jeder Warnung wird eine flüchtige Statusseite erstellt. Der manuelle Aufwand für jedes Replace führt zu vermeidbaren Verzögerungen. Vertrauenstore bieten einen praktischen Kompromiss.

Eine Richtlinie kann unabhängigen Beweisen Gewicht verleihen:

• Ausfälle aus mehreren Sondenregionen
• ein entsprechender Anstieg der Anwendungsfehler
• ein Abhängigkeitsvorfall von einem externen Anbieter
• eine starke Veränderung gegenüber der etablierten Grundlinie
• Kundenberichte, die zum gemessenen Symptom passen

Wenn die kombinierten Beweise einen Schwellenwert überschreiten, kann das System einen Entwurf eines Vorfalls erstellen, betroffene Komponenten auswählen und den Kommunikationseigentümer benachrichtigen. Bei Veranstaltungen mit hoher Zuverlässigkeit kann automatisch eine vorab genehmigte erste Nachricht veröffentlicht werden. Ereignisse mit geringerem Vertrauen bleiben intern, bis ein Antwortender die Auswirkung bestätigt.

Der Schwellenwert sollte die Kosten jedes Fehlers widerspiegeln. Ein falscher öffentlicher Vorfall schafft Verwirrung und untergräbt das Vertrauen. Eine verspätete Ankündigung führt dazu, dass Kunden keine offizielle Antwort erhalten. Die richtige Stability unterscheidet sich zwischen einer Verbraucheranwendung, einer Zahlungs-API und einem internen Analysedienst, aber der Kompromiss sollte bewusst und messbar sein.

Behalten Sie eine menschliche redaktionelle Ebene bei

Daten können Umfang und Zeitpunkt bestimmen. Es kann nicht immer die Konsequenz in einer Sprache erklären, die ein Kunde versteht.

„Verbraucherverzögerung hat 120.000 Nachrichten überschritten“ magazine betrieblich präzise sein, aber ein Kunde muss hören, dass die Webhook-Zustellung um bis zu 15 Minuten verzögert ist. „Erhöhte p95-Latenz“ wird zu „Dashboard-Suchen dauern länger als regular“. Die kundenorientierte Aussage sollte den Wahrheitsgehalt des Alerts wahren und gleichzeitig Implementierungsdetails durch beobachtete Wirkung ersetzen.

Vorlagen helfen, wenn sie echte Felder statt allgemeiner Bestätigung enthalten. Eine nützliche Vorlage für das erste Replace ist:

Wir untersuchen (beobachtete Auswirkungen), die sich auf (Komponente und Umfang) auswirken. (Unbeeinträchtigte Funktion) bleibt verfügbar. Wir haben das Drawback zum ersten Mal um (Zeitpunkt) beobachtet. Wir werden bis (Uhrzeit) ein weiteres Replace bereitstellen.

Die Vorlage zwingt den Autor, Beweise, Umfang und Zeitpunkt anzugeben. Es vermeidet Vermutungen über die Grundursache und die Wiederherstellung. Ein Mensch überprüft die Nachricht noch auf Klarheit und stellt sicher, dass sie keine sensiblen Infrastrukturdetails preisgibt.

Groups vergleichen Kommunikationstools für öffentliche Vorfälle sollten diesen Workflow genau prüfen. Das Seitendesign ist wichtig, aber die wichtigere Frage ist, ob das System den Überwachungsstatus akzeptieren, die menschliche Überprüfung gewährleisten und einen kohärenten Vorfallzeitplan aufrechterhalten kann.

Machen Sie die Aktualisierungsfrequenz zu einem Teil der Daten

„Wir werden Sie bald auf dem Laufenden halten“ ist keine betriebliche Verpflichtung. Speichern Sie den Zeitstempel für die nächste Aktualisierung als Teil des Vorfalldatensatzes und benachrichtigen Sie den Kommunikationseigentümer, bevor er abläuft.

Dadurch wird die Kommunikationsfrequenz zu etwas, das das Workforce messen kann. Zu den nützlichen Indikatoren gehören:

• Zeit von der bestätigten Auswirkung bis zum ersten öffentlichen Replace
• Prozentsatz der versprochenen Updates, die pünktlich veröffentlicht werden
• Anzahl der Korrekturen aufgrund vorzeitiger Inanspruchnahmen
• Zeit zwischen technischer Wiederherstellung und öffentlicher Lösung
• Supportvolumen vor und nach dem ersten Replace

Diese Messungen zeigen, ob die Kommunikation mit der Reaktion Schritt hält. Ein Workforce verfügt möglicherweise über eine hervorragende Erkennung und eine geringe Offenlegungslatenz. Ein anderer veröffentlicht vielleicht schnell, nimmt aber häufig Korrekturen vor, weil sein Vertrauensfenster zu freizügig ist.

Die Daten unterstützen auch unterschiedliche Kadenzen je nach Schweregrad. Bei einem kompletten Ausfall können Updates alle 20 oder 30 Minuten erforderlich sein. Eine geringfügige Verschlechterung kann ein längeres Intervall erfordern. Die Richtlinie sollte die Erwartungen festlegen, bevor der Einsatzleiter unter Druck gerät.

Überprüfen Sie die Wiederherstellung auf Kundenseite

Eine Rückkehr zur Normalität der internen Kennzahl ist ein Beweis für eine Erholung, sollte aber nicht der einzige Beweis sein. Die gleichen Exterior-In-Prüfungen, die zur Bestätigung der Auswirkungen verwendet werden, sollten sicherstellen, dass der Kundenpfad wieder funktioniert.

Für die Lösung können mehrere Bedingungen erforderlich sein:

1. Die Schadensbegrenzung bzw. Reparatur ist abgeschlossen.
2. Von den betroffenen Standorten werden externe Kontrollen durchgeführt.
3. Fehler- und Latenzindikatoren bleiben für einen Beobachtungszeitraum regular.
4. Rückstände, beispielsweise verspätete Nachrichten, wurden verarbeitet.
5. Keine neuen Kundenberichte stimmen mit dem Vorfallsymptom überein.

Der öffentliche Staat kann zur Überwachung übergehen, während diese Bedingungen bewertet werden. Erst dann sollte der Vorfall als gelöst markiert werden. Dadurch wird verhindert, dass die Seite zwischen „Gelöst“ und „Untersuchung“ hin und her schwankt, wenn eine schnelle Lösung fehlschlägt.

Bewahren Sie das Ereignis als analytischen Datensatz auf

Nach der Lösung sollten die öffentliche Zeitleiste und die interne Telemetrie durch die Vorfallkennung verknüpft bleiben. Dadurch entsteht eine dauerhafte Aufzeichnung für die Analyse nach dem Vorfall.

Das Workforce kann rekonstruieren, wann das erste Sign eintraf, wann die Auswirkungen bestätigt wurden, wann die Kunden darüber informiert wurden und wann die Wiederherstellung verifiziert wurde. Lücken werden sichtbar. Wenn die Überwachung den Fehler um 10:02 Uhr erkannte, das öffentliche Replace jedoch um 10:27 Uhr erschien, kann die Überprüfung feststellen, ob die Bestätigung zu lange gedauert hat, der Besitz unklar warfare oder der Veröffentlichungsworkflow fehlgeschlagen ist.

Mit der Zeit verbessern diese Datensätze die Übersetzungsebene. Wiederholte Fehlalarme können aus der automatischen Veröffentlichung entfernt werden. Häufige Vorfälle können bessere Vorlagen erhalten. Komponentenzuordnungen können korrigiert werden, wenn der öffentliche Bereich nicht mit den tatsächlichen Kundenauswirkungen übereinstimmt.

Kommunikation ist ein abgeleitetes operatives Produkt

Kundenorientierte Vorfallkommunikation sollte keine Kopie des Überwachungsstreams oder ein separater manueller Prozess ohne Verbindung dazu sein. Es handelt sich um ein abgeleitetes Datenprodukt: Ausgewählte Beobachtungen werden bestätigt, normalisiert, den Kundenfunktionen zugeordnet, überprüft und nach einem vorhersehbaren Zeitplan veröffentlicht.

Wenn diese Pipeline bewusst gestaltet wird, bleibt die Statusseite an der Realität ausgerichtet, ohne dass Kunden internen Störungen ausgesetzt werden. Die Antwortenden verbringen weniger Zeit damit, den Standing zwischen den Systemen zu kopieren, und die Kunden erhalten weniger Fakten, die sie tatsächlich nutzen können.

Von Abhas Ricky, Chief Technique Officer bei Cloudera

Künstliche Intelligenz treibt die nächste Welle der Unternehmenstransformation voran, doch viele Unternehmen bleiben stecken. Bedenken hinsichtlich der Sicherheit sensibler Daten und geistigen Eigentums halten Unternehmen von der Einführung von KI ab. Laut einer aktuellen Accenture-Studie 77 % der Organisationen Es fehlen die grundlegenden Daten- und KI-Sicherheitspraktiken, die zum Schutz kritischer Modelle, Datenpipelines und Cloud-Infrastruktur erforderlich sind.

Die Lösung liegt darin, die Herangehensweise von Unternehmen an KI zu überdenken. Anstatt wise Daten auf externe Plattformen zu verschieben, sollten Unternehmen Personal AI einführen: ein Modell, bei dem Workloads innerhalb sicherer Grenzen laufen, bei dem Modelle auf die Daten verlagert werden und bei dem Unternehmen die vollständige Kontrolle behalten. Personal KI ermöglicht den Zugriff auf jede Artwork von Daten, jederzeit und in jeder Umgebung – ohne Kompromisse bei Vertrauen oder Agilität.

Personal KI: Workloads ausführen, ohne Daten nach außen zu teilen

Herkömmliche KI-Ansätze erfordern häufig das Senden sensibler Informationen an externe Dienste zur Schulung und Schlussfolgerung. Dies schafft Risiken, erhöht die Latenz und erschwert Governance und Compliance. Personal KI verändert das Modell. Workloads werden überall dort ausgeführt, wo sich die Daten bereits befinden – vor Ort, in privaten oder öffentlichen Clouds oder am Edge –, ohne dass Daten außerhalb sicherer Grenzen verschoben werden müssen.

Dieser Ansatz schützt die Privatsphäre und verbessert gleichzeitig die Leistung. Es stellt sicher, dass die Daten unter Unternehmenskontrolle bleiben und komplexe Übertragungsprozesse vermieden werden. Dadurch wird Sicherheit zu einem Ermöglicher von Innovation und nicht zu einer Einschränkung.

KI bleibt balkanisiert – Warum Partnerökosysteme wichtig sind

Trotz Fortschritten wie der privaten KI bleibt jedoch eine sekundäre Herausforderung im Zusammenhang mit der Fragmentierung von Unternehmen bestehen.

Um Datensätze zu speichern, sind alle Unternehmen immer noch auf unterschiedliche Instruments angewiesen, die nicht aufeinander abgestimmt sind, wodurch Daten gefangen bleiben und die Groups nicht miteinander verbunden sind. Diese Balkanisierung entsteht, weil kein einzelner Anbieter das gesamte Spektrum der KI-Anforderungen abdecken kann. Jeder baut sein eigenes System auf, was zu einem Flickenteppich führt, der die Akzeptanz verlangsamt und das Vertrauen untergräbt.

Um diese Silos aufzubrechen, sind nicht nur einheitliche Plattformen, sondern auch starke Partnerökosysteme erforderlich. Auf dem überfüllten Technologiemarkt von heute führt kein Unternehmen isoliert Innovationen durch. Unternehmen profitieren, wenn Cloud-Anbieter, Infrastrukturunternehmen, Softwareanbieter und Integratoren zusammenarbeiten, um offene, interoperable Lösungen zu schaffen. Partnerökosysteme erweitern die Auswahl, sorgen für Flexibilität und stellen Referenzarchitekturen bereit, die Unternehmen bei der schnellen und zuverlässigen Bereitstellung unterstützen.

Ein gesundes Partnernetzwerk stellt außerdem sicher, dass KI-Workloads nahtlos in verschiedenen Umgebungen ausgeführt werden. Es fördert die Integration zwischen Datenmanagement-, Analyse- und maschinellen Lernsystemen. Anstatt Unternehmen in den geschlossenen Kreislauf eines einzigen Anbieters zu zwingen, fördern Ökosysteme Offenheit, sodass Unternehmen die Instruments auswählen können, die ihren Anforderungen am besten entsprechen, und gleichzeitig eine konsistente Governance und Sicherheit gewährleisten.

Aufbau sicherer, offener Systeme für den universellen Zugriff

Daher waren Open-Supply-Systeme noch nie so wichtig für die Behebung von Inoperabilität in verschiedenen Umgebungen. Durch den Aufbau auf offenen Requirements und Frameworks können Unternehmen strukturierte, unstrukturierte und Streaming-Daten in einer einzigen zugänglichen Struktur verbinden, ohne an proprietäre Systeme gebunden zu sein.

Offene Technologien beseitigen zwei der größten Hindernisse für den KI-Erfolg – ​​Fragmentierung und Lock-in –, indem sie Unternehmen Transparenz, Flexibilität und die Möglichkeit geben, sich mit der schnellen Forschungsgeschwindigkeit weiterzuentwickeln. Sie ermöglichen auch die Zusammenarbeit mit einer globalen Gemeinschaft, die ständig Verbesserungen vorantreibt und Innovationen stärkt, ohne die Kontrolle zu verlieren.

Open Supply ist auch eine Schlüsselkomponente der privaten KI. Sie ermöglicht es, Modelle in die Daten einzubringen, anstatt wise Daten an externe Dienste zu verschieben, und ermöglicht Unternehmen die konsistente Bereitstellung von Modellen in privaten Cloud-, öffentlichen Cloud- oder Edge-Umgebungen.

Wenn Unternehmen personal KI einführen, profitieren sie von mehreren dauerhaften Vorteilen, darunter:

• Sicherheit geht vor. Durch die Ausführung von Workloads dort, wo die Daten gespeichert sind, werden unnötige Übertragungen vermieden und das Risiko verringert.
• Freiheit zur Innovation. Open-Supply-Frameworks ermöglichen es Unternehmen, sich schnell anzupassen und die Abhängigkeit von einem einzelnen Anbieter zu vermeiden.
• Operative Agilität. Einheitliche Plattformen ermöglichen es Unternehmen, jederzeit und in jeder Umgebung auf alle Daten zuzugreifen.
• Governance durch Design. Die integrierte Aufsicht gewährleistet die Verantwortlichkeit und ermöglicht gleichzeitig eine umfassende Nutzung.

Wertschöpfung durch vertrauenswürdige, überall verfügbare KI

Da die IT-Umgebungen von Unternehmen immer komplexer und verteilter werden, ist die Dringlichkeit der Einführung von KI unbestreitbar, aber auch Bedenken hinsichtlich der Datensicherheit. Unternehmen benötigen eine zuverlässige, skalierbare Infrastruktur, die Kernabläufe unterstützt, die KI-Einführung rationalisiert und die Produktivität steigert, ohne das Vertrauen zu gefährden.

Unternehmen benötigen KI-Strategien, die es ihnen ermöglichen, Intelligenz in ihre Daten zu integrieren, wo auch immer sie sich befinden, in öffentlichen Clouds, in lokalen Umgebungen und am Netzwerkrand. Der Erfolg hängt von der Vereinheitlichung dieser Umgebungen ab, die auf Open-Supply-Grundlagen basieren, die einen Lock-in verhindern und die Flexibilität fördern. Indem Unternehmen die Kontrolle über alle Arten von Daten erlangen und starke Sicherheit und Governance einbetten, können Unternehmen mit Zuversicht Echtzeit- und Vorhersageeinblicke gewinnen. Die Unternehmen, die diesen Ansatz verfolgen, werden nicht nur die Entscheidungsfindung verändern, sondern auch die Widerstandsfähigkeit stärken, Ergebnisse verbessern und dauerhafte Wettbewerbsvorteile erzielen.

Um Dokumente zu handeln, geht es nicht mehr nur darum, Dateien in Ihren KI -Projekten zu öffnen, sondern darum, das Chaos in Klarheit zu verwandeln. Dokumente wie PDFs, Powerpoints und Wort überfluten unsere Workflows in jeder Kind und Größe. Das Abrufen strukturierter Inhalte aus diesen Dokumenten ist heute zu einer großen Aufgabe geworden. Markitdown MCP (Markdown Conversion Protocol) von Microsoft vereinfacht dies. Es wandelt verschiedene Dateien in ein strukturiertes Markdown -Format um. Dies hilft Entwicklern und technischen Autoren, Dokumentationsworkflows zu verbessern. Dieser Artikel erklärt Markitdown MCP und zeigt seine Verwendung. Wir werden den Markitdown MCP -Server einrichten und Markitdown im Kontext dieses Protokolls diskutieren. Die Verwendung des Markitdown -MCP -Servers zum Testen wird auch unten behandelt.

Was ist Markitdown MCP?

Markitdown MCP bietet eine Standardmethode für die Konvertierung von Dokumenten. Es fungiert als serverseitiges Protokoll. Es verwendet Microsoft Markitdown -Bibliothek im Backend. Der Server hostet eine erholsame API. Benutzer senden Dokumente wie PDFs oder Phrase -Dateien an diesen Server. Der Server verarbeitet dann diese Dateien. Es verwendet erweiterte Parsen und spezifische Formatierungsregeln. Der Ausgang ist Markdown -Textual content, der die Unique -Dokumentstruktur aufbewahrt.

Schlüsselmerkmale von Markitdown MCP

Der Markitdown MCP Server enthält mehrere nützliche Funktionen:

• Unterstützung für breite Format: Sie konvertiert gemeinsame Dateien wie PDF, DOCX und PPTX in Markdown.
• Strukturschutz: Sie verwendet Methoden, um Dokumentlayouts wie Überschriften und Pay attention zu verstehen und zu verwalten.
• Konfigurierbare Ausgabe: Benutzer können Einstellungen anpassen, um den endgültigen Markdown -Stil zu steuern.
• Serverbetrieb: Es wird als Serverprozess ausgeführt. Dies ermöglicht die Integration in automatisierte Systeme und Cloud -Setups.

Die Rolle des Abschlusses bei Arbeitsabläufen

Markdown ist ein beliebtes Format für die Dokumentation. Seine einfache Syntax erleichtert das Lesen und Schreiben. Viele Plattformen wie Github unterstützen es intestine. Statische Website -Generatoren verwenden es häufig. Das Konvertieren anderer Formate in die manuelle Markierung braucht Zeit. Markitdown MCP automatisiert diese Konvertierung. Dies bietet klare Vorteile:

• Effiziente Inhaltsverhandlung: Quelldokumente in nutzbare Markdowns verwandeln.
• Konsequente Zusammenarbeit: Standardformat hilft Groups, an Dokumenten zusammenzuarbeiten.
• Prozessautomatisierung: Fügen Sie die Konvertierung von Dokumenten in größere automatisierte Workflows ein.

Einrichten des Markitdown MCP Servers zur Integration

Wir können den Markitdown -MCP -Server mit verschiedenen Purchasers wie Claude, Windsurf und Cursor mit Docker -Bild einrichten, wie in der erwähnt Github Repo. Aber hier erstellen wir einen lokalen MCP -Shopper mithilfe Langchains MCP -Adapter. Wir brauchen einen Auslauf des Servers, um ihn mit Langchain zu verwenden. Der Server unterstützt verschiedene laufende Modi.

Set up

Installieren Sie zunächst die erforderlichen Python -Pakete.

pip set up markitdown-mcp langchain langchain_mcp_adapters langgraph langchain_groq

Serverkonfiguration

Führen Sie den Markitdown -MCP -Server mit dem STDIO -Modus aus. Dieser Modus verbindet die Standardeingangs- und Ausgangsströme. Es funktioniert intestine für skriptbasierte Integration. Führen Sie direkt im Terminal Folgendes aus.

markitdown-mcp

Der Server wird mit einigen Warnungen ausgeführt.

Wir können auch den SSE-Modus (Server-Despatched Occasions) verwenden. Dieser Modus passt zu Webanwendungen oder langjährigen Verbindungen. Es ist auch nützlich, wenn Sie einen Markitdown -MCP -Server einrichten, um bestimmte Szenarien zu testen.

markitdown-mcp --sse --host 127.0.0.1 --port 3001

Wählen Sie den Modus aus, der zu Ihrem Integrationsplan passt. Die Verwendung des Servers zum lokalen Testen über STDIO ist häufig ein guter Begin. Wir empfehlen den StDIO -Modus für diesen Artikel.

Markdown -Konvertierung mit Markitdown MCP

Wir haben bereits behandelt, wie Sie in unserem vorherigen Weblog einen MCP -Server und einen Shopper -Setup mit Langchain erstellen können MCP -Clientserver mit Langchain.

In diesem Abschnitt wird nun angezeigt, wie Langchain mit dem Markitdown MCP -Server verwendet wird. Es automatisiert die Konvertierung einer PDF -Datei in Markdown. Das Beispiel verwendet das Lama -Modell von CRQ über Chatgroq. Stellen Sie sicher, dass Sie die COQ -API -Style als Umgebungsvariable einrichten oder direkt an Chatgroq weitergeben.

Schritt 1: Importieren Sie zuerst die erforderlichen Bibliotheken.

from mcp import ClientSession, StdioServerParameters
from mcp.shopper.stdio import stdio_client
from langchain_mcp_adapters.instruments import load_mcp_tools
from langgraph.prebuilt import create_react_agent
import asyncio
from langchain_groq import ChatGroq

Schritt 2: Initialisieren Sie das COQ LLM, es ist kostenlos. Hier finden Sie den API -Schlüssel

Hier ist der COQ -API -Schlüssel: GROQ API -Schlüssel

# Initialize Groq mannequin
mannequin = ChatGroq(mannequin="meta-llama/llama-4-scout-17b-16e-instruct", api_key="YOUR_API_KEY")

Schritt 3: Konfigurieren Sie den MCP -Server

Wir verwenden StDioServerparameter und hier direkt das installierte Markitdown -MCP -Paket hier

server_params = StdioServerParameters(
   command="markitdown-mcp",
   args=()  # No extra arguments wanted for STDIO mode
)

Schritt 4: Definieren Sie nun die asynchrone Funktion

Dadurch wird der PDF -Pfad als Eingabe erfolgt, und die ClientSession beginnt mit der Kommunikation. load_mcp_tools bietet Funktionen für die Langchain -Interaktion mit Markitdown MCP. Dann wird ein React -Agent erstellt, es verwendet das Modell und die MCP -Instruments. Der Code erstellt eine Datei_uri für die PDF und sendet eine Eingabeaufforderung, in der der Agent aufgefordert wird, die Datei mit MCP zu konvertieren.

async def run_conversion(pdf_path: str):
   async with stdio_client(server_params) as (learn, write):
       async with ClientSession(learn, write) as session:

           await session.initialize()
           print("MCP Session Initialized.")

           # Load out there instruments
           instruments = await load_mcp_tools(session)
           print(f"Loaded Instruments: {(device.title for device in instruments)}")

           # Create ReAct agent
           agent = create_react_agent(mannequin, instruments)
           print("ReAct Agent Created.")

           # Put together file URI (convert native path to file:// URI)
           file_uri = f"file://{pdf_path}"
           # Invoke agent with conversion request
           response = await agent.ainvoke({

               "messages": (("person", f"Convert {file_uri} to markdown utilizing Markitdown MCP simply return the output from MCP server"))

           })

           # Return the final message content material
           return response("messages")(-1).content material

Schritt 5: Dieser Code ruft die Funktion run_conversion auf

Wir rufen und extrahieren Markdown aus der Antwort. Es speichert den Inhalt PDF.MD und druckt schließlich die Ausgabe im Terminal.

if __name__ == "__main__":

   pdf_path = "/dwelling/harsh/Downloads/LLM Analysis.pptx.pdf"  # Use absolute path
   end result = asyncio.run(run_conversion(pdf_path))

   with open("pdf.md", 'w') as f:
      f.write(end result)

   print("nMarkdown Conversion Consequence:")
   print(end result)

Ausgabe

Voller Code

from mcp import ClientSession, StdioServerParameters
from mcp.shopper.stdio import stdio_client

from langchain_mcp_adapters.instruments import load_mcp_tools
from langgraph.prebuilt import create_react_agent

import asyncio
from langchain_groq import ChatGroq
# Initialize Groq mannequin
mannequin = ChatGroq(mannequin="meta-llama/llama-4-scout-17b-16e-instruct", api_key="")
# Configure MCP server
server_params = StdioServerParameters(

   command="markitdown-mcp", 
   args=()  # No extra arguments wanted for STDIO mode

)

async def run_conversion(pdf_path: str):
   async with stdio_client(server_params) as (learn, write):

       async with ClientSession(learn, write) as session:
           await session.initialize()

           print("MCP Session Initialized.")
           # Load out there instruments
           instruments = await load_mcp_tools(session)

           print(f"Loaded Instruments: {(device.title for device in instruments)}")
           # Create ReAct agent

           agent = create_react_agent(mannequin, instruments)
           print("ReAct Agent Created.")

           # Put together file URI (convert native path to file:// URI)

           file_uri = f"file://{pdf_path}"
           # Invoke agent with conversion request
           response = await agent.ainvoke({

               "messages": (("person", f"Convert {file_uri} to markdown utilizing Markitdown MCP simply retrun the output from MCP server"))

           })

           # Return the final message content material
           return response("messages")(-1).content material

if __name__ == "__main__":
   pdf_path = "/dwelling/harsh/Downloads/LLM Analysis.pdf"  # Use absolute path

   end result = asyncio.run(run_conversion(pdf_path))
   with open("pdf.md", 'w') as f:

       f.write(end result)
   print("nMarkdown Conversion Consequence:")
   print(end result)

Untersuchung der Ausgabe

Das Skript generiert eine PDF.MD -Datei. Diese Datei enthält die Markdown -Model des Eingabe -PDF. Die Konversionsqualität hängt von der Struktur des Originaldokuments ab. Markitdown MCP bewahrt normalerweise Elemente wie::

• Überschriften (verschiedene Ebenen)
• Absatztext
• Pay attention (Bulleted und nummeriert)
• Tabellen (konvertiert in Markdown -Syntax)
• Codeblöcke

Ausgabe

Hier in der Ausgabe können wir sehen, dass es die Überschriften, Inhalte und den normalen Textual content im Markdown -Format erfolgreich abgerufen hat.

Das Ausführen eines lokalen Servers zum Testen hilft daher bei der Bewertung verschiedener Dokumenttypen.

Auch beobachten:

https://www.youtube.com/watch?v=lyfr7qusvss

Praktische Anwendungsfälle in LLM -Pipelines

Das Integrieren von Markitdown MCP kann mehrere KI -Workflows verbessern:

• Wissensbasisgebäude: Dokumente in Markdown umwandeln. Nehmen Sie diesen Inhalt in Wissensbasen oder Lappensysteme ein.
• LLM -Inhaltsvorbereitung: Quelldateien in Markdown verwandeln. Bereiten Sie eine konsistente Eingabe für LLM -Zusammenfassung oder Analyseaufgaben vor.
• Dokumentdatenextraktion: Umwandeln Sie Dokumente mit Tabellen in Markdown. Dies vereinfacht die Parsen strukturierter Daten.
• Dokumentationsautomatisierung: Generieren Sie technische Handbücher. Konvertieren Sie Quelldateien wie Phrase -Dokumente in Markdown für statische Website -Generatoren.

Abschluss

Markitdown MCP bietet eine fähige serverbasierte Methode für die Dokumentenkonvertierung. Es behandelt mehrere Formate. Es erzeugt eine strukturierte Markdown -Ausgabe. Durch die Integration in LLMs können Sie die Automatisierung von Dokumentenverarbeitungsaufgaben. Dieser Ansatz unterstützt skalierbare Dokumentationspraktiken. Wenn Sie den Server zum Testen verwenden, wird die Bewertung unkompliziert. Markitdowns MCP wird am besten durch seine praktische Anwendung in diesen Workflows verstanden.

Erforschen Sie Markitdown MCP Github Repository Weitere Informationen.

Häufig gestellte Fragen

Hallo, ich bin Pankaj Singh Negi – Senior Content material Editor | Leidenschaftlich über das Geschichtenerzählen und das Erstellen überzeugender Erzählungen, die Ideen in einen wirkungsvollen Inhalt verwandeln. Ich liebe es, über die Technologie zu lesen, die unseren Lebensstil revolutioniert.

In diesem Abschnitt werde ich einige Implementierungsdetails von Baker teilen. Da es sich wieder um Open Supply handelt, lade ich meine technischen Leser ein, den Code auf GitHub zu überprüfen. Einige Leser möchten vielleicht zu dem springen nächsten Abschnitt.

Die Anwendung ist minimalistisch mit einer einfachen 3-Ebenen-Architektur und quick vollständig in Python erstellt.

Es besteht aus folgenden Komponenten:

1. Frontend: A Streamlit Die Benutzeroberfläche bietet Benutzern eine intuitive Plattform, um mit dem System zu interagieren, Rezepte abzufragen und Empfehlungen zu erhalten.
2. Backend: Gebaut mit FastAPIDas Backend dient als Schnittstelle zur Bearbeitung von Benutzeranfragen und zur Bereitstellung von Empfehlungen.
3. Motor: Die Engine enthält die Kernlogik zum Suchen und Filtern von Rezepten sowie deren Nutzung Mischling als Abfrage-Builder.
4. Datenbank: Die Rezepte werden in einem gespeichert MongoDB Datenbank, die die von der Engine generierten Aggregationspipelines verarbeitet.

Backend-Setup

Das Backend wird in initialisiert app.pywo FastAPI-Endpunkte definiert sind. Zum Beispiel:

from fastapi import FastAPI
from baker.engine.core import find_recipes
from baker.fashions.ingredient import Ingredient
app = FastAPI()
@app.get("/")
def welcome():
return {"message": "Welcome to the Baker API!"}
@app.put up("/recipes")
def _find_recipes(elements: listing(Ingredient), serving_size: int = 1) -> listing(dict):
return find_recipes(elements, serving_size)

Der /recipes Der Endpunkt akzeptiert eine Zutatenliste und eine Portionsgröße und delegiert dann die Verarbeitung an die Engine.

Rezept-Engine-Logik

Das Herzstück der Anwendung liegt in core.py innerhalb der engine Verzeichnis. Es verwaltet Datenbankverbindungen und Abfragepipelines. Unten finden Sie ein Beispiel dafür find_recipes Funktion:

# Imports and the get_recipes_collection operate will not be included
def find_recipes(elements, serving_size=1):
# Get the recipes assortment
recipes = get_recipes_collection()
# Create the pipeline
pipeline = Pipeline()
pipeline = include_normalization_steps(pipeline, serving_size)
question = generate_match_query(elements, serving_size)
print(question)
pipeline.match(question=question).challenge(
embody=(
"id",
"title",
"preparation_time",
"cooking_time",
"original_serving_size",
"serving_size",
"elements",
"steps",
),
exclude="_id",
)
# Discover the recipes
end result = recipes.mixture(pipeline.export()).to_list(size=None)
return end result
def generate_match_query(elements: listing(Ingredient), serving_size: int = 1) -> dict:
"""Generate the match question."""
operands = ()
for ingredient in elements:
operand = {
"elements.title": ingredient.title,
"elements.unit": ingredient.unit,
"elements.amount": {"$gte": ingredient.amount / serving_size},
}
operands.append(operand)
question = {"$and": operands}
return question
def include_normalization_steps(pipeline: Pipeline, serving_size: int = 1):
"""Provides steps in a pipeline to normalize the elements amount within the db
The steps beneath normalize the portions of the elements within the recipes within the DB by the recipe serving measurement.
"""
# Unwind the elements
pipeline.unwind(path="$elements")
pipeline.add_fields({"original_serving_size": "$serving_size"})
# Add the normalized amount
pipeline.add_fields(
{
# "orignal_serving_size": "$serving_size",
"serving_size": serving_size,
"elements.amount": S.multiply(
S.subject("elements.amount"),
S.divide(serving_size, S.max((S.subject("serving_size"), 1))),
),
}
)
# Group the outcomes
pipeline.group(
by="_id",
question={
"id": {"$first": "$id"},
"title": {"$first": "$title"},
"original_serving_size": {"$first": "$original_serving_size"},
"serving_size": {"$first": "$serving_size"},
"preparation_time": {"$first": "$preparation_time"},
"cooking_time": {"$first": "$cooking_time"},
# "directions_source_text": {"$first": "$directions_source_text"},
"elements": {"$addToSet": "$elements"},
"steps": {"$first": "$steps"},
},
)
return pipeline

Die Kernlogik von Bäcker wohnt in der find_recipes Funktion.

Diese Funktion erstellt dank monggregate eine MongoDB-Aggregationspipeline. Diese Aggregationspipeline umfasst mehrere Schritte.

Die ersten Schritte werden von der generiert include_normalization_steps Funktion, die die Mengen der Zutaten in der Datenbank dynamisch aktualisiert, um sicherzustellen, dass wir Äpfel mit Äpfeln vergleichen. Dies erfolgt durch die Aktualisierung der Zutatenmengen in der Datenbank auf die vom Benutzer gewünschte Portion.

Anschließend wird die eigentliche Matching-Logik erstellt generate_match_query Funktion. Dabei stellen wir sicher, dass die Rezepte nicht mehr erfordern, als der Benutzer für die betreffenden Zutaten zur Verfügung hat.

Schließlich filtert eine Projektion die Felder heraus, die wir nicht zurückgeben müssen.

Bäcker hilft Ihnen, ein besseres Schicksal für Ihre Zutaten zu finden, indem es Rezepte findet, die zu dem passen, was Sie bereits zu Hause haben.

Die App verfügt über eine einfache formularbasierte Oberfläche. Geben Sie Ihre Zutaten ein, geben Sie deren Mengen an und wählen Sie aus den verfügbaren Optionen die Maßeinheit aus.

Im obigen Beispiel suche ich nach einem Rezept für zwei Portionen um 4 Tomaten und 2 Karotten zu verwerten, die etwas zu lange in meiner Küche gestanden haben.

Bäcker habe zwei Rezepte gefunden! Wenn Sie auf ein Rezept klicken, können Sie die vollständigen Particulars anzeigen.

Bäcker Passt die Mengen im Rezept an die von Ihnen eingestellte Portionsgröße an. Wenn Sie beispielsweise die Portionsgröße von zwei auf vier Personen anpassen, berechnet die App die Zutatenmengen entsprechend neu.

Durch die Aktualisierung der Portionsgröße können sich auch die angezeigten Rezepte ändern. Bäcker stellt sicher, dass die vorgeschlagenen Rezepte nicht nur zur Portionsgröße, sondern auch zu den Zutaten und Mengen passen, die Sie zur Hand haben. Wenn Sie beispielsweise nur 4 Tomaten und 2 Karotten für zwei Personen haben, Bäcker Ich werde es vermeiden, Rezepte zu empfehlen, die 4 Tomaten und 4 Karotten erfordern.

Eine intuitive Anleitung zur Textvektorisierung

In meinem letzten Put uphaben wir uns Basis Fashions und Massive Language Fashions (LLMs) genauer angesehen. Wir haben versucht zu verstehen, was sie sind, wie sie verwendet werden und was sie so besonders macht. Wir haben untersucht, wo sie intestine funktionieren und wo sie vielleicht nicht funktionieren. Wir haben ihre Anwendungsmöglichkeiten in verschiedenen Bereichen wie dem Verstehen von Texten und der Generierung von Inhalten besprochen. Diese LLMs haben den Bereich der Verarbeitung natürlicher Sprache (NLP) grundlegend verändert.

Wenn wir an eine NLP-Pipeline denken, ist Characteristic Engineering (auch bekannt als Merkmalsextraktion oder Textdarstellung oder Textvektorisierung) ist ein sehr wesentlicher und wichtiger Schritt. Dieser Schritt umfasst Techniken zur Darstellung von Textual content als Zahlen (Merkmalsvektoren). Wir müssen diesen Schritt ausführen, wenn wir an einem NLP-Drawback arbeiten, da Pc keinen Textual content verstehen können, sondern nur Zahlen. Und diese numerische Darstellung von Textual content muss in die Algorithmen des maschinellen Lernens eingespeist werden, um verschiedene textbasierte Anwendungsfälle wie Sprachübersetzung, Stimmungsanalyse, Zusammenfassung usw. zu lösen.

Diejenigen von uns, die sich mit der Pipeline des maschinellen Lernens im Allgemeinen auskennen, wissen, dass Characteristic Engineering ein sehr wichtiger Schritt ist, um gute Ergebnisse aus dem Modell zu erzielen. Dasselbe Konzept gilt auch für NLP. Wenn wir eine numerische Darstellung von Textdaten generieren, ist ein wichtiges Ziel, das wir erreichen wollen, dass die generierte numerische Darstellung sollte in der Lage sein, die Bedeutung des zugrunde liegenden Textes zu erfassen. Daher werden wir in unserem heutigen Beitrag nicht nur die verschiedenen zu diesem Zweck verfügbaren Techniken besprechen, sondern auch bewerten, wie nah sie bei jedem Schritt unserem Ziel kommen.

Einige der wichtigsten Ansätze zur Merkmalsextraktion sind:

– Eine Sizzling-Kodierung

– Beutel mit Wörtern (BOW)

– N-Gramme

– TF-IDF

– Worteinbettungen

Wir beginnen mit dem Verständnis einiger grundlegender Terminologien und ihrer Beziehung zueinander.

– Korpus — Alle Wörter im Datensatz

– Wortschatz — Eindeutige Wörter im Datensatz

– Dokumentieren — Eindeutige Datensätze im Datensatz

– Wort — Jedes Wort in einem Dokument

Nehmen wir beispielsweise der Einfachheit halber an, dass unser Datensatz nur drei Sätze enthält. Die folgende Tabelle zeigt den Unterschied zwischen Korpus und Vokabular.

Jetzt wird jeder der drei Datensätze im obigen Datensatz als Dokument (D) und jedes Wort im Dokument als Wort (W) bezeichnet.

Beginnen wir nun mit den Techniken.

Dies ist eine der grundlegendsten Techniken zum Umwandeln von Textual content in Zahlen.

Wir verwenden denselben Datensatz wie oben. Unser Datensatz enthält drei Dokumente – wir können sie D1, D2 und D3 nennen.

Wir wissen, dass das Vokabular (V) (Katze, spielt, Hund, Junge, Ball) ist und 5 Elemente enthält. Bei One Sizzling Encoding (OHE) stellen wir jedes Wort in jedem Dokument basierend auf dem Vokabular des Datensatzes dar. „1“ erscheint an Positionen, an denen eine Übereinstimmung vorliegt.

Aus den oben genannten Daten können wir daher für jedes Dokument eine Sizzling-Encoded-Darstellung ableiten.

Was wir hier im Wesentlichen tun, ist, dass wir jedes Wort unseres Dokuments in ein 2-dimensionaler Vektor, wobei die erste Dimension die Anzahl der Wörter im Dokument und der zweite Wert die Größe des Wortschatzes angibt (V=5 in unserem Fall).

Obwohl diese Methode sehr einfach zu verstehen und umzusetzen ist, weist sie auch einige Nachteile auf, weshalb die Verwendung dieser Technik nicht empfohlen wird.

– Spärliche Darstellung (d. h. es gibt viele Nullen und für jedes Wort steht an nur einer Stelle eine Eins). Je größer das Corpus, desto größer der V-Wert und desto spärlicher die Darstellung.

– Leidet an Aus dem Vokabular Probleme – das heißt, wenn zum Zeitpunkt der Inferenz ein neues Wort eingeführt wird (ein Wort, das während des Trainings nicht in V vorhanden ist), funktioniert der Algorithmus nicht.

– Letzter und wichtigster Punkt: Dadurch wird die semantische Beziehung zwischen Wörtern nicht erfasst (was unser Hauptziel ist, wenn Sie sich an unsere Diskussion oben erinnern).

Das führt uns zur Untersuchung der nächsten Technik

Es ist eine sehr beliebte und ziemlich alte Technik.

Der erste Schritt besteht darin, erneut das Vokabular (V) aus dem Datensatz zu erstellen. Dann vergleichen wir die Anzahl der Vorkommen jedes Wortes aus dem Dokument mit dem erstellten Vokabular. Die folgende Demonstration anhand früherer Daten hilft, dies besser zu verstehen

Im ersten Dokument kommt „Katze“ einmal vor, „spielt“ einmal und auch „Ball“. Die Anzahl für jedes dieser Wörter ist additionally 1 und die anderen Positionen sind mit 0 gekennzeichnet. Auf ähnliche Weise können wir die jeweiligen Anzahlen für jedes der beiden anderen Dokumente ermitteln.

Die BOW-Technik wandelt jedes Dokument in einen Vektor der Größe des Vokabulars V um. Hier erhalten wir drei 5-dimensionale Vektoren — (1,1,0,0,1), (0,1,1,0,1) und (0,1,0,1,1)

Bag of Phrases wird bei Klassifizierungsaufgaben verwendet und hat sich als recht leistungsfähig erwiesen. Und wenn Sie sich die Tabelle ansehen, können Sie erkennen, dass es auch hilft, die Ähnlichkeit zwischen den Sätzen zu erfassen – zumindest ein wenig. Zum Beispiel: „spielt“ und „Ball“ kommen in allen drei Dokumenten vor, und daher können wir an diesen Positionen für alle drei Dokumente 1 sehen.

Professional:

– Sehr einfach zu verstehen und umzusetzen

– Das zuvor festgestellte Drawback der festen Länge tritt hier nicht auf, da die Zählungen auf der Grundlage des vorhandenen Wortschatzes berechnet werden, was wiederum dazu beiträgt, das in der früheren Technik festgestellte Drawback des fehlenden Wortschatzes zu lösen. Wenn additionally zum Zeitpunkt der Inferenz ein neues Wort in den Daten erscheint, werden die Berechnungen auf der Grundlage der vorhandenen Wörter und nicht der neuen Wörter durchgeführt.

Nachteile:

– Dies ist immer noch eine spärliche Darstellung, die für die Berechnung schwierig ist

– Obwohl wir bei einem neuen Wort keinen Fehler mehr erhalten, da nur die vorhandenen Wörter berücksichtigt werden, gehen durch das Ignorieren der neuen Wörter tatsächlich Informationen verloren.

– Die Reihenfolge der Wörter wird nicht berücksichtigt, da diese für das Verständnis des betreffenden Textes sehr wichtig sein kann.

– Wenn Dokumente meistens aus gemeinsamen Wörtern bestehen, aber eine kleine Änderung eine gegenteilige Bedeutung vermitteln kann, funktioniert BOW nicht. Beispiel:

Beispiel: Angenommen, es gibt zwei Sätze –

1. Ich magazine es, wenn es regnet.

2. Ich magazine es nicht, wenn es regnet.

Mit der Artwork und Weise, wie BOW berechnet wird, können wir sehen, dass beide Sätze als ähnlich betrachtet werden, da alle Wörter außer „don‘t“ in beiden Sätzen vorhanden sind, aber dieses einzelne Wort die Bedeutung des zweiten Satzes im Vergleich zum ersten völlig verändert.

Diese Technik ähnelt BOW, das wir gerade gelernt haben, aber dieses Mal wird unser Vokabular nicht aus einzelnen Wörtern, sondern aus N-Grammen bestehen (2 Wörter zusammen, bekannt als Bigrams, 3 Wörter zusammen, bekannt als Trigramms … oder allgemeiner ausgedrückt – n Wörter zusammen, bekannt als „N-Gramme“).

Die Ngrams-Technik ist eine Verbesserung gegenüber Bag of Phrases, da sie hilft, die semantische Bedeutung der Sätze zumindest bis zu einem gewissen Grad zu erfassen. Betrachten wir das oben verwendete Beispiel.

1. Ich magazine es, wenn es regnet.

2. Ich magazine es nicht, wenn es regnet.

Diese beiden Sätze haben eine völlig gegensätzliche Bedeutung und ihre Vektordarstellungen sollten daher weit auseinander liegen.

Wenn wir nur die einzelnen Wörter, additionally BOW mit n=1 oder Unigramme verwenden, sieht ihre Vektordarstellung wie folgt aus

D1 kann als (1,1,1,1,1,0) dargestellt werden, während D2 als (1,1,1,1,1,1) dargestellt werden kann.

D1 und D2 scheinen sehr ähnlich zu sein und der Unterschied scheint nur in einer Dimension aufzutreten. Daher können sie beim Plotten in einem Vektorraum recht nahe beieinander dargestellt werden.

Sehen wir uns nun an, warum die Verwendung von Bigrammen in einer solchen Scenario nützlicher sein kann.

Mit diesem Ansatz können wir sehen, dass die Werte in drei Dimensionen nicht übereinstimmen, was im Vergleich zur früheren Technik definitiv dazu beiträgt, die Unähnlichkeit der Sätze im Vektorraum besser darzustellen.

Professional

· Es handelt sich um einen sehr einfachen und intuitiven Ansatz, der leicht zu verstehen und umzusetzen ist

· Hilft, die semantische Bedeutung des Textes zumindest teilweise zu erfassen

Nachteile:

· Rechentechnisch aufwändiger, da wir jetzt anstelle einzelner Token eine Kombination von Token verwenden. Die Verwendung von N-Grammen vergrößert den Merkmalsraum erheblich. In praktischen Fällen werden wir es beispielsweise nicht mit wenigen Wörtern zu tun haben, sondern unser Vokabular kann Tausende von Wörtern umfassen, die Anzahl der möglichen Bigramme wird sehr hoch sein.

· Diese Artwork der Datendarstellung ist immer noch spärlich. Da N-Gramme bestimmte Wortfolgen erfassen, tauchen viele N-Gramme im Korpus möglicherweise nicht häufig auf, was zu einer spärlichen Matrix führt.

· Das OOV-Drawback besteht weiterhin. Wenn ein neuer Satz hinzukommt, wird er ignoriert, da ähnlich wie bei der BOW-Technik nur die im Vokabular vorhandenen Wörter/Bigramme berücksichtigt werden.

Es ist möglich, N-Gramme (Bigramme, Trigramme usw.) zusammen mit Unigrammen zu verwenden und kann in bestimmten Anwendungsfällen zum Erreichen guter Ergebnisse beitragen.

Für die Techniken, die wir bisher oben besprochen haben, haben wir den Wert an jeder Place basierend auf dem Vorhandensein oder Fehlen eines bestimmten Wortes/N-Gramms oder der Häufigkeit des Wortes/N-Gramms verwendet.

Diese Technik verwendet eine einzigartige Logik (Formel), um die Gewichte für jedes Wort basierend auf zwei Aspekten zu berechnen –

Termfrequenz (TF)– Indikator dafür, wie häufig ein Wort in einem Dokument vorkommt. Es handelt sich um das Verhältnis der Häufigkeit, mit der ein Wort in einem Dokument vorkommt, zur Gesamtzahl der Wörter im Dokument.

Die Inverse Doc Frequency (IDF) hingegen gibt an, Wichtigkeit eines Begriffs im Hinblick auf das gesamte Korpus.

Formel von TF-IDF:

Gehen wir die Berechnung nun anhand unseres Korpus mit drei Dokumenten durch.

1. Katze spielt Ball (D1)

2. Hund spielt Ball (D2)

3. Junge spielt Ball (D3)

Aus der obigen Tabelle können wir ersehen, dass der Effekt der in allen Dokumenten vorkommenden Wörter (Spiele und Ball) auf 0 reduziert wurde.

Berechnung des TF-IDF mit der Formel TF-IDF(t,d) = TF(t,d) × IDF(t,D)

Wir können sehen, wie die gebräuchlichen Wörter „spielt“ und „Ball“ weggelassen werden und wichtigere Wörter wie „Katze“, „Hund“ und „Junge“ identifiziert werden.

Der Ansatz hilft additionally dabei, weist Wörtern, die in einem bestimmten Dokument häufig vorkommen, im gesamten Korpus jedoch seltener auftauchen, höhere Gewichte zu.TF-IDF ist sehr nützlich für Aufgaben des maschinellen Lernens, wie etwa Textklassifizierung, Informationsabruf usw.

Wir werden jetzt fortgeschrittenere Vektorisierungstechniken erlernen.

Ich werde dieses Thema mit einem Zitat aus der Definition von Worteinbettungen beginnen, die wunderbar erklärt wird unter Verknüpfung

„Worteinbettungen sind eine Möglichkeit, Wörter als Vektoren in einem mehrdimensionalen Raum darzustellen, wobei die Entfernung und Richtung zwischen den Vektoren die Ähnlichkeit und die Beziehungen zwischen den entsprechenden Wörtern widerspiegeln.“

Bild vom Autor

In Python sind Zeichenfolgen unveränderliche Zeichenfolgen, die für Menschen lesbar sind und normalerweise in einer bestimmten Zeichenkodierung wie UTF-8 kodiert sind. Während Bytes rohe Binärdaten darstellen. Ein Byte-Objekt ist unveränderlich und besteht aus einem Array von Bytes (8-Bit-Werten). In Python 3 sind Zeichenfolgenliterale standardmäßig Unicode, während Byteliterale mit einem b.

Das Konvertieren von Bytes in Zeichenfolgen ist eine häufige Aufgabe in Python, insbesondere beim Arbeiten mit Daten aus Netzwerkvorgängen, Datei-E/A oder Antworten von bestimmten APIs. Dies ist ein Tutorial zum Konvertieren von Bytes in Zeichenfolgen in Python.

1. Konvertieren Sie Bytes mit der Methode decode() in Zeichenfolgen

Der einfachste Weg, Bytes in einen String umzuwandeln, ist die Verwendung des decode() Methode auf dem Byte-Objekt (oder der Byte-Zeichenfolge). Diese Methode erfordert die Angabe der verwendeten Zeichenkodierung.

Notiz: Strings haben keine zugehörige Binärkodierung und Bytes haben keine zugehörige Textkodierung. Um Bytes in Strings umzuwandeln, können Sie den decode() Methode auf dem Bytes-Objekt. Und um Strings in Bytes umzuwandeln, können Sie die encode() Methode auf die Zeichenfolge. Geben Sie in beiden Fällen die zu verwendende Kodierung an.

Beispiel 1: UTF-8-Kodierung

Hier konvertieren wir byte_data in einen UTF-8-kodierten String mit dem decode() Methode:

# Pattern byte object
byte_data = b'Whats up, World!'

# Changing bytes to string 
string_data = byte_data.decode('utf-8')

print(string_data)  

Sie sollten die folgende Ausgabe erhalten:

Sie können die Datentypen vor und nach der Konvertierung wie folgt überprüfen:

print(sort(bytes_data))
print(sort(string_data))

Die Datentypen sollten wie erwartet sein:

Output >>>
<class 'bytes'>
<class 'str'>

Beispiel 2: Umgang mit anderen Kodierungen

Manchmal kann die Bytefolge andere Kodierungen als UTF-8 enthalten. Sie können dies umgehen, indem Sie das entsprechende Kodierungsschema angeben, das beim Aufruf des decode() Methode für das Byteobjekt.

So können Sie eine Bytefolge mit UTF-16-Kodierung dekodieren:

# Pattern byte object 
byte_data_utf16 = b'xffxfeHx00ex00lx00lx00ox00,x00 x00Wx00ox00rx00lx00dx00!x00'

# Changing bytes to string 
string_data_utf16 = byte_data_utf16.decode('utf-16')

print(string_data_utf16)  

Und hier ist die Ausgabe:

Verwenden von Chardet zum Erkennen von Kodierungen

In der Praxis ist Ihnen das verwendete Kodierungsschema möglicherweise nicht immer bekannt. Und nicht übereinstimmende Kodierungen können zu Fehlern oder verstümmeltem Textual content führen. Wie können Sie dieses Downside additionally umgehen?

Du kannst den … benutzen Chardet-Bibliothek (Chardet mit Pip installieren: pip set up chardet), um die Kodierung zu erkennen. Und verwenden Sie sie dann im Methodenaufruf `decode()`. Hier ist ein Beispiel:

import chardet

# Pattern byte object with unknown encoding
byte_data_unknown = b'xe4xbdxa0xe5xa5xbd'

# Detecting the encoding
detected_encoding = chardet.detect(byte_data_unknown)
encoding = detected_encoding('encoding')
print(encoding)

# Changing bytes to string utilizing detected encoding
string_data_unknown = byte_data_unknown.decode(encoding)

print(string_data_unknown) 

Sie sollten eine ähnliche Ausgabe erhalten:

Fehlerbehandlung bei der Dekodierung

Der bytes Das Objekt, mit dem Sie arbeiten, ist möglicherweise nicht immer gültig. Es kann manchmal ungültige Sequenzen für die angegebene Kodierung enthalten. Dies führt zu Fehlern.

Hier, byte_data_invalid
enthält die ungültige Sequenz xff:

# Pattern byte object with invalid sequence for UTF-8
byte_data_invalid = b'Whats up, World!xff'

# strive changing bytes to string 
string_data = byte_data_invalid.decode('utf-8')

print(string_data) 

Beim Versuch, es zu dekodieren, wird die folgende Fehlermeldung angezeigt:

Traceback (most up-to-date name final):
  File "/residence/balapriya/bytes2str/foremost.py", line 5, in 
	string_data = byte_data_invalid.decode('utf-8')
              	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeDecodeError: 'utf-8' codec cannot decode byte 0xff in place 13: invalid begin byte

Es gibt jedoch mehrere Möglichkeiten, mit diesen Fehlern umzugehen. Sie können solche Fehler beim Dekodieren ignorieren oder ungültige Sequenzen durch einen Platzhalter ersetzen.

Fehler ignorieren

Um ungültige Sequenzen beim Dekodieren zu ignorieren, können Sie die Fehler festlegen, die Sie festlegen können errors Zu ignore im decode() Methodenaufruf:

# Pattern byte object with invalid sequence for UTF-8
byte_data_invalid = b'Whats up, World!xff'

# Changing bytes to string whereas ignoring errors
string_data = byte_data_invalid.decode('utf-8', errors="ignore")

print(string_data) 

Sie erhalten nun die folgende Ausgabe ohne Fehler:

Ersetzen von Fehlern

Sie können ungültige Sequenzen auch durch den Platzhalter ersetzen. Dazu können Sie errors Zu substitute wie gezeigt:

# Pattern byte object with invalid sequence for UTF-8
byte_data_invalid = b'Whats up, World!xff'

# Changing bytes to string whereas changing errors with a placeholder
string_data_replace = byte_data_invalid.decode('utf-8', errors="substitute")

print(string_data_replace)  

Nun wird die ungültige Sequenz (am Ende) durch einen Platzhalter ersetzt:

Output >>>
Whats up, World!�

2. Konvertieren Sie Bytes mit dem str()-Konstruktor in Zeichenfolgen

Der decode() Methode ist die häufigste Methode, um Bytes in Strings umzuwandeln. Sie können aber auch die str() Konstruktor, um einen String aus einem Bytes-Objekt zu erhalten. Sie können das Kodierungsschema übergeben an str() etwa so:

# Pattern byte object
byte_data = b'Whats up, World!'

# Changing bytes to string
string_data = str(byte_data,'utf-8')

print(string_data)

Dies gibt aus:

3. Konvertieren Sie Bytes mit dem Codecs-Modul in Zeichenfolgen

Eine weitere Methode zum Konvertieren von Bytes in Zeichenfolgen in Python ist die Verwendung von decode() Funktion aus dem eingebauten Codecs Modul. Dieses Modul bietet Komfortfunktionen zum Kodieren und Dekodieren.

Sie erreichen uns unter decode() Funktion mit dem Bytes-Objekt und dem Kodierungsschema wie gezeigt:

import codecs

# Pattern byte object
byte_data = b'Whats up, World!'

# Changing bytes to string
string_data = codecs.decode(byte_data,'utf-8')

print(string_data)  

Wie erwartet wird auch Folgendes ausgegeben:

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man in Python Bytes in Zeichenfolgen umwandelt und dabei auch verschiedene Kodierungen und potenzielle Fehler problemlos handhabt. Insbesondere haben wir Folgendes gelernt:

• Verwenden Sie die decode() Methode zum Konvertieren von Bytes in eine Zeichenfolge unter Angabe der richtigen Kodierung.
• Behandeln Sie potenzielle Decodierungsfehler mit dem errors Parameter mit Optionen wie ignore oder substitute.
• Verwenden Sie die str() Konstruktor zum Konvertieren eines gültigen Byteobjekts in eine Zeichenfolge.
• Verwenden Sie die decode() Funktion aus dem codecs Modul, das in die Python-Standardbibliothek integriert ist, um ein gültiges Byteobjekt in eine Zeichenfolge zu konvertieren.

Viel Spaß beim Programmieren!

Bala Priya C ist Entwicklerin und technische Redakteurin aus Indien. Sie arbeitet gerne an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessens- und Fachgebiete umfassen DevOps, Datenwissenschaft und natürliche Sprachverarbeitung. Sie liest, schreibt, programmiert und trinkt gerne Kaffee! Derzeit arbeitet sie daran, ihr Wissen zu lernen und mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt auch ansprechende Ressourcenübersichten und Programmier-Tutorials.