Gemini 3 ist erschienen und erobert bereits die Welt im Sturm. Sie fragen sich vielleicht: Wie steht es derzeit um die besten Fashions der Welt? Und ein Title fällt mir besonders ein: GPT 5.1.

Und hier wird der Vergleich interessant. Diese beiden konkurrieren nicht nur mit der reinen Modellleistung. Um dorthin zu gelangen, nehmen sie völlig unterschiedliche Wege. Gemini 3 treibt die native Multimodalität und die tiefe Integration im gesamten Google-Ökosystem voran. GPT 5.1 konzentriert sich auf stabiles Denken, Leistung in langen Kontexten und ausgefeilte Alltagstauglichkeit. Werden sie dem Hype gerecht und welches ist für einen echten Benutzer wirklich wichtig? Erfahren Sie es in diesem Artikel.

Die Frage, die Sie sich stellen sollten, lautet additionally: „Welches passt zu meiner Arbeit?“ statt „Was ist besser?“ weil sie eindeutig auf unterschiedliche Anwendungsfälle zugeschnitten sind.

Die Konkurrenten

Bevor wir uns darauf einlassen, machen wir uns mit den Seiten vertraut. Auf der einen Seite haben wir Gemini 3 und auf der anderen GPT 5.1.

Was ist Gemini 3?

Gemini 3, veröffentlicht unter dem Namen Gemini 3 Professional, ist das neueste Mitglied der Gemini-Modellfamilie. Eine lang erwartete Veröffentlichung des Modells, die dazu bestimmt ist, die Grenzen großer Sprachmodelle zu erweitern. Der wichtigste Alleinstellungsmerkmal von Gemini 3 ist seine tiefe Integration in die Suche, Android, Chrome und Workspace. Dies ist besonders nützlich für Personen, die mit dem Google-Ökosystem aus Google Drive, YouTube, Gmail usw. vertraut sind.

Weitere Einzelheiten zu Gemini 3 erfahren Sie in Das Artikel.

Was ist GPT 5.1?

GPT-5.1 ist OpenAIs neuestes Improve der GPT-Familie und es fühlt sich endlich so an, als ob die Model GPT-5 sein sollte. Bei einfachen Aufgaben ist es schneller, bei komplexen Aufgaben gezielter und bei der Befolgung von Anweisungen deutlich besser. Mit Optionen wie „Prompt“ für Geschwindigkeit und „Pondering“ für tiefergehendes Denken können Benutzer entscheiden, wie sich das Modell verhält. Der Ton ist wärmer, die Gespräche fühlen sich natürlicher an und das Mannequin bleibt auf dem richtigen Weg, ohne abzudriften. Dank der verbesserten Kontextverarbeitung werden auch weniger Fehler gemacht, was insgesamt zu einem stabileren und zuverlässigeren Eindruck führt.

Die vollständige Aufschlüsselung von GPT-5.1 finden Sie in Das Artikel.

Wie greife ich zu?

Sie können mit auf Gemini 3 zugreifen Google AI Studio und ChatGPT 5.1 unter chatgpt.com. Für den Zugriff auf ChatGPT 5.1 ist der Zugriff auf eines der kostenpflichtigen Abonnements von OpenAI erforderlich: Go, Plus, Professional.

Wenn Sie versuchen, auf andere Weise auf Gemini 3 zuzugreifen, können Sie den folgenden Artikel lesen: 5 Möglichkeiten, auf Gemini 3 zuzugreifen: Von der API zur App

Palms-On: Zeit für die Arbeit!

Um zu sehen, wie intestine diese Modelle bei verschiedenen Aufgaben funktionieren, würde ich sie anhand der folgenden Aufgaben testen:

1. Vibe-Codierung
2. Bildverarbeitung
3. Codegenerierung

Ich würde Gemini 3 Professional auf Google AI Studio testen. Dies liegt daran, dass sich die Gemini-App noch in der Umstellung auf das neue Modell befindet, während AI Studio diesen bereits hinter sich hat.

Vibe-Codierung

Eine der häufigsten Aufgaben, für die LLMs verwendet werden, ist die Vibe-Codierung. Dies ermöglicht es, ein technisch nicht versiertes Publikum anzusprechen, das etwas bauen möchte. Ich würde die Modelle anhand der folgenden Eingabeaufforderung testen:

Immediate:

Erstellen Sie ein kleines, spielbares 2D-Kampfspiel, das von frühen Avenue Fighter-Titeln inspiriert ist. Fügen Sie zwei Charaktere auf dem Bildschirm mit Gesundheitsbalken, einem Timer und einem einfachen Bühnenhintergrund hinzu. Jeder Charakter sollte über leichte Schläge, schwere Schläge, Sprünge, Hocken und Gehen verfügen. Die Steuerung sollte über Tastatureingabe erfolgen: Pfeiltasten zum Bewegen und Springen, A für leichten Schlag, S für starken Schlag. Wenn die Gesundheit eines Charakters Null erreicht, zeigen Sie einen klaren Gewinnbildschirm an und lassen Sie den Spieler neu starten. Halten Sie die Grafik einfach, aber lebendig, mit klobiger Pixelkunst und lesbaren Animationen. Lassen Sie es mithilfe von HTML, CSS und JavaScript in einer einzelnen Datei oder einem kleinen Paket direkt im Browser laufen. Stellen Sie sicher, dass es sofort und ohne zusätzliche Einrichtung einfach zu spielen ist.

Antwort Zwillinge 3:

Antwort ChatGPT 5.1:

Urteil: Gemini 3 hat meiner Meinung nach die beste Nachahmung von Avenue Fighter 1 geschafft, die mit einfachem HTML, CSS und Javascript möglich ist. Das Spiel warfare funktional, spielbar und verfügte sogar über eine anständige Schwerkraft- und Gesundheitsmechanik. Kurzfristig warfare die Resonanz zufriedenstellend.

ChatGPT 5.1 hat etwas gemacht. Ob es Contra oder Avenue Fighter warfare, konnte ich nicht sagen. Es funktioniert zumindest.

Bildverarbeitung

Die Verarbeitung komplexer Bilder warfare für diese scheinbar brillanten Modelle schon immer eine große Herausforderung. Für diese Aufgabe würde ich das folgende Bild verwenden:

Dieses Bild hat insgesamt 943 Punkte, davon sind 933 blau/cyan und 10 rosa. Ich würde testen, ob die Modelle in der Lage sind, ihre Zahlen herauszufinden oder nicht.

Immediate:

Wie viele Punkte enthält dieses Bild und in welchen Farben (sofern sie unterschiedliche Farben haben). Ich brauche die genaue Nummer.

Antwort Zwillinge 3:

Antwort ChatGPT 5.1:

Urteil: Gemini 3 ist dabei durcheinander geraten. Es begann mit der Angabe der Häufigkeit der blauen und rosa Punkte, wobei die blauen Punkte stark überragt wurden. Dann folgte eine Erklärung, die ungeheuerlich ist. Es entstand ein perfektes gestaffeltes Gittermuster im Bild (was nicht der Fall warfare). Auch alle darin vorgelegten Berechnungen waren überzeugend falsch.

ChatGPT 5.1 hingegen erkannte die richtige Farbe sowie die Anzahl der im Bild vorhandenen Punkte. Die Ergebnisse wurden in einer kurzen Antwort übermittelt.

Codegenerierung

Ich meine, wenn es einem Programmierer seinen Job wegnimmt, dann könnte er es auch besser machen! In dieser Aufgabe würden wir testen, wie intestine die Modelle bei einem sehr einfachen Codierungsproblem funktionieren:

Immediate:

Schreiben 20 Zeilen Python max Das:

1. Lädt eine lokale CSV,
2. Erkennt doppelte Datensätze mit irgendeiner Methode,
3. Gibt nur die aus einzigartige Zeilen in eine neue Datei,
4. Keine externen Bibliotheken außer csv.

Antwort Zwillinge 3:

Antwort ChatGPT 5.1:

Urteil: Gemini 3 lieferte insgesamt den besseren Code. Der Code erfüllte unsere 4 Kriterien und der Gedanke (wenn er erweitert wurde) enthielt sogar eine prägnante Erklärung der Set-Funktion, die die einzigartige Wertfunktionalität unseres Codes bereitstellte. Und das alles in nur 11 Zeilen Code! Ein Programmiermeister würde diesen optimierten Code sehr zu schätzen wissen.

ChatGPT 5.1 erledigt einfach die Arbeit. Die Antwort ist ziemlich dürftig und besteht nur aus dem Code, und selbst der Code tut dies in einem wirklich einfachen Stil. Mit 17 Codezeilen verlangt der Code nach Inspiration.

Benchmarks

Der Umfang meiner Checks warfare recht begrenzt, daher ist es besser, auf Benchmark-Ergebnisse zurückzugreifen, um zu sehen, wie intestine die Modelle bei verschiedenen Arbeitslasten im Vergleich zueinander abschneiden.

Gemini 3 ging als einstimmiger Gewinner in der Kategorie „Alles!?“ hervor. Wenn man bedenkt, dass ein solches Modell kostenlos verfügbar ist, während GPT 5.1 noch für Nicht-Abonnenten eingeführt werden muss, spricht das eindeutig für die Richtung, in die sich Gemini bewegt.

Abschluss

Letztlich ist dies keine Geschichte eines klaren Verlierers. Gemini 3 scheint heute der stärkere Allrounder zu sein. Eng in das Google-Ökosystem integriert, hervorragend für alltägliche Aufgaben geeignet und bei den meisten öffentlichen Benchmarks vorne – und das alles bei weitaus besserer Zugänglichkeit. GPT 5.1 behauptet sich immer noch mit stabiler Argumentation, flexiblen Modi und einem sehr natürlichen Gesprächsstil, insbesondere für Benutzer, die bereits tief im OpenAI-Stack verankert sind.

Der kluge Schachzug besteht additionally nicht darin, einen „Champion“ auszuwählen, sondern einen Teamkollegen. Probieren Sie beide aus, ordnen Sie sie Ihren Arbeitsabläufen zu und lassen Sie sich mit dem richtigen Modell zehnmal größer fühlen.

Häufig gestellte Fragen

OpenAI liefert Produkte schnell, aber ist die Qualität erstklassig? Das ist fraglich! Sie haben kürzlich ihren eigenen Browser, ChatGPT Atlas, gestartet. Vom Aussehen her scheint es Chrome ziemlich ähnlich zu sein Der Komet der Perplexitätwahrscheinlich eine Mischung aus beidem. Ich persönlich liebe Comet und benutze es schon seit einiger Zeit. In diesem Weblog führe ich Sie zunächst durch die Funktionen von ChatGPT Atlas und vergleiche es dann mit Comet hinsichtlich der spezifischen Aufgaben, die Comet superschnell erledigt. Sind Sie bereit?

Hauptmerkmale des ChatGPT-Atlas?

• Webweites Dienstprogramm: Bringen Sie ChatGPT ins Web, um sofortige Antworten, intelligentere Vorschläge und Hilfe bei verschiedenen Aufgaben zu erhalten.
• ChatGPT-Seitenleiste: Öffnen Sie in jedem Fenster eine spezielle Seitenleiste, um Inhalte zusammenzufassen, Produkte zu vergleichen oder Daten direkt von der angezeigten Web site aus zu analysieren.

• Kontextuelles Gedächtnis: Das Modell kann dort weitermachen, wo Sie aufgehört haben. Sie können steuern, was ChatGPT speichert, um sicherzustellen, dass bei Bedarf relevante Particulars bereitgestellt werden.

• Cursor-Zusammenarbeit: Verwandeln Sie Ihren Cursor in einen Mitarbeiter. Markieren Sie Textual content in E-Mails, Kalendereinladungen oder Dokumenten und erhalten Sie mit einem einzigen Klick Unterstützung aus dem Chat.

Erweiterte Funktionen

• Agentenmodus (Aktionsergreifung): ChatGPT kann in Ihrem Namen mit Web sites interagieren (immer unter Ihrer Kontrolle). Verwenden Sie es, um Aufgaben von Anfang bis Ende zu erledigen, beispielsweise Recherchen und Einkäufe für eine Reise. Hinweis: Diese Funktion ist in der Vorschau für Plus-, Professional- und Enterprise-Konten verfügbar.

• Intelligentere Suchen: Erhalten Sie Informationen so, wie Sie es möchten, mit der Möglichkeit, nach Textual content, Bildern, Movies oder Nachrichtenartikeln zu suchen.

Benutzerkontrolle und -erfahrung

• Vollständige Datenschutzkontrolle: Sie haben die Kontrolle. Sie können jederzeit entscheiden, welche Web sites ChatGPT sehen kann, Ihren Browserverlauf löschen, den Inkognito-Modus verwenden und Browserspeicher verwalten.
• Benutzerfreundlichkeit: Navigieren Sie ganz einfach im Internet mit Standardfunktionen wie Tabs, automatischer Vervollständigung, einer Suchleiste und Lesezeichen.
• Anpassung: Legen Sie ganz einfach Ihre Searching-Einstellungen und Farben fest, um es individuell anzupassen.

Wie greife ich auf den ChatGPT-Atlas zu?

Sie sind jetzt bereit, ChatGPT Atlas zu verwenden!

Probieren wir ChatGPT Atlas aus

Um die Fähigkeiten von Atlas zu testen, habe ich eine Reihe praktischer, alltäglicher Aufgaben ausgeführt.

Aufgabe 1: PDF-Zusammenfassung

Ich habe eine umfangreiche Forschungsarbeit gelesen und brauchte einen schnellen Überblick. Ich habe ChatGPT Atlas gebeten, das PDF für mich zusammenzufassen. Die Ergebnisse, die ich erhielt, waren anständig und lieferten eine hilfreiche, umfassende Erklärung des Konzepts. Diese Funktion kann für Studenten und Berufstätige, die neue Themen erlernen, äußerst hilfreich sein.

Aufgabe 2: Codierung

Codierung aller Artwork wird mit ChatGPT Atlas zur „Vibe-Codierung“. Da der Browser von unterstützt wird GPT-5Es bietet leistungsstarke Codierungsfunktionen direkt zur Hand. Sie können den Agenten anrufen und zwischen den von Ihnen ausgeführten Codierungsaufgaben Fragen stellen oder Codefragmente verfeinern.

Das vollständige Video finden Sie hier!

Aufgabe 3: On-line-Buying

Für diese Aufgabe habe ich mich bei meinem Myntra-Konto angemeldet und den Agentenmodus von Atlas gebeten, für mich ein schwarzes Hemd unter 5.000 INR in Größe L zu bestellen. Leider scheiterte der Browser bei dieser Aufgabe wiederholt. Wie Sie unten sehen können, hatte der Agent Probleme mit der Benutzeroberfläche, was zeigt, dass sich diese erweiterte Funktion noch in einem sehr frühen Stadium befindet. Überprüfen Sie den Fehler unten:

Ist ChatGPT Atlas besser als Comet?

Nachdem ich beide Plattformen ausgiebig genutzt habe, muss ich zu dem Schluss kommen, dass Comet ein viel besserer Assistent für allgemeine Aufgaben ist. Es ist außerdem kostenlos und sehr praktisch in der Anwendung. Für ChatGPT Atlas ist das Wertversprechen viel stärker, wenn Sie bereits Zugriff auf ein ChatGPT Plus-Konto haben, da Ihr Chat-Speicher und -Verlauf sofort importiert werden, wodurch das Gesamterlebnis personalisierter wird.

Lesen Sie auch: 8 einfache Möglichkeiten, kostenlos auf ChatGPT zuzugreifen

Abschluss

Der neue ChatGPT-Atlas von OpenAI macht ihre Ambitionen deutlich: Sie sehen das Internet als einen Ort zum Handeln und nicht nur als Info. Aber wie meine Assessments gezeigt haben, müssen noch einige Probleme behoben werden. Für die meisten von uns, die nur schnell Antworten erhalten möchten, ist Comet derzeit die bessere Wahl. Es ist schneller, zuverlässiger und seine Zitate schaffen sofort Vertrauen. Atlas fühlt sich eher wie eine Wette auf die Zukunft an. Großartig, wenn Sie bereits ChatGPT Plus-Benutzer sind und neugierig sind, wohin sich die Webautomatisierung entwickeln wird, auch angesichts der aktuellen Fehler. Es kommt wirklich darauf an, ob Sie heute einen soliden Forschungsassistenten oder einen frühen Job bei einem automatisierten Agenten suchen.

Häufig gestellte Fragen

Claude Haiku 4.5 ist das neueste kleine Modell von Anthropic, veröffentlicht am 15^Th Oktober an alle Benutzer. Es ist eine starke Erinnerung daran, dass Geschwindigkeit und Intelligenz keinen hohen Preis haben müssen.

Noch vor fünf Monaten galt Claude Sonnet 4 als Maßstab für ausgewogene Leistung. Jetzt bietet Haiku 4.5 nahezu die gleichen Programmier- und Argumentationsfähigkeiten bei einem Drittel der Kosten und mehr als der doppelten Geschwindigkeit.

Diese Model ist nicht nur ein weiteres Improve. Es zeigt, wie viel Fläche kleinere Modelle bei guter Konstruktion abdecken können. In diesem Artikel schauen wir uns an, was in Haiku 4.5 neu ist, wie es funktioniert und warum es wichtig ist.

Hintergrund: Wo Haiku in die Claude-Familie passt

Die Claude-Familie von Anthropic umfasst drei Kernmodelle Opus, SonettUnd Haiku. EJedes Modell ist für unterschiedliche Bedürfnisse konzipiert.

• Claude Opus ist das leistungsfähigste Modell. Es ist für tiefgreifendes Denken und komplexe Aufgaben konzipiert.
• Claude Sonett bietet ein Gleichgewicht zwischen Intelligenz und Effizienz. Es ist splendid für professionelle und geschäftliche Aufgaben.
• Claude Haiku ist der kleinste und schnellste der drei. Es wurde für Anwendungen entwickelt, die Geschwindigkeit, Skalierbarkeit und Kosteneffizienz erfordern.

Mit Haiku 4.5Anthropic hat dieses leichte Modell noch weiter vorangetrieben und bietet schnellere Reaktionen, verbesserte Programmierfähigkeiten und zuverlässige Genauigkeit bei minimalen Kosten. Es ist die ideale Wahl für Entwickler, die sowohl Leistung als auch Skalierbarkeit suchen.

Wichtige Verbesserungen in Haiku 4.5 gegenüber Haiku 3.5

Höchstleistung bei hoher Geschwindigkeit

Claude Haiku 4.5 bietet eine mit Sonnet 4 vergleichbare Leistung bei Argumentation, Codierung und komplexen Aufgaben, jedoch bei mehr als der doppelten Geschwindigkeit und einem Drittel der Kosten, was es splendid für Anwendungen mit hohem Volumen macht.

Erweiterte Denkfähigkeiten

Zum ersten Mal in der Haiku-Familie 4,5 Unterstützungen erweitertes Denkenwas erweitertes Denken ermöglicht:

• Greifen Sie auf interne Überlegungen zur Lösung komplexer Probleme zu
• Zusammengefasste Denkergebnisse für produktionsbereite Bereitstellungen
• Verschachteltes Denken zwischen Software-Aufrufen für mehrstufige Arbeitsabläufe
• Kontrollieren Sie die Token-Budgets, um Argumentationstiefe mit Geschwindigkeit in Einklang zu bringen

Kontextbewusstsein

Claude Haiku 4.5 stellt vor KontextbewusstseinDadurch kann das Modell seinen Konversationsraum effektiver verwalten:

• Verfolgung des Token-Budgets: Überwacht den verbleibenden Kontext nach jedem Software-Aufruf in Echtzeit
• Verbesserte Aufgabenpersistenz: Führt Aufgaben effizient aus, indem der verfügbare Platz erkannt wird
• Multikontext-Workflows: Behandelt Statusübergänge reibungslos über längere Sitzungen hinweg

Das ist das erstes Haiku-Modell um natives Kontextbewusstsein einzubeziehen.

Starke Codierung und Werkzeugnutzung

Claude Haiku 4.5 Angebote robuste Codierungsfunktionen und volle Software-Unterstützung:

• Programmierkenntnisse: Hervorragend bei der Codegenerierung, beim Debuggen und beim Refactoring
• Vollständige Software-Integration: Funktioniert mit allen Claude 4 Instruments, einschließlich Bash, Codeausführung, Texteditor, Websuche und Computernutzung
• Erweiterte Computernutzung: Optimiert für autonome Desktop- und Browser-Automatisierung
• Parallele Werkzeugausführung: Koordiniert mehrere Instruments effizient für komplexe Arbeitsabläufe

Benchmarks und vergleichende Bewertung

Bei Normal-Benchmarks übertrifft das Claude Haiku 4.5 sein Gewicht. Es passt Sonett 4.5 bei vielen Codierungs- und Argumentationstests und liefert dabei grob gesagt eine wesentlich bessere Effizienz ein Drittel der Kosten und vorbei doppelt so schnell bei durchsatz- und latenzempfindlichen Aufgaben.

Im Vergleich zu früheren Haiku-Versionen verbessert 4.5 den Token-pro-Sekunde-Durchsatz, die Multi-Software-Orchestrierung und die Multi-Flip-Kohärenz, wodurch es besonders stark für Echtzeitassistenten und Pipelines mit hohem Volumen ist.

Kurz gesagt: Haiku 4.5 bietet nahezu grenzenlose Genauigkeit mit einem klaren Vorsprung in Bezug auf Kostenleistung und Reaktionsfähigkeit.

Sicherheitsbewertungen

In seinen Sicherheitsbewertungen berichtet Anthropic, dass Claude Haiku 4.5 umfassende Ausrichtungstests mit geringen Raten an besorgniserregendem Verhalten und deutlichen Vorteilen gegenüber Haiku 3.5 bestanden hat. Automatisierte Auswertungen ergaben, dass Haiku 4.5 eine statistisch signifikant geringere Price an Fehlverhalten aufweist als Sonnet 4.5 und Opus 4.1, was es in dieser Hinsicht zum sichersten Modell des Unternehmens macht.

Exams ergaben außerdem nur begrenzte Risiken im Zusammenhang mit chemischen, biologischen, radiologischen und nuklearen (CBRN) Inhalten, sodass Haiku 4.5 unter AI Security Degree 2 (ASL-2) veröffentlicht wird, während Sonnet 4.5 und Opus 4.1 weiterhin unter ASL-3 eingestuft werden.

Aufgaben aus der realen Welt mit Haiku 4.5

In diesem Abschnitt werden wir dieses neueste LLM anhand von drei Hauptaufgaben testen:

Codierung

Aufforderung 1: „Erstellen Sie eine Webseite, auf der Objekte der Schwerkraft unterliegen und mit der Umgebung interagieren. Die Objekte können alles sein: Quadrate, Bilder oder Formen.

Ausgabe:

Hier können Sie es selbst ausprobieren: Claude

Rezension:

Es entstand eine gute Net-App, die den meisten Gesetzen der Physik folgte. Als Bonus habe ich Variationen für Masse und Elastizität hinzugefügt, diese wurden jedoch ignoriert. Bei der Simulation wurde die Schwerkraft korrekt angewendet (Objekte werden nach unten beschleunigt), und alle Objekte zeigten einen Drehimpuls. Allerdings hätte sich nach Kollisionen nur die runde Kugel weiterdrehen sollen, die anderen hätten stehen bleiben sollen, taten es aber nicht. Als ich auf dieses Downside hingewiesen habe, wurde das Verhalten korrigiert, obwohl die erste Antwort den zuvor erwähnten Fehler aufwies.

Argumentation

Immediate: „Das Diagramm stellt den Umsatzanteil der verschiedenen Unternehmen im Technologiesektor in Cuckooland dar. Analysieren Sie die Grafik und beantworten Sie Folgendes:

1. Im Jahr 2001 wuchs das Unternehmen mit dem schnellsten Wachstum um 100 %. Wie hoch conflict die Wachstumsrate des Unternehmens mit der geringsten Wachstumsrate?
2. Im Jahr 2002 betrug die Wachstumsrate des gesamten Sektors 39 %. Wie hoch conflict die absolute Wachstumsrate von SCT?
3. Der Gesamtumsatz im Jahr 2006 betrug 21,2 Milliarden US-Greenback, der Gesamtumsatz im Jahr 2005 betrug 18,1 Milliarden US-Greenback. Wie hoch conflict die absolute Wachstumsrate in Centure?
4. Im Jahr 2004 hat die gesamte Branche 4 Milliarden US-Greenback hinzugefügt, wovon COGN einen Anstieg von 1 Milliarde US-Greenback beisteuerte. Wie hoch conflict die Wachstumsrate der gesamten Branche im Jahr 2004?„

Ausgabe:

Argumentation:

Rezension:

Die erste Antwort ist falsch. Die richtige Antwort ist 33 %. Die erste Frage bestand aus drei Teilen: Zuerst sollte das Unternehmen mit dem höchsten Wachstum gefunden werden, dann das Unternehmen mit dem langsamsten Wachstum und schließlich das Wachstum des Unternehmens mit dem langsamsten Wachstum. Die ersten beiden Teile wurden zufriedenstellend abgeschlossen, im dritten Teil wurde jedoch nur die Änderung der Umsatzbeteiligung berechnet.

Aufforderung 2: „Zwei-Eier-Downside (schwere Model) Sie haben ein 100-stöckiges Gebäude und zwei identische Eier. Sie möchten die höchste Etage finden, aus der ein Ei fallen gelassen werden kann, ohne zu zerbrechen. Wie viele Tropfen sind im schlimmsten Fall mindestens nötig?„

Ausgabe:

Rezension:

Es hat hier gute Arbeit geleistet, indem es die richtige Antwort mit der richtigen Begründung und Mathematik dahinter gegeben hat.

Aufforderung 3: „Wenn eine Individual einen Goldbarren besitzt und einem Arbeiter an sechs aufeinanderfolgenden Tagen die gleiche Menge Gold zahlen muss, wie viele Kürzungen muss die Individual dann mindestens vornehmen?“

Ausgabe:

Rezension:

Es hat hier gute Arbeit geleistet und die richtige Antwort gegeben. Aber anstatt die Antwort direkt zu geben, wurde eine weitere Iteration durchgeführt.

Abschluss

Claude Haiku 4.5 beweist, dass kleine Modelle große Ergebnisse liefern können. Mit grenznaher Intelligenz, erweitertem Denken und blitzschnellen Reaktionen überbrückt es erfolgreich die Lücke zwischen Effizienz und Leistungsfähigkeit. Anthropic hat Haiku zu einem Modell verfeinert, das komplexe Codierungs- und Argumentationsaufgaben zu einem Bruchteil der Kosten ausführt, ohne Kompromisse bei Genauigkeit oder Sicherheit einzugehen.

In realen Exams zeigte Haiku 4.5 starke Programmierkenntnisse, logisches Denken und die Fähigkeit, sich an Benutzerfeedback anzupassen, wodurch es sowohl für Entwickler als auch für Unternehmen geeignet ist. Die Einbeziehung von erweitertem Denken, Kontextbewusstsein und verbesserter Werkzeugnutzung markiert eine bedeutende Weiterentwicklung in der Artwork und Weise, wie leichtgewichtige Modelle für groß angelegte, intelligente Arbeitsabläufe eingesetzt werden können.

Insgesamt ist Claude Haiku 4.5 ein kraftvoller Fortschritt für zugängliche Hochgeschwindigkeits-KI und bietet die perfekte Mischung aus Intelligenz, Leistung und Sicherheit für moderne Anwendungen.

Häufig gestellte Fragen

In letzter Zeit habe ich mich gefragt, ob ich wirklich noch kostenpflichtige Abonnements für ChatGPT oder Claude benötige. China hat ein beeindruckendes LLM nach dem anderen eingeführt, und das neueste, GLM 4.6, wird als eines der bisher besten gefeiert. Dieses Modell konkurriert Claude 4,5 Sonett in Codierung und Übereinstimmungen GPT-5 Und Gemini 2.5 Professional in der Texterstellung und Argumentation. Und hier ist der Clou: Während die großen Technologieanbieter für ähnliche Funktionen zwischen 10 und 30 US-Greenback professional Monat verlangen, haben Sie mit GLM 4.6 kostenlosen Zugriff auf alles. In diesem Beitrag befassen wir uns mit GLM 4.6, dem Zugriff darauf, seinen Funktionen, Leistungsbenchmarks und einem praktischen Check an realen Aufgaben.

Beginnen wir mit GLM 4.6!

Was ist GLM 4.6?

GLM 4.6 wurde von der chinesischen Firma Zhipu AI entwickelt und ist das neueste große Sprachmodell und ein Improve gegenüber seinem Vorgänger GLM 4.5. Es handelt sich um ein Textgenerierungsmodell, das ausschließlich mit Textual content als Eingabe und Ausgabe arbeitet. Das Modell umfasst verbesserte Codierungs-, Argumentations- und Agentenfunktionen, die es ihm ermöglichen, aus dem Satz verfügbarer Instruments proaktiv das richtige Device für eine bestimmte Aufgabe auszuwählen.

Hauptmerkmale von GLM 4.6

• Erweitertes Kontextfenster: GLM 4.6 verfügt über ein Kontextfenster von 200.000 Token, was deutlich größer ist als das 128.000-Fenster von GLM 4.5.
• Besseres Denken und bessere Agentenfähigkeiten: Das Modell zeigt eine verbesserte Argumentation und Agentenleistung. Es lässt sich reibungslos in Agenten-Frameworks integrieren und liefert konsistentere, zuverlässigere Ausgaben.
• Bessere Codierung: GLM 4.6 schneidet bei Codierungs-Benchmarks außergewöhnlich intestine ab und lässt sich effektiv in Instruments wie integrieren Claude CodeCline und Kilo-Code.

Das Beste daran?

Die Gewichte des GLM 4.6-Modells sind auf Hugging Face unter der MIT-Lizenz öffentlich verfügbar, was es zu einem Open-Entry-Modell macht. Tatsächlich liegt es derzeit auf Platz 1 unter den offenen Modellen und auf Platz 4 insgesamt LMArena-Rangliste.

Ist GLM 4.6 kostenlos oder kostenpflichtig?

Auf das Modell kann über seine Chat-Plattform frei zugegriffen werden. Dabei unterstützt Sie der Chatbot bei allen möglichen Aufgaben, sei es Texterstellung, Codierung, Bearbeitung. Für die API fallen jedoch einige Kosten an, die von der Nutzung und den Kosten für Eingabe- und Ausgabe-Tokens abhängen. Schließlich gibt es für GLM-4.6 einen Codierungsplan, bei dem die Gentle-Model etwa 3 US-Greenback professional Monat und die Professional-Model etwa 15 US-Greenback professional Monat kostet.

Wie greife ich auf GLM-4.6 zu?

Jeder kann über die Chat-Schnittstelle oder API auf dieses Modell zugreifen.

So greifen Sie über die Chat-Oberfläche darauf zu:

• Gehen Sie zu diesen Hyperlink.
• Melden Sie sich an oder registrieren Sie sich, um Ihr Konto zu erstellen.
• Wählen Sie aus der Dropdown-Liste oben in der Mitte des Bildschirms das Modell GLM-4.6 aus

• Fügen Sie die Eingabeaufforderung in die Chatbox in der Mitte des Bildschirms ein.

So greifen Sie über die API auf GLM-4.6 zu:

1. Besuchen diese Web site und klicken Sie auf „API-Schlüssel“.
2. Wenn Sie noch kein Konto haben, erstellen Sie ein neues Konto oder melden Sie sich bei Google an
3. Klicken Sie nun auf „Neuen API-Schlüssel erstellen“, geben Sie Ihrer API einen Namen und klicken Sie auf „Bestätigen“.

Aufgaben aus der Praxis mit GLM-4.6

In diesem Abschnitt werden wir dieses neueste LLM anhand von drei Hauptaufgaben testen:

1. Codierung
2. Argumentation
3. Agentenfähigkeiten

Beginnen wir mit dem ersten!

Codierung

Immediate: „Erstellen Sie eine Börsenanalyse-App, die den Menschen Vorschläge macht, wie sie ihre Investitionen basierend auf ihren zukünftigen Zielen diversifizieren können.“

Ausgabe:

Die vollständige Ausgabe finden Sie hier!

Rezension:

Ich habe mit diesem LLM eine hervorragende Leistung erzielt. Ich habe das Device „Full Stack“ ausgewählt, nachdem ich meine Eingabeaufforderung geschrieben hatte, um sicherzustellen, dass das Modell versteht, dass es einen Prototyp für meine Idee erstellen muss. Die Anfrage bestand darin, eine Marktanalyse-App zu erstellen, die den Nutzern dabei helfen könnte, herauszufinden, wie viel sie investieren sollten und wie sie ihre Investitionen an zukünftigen Zielen ausrichten können.

Die generierte Webseite enthielt mehrere Registerkarten: Dashboard, Anlageziele, Portfolioanalyse und KI-Empfehlungen. Jede Registerkarte diente einem klaren Zweck und half Benutzern dabei, ihre Investitionen basierend auf ihren Zielen zu planen, zu verfolgen und zu optimieren. Ich fand die gesamte Benutzeroberfläche benutzerfreundlich und interaktiv, insbesondere die Abschnitte zu Anlagezielen und KI-Empfehlungen, die umsetzbare Erkenntnisse und ein reibungsloses Erlebnis lieferten.

Argumentation

Immediate: „Analysieren Sie das Bild und beschreiben Sie, was passiert. Folgen Sie den Pfeilen, um die Entwicklung von Closed- und Open-Supply-Modellen im angezeigten Maßstab zu verfolgen. Interpretieren Sie, was das bedeutet, erkunden Sie seine Auswirkungen und bieten Sie einen gezielten, tiefen Einblick in die Zukunft von Open-Supply-Modellen. Untermauern Sie Ihre Schlussfolgerungen mit einfachen, klaren Diagrammen oder Bildern, um die Erkenntnisse leicht verständlich zu machen.“

Ausgabe:

Rezension:

Das Mannequin gab die Antwort zunächst auf Chinesisch, additionally bat ich es, sie auf Englisch bereitzustellen. Das Bild wurde korrekt gelesen und identifiziert, wo jedes LLM stand und wohin die Pfeile zeigten. Aber seine Begründung warfare nicht zutreffend. Die Interpretation des Modells warfare weit von dem entfernt, was das Bild andeutete.

Das Bild zeigte, dass die Kluft zwischen Open-Supply- und Closed-Supply-Modellen kleiner wird, das Modell sagte jedoch, dass die Kluft größer wird. Außerdem wurde eine Mindmap für die Zukunft von Open-Supply-Modellen erstellt, die zwar intestine aussah, deren Inhalt jedoch größtenteils falsch warfare.

Agentenfähigkeiten

Immediate: „Ich möchte die vollständige Liste der von Trump gegen verschiedene Länder verhängten Zölle, die Änderung der Steuersätze vor und nach der Einführung der Zölle und die möglichen Auswirkungen auf die Wirtschaft dieses Landes und der USA nach der Einführung dieser Zölle. Erstellen Sie eine Visualisierung der Gesamtzölle, die Trump verschiedenen Ländern auferlegt hat, und eine Grafik der wirtschaftlichen Auswirkungen.”

Ausgabe:

Rezension:

Auf den ersten Blick sieht die Ausgabe detailliert und vollständig aus. Es scheint alles abzudecken, wonach Sie gefragt haben. Aber wie immer ist es wichtig, es sorgfältig zu lesen, bevor man sich darauf verlässt. Das Modell beginnt intestine und erklärt die Auswirkungen der Trump-Zölle, doch die Probleme zeigen sich im Element. Die dort aufgeführten Tarifsätze wurden nur bis zum 9. April aktualisiert, und selbst nach mehreren Versuchen gelang es dem Modell nicht, die neuesten Daten einzubeziehen. Dies zeigt eine deutliche Einschränkung seiner Agentenfähigkeiten.

Leistung und Benchmarks

GLM 4.6 schneidet bei wichtigen Benchmarks für Argumentation, Codierung und Agentenaufgaben intestine ab und zeigt deutliche Verbesserungen gegenüber GLM 4.5 und konkurrierenden Modellen:

• ZIEL 25: Höchste Gesamtpunktzahl, führend im Denken mit Werkzeugen.
• GPQA und LiveCodeBench v6: Starke Leistung bei der Problemlösung und Codierungsgenauigkeit.
• BrowseComp: Deutliche Verbesserung bei Searching- und Verständnisaufgaben.
• SWE-Bench verifiziert: Wettbewerbsfähige Ergebnisse, ähnlich den Claude-Modellen.
• HLE & Terminal-Bench: Mäßige Ergebnisse mit Verbesserungspotenzial.
• τ²-Financial institution: Etwas hinter Claude Sonnet, aber immer noch solide.

Lesen Sie auch: 14 beliebte LLM-Benchmarks, die Sie im Jahr 2025 kennen sollten

Ist GLM-4.6 besser als GPT-5 oder Gemini 2.5 Professional oder Claude Sonnet 4.5?

Bisher denke ich, dass die Antwort auf diese Frage NEIN lautet. Das Modell verfügt über ein riesiges Kontextfenster, seine Argumentations- und Agentenfähigkeiten haben jedoch keine Probability gegen die Topmodelle von OpenAI oder Google. Das Modell ist schnell, halluziniert aber irgendwie in der Artwork und Weise, wie es Informationen abruft und verarbeitet. Was die Codierung betrifft, zeigt es deutliche Verbesserungen gegenüber dem letzten Modell und mit seinen Integrationen in High-Codierungstools wie Claude Code wird dieses Modell ein Begleiter für Codierer zu einem günstigeren Preis sein.

Weitere wichtige Veröffentlichungen:

Abschluss

GLM 4.6 ist kein Modell, das Sie für alltägliche Aufgaben verwenden würden. Obwohl es kostenlos ist, sind seine Antworten weniger zuverlässig als die anderer Modelle. LLMs haben sich in den letzten Monaten rasant verbessert, und viele offene Modelle weisen mittlerweile eine beeindruckende Ausgereiftheit auf. Im Vergleich dazu bleibt GLM 4.6 immer noch hinter diesem Normal zurück. Es hat jedoch positives Suggestions für seine Codierungsleistung erhalten. Wir können davon ausgehen, dass sich die Ergebnisse in den kommenden Tagen verbessern werden.

Probieren Sie es aus und lassen Sie mich wissen, ob Sie mit meiner Bewertung einverstanden sind.

Die meisten Unternehmen kämpfen mit den mit dem KI -Einsatz verbundenen Kosten und Latenz. Dieser Artikel zeigt, wie Sie ein hybrides System erstellen, das:

• Verfahren Sie 94,9% der Anfragen auf Kantengeräte (Antwortzeiten von Sub-20 ms)
• Reduziert die Inferenzkosten im Vergleich zu Cloud-Lösungen um 93,5%
• Hält 99,1% der ursprünglichen Modellgenauigkeit durch intelligente Quantisierung bei
• Hält wise Daten lokal, um die Einhaltung der Einhaltung zu erleichtern

Wir werden die vollständige Implementierung mit Code von der Domänenanpassung bis zur Produktionsüberwachung durchlaufen.

Das eigentliche Downside, von dem niemand spricht

Stellen Sie sich Folgendes vor: Sie haben ein ausgezeichnetes KI -Modell für den Kundensupport erstellt. Es funktioniert hervorragend in Ihrem Jupyter -Notizbuch. Wenn Sie es jedoch für die Produktion einsetzen, stellen Sie fest:

• Cloud Inferenz kostet 2.900 USD/Monat für anständige Verkehrsmengen
• Reaktionszeiten schweben etwa 200 ms (Kunden bemerken die Verzögerung)
• Information kreuzt die internationalen Grenzen (Compliance -Staff ist nicht glücklich)
• Kosten skalieren unvorhersehbar mit Verkehrspikes

Klingt vertraut? Du bist nicht allein. Laut Forbes Tech Council (2024) können bis zu 85% der KI -Modelle den erfolgreichen Einsatz nicht erreichen, wobei die Kosten und die Latenz die Hauptbarrieren sind.

Die Lösung: Denken Sie wie Flughafensicherheit nach

Was wäre, wenn wir könnten, anstatt jede Abfrage an ein massives Cloud -Modell zu senden:

• Behandeln Sie 95% der Routineanfragen vor Ort (wie die schnelle Spur des Flughafens Safety)
• Eskalieren Sie nur komplexe Fälle in die Cloud (sekundäres Screening)
• Führen Sie eine klare Aufzeichnung von Routing -Entscheidungen (für Audits) eindeutig.

Dieser „Kanten“ -Ansatz spiegelt wider, wie Menschen natürlich mit Unterstützungsanfragen umgehen. Erfahrene Agenten können die meisten Probleme schnell lösen und nur die kniffligen Spezialisten eskalieren.

Was wir zusammen aufbauen werden

Am Ende dieses Artikels haben Sie:

1. Ein domänen angepasstes Modell Das versteht die Kundendienstsprache
2. Eine 84% kleinere quantisierte Model Das läuft schnell auf der CPU
3. Ein intelligenter Router Das entscheidet über Edge vs. Cloud professional Abfrage
4. Produktionsüberwachung Alles gesund zu halten

Beginnen wir mit dem Codieren.

Umgebungsaufbau: Es wird vom ersten Tag an richtig gestrichen

Lassen Sie uns zunächst eine reproduzierbare Umgebung schaffen. Nichts tötet Schwung als einen Tag damit, Bibliothekskonflikte zu debuggen.

import os
import warnings
import numpy as np
import pandas as pd
import torch
import tensorflow as tf
from transformers import (
    DistilBertTokenizerFast, DistilBertForMaskedLM, 
    Coach, TrainingArguments, TFDistilBertForSequenceClassification
)
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
import onnxruntime as ort
import time
from collections import deque

def setup_reproducible_environment(seed=42):
    """Make outcomes reproducible throughout runs"""
    np.random.seed(seed)
    torch.manual_seed(seed)
    tf.random.set_seed(seed)
    torch.backends.cudnn.deterministic = True
    tf.config.experimental.enable_op_determinism()
    warnings.filterwarnings('ignore')
    print(f" Atmosphere configured (seed: {seed})")   

setup_reproducible_environment()

# {Hardware} specs for replica
SYSTEM_CONFIG = {
    "cpu": "Intel Xeon Silver 4314 @ 2.4GHz",
    "reminiscence": "64GB DDR4", 
    "os": "Ubuntu 22.04",
    "python": "3.10.12",
    "key_libs": {
        "torch": "2.7.1",
        "tensorflow": "2.14.0", 
        "transformers": "4.52.4",
        "onnxruntime": "1.17.3"
    }
}

# Venture construction
PATHS = {
    "knowledge": "./knowledge",
    "fashions": {
        "domain_adapted": "./fashions/dapt",
        "classifier": "./fashions/classifier",
        "onnx_fp32": "./fashions/onnx/model_fp32.onnx", 
        "onnx_quantized": "./fashions/onnx/model_quantized.onnx"
    },
    "logs": "./logs"
}

# Create directories
for path in PATHS.values():
    if isinstance(path, dict):
        for p in path.values():
            os.makedirs(os.path.dirname(p) if '.' in os.path.basename(p) else p, exist_ok=True)
    else:
        os.makedirs(path, exist_ok=True)

print(" Venture construction prepared")  # IMPROVED: Added emoji for consistency

Schritt 1: Domänenanpassung – Lehre KI, „Unterstützung“ zu sprechen, „Unterstützung“ zu sprechen.

Reguläre Sprachmodelle kennen Englisch, aber sie wissen nicht, wie es geht Englisch unterstützen. Es gibt einen großen Unterschied zwischen „Ich brauche Hilfe“ und „Das ist völlig inakzeptabel – ich fordere sofort mit einem Supervisor zu sprechen!“

Area-adaptive Pre-Coaching (DAPT) befasst sich mit dem Sprachlernen des Modells in den Kundendienstkonversationen, bevor Sie es zur Klassifizierung ausbilden.

class CustomerServiceTrainer:
    """Full pipeline for area adaptation + classification"""
    
    def __init__(self, base_model="distilbert-base-uncased"):
        self.base_model = base_model
        self.tokenizer = DistilBertTokenizerFast.from_pretrained(base_model)
        print(f" Initialized with {base_model}")   
    
    def domain_adaptation(self, texts, output_path, epochs=2, batch_size=32):
        """
        Section 1: Adapt mannequin to customer support language patterns
        
        That is like language immersion - the mannequin learns support-specific 
        vocabulary, escalation phrases, and customary interplay patterns.
        """
        from datasets import Dataset
        from transformers import DataCollatorForLanguageModeling
        
        print(f" Beginning area adaptation on {len(texts):,} conversations...")  
        
        # Create dataset for masked language modeling
        dataset = Dataset.from_dict({"textual content": texts}).map(
            lambda examples: self.tokenizer(
                examples("textual content"), 
                padding="max_length", 
                truncation=True, 
                max_length=128  # Maintain cheap for reminiscence
            ), 
            batched=True,
            remove_columns=("textual content")
        )
        
        # Initialize mannequin for continued pre-training
        mannequin = DistilBertForMaskedLM.from_pretrained(self.base_model)
        print(f"    Mannequin parameters: {mannequin.num_parameters():,}")   
        
        # Coaching setup
        training_args = TrainingArguments(
            output_dir=output_path,
            num_train_epochs=epochs,
            per_device_train_batch_size=batch_size,
            logging_steps=200,
            save_steps=1000,
            fp16=torch.cuda.is_available(),  # Use combined precision if GPU out there
        )
        
        coach = Coach(
            mannequin=mannequin,
            args=training_args,
            train_dataset=dataset,
            data_collator=DataCollatorForLanguageModeling(
                self.tokenizer, multilevel marketing=True, mlm_probability=0.15
            )
        )
        
        # Practice and save
        coach.prepare()
        coach.save_model(output_path)
        self.tokenizer.save_pretrained(output_path)
        
        print(f" Area adaptation full: {output_path}")   
        return output_path
    
    def train_classifier(self, X_train, X_val, y_train, y_val, 
                        dapt_model_path, output_path, epochs=8):
        """
        Section 2: Two-stage classification coaching
        
        Stage 1: Heat up classifier head (spine frozen)
        Stage 2: Tremendous-tune complete mannequin with smaller studying fee
        """
        from transformers import create_optimizer
        
        print(f" Coaching classifier on {len(X_train):,} samples...")   
        
        # Encode labels
        self.label_encoder = LabelEncoder()
        y_train_enc = self.label_encoder.fit_transform(y_train)
        y_val_enc = self.label_encoder.rework(y_val)
        
        print(f"    Lessons: {checklist(self.label_encoder.classes_)}")  
        
        # Create TensorFlow datasets
        def make_dataset(texts, labels, batch_size=128, shuffle=False):
            encodings = self.tokenizer(
                texts, padding="max_length", truncation=True,
                max_length=256, return_tensors="tf"  # Longer for classification
            )
            dataset = tf.knowledge.Dataset.from_tensor_slices((dict(encodings), labels))
            if shuffle:
                dataset = dataset.shuffle(10000, seed=42)
            return dataset.batch(batch_size).prefetch(tf.knowledge.AUTOTUNE)
        
        train_dataset = make_dataset(X_train, y_train_enc, shuffle=True)
        val_dataset = make_dataset(X_val, y_val_enc)
        
        # Load domain-adapted mannequin for classification
        mannequin = TFDistilBertForSequenceClassification.from_pretrained(
            dapt_model_path, num_labels=len(self.label_encoder.classes_)
        )
        
        # Optimizer with warmup
        total_steps = len(train_dataset) * epochs
        optimizer, _ = create_optimizer(
            init_lr=3e-5,
            num_train_steps=total_steps,
            num_warmup_steps=int(0.1 * total_steps)
        )
        
        mannequin.compile(
            optimizer=optimizer,
            loss='sparse_categorical_crossentropy',
            metrics=('accuracy')
        )
        
        # Stage 1: Classifier head warm-up
        print("    Stage 1: Warming up classifier head...")   
        mannequin.distilbert.trainable = False
        mannequin.match(train_dataset, validation_data=val_dataset, epochs=1, verbose=1)
        
        # Stage 2: Full fine-tuning  
        print("    Stage 2: Full mannequin fine-tuning...")   
        mannequin.distilbert.trainable = True
        mannequin.optimizer.learning_rate = 3e-6  # Smaller LR for stability
        
        # Add callbacks for higher coaching
        callbacks = (
            tf.keras.callbacks.EarlyStopping(endurance=2, restore_best_weights=True),
            tf.keras.callbacks.ReduceLROnPlateau(issue=0.5, endurance=1)
        )
        
        historical past = mannequin.match(
            train_dataset, 
            validation_data=val_dataset,
            epochs=epochs-1,  # Already did 1 epoch
            callbacks=callbacks,
            verbose=1
        )
        
        # Save every thing
        mannequin.save_pretrained(output_path)
        self.tokenizer.save_pretrained(output_path)
        
        import joblib
        joblib.dump(self.label_encoder, f"{output_path}/label_encoder.pkl")
        
        best_acc = max(historical past.historical past('val_accuracy'))
        print(f" Coaching full! Finest accuracy: {best_acc:.4f}")   
        
        return mannequin, historical past

# Let's create some pattern knowledge for demonstration
def create_sample_data(n_samples=5000):
    """Generate practical customer support knowledge for demo"""
    np.random.seed(42)
    
    # Pattern dialog templates
    templates = {
        'constructive': (
            "Thanks a lot for the wonderful customer support at this time!",
            "Nice job resolving my situation shortly and professionally.",
            "I actually admire the assistance with my account.",
            "The help group was improbable and really educated.",
            "Good service, precisely what I wanted."
        ),
        'adverse': ( 
            "That is fully unacceptable and I demand to talk with a supervisor!",
            "I am extraordinarily annoyed with the poor service high quality.",
            "This situation has been ongoing for weeks with out decision.",
            "Horrible expertise, worst customer support ever.",
            "I desire a full refund instantly, that is ridiculous."
        ),
        'impartial': (
            "I need assistance with my account settings please.",
            "Are you able to examine the standing of my current order?", 
            "What are what you are promoting hours and phone data?",
            "I've a query about billing and fee choices.",
            "Please assist me perceive the refund course of."
        )
    }
    
    knowledge = ()
    for _ in vary(n_samples):
        sentiment = np.random.alternative(('constructive', 'adverse', 'impartial'), 
                                   p=(0.4, 0.3, 0.3))  # Real looking distribution
        template = np.random.alternative(templates(sentiment))
        
        # Add some variation
        if np.random.random() < 0.2:  # 20% get account numbers
            template += f" My account quantity is {np.random.randint(100000, 999999)}."
        
        knowledge.append({
            'transcript': template,
            'sentiment': sentiment
        })
    
    df = pd.DataFrame(knowledge)
    print(f" Created {len(df):,} pattern conversations")   
    print(f" Sentiment distribution:n{df('sentiment').value_counts()}")  
    return df

# Execute area adaptation and classification coaching
coach = CustomerServiceTrainer()

# Create pattern knowledge (exchange along with your precise knowledge)
df = create_sample_data(5000)

# Cut up knowledge
X_train, X_val, y_train, y_val = train_test_split(
    df('transcript'), df('sentiment'), 
    test_size=0.2, stratify=df('sentiment'), random_state=42
)

# Run area adaptation
dapt_path = coach.domain_adaptation(
    df('transcript').tolist(), 
    PATHS('fashions')('domain_adapted'),
    epochs=2
)

# Practice classifier
mannequin, historical past = coach.train_classifier(
    X_train.tolist(), X_val.tolist(),
    y_train.tolist(), y_val.tolist(),
    dapt_path,
    PATHS('fashions')('classifier'),
    epochs=6
)

Schritt 2: Modellkomprimierung – die Reduzierung von 84% Größen

Für den Zaubertrick: Wir werden unser Modell um 84% komprimieren und gleichzeitig quick die gesamte Genauigkeit beibehalten. Dies macht den Einsatz von Edge ermöglicht.

Der wichtigste Einblick ist, dass die meisten neuronalen Netze überbetont werden. Sie verwenden 32-Bit-Gleitkomma-Zahlen, wenn 8-Bit-Ganzzahlen für die meisten Aufgaben intestine funktionieren. Es ist wie die Verwendung einer hochauflösenden Kamera, wenn eine Telefonkamera Ihnen das gleiche Ergebnis für soziale Medien liefert.

class ModelCompressor:
    """ONNX-based mannequin compression with complete validation"""
    
    def __init__(self, model_path):
        self.model_path = model_path
        self.tokenizer = DistilBertTokenizerFast.from_pretrained(model_path)
        print(f" Compressor prepared for {model_path}")
    
    def compress_to_onnx(self, fp32_output, quantized_output):
        """
        Two-step course of:
        1. Convert TensorFlow mannequin to ONNX (cross-platform format)
        2. Apply dynamic INT8 quantization (no calibration wanted)
        """
        from optimum.onnxruntime import ORTModelForSequenceClassification
        from onnxruntime.quantization import quantize_dynamic, QuantType
        
        print(" Step 1: Changing to ONNX format...")
        
        # Export to ONNX (this makes the mannequin transportable throughout platforms)
        ort_model = ORTModelForSequenceClassification.from_pretrained(
            self.model_path, export=True, supplier="CPUExecutionProvider"
        )
        ort_model.save_pretrained(os.path.dirname(fp32_output))
        
        # Rename to our desired path
        generated_path = os.path.be part of(os.path.dirname(fp32_output), "mannequin.onnx")
        if os.path.exists(generated_path):
            os.rename(generated_path, fp32_output)
        
        fp32_size = os.path.getsize(fp32_output) / (1024**2)  # MB
        print(f"    Unique ONNX mannequin: {fp32_size:.2f}MB")
        
        print(" Step 2: Making use of dynamic INT8 quantization...")
        
        # Dynamic quantization - no calibration dataset wanted!
        quantize_dynamic(
            model_input=fp32_output,
            model_output=quantized_output,
            op_types_to_quantize=(QuantType.QInt8, QuantType.QUInt8),
            weight_type=QuantType.QInt8,
            optimize_model=False  # Maintain optimization separate
        )
        
        quantized_size = os.path.getsize(quantized_output) / (1024**2)  # MB
        compression_ratio = (fp32_size - quantized_size) / fp32_size * 100
        
        print(f"    Quantized mannequin: {quantized_size:.2f}MB")   
        print(f"    Compression: {compression_ratio:.1f}% dimension discount")   
        
        return fp32_output, quantized_output, compression_ratio
    
    def benchmark_models(self, fp32_path, quantized_path, test_texts, test_labels):
        """
        Examine FP32 vs INT8 fashions on accuracy, pace, and dimension
        
        That is essential - we have to confirm our compression did not break something!
        """
        print(" Benchmarking mannequin efficiency...")   
        
        outcomes = {}
        
        for title, model_path in (("FP32 Unique", fp32_path), ("INT8 Quantized", quantized_path)):
            print(f"   Testing {title}...")
            
            # Load mannequin for inference
            session = ort.InferenceSession(model_path, suppliers=("CPUExecutionProvider"))
            
            # Check on consultant pattern (500 examples for pace)
            test_sample = min(500, len(test_texts))
            correct_predictions = 0
            latencies = ()
            
            # Heat up the mannequin (vital for truthful timing!)
            warmup_text = "Thanks in your assist with my order at this time"
            warmup_encoding = self.tokenizer(
                warmup_text, padding="max_length", truncation=True,
                max_length=256, return_tensors="np"
            )
            
            for _ in vary(10):  # 10 warmup runs
                _ = session.run(None, {
                    "input_ids": warmup_encoding("input_ids"),
                    "attention_mask": warmup_encoding("attention_mask")
                })
            
            # Precise benchmarking
            for i in vary(test_sample):
                textual content, true_label = test_texts(i), test_labels(i)
                
                encoding = self.tokenizer(
                    textual content, padding="max_length", truncation=True,
                    max_length=256, return_tensors="np"
                )
                
                # Time the inference
                start_time = time.perf_counter()
                outputs = session.run(None, {
                    "input_ids": encoding("input_ids"),
                    "attention_mask": encoding("attention_mask")
                })
                latency_ms = (time.perf_counter() - start_time) * 1000
                latencies.append(latency_ms)
                
                # Verify accuracy
                predicted_class = np.argmax(outputs(0))
                if predicted_class == true_label:
                    correct_predictions += 1
            
            # Calculate metrics
            accuracy = correct_predictions / test_sample
            mean_latency = np.imply(latencies)
            p95_latency = np.percentile(latencies, 95)
            model_size_mb = os.path.getsize(model_path) / (1024**2)
            
            outcomes(title) = {
                "accuracy": accuracy,
                "mean_latency_ms": mean_latency,
                "p95_latency_ms": p95_latency,
                "model_size_mb": model_size_mb,
                "throughput_qps": 1000 / mean_latency  # Queries per second
            }
            
            print(f"      ✓ Accuracy: {accuracy:.4f}")
            print(f"      ✓ Imply latency: {mean_latency:.2f}ms")
            print(f"      ✓ P95 latency: {p95_latency:.2f}ms")
            print(f"      ✓ Mannequin dimension: {model_size_mb:.2f}MB")
            print(f"      ✓ Throughput: {outcomes(title)('throughput_qps'):.1f} QPS")
        
        # Present the comparability
        if len(outcomes) == 2:
            fp32_results = outcomes("FP32 Unique") 
            int8_results = outcomes("INT8 Quantized")
            
            size_reduction = (1 - int8_results("model_size_mb") / fp32_results("model_size_mb")) * 100
            accuracy_retention = int8_results("accuracy") / fp32_results("accuracy")
            latency_change = ((int8_results("mean_latency_ms") - fp32_results("mean_latency_ms")) 
                             / fp32_results("mean_latency_ms")) * 100
            
            print(f"n Quantization Impression Abstract:")   
            print(f"    Measurement discount: {size_reduction:.1f}%")  
            print(f"    Accuracy retention: {accuracy_retention:.1%}")  
            print(f"    Latency change: {latency_change:+.1f}%")  
            print(f"    Reminiscence saved: {fp32_results('model_size_mb') - int8_results('model_size_mb'):.1f}MB")    
        
        return outcomes

# Execute mannequin compression
compressor = ModelCompressor(PATHS('fashions')('classifier'))

# Compress the mannequin
fp32_path, quantized_path, compression_ratio = compressor.compress_to_onnx(
    PATHS('fashions')('onnx_fp32'),
    PATHS('fashions')('onnx_quantized')
)

# Load check knowledge and label encoder for benchmarking  
import joblib
label_encoder = joblib.load(f"{PATHS('fashions')('classifier')}/label_encoder.pkl")
test_labels_encoded = label_encoder.rework(y_val(:500))

# Benchmark the fashions
benchmark_results = compressor.benchmark_models(
    fp32_path, quantized_path,
    X_val(:500).tolist(), test_labels_encoded
)   

Schritt 3: Der Good Router – entscheidende Rand vs. Cloud

Hier geschieht die Hybridmagie. Unser Router analysiert jede Kundenabfrage und bestimmt, ob sie lokal (am Rand) umgehen oder an die Cloud weiterleitet. Betrachten Sie es als einen intelligenten Verkehrscontroller.

Der Router berücksichtigt fünf Faktoren:

1. Textlänge – Längere Fragen bedeuten oft komplexe Probleme
2. Satzstruktur – Mehrere Klauseln deuten nuancierte Probleme vor
3. Emotionale Indikatoren – Wörter wie „frustrierte“ Signalkalationsbedürfnisse
4. Modellvertrauen – Wenn sich die KI nicht sicher ist, Weg zur Cloud
5. Eskalationsschlüsselwörter – „Supervisor“, „Beschwerde“ usw.

class IntelligentRouter:
    """
    Good routing system that maximizes edge utilization whereas sustaining high quality
    
    The core perception: 95% of buyer queries are routine and will be dealt with
    by a small, quick mannequin. The remaining 5% want the complete energy of the cloud.
    """
    
    def __init__(self, edge_model_path, cloud_model_path, tokenizer_path):
        # Load each fashions
        self.edge_session = ort.InferenceSession(
            edge_model_path, suppliers=("CPUExecutionProvider")
        )
        self.cloud_session = ort.InferenceSession(
            cloud_model_path, suppliers=("CPUExecutionProvider")  # Also can use GPU
        )
        
        # Load tokenizer and label encoder
        self.tokenizer = DistilBertTokenizerFast.from_pretrained(tokenizer_path)
        import joblib
        self.label_encoder = joblib.load(f"{tokenizer_path}/label_encoder.pkl")
        
        # Routing configuration (tuned by experimentation)
        self.complexity_threshold = 0.75    # Path to cloud if complexity > 0.75
        self.confidence_threshold = 0.90    # Path to cloud if confidence < 0.90
        self.edge_preference = 0.95         # 95% desire for edge when potential
        
        # Price monitoring (practical cloud pricing)
        self.prices = {
            "edge": 0.001,   # $0.001 per inference on edge
            "cloud": 0.0136  # $0.0136 per inference on cloud (OpenAI-like pricing)
        }
        
        # Efficiency metrics
        self.metrics = {
            "total_requests": 0,
            "edge_requests": 0,
            "cloud_requests": 0,
            "total_cost": 0.0,
            "routing_reasons": {}
        }
        
        print(" Good router initialized")
        print(f" Complexity threshold: {self.complexity_threshold}")
        print(f" Confidence threshold: {self.confidence_threshold}")
        print(f" Cloud/edge value ratio: {self.prices('cloud')/self.prices('edge'):.1f}x")
    
    def analyze_complexity(self, textual content, model_confidence):
        """
        Multi-dimensional complexity evaluation
        
        That is the guts of our routing logic. We have a look at a number of indicators
        to find out if a question wants the complete energy of the cloud mannequin.
        """
        
        # Issue 1: Size complexity (normalized by typical buyer messages)
        # Longer messages typically point out extra advanced points
        length_score = min(len(textual content) / 200, 1.0)  # 200 chars = typical message
        
        # Issue 2: Syntactic complexity (sentence construction)
        sentences = (s.strip() for s in textual content.cut up('.') if s.strip())
        phrases = textual content.cut up()
        
        if sentences and phrases:
            avg_sentence_length = len(phrases) / len(sentences)
            syntax_score = min(avg_sentence_length / 15, 1.0)  # 15 phrases = common
        else:
            syntax_score = 0.0
        
        # Issue 3: Mannequin uncertainty (inverse of confidence)
        # If the mannequin is not assured, it is most likely a posh case
        uncertainty_score = 1 - abs(2 * model_confidence - 1)
        
        # Issue 4: Escalation/emotional key phrases
        escalation_keywords = (
            'annoyed', 'indignant', 'unacceptable', 'supervisor', 'supervisor',
            'grievance', 'horrible', 'terrible', 'disgusted', 'livid'
        )
        
        keyword_matches = sum(1 for phrase in escalation_keywords if phrase in textual content.decrease())
        emotion_score = min(keyword_matches / 3, 1.0)  # Normalize to 0-1
        
        # Weighted mixture (weights tuned by experimentation)
        complexity = (
            0.3 * length_score +      # Size issues most
            0.3 * syntax_score +      # Construction is vital  
            0.2 * uncertainty_score + # Mannequin confidence
            0.2 * emotion_score       # Emotional indicators
        )
        
        return complexity, {
            'size': length_score,
            'syntax': syntax_score,
            'uncertainty': uncertainty_score,
            'emotion': emotion_score,
            'keyword_matches': keyword_matches
        }
    
    def route_queries(self, queries):
        """
        Predominant routing pipeline
        
        1. Get preliminary predictions from cloud mannequin (for confidence scores)
        2. Analyze complexity of every question
        3. Route easy queries to edge, advanced ones keep on cloud
        4. Return outcomes with routing choices logged
        """
        print(f" Routing {len(queries)} buyer queries...")
        
        # Step 1: Get cloud predictions for complexity evaluation
        cloud_predictions = self._run_inference(self.cloud_session, queries, "cloud")
        
        # Step 2: Analyze every question and make routing choices
        edge_queries = ()
        edge_indices = ()
        routing_decisions = ()
        
        for i, (question, cloud_result) in enumerate(zip(queries, cloud_predictions)):
            if "error" in cloud_result:
                # If cloud failed, drive to edge as fallback
                resolution = {
                    "route": "edge", 
                    "cause": "cloud_error",
                    "complexity": 0.0, 
                    "confidence": 0.0
                }
                edge_queries.append(question)
                edge_indices.append(i)
            else:
                # Analyze complexity
                complexity, breakdown = self.analyze_complexity(
                    question, cloud_result("confidence")
                )
                
                # Make routing resolution
                should_use_edge = (
                    complexity <= self.complexity_threshold and
                    cloud_result("confidence") >= self.confidence_threshold and
                    np.random.random() < self.edge_preference
                )
                
                # Decide cause for routing resolution
                if should_use_edge:
                    cause = "optimal_edge"
                    edge_queries.append(question)
                    edge_indices.append(i)
                else:
                    if complexity > self.complexity_threshold:
                        cause = "high_complexity"
                    elif cloud_result("confidence") < self.confidence_threshold:
                        cause = "low_confidence"
                    else:
                        cause = "random_cloud"
                
                resolution = {
                    "route": "edge" if should_use_edge else "cloud",
                    "cause": cause,
                    "complexity": complexity,
                    "confidence": cloud_result("confidence"),
                    "breakdown": breakdown
                }
            
            routing_decisions.append(resolution)
        
        # Step 3: Run edge inference for chosen queries
        if edge_queries:
            edge_results = self._run_inference(self.edge_session, edge_queries, "edge")
            
            # Change cloud outcomes with edge outcomes for routed queries
            for idx, edge_result in zip(edge_indices, edge_results):
                cloud_predictions(idx) = edge_result
        
        # Step 4: Add routing metadata and prices
        for i, (consequence, resolution) in enumerate(zip(cloud_predictions, routing_decisions)):
            consequence.replace(resolution)
            consequence("value") = self.prices(resolution("route"))
        
        # Step 5: Replace metrics
        edge_count = len(edge_queries)
        cloud_count = len(queries) - edge_count
        
        self.metrics("total_requests") += len(queries)
        self.metrics("edge_requests") += edge_count
        self.metrics("cloud_requests") += cloud_count
        
        batch_cost = edge_count * self.prices("edge") + cloud_count * self.prices("cloud")
        self.metrics("total_cost") += batch_cost
        
        # Monitor routing causes
        for resolution in routing_decisions:
            cause = resolution("cause")
            self.metrics("routing_reasons")(cause) = (
                self.metrics("routing_reasons").get(cause, 0) + 1
            )
        
        print(f" Routed: {edge_count} edge, {cloud_count} cloud")
        print(f" Batch value: ${batch_cost:.4f}")
        print(f" Edge utilization: {edge_count/len(queries):.1%}")
        
        return cloud_predictions, {
            "total_queries": len(queries),
            "edge_utilization": edge_count / len(queries),
            "batch_cost": batch_cost,
            "avg_complexity": np.imply((d("complexity") for d in routing_decisions))
        }
    
    def _run_inference(self, session, texts, supply):
        """Run batch inference with error dealing with"""
        strive:
            # Tokenize all texts
            encodings = self.tokenizer(
                texts, padding="max_length", truncation=True,
                max_length=256, return_tensors="np"
            )
            
            # Run inference
            outputs = session.run(None, {
                "input_ids": encodings("input_ids"),
                "attention_mask": encodings("attention_mask")
            })
            
            # Course of outcomes
            outcomes = ()
            for i, logits in enumerate(outputs(0)):
                predicted_class = int(np.argmax(logits))
                confidence = float(np.max(self._softmax(logits)))
                predicted_sentiment = self.label_encoder.inverse_transform((predicted_class))(0)
                
                outcomes.append({
                    "textual content": texts(i),
                    "predicted_class": predicted_class,
                    "predicted_sentiment": predicted_sentiment,
                    "confidence": confidence,
                    "processing_location": supply
                })
            
            return outcomes
            
        besides Exception as e:
            # Return error outcomes
            return ({"textual content": textual content, "error": str(e), "processing_location": supply} 
                   for textual content in texts)
    
    def _softmax(self, x):
        """Convert logits to possibilities"""
        exp_x = np.exp(x - np.max(x))
        return exp_x / np.sum(exp_x)
    
    def get_system_stats(self):
        """Get complete system statistics"""
        if self.metrics("total_requests") == 0:
            return {"error": "No requests processed"}
        
        # Calculate value financial savings vs cloud-only
        cloud_only_cost = self.metrics("total_requests") * self.prices("cloud")
        actual_cost = self.metrics("total_cost")
        savings_percent = (cloud_only_cost - actual_cost) / cloud_only_cost * 100
        
        return {
            "total_queries_processed": self.metrics("total_requests"),
            "edge_utilization": self.metrics("edge_requests") / self.metrics("total_requests"),
            "cloud_utilization": self.metrics("cloud_requests") / self.metrics("total_requests"), 
            "total_cost": self.metrics("total_cost"),
            "cost_per_query": self.metrics("total_cost") / self.metrics("total_requests"),
            "cost_savings_percent": savings_percent,
            "routing_reasons": dict(self.metrics("routing_reasons")),
            "estimated_monthly_savings": (cloud_only_cost - actual_cost) * 30
        }

# Initialize the router
router = IntelligentRouter(
    edge_model_path=PATHS('fashions')('onnx_quantized'),
    cloud_model_path=PATHS('fashions')('onnx_fp32'), 
    tokenizer_path=PATHS('fashions')('classifier')
)

# Check with practical buyer queries
test_queries = (
    "Thanks a lot for the wonderful customer support at this time!",
    "I am extraordinarily annoyed with this ongoing billing situation that has been occurring for 3 months regardless of a number of calls to your help group who appear fully unable to resolve these advanced account synchronization issues.",
    "Are you able to please assist me examine my order standing?",
    "What's your return coverage for faulty merchandise?",
    "That is fully unacceptable and I demand to talk with a supervisor instantly about these billing errors!",
    "My account quantity is 123456789 and I need assistance with the improve course of.",
    "Good day, I've a fast query about my current buy.",
    "The technical help group was unable to resolve my connectivity situation and I would like escalation to a senior specialist who can deal with enterprise community configuration issues."
)

# Route the queries
outcomes, batch_metrics = router.route_queries(test_queries)

# Show detailed outcomes
print(f"n DETAILED ROUTING ANALYSIS:")
for i, (question, consequence) in enumerate(zip(test_queries, outcomes)):
    route = consequence.get("processing_location", "unknown").higher()
    sentiment = consequence.get("predicted_sentiment", "unknown")
    confidence = consequence.get("confidence", 0)
    complexity = consequence.get("complexity", 0)
    cause = consequence.get("cause", "unknown")
    value = consequence.get("value", 0)
    
    print(f"nQuery {i+1}: "{question(:60)}..."")
    print(f"   Route: {route} (cause: {cause})")
    print(f"   Sentiment: {sentiment} (confidence: {confidence:.3f})")
    print(f"   Complexity: {complexity:.3f}")
    print(f"   Price: ${value:.6f}")

# Present system-wide efficiency
system_stats = router.get_system_stats()
print(f"n SYSTEM PERFORMANCE SUMMARY:")
print(f"   Whole queries: {system_stats('total_queries_processed')}")
print(f"   Edge utilization: {system_stats('edge_utilization'):.1%}")  
print(f"   Price per question: ${system_stats('cost_per_query'):.6f}")
print(f"   Price financial savings: {system_stats('cost_savings_percent'):.1f}%")
print(f"   Month-to-month financial savings estimate: ${system_stats('estimated_monthly_savings'):.2f}")

Schritt 4: Produktionsüberwachung – Halten Sie es gesund

Ein System ohne Überwachung ist ein System, das darauf wartet, zu scheitern. Unser Überwachungsaufbau ist leicht, aber wirksam, um die wichtigsten Probleme zu erfassen: Genauigkeitsabfälle, Kostenspitzen und Routingprobleme.

class ProductionMonitor:
    """
    Light-weight manufacturing monitoring for hybrid AI programs
    
    Tracks the metrics that really matter for enterprise outcomes:
    - Edge utilization (value affect)
    - Accuracy tendencies (high quality affect) 
    - Latency distribution (consumer expertise affect)
    - Price per question (funds affect)
    """
    
    def __init__(self, alert_thresholds=None):
        # Set wise defaults for alerts
        self.thresholds = alert_thresholds or {
            "min_edge_utilization": 0.80,  # Alert if < 80% edge utilization
            "min_accuracy": 0.85,          # Alert if accuracy drops under 85%
            "max_cost_per_query": 0.01,   # Alert if value > $0.01 per question
            "max_p95_latency": 150         # Alert if P95 latency > 150ms
        }
        
        # Environment friendly storage with ring buffers (memory-bounded)
        self.metrics_history = deque(maxlen=10000)  # ~1 week at 1 batch/minute
        self.alerts = ()
        
        print(" Manufacturing monitoring initialized")
        print(f"   Thresholds: {self.thresholds}")
    
    def log_batch(self, batch_metrics, accuracy=None, latencies=None):
        """
        Report batch efficiency and examine for points
        
        This will get known as after each batch of queries is processed.
        """
        timestamp = time.time()
        
        # Create efficiency report
        report = {
            "timestamp": timestamp,
            "edge_utilization": batch_metrics("edge_utilization"),
            "total_cost": batch_metrics("batch_cost"),
            "avg_complexity": batch_metrics.get("avg_complexity", 0),
            "query_count": batch_metrics("total_queries"),
            "accuracy": accuracy
        }
        
        # Add latency stats if offered
        if latencies:
            report.replace({
                "mean_latency": np.imply(latencies),
                "p95_latency": np.percentile(latencies, 95),
                "p99_latency": np.percentile(latencies, 99)
            })
        
        self.metrics_history.append(report)
        
        # Verify for alerts
        alerts = self._check_alerts(report)
        self.alerts.lengthen(alerts)
        
        if alerts:
            for alert in alerts:
                print(f" ALERT: {alert}")
    
    def _check_alerts(self, report):
        """Verify present metrics towards thresholds"""
        alerts = ()
        
        # Edge utilization alert
        if report("edge_utilization") < self.thresholds("min_edge_utilization"):
            alerts.append(
                f"Low edge utilization: {report('edge_utilization'):.1%} "
                f"< {self.thresholds('min_edge_utilization'):.1%}"
            )
        
        # Accuracy alert
        if report.get("accuracy") and report("accuracy") < self.thresholds("min_accuracy"):
            alerts.append(
                f"Low accuracy: {report('accuracy'):.3f} "
                f"< {self.thresholds('min_accuracy'):.3f}"
            )
        
        # Price alert
        cost_per_query = report("total_cost") / report("query_count")
        if cost_per_query > self.thresholds("max_cost_per_query"):
            alerts.append(
                f"Excessive value per question: ${cost_per_query:.4f} "
                f"> ${self.thresholds('max_cost_per_query'):.4f}"
            )
        
        # Latency alert
        if report.get("p95_latency") and report("p95_latency") > self.thresholds("max_p95_latency"):
            alerts.append(
                f"Excessive P95 latency: {report('p95_latency'):.1f}ms "
                f"> {self.thresholds('max_p95_latency')}ms"
            )
        
        return alerts
    
    def generate_health_report(self):
        """Generate complete system well being report"""
        if not self.metrics_history:
            return {"standing": "No knowledge out there"}
        
        # Analyze current efficiency (final 100 batches or 24 hours)
        now = time.time()
        recent_cutoff = now - (24 * 3600)  # 24 hours in the past
        
        recent_records = (
            r for r in self.metrics_history 
            if r("timestamp") > recent_cutoff
        )
        
        if not recent_records:
            recent_records = checklist(self.metrics_history)(-100:)  # Final 100 batches
        
        # Calculate key metrics
        total_queries = sum(r("query_count") for r in recent_records)
        total_cost = sum(r("total_cost") for r in recent_records)
        
        # Efficiency averages
        avg_metrics = {
            "edge_utilization": np.imply((r("edge_utilization") for r in recent_records)),
            "cost_per_query": total_cost / total_queries if total_queries > 0 else 0,
            "avg_complexity": np.imply((r.get("avg_complexity", 0) for r in recent_records))
        }
        
        # Accuracy evaluation (if out there)
        accuracy_records = (r("accuracy") for r in recent_records if r.get("accuracy"))
        if accuracy_records:
            avg_metrics.replace({
                "current_accuracy": accuracy_records(-1),
                "avg_accuracy": np.imply(accuracy_records),
                "accuracy_trend": self._calculate_trend(accuracy_records(-10:))
            })
        
        # Latency evaluation (if out there)  
        latency_records = (r.get("p95_latency") for r in recent_records if r.get("p95_latency"))
        if latency_records:
            avg_metrics.replace({
                "current_p95_latency": latency_records(-1),
                "avg_p95_latency": np.imply(latency_records),
                "latency_trend": self._calculate_trend(latency_records(-10:))
            })
        
        # Current alerts
        recent_alert_count = len(self.alerts) if self.alerts else 0
        
        # Total well being evaluation
        health_score = self._calculate_health_score(avg_metrics, recent_alert_count)
        
        return {
            "timestamp": now,
            "period_analyzed": f"{len(recent_records)} batches ({total_queries:,} queries)",
            "health_score": health_score,
            "health_status": self._get_health_status(health_score),
            "performance_metrics": avg_metrics,
            "recent_alerts": recent_alert_count,
            "suggestions": self._generate_recommendations(avg_metrics, recent_alert_count),
            "cost_analysis": {
                "total_cost_analyzed": total_cost,
                "daily_cost_estimate": total_cost * (86400 / (24 * 3600)),  # Scale to each day
                "monthly_cost_estimate": total_cost * (86400 * 30 / (24 * 3600))
            }
        }
    
    def _calculate_trend(self, values, min_samples=3):
        """Calculate if metrics are bettering, steady, or declining"""
        if len(values) < min_samples:
            return "insufficient_data"
        
        # Easy linear regression slope
        x = np.arange(len(values))
        slope = np.polyfit(x, values, 1)(0)
        
        # Decide significance
        std_dev = np.std(values)
        threshold = std_dev * 0.1  # 10% of std dev
        
        if abs(slope) < threshold:
            return "steady"
        elif slope > 0:
            return "bettering" 
        else:
            return "declining"
    
    def _calculate_health_score(self, metrics, alert_count):
        """Calculate total system well being (0-100)"""
        rating = 100
        
        # Penalize primarily based on metrics
        if metrics("edge_utilization") < 0.9:
            rating -= 10  # Edge utilization penalty
        if metrics("edge_utilization") < 0.8:
            rating -= 20  # Extreme edge utilization penalty
            
        if metrics.get("current_accuracy", 1.0) < 0.9:
            rating -= 15  # Accuracy penalty
        if metrics.get("current_accuracy", 1.0) < 0.8:
            rating -= 30  # Extreme accuracy penalty
            
        # Alert penalty
        rating -= min(alert_count * 5, 30)  # Max 30 level penalty for alerts
        
        return max(0, rating)
    
    def _get_health_status(self, rating):
        """Convert numeric well being rating to standing"""
        if rating >= 90:
            return "wonderful"
        elif rating >= 75:
            return "good"
        elif rating >= 60:
            return "truthful"
        elif rating >= 40:
            return "poor"
        else:
            return "important"
    
    def _generate_recommendations(self, metrics, alert_count):
        """Generate actionable suggestions"""
        suggestions = ()
        
        if metrics("edge_utilization") < 0.8:
            suggestions.append(
                f"Low edge utilization ({metrics('edge_utilization'):.1%}): "
                "Take into account decreasing complexity threshold or confidence threshold"
            )
        
        if metrics.get("current_accuracy", 1.0) < 0.85:
            suggestions.append(
                f"Low accuracy ({metrics.get('current_accuracy', 0):.3f}): "
                "Assessment mannequin efficiency and take into account retraining"
            )
        
        if metrics("cost_per_query") > 0.005:  # > $0.005 per question
            suggestions.append(
                f"Excessive value per question (${metrics('cost_per_query'):.4f}): "
                "Enhance edge utilization to cut back prices"
            )
        
        if alert_count > 5:
            suggestions.append(
                f"Excessive alert quantity ({alert_count}): "
                "Assessment alert thresholds and tackle underlying points"
            )
        
        if not suggestions:
            suggestions.append("System working inside regular parameters")
        
        return suggestions

# Initialize monitoring
monitor = ProductionMonitor()

# Log our batch efficiency
monitor.log_batch(batch_metrics)

# Generate well being report
health_report = monitor.generate_health_report()

print(f"n SYSTEM HEALTH REPORT:")
print(f" Well being Standing: {health_report('health_status').higher()} ({health_report('health_score')}/100)")
print(f" Interval: {health_report('period_analyzed')}")

print(f"n Key Metrics:")
for metric, worth in health_report('performance_metrics').objects():
    if isinstance(worth, float):
        if 'utilization' in metric:
            print(f"   {metric}: {worth:.1%}")
        elif 'value' in metric:
            print(f"   {metric}: ${worth:.4f}")
        else:
            print(f"   {metric}: {worth:.3f}")
    else:
        print(f"   {metric}: {worth}")

print(f"n Price Evaluation:")
for metric, worth in health_report('cost_analysis').objects():
    print(f"   {metric}: ${worth:.4f}")

print(f"n Suggestions:")
for i, rec in enumerate(health_report('suggestions'), 1):
    print(f"   {i}. {rec}")

Was wir gebaut haben: Ein produktionsbereites System

Machen wir einen Schritt zurück und schätzen, was wir erreicht haben:

1. Domänen angepasster Modell Das versteht die Kundendienstsprache
2. 84% kleineres quantisiertes Modell Das läuft auf Commonplace -CPU -{Hardware}
3. Good Router Das verarbeitet 95% der Abfragen lokal
4. Produktionsüberwachung Das fängt Probleme auf, bevor sie sich auf Benutzer auswirken

So sehen die Zahlen in der Praxis aus:

# Let's summarize our system's efficiency
print(" HYBRID EDGE-CLOUD AI SYSTEM PERFORMANCE")
print("=" * 50)

# Mannequin compression outcomes
fp32_size = benchmark_results("FP32 Unique")("model_size_mb")
int8_size = benchmark_results("INT8 Quantized")("model_size_mb") 
compression_ratio = (1 - int8_size/fp32_size) * 100

print(f" Mannequin Compression:")
print(f"   Unique dimension: {fp32_size:.1f}MB")
print(f"   Quantized dimension: {int8_size:.1f}MB")
print(f"   Compression: {compression_ratio:.1f}%")

# Accuracy retention
fp32_acc = benchmark_results("FP32 Unique")("accuracy")
int8_acc = benchmark_results("INT8 Quantized")("accuracy")
accuracy_retention = int8_acc / fp32_acc * 100

print(f"n Accuracy:")
print(f"   Unique accuracy: {fp32_acc:.3f}")
print(f"   Quantized accuracy: {int8_acc:.3f}")  
print(f"   Retention: {accuracy_retention:.1f}%")

# Efficiency metrics
fp32_latency = benchmark_results("FP32 Unique")("mean_latency_ms")
int8_latency = benchmark_results("INT8 Quantized")("mean_latency_ms")

print(f"n Efficiency:")
print(f"   FP32 imply latency: {fp32_latency:.1f}ms")
print(f"   INT8 imply latency: {int8_latency:.1f}ms")
print(f"   FP32 P95 latency: {benchmark_results('FP32 Unique')('p95_latency_ms'):.1f}ms")
print(f"   INT8 P95 latency: {benchmark_results('INT8 Quantized')('p95_latency_ms'):.1f}ms")

# Routing and value metrics  
system_stats = router.get_system_stats()
print(f"n Routing Effectivity:")
print(f"   Edge utilization: {system_stats('edge_utilization'):.1%}")
print(f"   Price financial savings: {system_stats('cost_savings_percent'):.1f}%")
print(f"   Price per question: ${system_stats('cost_per_query'):.6f}")

# System well being
print(f"n System Well being:")
print(f"   Standing: {health_report('health_status').higher()}")
print(f"   Rating: {health_report('health_score')}/100")
print(f"   Current alerts: {health_report('recent_alerts')}")

print("n" + "=" * 50)

Wichtige Take -Aways und nächste Schritte

Wir haben etwas Praktisches aufgebaut: ein hybrides KI-System, das Cloud-Qualitätsergebnisse zu Kosten und Latenzen auf Kantenebene liefert. Hier ist, was es funktioniert:

Die 95/5 Regel: Die meisten Kundenanfragen sind Routine. Ein intestine abgestimmtes kleines Modell kann sie perfekt umgehen und nur die wirklich komplexen Fälle für die Wolke hinterlassen.

Kompression ohne Kompromiss: Dynamic Int8 Quantisierung erreicht eine Größe von 84% mit minimaler Genauigkeitsverlust, wodurch die Notwendigkeit von Kalibrierungsdatensätzen beseitigt wird.

Intelligentes Routing: Unsere mehrdimensionale Komplexitätsanalyse stellt sicher, dass Abfragen aus den richtigen Gründen am richtigen Ort gehen.

Produktionsüberwachung: Einfache Warnungen für die wichtigsten Metriken halten das System gesund in der Produktion.

Wohin von hier aus gehen soll

Fang klein: Bereitstellen Sie zuerst in einer Teilmenge Ihres Datenverkehrs. Validieren Sie die Ergebnisse entsprechen Ihren Erwartungen, bevor Sie sich vergrößern.

Allmählich einstellen: Passen Sie die Routing-Schwellenwerte wöchentlich an, basierend auf Ihrer spezifischen Qualität im Vergleich zu den Kosten-Kompromisse.

Skalieren nachdenklich: Fügen Sie mehr Kantenknoten hinzu, wenn der Verkehr wächst. Die Architektur skaliert horizontal.

Lernen Sie weiter: Überwachen Sie Routing -Entscheidungen und Genauigkeitstrends. Die Daten leiten Ihre nächsten Optimierungen.

Das größere Bild

Hier geht es nicht nur um Kontaktzentren oder den Kundendienst. Das gleiche Muster funktioniert überall, wo Sie haben:

• Routineanfragen mit hohem Volumen gemischt mit gelegentlichen komplexen Fällen
• Kostensensitivität und Latenzanforderungen
• Compliance- oder Datensouveränitätsbedenken

Denken Sie an Ihre eigenen KI -Anwendungen. Wie viele sind wirklich komplex gegenüber Routine? Wir wetten, dass die meisten der 95/5 -Regel folgen und sie perfekte Kandidaten für diesen hybriden Ansatz machen.

In der Zukunft von AI geht es nicht um größere Modelle – es geht um intelligentere Architekturen. Systeme, die mehr mit weniger tun, Daten dort halten, wo sie hingehören, und kosten das, was Sie sich leisten können, um zu bezahlen.

Bereit, es selbst zu versuchen? Der vollständige Code ist in diesem Artikel verfügbar. Beginnen Sie mit Ihren eigenen Daten, befolgen Sie die Setup -Anweisungen und sehen Sie, wie Ihr 95/5 Cut up aussieht.

*Alle Bilder, sofern nicht anders angegeben, stammen vom Autor.

Referenzen und Ressourcen

• Forschungspapier: „Vergleichende Analyse von Edge vs. Cloud Contact Middle -Bereitstellungen: Eine technische und architektonische Perspektive“ – IEEE ICECCE 2025
• Komplettes Notizbuch: Alle Code aus diesem Artikel sind als reproduzierbares Jupyter -Notizbuch verfügbar
• Umgebungsspezifikationen: Intel Xeon Silver 4314, 64 GB RAM, Ubuntu 22.04, Python 3.10

Das hier beschriebene System repräsentiert unabhängige Forschung und ist nicht mit einem Arbeitgeber oder einer gewerblichen Einheit verbunden. Die Ergebnisse können je nach {Hardware}, Dateneigenschaften und domänenspezifischen Faktoren variieren.

Möchtest du Um die Implementierungsdetails zu besprechen oder Ihre Ergebnisse zu teilen? Bitte zögern Sie nicht, sich zu verbinden mit mir in den Kommentaren unten.

Verpassen Sie nie eine neue Ausgabe von Die Variableunser wöchentlicher E-newsletter mit einer erstklassigen Auswahl an Picks der Redakteure, Deep Dives, Group Information und mehr.

AI-betriebene Werkzeuge Neige dazu, excessive Reaktionen zu erzeugen: Auf der einen Seite haben wir das „Es ist Magie!“ und „das Beste aller Zeiten!“ Menge. Auf der anderen Seite finden wir das „Wir sind zum Scheitern verurteilt!“ Lager. Dies sind natürlich keine statischen oder monolithischen Gruppen. Möglicherweise befinden Sie sich sogar an beiden Enden des Spektrums – innerhalb eines einzigen Tags.

Wir denken, dass der beste Weg, Übertreibung zu widerstehen, darin besteht, zu prüfen, wie LLMs (und die Produkte, die sie ermöglicht haben) funktionieren und wie sie es nicht tun. Was sie erreichen können und wo sie weiter kämpfen.

Für nuancierte Ansätze für das Innenleben von KI -Instruments laden wir Sie ein, die Highlights dieser Woche zu erkunden. Sie werden mehr als ein paar Mythen gebrochen sehen und noch mehr Einsichten gewonnen.

---

Generative AI Mythen, Busted: Der schnelle Führer eines Ingenieurs

Angesichts der häufigen Fragen (und zunehmender Angst) über die Rolle und den Einfluss von AI, Amy Ma wollte ihren technischen Kollegen klar machen, worum es bei der Aufregung geht. Das Ergebnis ist ein klarer, zugänglicher und ebenerleiter Grundvorgang für eine Technologie, die selbst erfahrene Industrie -Tierärzte manchmal schwer zu verstehen haben.

KI sicher und verantwortungsbewusst einsetzen

Was braucht es, um vertrauenswürdige KI -Anwendungen aufzubauen? Stephanie Kirmer und einige ihrer jüngsten Co-Panelisten in IEEE werfen einen schneidenden und pragmatischen Blick auf einige der beständigsten Mythen rund um die AI-Ethik und ihre täglichen Herausforderungen, von der Beobachtbarkeit bis zur Regierungsführung.

Rag erklärte: Verständnis von Einbettungen, Ähnlichkeit und Abruf

Die retrieval-augmented-Era ist seit einiger Zeit bei uns, aber einige seiner Komponenten bleiben nicht untersucht. Der neueste Erklärer von Maria Mouschotzis befasst sich mit einigen allgemeineren Wissenslücken.

---

Die meistgelesenen Geschichten dieser Woche

Karrierewege, Datenanalysen und Unterricht mit AI: Erforschen Sie die Geschichten, die in der vergangenen Woche das größte Aufsehen in unserer Group erzielt haben.

Wie man maschinelles Lerningenieur (Schritt für Schritt) von Egor Howell wird

Meine Experimente mit NotebookLM für den Unterricht, von Parul Pandey

Von Python bis JavaScript: Ein Playbook für Datenanalysen in N8N mit Codeknotenbeispielen von Samir Saci

---

Andere empfohlene Lesevorgänge

Verpassen Sie nicht unsere neueste Ernte von herausragenden Artikeln, von immersiven tiefen Tauchgängen über die universelle Berechnung bis hin zu einem gründlichen Leitfaden zur kausalen Inferenz in den Einzelhandelsanalysen.

• Analyse der Umsatzverschiebung im Einzelhandel mit kausalen Auswirkungen: Eine Fallstudie bei Carrefour von Thanh Liêm Nguyen

• Implementierung des Kaffeemaschineprojekts in Python mit objektorientiertem Programmieren von Mahnoor Javed

• Erkundung von Verdienstreihenfolge und marginaler Kürzungskostenkurve in Python von Himalaya Bir Shrestha

• Schnellprototyping von Chatbots mit Strom und Kettenbeleuchtung von Chinmay Kakatkar

---

Zu tds beitragen

Wir lieben es, Artikel von neuen Autoren zu veröffentlichen. Wenn Sie additionally kürzlich ein interessantes Projektwechsel, Tutorial oder theoretische Reflexion über eines unserer Kernthemen geschrieben haben, warum nicht mit uns teilen?

---

Abonnieren Sie unseren E-newsletter

Wir alle sollten zugeben, dass der September der Monat conflict Gemini Nano Banane. Jeder hat mit dem Modell herumgespielt und schrullige Bearbeitungen und lustige Selfies in den sozialen Medien veröffentlicht. Die Chancen stehen intestine, dass Sie es auch ausprobiert haben oder zumindest ein Dutzend dieser Promi -Mashups und 3D -Figur -Pfosten in Ihrem Feed vorbeigefahren haben. Aber während Nano Banana die lässige Seite der Bildgenerierung dominiert hat, hat Qwen das professionelle Bearbeitungsspiel leise auferlegt. Erst letzten Monat hat das Workforce Qwen-Picture-Edit veröffentlicht, und jetzt sind sie mit einer verbesserten Model zurück: Qwen-Picture-Edit-2509, die sich auf Konsistenz, Flexibilität und Kontrolle konzentriert. Im Vergleich zur Veröffentlichung im August macht das neue Replace für Schöpfer, Entwickler und Forscher leistungsfähiger, während sie dennoch für alle zugänglich bleiben, die experimentieren möchten.

Wenn Sie mehr über das Vorgängermodell erfahren möchten, lesen Sie unseren detaillierten Artikel über Qwen-Picture-Edit!

Was ist neu in Qwen-Picture-Edit-2509?

Im Vergleich zur Veröffentlichung des letzten Monats führt diese Model vier wichtige Verbesserungen vor:

Multi-Picture-Bearbeitungsunterstützung

Mit Qwen-Picture-Edit-2509 können Sie jetzt mehrere Bilder gleichzeitig bearbeiten. Das Modell wurde unter Verwendung von Bildverzögerung geschult, wodurch nahtlose Bearbeitungen über Kombinationen hinweg wie folgt ermöglicht werden:

• Particular person + Particular person
• Particular person + Produkt
• Particular person + Szene

Es funktioniert am besten mit 1–3 Eingangsbildern und integriert sich auch intestine in ControlNET -Karten wie Tastoint für Pose -Änderungen.

Verbesserte Ein-Picture-Konsistenz

Bei der Bearbeitung eines einzelnen Bildes konzentriert sich das September -Replace stark auf die Konsistenz:

• Particular person Bearbeitung: Gesichter behalten ihre Identität über verschiedene Posen und Porträtstile hinweg.
• Produktbearbeitung: Logos und Objekte behalten ihr Aussehen bei und machen Produktplakate einfacher zu generieren.
• Textbearbeitung: Sie können nicht nur die Wörter ändern, sondern auch Schriftarten, Farben und Materialien mit Präzision anpassen.

Native ControlNET -Unterstützung

Das Replace fügt eine reibungslose Integration mit ControlNET -Eingängen wie Tiefenkarten, Edge -Karten und Tastoint -Karten hinzu und erweitert die kreative Kontrolle für technische und künstlerische Anwendungsfälle.

Verbesserte Textintegration + Bildintegration

Qwen-Picture-edit-2509 kann jetzt die Textbearbeitung nahtlos mit Bildmanipulation mischen. Das Entwerfen eines Posters, auf dem Schriftarten, Stile und Visuals konsequent interagieren.

Lesen Sie auch: Qwen3-omni Evaluation: Multimodales Kraftpaket oder überprüftes Versprechen?

Praktische Aufforderungen zum Versuchen mit Qwen-Picture-Edit-2509

Für all diese Aufgaben verwende ich sowohl Qwen-Picture-Edit-2509- als auch Nano-Banane, um die Ausgaben zu vergleichen und zu sehen, wie Qwen bei jeder Aufgabe funktioniert.

Aufgabe 1: Particular person + Particular person

Immediate: “Verwenden Sie Bild A und Bild B. Fucken Sie sie in ein Foto, auf dem beide Personen auf einer Parkbank sitzen. Gesichtsidentität und natürliche Beleuchtung bewahren. ““

Das neue Merkmal des QWEN Picture -Bearbeitungsmodells bemüht sich immer noch darum, die Gesichtszüge intakt zu halten. Wie Sie im obigen Bild sehen können, hat Nano Banane die Gesichter beider Menschen besser beibehalten. Qwen veränderte auch die Tasche im Originalbild, während Nano Banane sie unverändert hielt.

Aufgabe 2: Particular person + Szene

Immediate: „Legen Sie dieses Porträt nachts in eine geschäftige Tokyo -Straße mit Neonschildern. Halten Sie die Gesichtsidentität und den korrekten Hautton.“

Qwen hat großartige Arbeit geleistet, um die Gesichtsausdrücke und die allgemeine Bildqualität beizubehalten. Die Blitz- und Gesamtbildmischung sieht intestine aus. Nano Banane ging jedoch einen Schritt voraus und bearbeitete den Hintergrundlitz nach dem Foto, wodurch es realer aussah.

Aufgabe 3: Particular person + Produktanzeige

Immediate: „Verwenden Sie dieses Porträt und dieses Produktbild. Lassen Sie es wie eine Anzeige aussehen, in der die Particular person das Produkt hält. Halten Sie das Produktetikett lesbar.“

Für diese Aufgabe habe ich die Bilder sowohl des Modells als auch des Produkts in beide Modelle mit derselben Eingabeaufforderung hinzugefügt. Die Ausgabe von Qwen sieht besser aus, während die Nano -Banane die beiden Fotos einfach zusammengestellt hat, ohne viel darüber nachzudenken, sie zu kombinieren.

Aufgabe 4: Pose Management mit Tastoint Map stellen

Die folgenden Bilder zeigen den Prozess, bei dem eine Tastoint -Pose -Karte aus einem Bild verwendet wird, um eine bestimmte Haltung in ein anderes Bild in ein anderes Bild zu übertragen und gleichzeitig ihre Gesichtsidentität zu erhalten. Die Beispiele zeigen auch, wie diese Technologie mit anderen komplexen Bearbeitungsaufgaben kombiniert werden kann, z. B. das Ändern des Hintergrunds und die Manipulation von Objekten.

Ich habe diese neue Funktion von QWEN in der folgenden Eingabeaufforderung verwendet:

Immediate: „Verwenden Sie dieses Porträt und diese Tastoint -Pose -Karte. Rücken Sie die Particular person auf, um die Karte zu entsprechen und gleichzeitig die Gesichtsidentität zu halten.“

Qwen Picture Edit hat explizite Unterstützung für die keypointgestützte Bearbeitung. Deshalb synchronisierte Ihre Sketch + Tastoint Overlay perfekt. Es weiß, wie man die Keypoint -Karte liest, und dann die Technology zu konditionieren. Wenn Sie mit Posen, Blickwinkeln, Haltung oder Interaktionen mit Orientierungspunkten spielen möchten (wie Eiffelturm, Qutub Minar, Taj Mahal, Akshardham), sollten Sie sich bei Qwen Picture Edit (oder einem Modell, in dem „Pose Management“ / „Keypoint Conditioning“) festhalten.

Nano Banane hat jedoch keine Keypoint-Map-Konditionierungspipeline. Aus diesem Grund hat es gerade Ihr Eingabebild ohne Änderungen wieder aufgenommen: Es kann nach Stil, Textur, Hintergrund-Swaps usw. bearbeiten, aber es analysiert oder durchsetzen Sie keine Karten von Menschen/Objekten.

Aufgabe 5: Textual content zum Bild hinzufügen

Immediate: „Das Mädchen im hochgeladenen Bild hält eine Kreidebrett mit dem Textual content“ Mach mich meiner Genai -Meisterklasse an, um ein Experte im Jahr 2025 „zu werden“, geschrieben darauf.

Zwischen den beiden Antworten ist Qwens Ausgabe eindeutig besser. In der QWEN -Model sitzt der Textual content auf natürliche Weise auf der Tafel, ist ordnungsgemäß mit der Perspektive ausgerichtet und sieht so aus, als ob er tatsächlich auf eine Tafel gehört. Der Schriftstil ist konsistent, sauber und sehr lesbar, wodurch die Botschaft klarer wirkt. Der Textual content fügt sich nahtlos in die Boardoberfläche ein, sodass sich das Endergebnis authentisch und realistisch anfühlt.

Andererseits sieht Geminis Antwort eher wie eine digitale Overlay aus. Die Textausrichtung stimmt nicht vollständig mit dem Winkel des Boards überein, und der Schriftartstil erscheint weniger wie Kreideschreiben als eher wie digitale Standardtext. Aus diesem Grund fühlt sich der Textual content so an, als würde er eher auf das Board geklebt als in ihn integriert.

Aufgabe 6: Cartoon- oder Anime -Variante

Immediate: „Verwandeln Sie dieses Bild in einen Anime -Stil -Charakter, während Sie die gleiche Gesichtsidentität und denselben Ausdruck erhalten.“

Zwischen den beiden Ergebnissen ist die Model von Qwen-Picture-Edit-2509 eindeutig besser, da sie die Particular person vollständig in einen Anime-Stil-Charakter verwandelt und gleichzeitig das gleiche Outfit, das gleiche Pose und den Ausdruck beibehält, und es der Aufgabe der Aufgabe treu, während Nano-Banana-Model quick identisch mit dem Enter-Foto mit einem kleinen Anime-Stylizing-Retouch-Retouch-Retouch-Retouch-Retouch-Retoucher-Erfordernis und einem Anime-Erfordernis und dem Anfordern.

Aufgabe 7: Produktplakat

Immediate: „Machen Sie eine saubere marktfähige Poster für diesen Schuh. Verwenden Sie einen einfachen Hintergrund. Fügen Sie den Produktnamen unten fettem Typ hinzu – Soulshoe „.

Zwischen den beiden ist Qwens Poster besser, weil es über ein einfaches Schaufenster hinausgeht und das Produkt tatsächlich vermarktet. Der leuchtende Effekt lässt die Schuhe hervorheben, der Slogan „Wo Consolation trifft Model“ fügt emotionale Anziehungskraft hinzu, und der Abzeichen „Restricted Version“ schafft Dringlichkeit, die sie alle wie eine polierte Werbekampagne aussehen lässt, während Geminis Ausgabe, obwohl sie sauber und professionell ist, eher wie ein einfaches Katalogbild als ein marktfähiges Poster anfühlt.

Mein Urteil

Nano Banane macht Spaß, ist zugänglich und sofort gemeinsam genutzt. Perfekt für Meme, Selfies und soziale Tendencies. Qwen hingegen ist strukturiert, vielseitig und produktionsbereit, was es zur besseren Wahl für Schöpfer, Designer und Fachkräfte macht, die Zuverlässigkeit in Bezug auf Outputs wünschen.

Lesen Sie auch:

Abschluss

KI -Bildmodelle verbessern sich Monat zu Monat. August gab uns das erste Qwen -Bild. Der September hat uns diese neue Model mit Multi -Picture -Unterstützung und besserer Konsistenz gegeben. Nächsten Monat, wer weiß, was kommen wird. Wenn Sie es lieben, zu experimentieren, öffnen Sie Qwen Chat und probieren Sie die Aufforderungen aus, die ich geteilt habe. Beginnen Sie mit etwas Einfachem, als sich selbst in einen neuen Hintergrund zu setzen. Wechseln Sie dann zu Multi -Bild -Bearbeitungen und -Plaksen.

Ich werde weiter testen und teilen, was funktioniert. Wenn Sie eine dieser Eingaben ausprobieren, lassen Sie mich wissen, welches Ergebnis Sie haben. Manchmal ist der Spaß in den Überraschungen.