Zwillingsmodelle haben immer mit den Fortschritten der KI Schritt gehalten. Von textbasierten Chatbots im Jahr 2023 hat sich Gemini zu einem multimodalen System entwickelt, das in der Lage ist, Textual content, Audio, Bilder usw. zu verstehen und zu generieren. und jetzt Movies.

Die Erstellung von KI-Movies ist kein eigenständiges Software mehr. Mit Zwillinge OmniVideoerstellung wird zum Mainstream.

Zwillinge Omni ist nicht wichtig, weil es Movies generiert.

Dies ist wichtig, da die Videogenerierung zu einer weiteren Funktion eines KI-Assistenten wird

Bei richtiger Anwendung können die Anwendungsfälle dafür tatsächlich sehr kreativ sein (wenn man über die Leitplanken hinausschauen kann).

Satz oder Bild → Video

Ja, du hast es richtig gelesen. Zumindest kann Gemini Omni mit einem einzelnen Bild oder einer Textzeile arbeiten ein ganzes Video!

Dies ist möglich, weil Gemini Omni Textual content, Bilder, Audio und Video nicht als separate Aufgaben behandelt.

Stattdessen versteht es sie als verschiedene Formen von Informationen. Als Ergebnis eine einfache Eingabeaufforderung wie „Eine Drohne fliegt bei Sonnenaufgang über schneebedeckte Berge“ kann zu einer vollständigen Videosequenz mit Bewegung, Szenenübergängen und filmischen Particulars erweitert werden.

Ebenso können Benutzer ein statisches Bild bereitstellen und Gemini Omni bitten, es zu animieren, wodurch natürliche Kamerabewegungen, Objektbewegungen und Umgebungseffekte aus einer einzigen visuellen Eingabe erzeugt werden.

Anwendungsfälle von Gemini Omni

Hier sind die 3 Hauptanwendungsfälle für Gemini Omni:

1. Bild-zu-Video-Generierung

Prüfen: Laden Sie ein Bild hoch und animieren Sie es in ein Video.

Immediate: „Dies ist die Silhouette einer fiktiven mörderähnlichen Figur (wie die Hauptfigur in American Psyc*o). Ich möchte, dass Sie sie auf eine Weise animieren, die eine heimliche, gefährliche Persönlichkeit vermittelt und gleichzeitig den Stil des Movies mit dem Bild im Einklang hält.“

Ergebnis:

Abgesehen von der Hintergrundmusik warfare das Video großartig. Der Stil wurde einigermaßen vom Eingabebild übernommen (obwohl ich wollte, dass alles 2D-codiert ist).

Notiz: Obwohl bei dieser Aufgabe nur ein Bild für die Videogenerierung verwendet werden sollte, musste eine zusätzliche Eingabeaufforderung für einen bestimmten Kontext bereitgestellt werden.

2. Textual content-zu-Video-Generierung

Prüfen: Generieren Sie eine filmische Szene nur mit einer Textaufforderung.

Immediate:

TITLE: The Cloud Painter
STYLE: Whimsical animated brief movie. Charming, lighthearted, visually polished. Delicate storybook aesthetic. Excessive-quality animation. Constant character design all through the complete video.
PROMPT:
A small, spherical white rabbit sporting a yellow raincoat stands alone in an unlimited inexperienced meadow beneath an overcast sky.
The rabbit stays the identical dimension, look, clothes, and proportions all through the complete video.
In its paw, the rabbit holds a tiny paintbrush that glows with comfortable golden mild.
Curious, the rabbit reaches upward and gently paints a streak throughout a low-hanging cloud.
Wherever the comb touches, the grey cloud transforms into colourful shapes.
The rabbit paints a small fish-shaped cloud. The fish lazily swims by the sky.
The rabbit laughs and paints a bird-shaped cloud. The cloud chicken flaps its wings and joins the fish.
Excited, the rabbit continues portray. The sky step by step fills with playful cloud creatures: whales, turtles, foxes, and dragons, all made fully from comfortable fluffy clouds.
The rabbit by no means adjustments clothes, by no means adjustments species, and all the time stays a small white rabbit in a yellow raincoat.
A delicate breeze carries the cloud creatures throughout the sky. The rabbit watches proudly from the meadow under.
Golden daylight slowly breaks by the clouds, illuminating the scene with heat afternoon mild.
The cloud animals collect overhead and kind an enormous coronary heart form within the sky.
The rabbit sits quietly within the grass and admires its work.
Remaining shot: a large cinematic view of the meadow, the rabbit sitting peacefully beneath a sky crammed with stunning dwelling cloud creatures drifting into the sundown.
VISUAL REQUIREMENTS:
• One character solely
• Constant rabbit look in each shot
• Constant yellow raincoat
• Delicate pastel shade palette
• Mild digicam actions
• Storybook-quality visuals
• Cute however elegant design
• No dialogue
• Excessive visible coherence
• Clean animation
• Sturdy character consistency
NEGATIVE PROMPT:
Character altering look, altering clothes, additional limbs, lacking limbs, human arms, life like people, a number of rabbits, duplicated characters, distorted anatomy, flickering objects, inconsistent proportions, textual content, subtitles, watermark, emblem, horror, darkness, aggressive motion, chaotic movement.

Ergebnis:

Ein tolles Video zur Aufforderung, das bereitgestellt wurde. Die Animation entsprach der Aufforderung.

Notiz: A adverse Aufforderung ist im Grunde eine Liste von Dingen, die Sie dem Modell mitteilen:

Bitte tun Sie das nicht.

Stellen Sie sich die Hauptaufforderung als Beschleuniger und die adverse Aufforderung als Leitplanke vor.

3. Movies bearbeiten

Prüfen: Verwenden Sie ein Video als Eingabe und bearbeiten Sie es entsprechend der Aufforderung.

Immediate: „Drehen Sie dieses Video meines Gameplays im Anime-Stil. Schwarz-Weiß-Panels und all das gute Zeug.“

Ergebnis:

Endgültiges Urteil

Diese drei Exams decken die meisten realen Anwendungsfälle ab: Erstellen von Movies von Grund auf, Animieren vorhandener Bilder und Wahrung der Konsistenz mithilfe von Referenzbildern. Zusammen ergeben sie ein klares Bild davon, wo sich Gemini Omni auszeichnet und wo seine aktuellen Grenzen deutlich werden.

Wo Gemini Omni immer noch zu kurz kommt

Hier sind einige der Einschränkungen von Gemini Omni:

• Das Nutzungslimit erschöpft sich bei der Erstellung von maximal 3–5 Movies. Ein einzelnes 10-Sekunden-Video für diesen Artikel verbrauchte etwa 22 % des Nutzungslimits.

• Die Videodauer ist auf ca. begrenzt 10 Sekunden bei max.
• Generierte Movies enthalten KI-Wasserzeichen über SynthID.
• Für den Zugriff ist ein kostenpflichtiger Google AI-Plan erforderlich: Plus, Professional oder Extremely.
• Sie können nur ein Video als Eingabe/Referenz hochladen.
• Einige Funktionen sind regional beschränkt, insbesondere Avatare und Video-zu-Video-Bearbeitung.
• Die Nutzungsbeschränkungen hängen vom Plan des Benutzers ab und können aufgrund der Videogenerierung schnell erreicht werden mehr Rechenleistung.
• Je nach Richtlinien und Verfügbarkeit funktionieren bestimmte Ähnlichkeits-/Avatarfunktionen möglicherweise nicht mit allen persönlichen oder menschlichen Bildern.

Das größte Drawback von Gemini Omni ist Urheberrechtsrichtlinie Und Leitplanken Dritter. Sie könnten quick nie mit einem Inhalt arbeiten, der Folgendes zeigt:

1. Besteht aus einem Promi
2. Die Quelle stammt von einer seriösen Stelle im Web

Selbst wenn Sie etwas völlig Neues hochladen, werden Sie möglicherweise mit Folgendem begrüßt:

Die Dauer der Videogenerierung (in den meisten Fällen < eine Minute) und die Nutzungsbeschränkungen sind zweitrangige Probleme. Für mich warfare die ständige Verweigerung der Zeugung aus unterschiedlichen Gründen der ärgerlichste Teil meiner Erfahrung mit Gemini Omni.

So greifen Sie auf Gemini Omni zu

Es gibt zwei Möglichkeiten, auf Gemini Omni zuzugreifen:

• Gemini-Abonnements: Verwenden Sie Folgendes kostenpflichtige Abonnements:
  • Google AI Plus
  • Google AI Professional
  • Google AI Extremely
• Entwicklerzugriff: Entwickler können darauf zugreifen über:

Zugangsbeschränkungen und Verfügbarkeit können je nach Tarif und Area variieren. Gemini verwendet rechenbasierte Grenzwerte, die je nach Komplexität des Movies, seiner Größe und anderen Faktoren variieren.

Abschluss

Gemini Omni macht eines klar: Die KI-Videogenerierung ist keine eigenständige Neuheit mehr. In den Bereichen Bild-zu-Video, Textual content-zu-Video und Videobearbeitung zeigt es, wie aus einer einfachen Aufforderung oder Referenz eine brauchbare visuelle Sequenz mit überraschender Geschwindigkeit, Stil und kreativer Bandbreite werden kann.

Aber das Erlebnis ist nicht reibungslos. Kurze Laufzeiten, Nutzungsbeschränkungen, Wasserzeichen, regionale EinschränkungenUnd strenge InhaltsleitlinieIch halte es immer noch zurück. Im Second scheint Gemini Omni ein beeindruckender Einblick in die nahtlose Videogenerierung der Zukunft zu sein.

Bild vom Autor

# Einführung

Wir alle wissen, dass es einfach schwierig ist, eine neue Codebasis zu verstehen. Sie öffnen eine Datei nach der anderen, lesen sich Kommentare durch, die wenig Sinn ergeben, und versuchen herauszufinden, wie verschiedene Teile zusammenhängen. Dabei spielt es keine Rolle, ob Sie in der Forschung tätig sind oder in einem Unternehmen arbeiten; es ist der gleiche Kampf. Aber KI-Instruments machen diesen Weg einfacher. Sie können die Funktionsweise des Codes abbilden, Ihnen schnelle Zusammenfassungen geben und Fragen beantworten, wie es ein Kollege tun würde. Es geht viel schneller, als alles von Hand zu erledigen. Schauen wir uns fünf solcher Instruments an, die wirklich helfen.

# 1. Google Code Wiki

Google Code Wiki ist ein KI-basiertes Dokumentationstool. Es scannt ein Repository nach jedem Commit und erstellt eine strukturierte Dokumentation. Es kann Diagramme hinzufügen und verschiedene Teile des Codes miteinander verknüpfen. Es gibt auch eine Chat-Oberfläche, die auf der Gemini-KI von Google basiert. Sie können Fragen zum Code in natürlicher Sprache stellen. Code Wiki befindet sich derzeit in der öffentlichen Vorschau und ist für öffentliche Repositories kostenlos. Personal Repositories werden über eine Warteliste mit einem CLI-Device unterstützt.

# 2. DeepWiki

DeepWiki generiert interaktive Dokumentation für jedes GitHub-Repo. Sie geben einfach die Repo-URL ein und es werden strukturierte Dokumente mit Architektur- und Moduldiagrammen erstellt. Sie können auch Fragen zum Code in einer Konversationsoberfläche stellen. Die Hauptfunktionen sind für öffentliche Repositories kostenlos. Unternehmensfunktionen wie privater Repo-Help und dedizierter Help sind zu individuellen Preisen verfügbar.

# 3. Erklären Sie GitHub

Erklären SieGitHub hilft Ihnen, GitHub-Repositories schnell zu erkunden. Sie erhalten schnelle Zusammenfassungen, visuelle Karten und einen KI-Chat, der Fragen zu Funktionen, Struktur und Architektur beantwortet. Es ist für öffentliche Repositories kostenlos und Sie müssen sich nicht anmelden oder abonnieren. Es wurde entwickelt, um die Code-Exploration zu vereinfachen.

# 4. GitDocs AI

GitDocs KI hilft Ihnen beim Schreiben der Dokumentation für Ihren Code. Es generiert automatisch README-Dateien und andere Dokumente. Die KI durchsucht Ihr Repo und erstellt Abschnitte, Beispiele und Vorlagen. Es stellt eine direkte Verbindung zu GitHub her und ermöglicht die Bearbeitung und Vorschau. Es gibt eine kostenlose Model und kostenpflichtige Pläne sind für erweiterte Funktionen oder die Teamnutzung verfügbar.

# 5. GitSummarize

GitSummarize verwandelt ein GitHub-Repo in einen vollständigen Dokumentations-Hub. Es erstellt automatisch Zusammenfassungen und Dokumente. Dies erleichtert das Verständnis großer, komplexer Codebasen. Es ist kostenlos, es auszuprobieren. Es ist Open Supply mit einer Neighborhood dahinter. Bezahlte Pläne oder Unternehmenspreise werden nicht klar aufgeführt.

# Zusammenfassung

• Am besten zum Verständnis ganzer Codebasen geeignet: CodeWiki und DeepWiki
• Einfachste Sofortcode-Erklärung: ExplainGitHub
• Beste README-Datei/Dokumenterstellung: GitDocs AI
• Detaillierter Dokumentations-Hub mit Architekturvisualisierungen: GitSummarize

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und ein technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Technology Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.

Einführung

Zeitreihendaten Normalerweise ist ein tiefgreifendes Verständnis erforderlich, um effektive und aufschlussreiche Prognosemodelle zu erstellen. Zwei Schlüsseleigenschaften sind bei der Zeitreihenvorhersage von entscheidender Bedeutung: Darstellung und Granularität.

• Bei der Darstellung geht es darum, zeitliche Rohdaten – z. B. tägliche oder stündliche Messungen – mithilfe sinnvoller Ansätze in aussagekräftige Muster umzuwandeln
• Bei der Granularität geht es darum, zu analysieren, wie genau solche Muster Variationen im Zeitverlauf erfassen.

Als zwei Seiten derselben Medaille sind ihre Unterschiede subtil, aber eines ist sicher: Beide werden durch erreicht Function-Engineering.

In diesem Artikel werden 10 einfache Python-Einzeiler zum Generieren von Zeitreihenfunktionen basierend auf verschiedenen Merkmalen und Eigenschaften vorgestellt, die den Rohzeitreihendaten zugrunde liegen. Diese Einzeiler können einzeln oder in Kombination verwendet werden, um Ihnen bei der Erstellung informativerer Datensätze zu helfen, die viel über das zeitliche Verhalten Ihrer Daten verraten – wie sie sich entwickeln, wie sie schwanken und welche Traits sie im Laufe der Zeit aufweisen.

Beachten Sie, dass unsere Beispiele verwenden Pandas Und NumPy.

1. Verzögerungsfunktion (autoregressive Darstellung)

Die Idee hinter der Verwendung autoregressiver Darstellungs- oder Verzögerungsmerkmale ist einfacher als es klingt: Sie besteht darin, die vorherige Beobachtung als neues Prädiktormerkmal in die aktuelle Beobachtung einzufügen. Im Wesentlichen ist dies wohl die einfachste Methode, zeitliche Abhängigkeiten darzustellen, z. B. zwischen dem aktuellen Zeitpunkt und früheren Zeitpunkten.

Schauen wir uns diesen als ersten einzeiligen Beispielcode in dieser Liste von 10 genauer an.

In diesem einzeiligen Beispiel wird davon ausgegangen, dass Sie einen Rohzeitreihendatensatz in einem gespeichert haben DataFrame angerufen dfeines der vorhandenen Attribute ist benannt 'worth'. Beachten Sie, dass das Argument in der shift() Die Funktion kann angepasst werden, um den registrierten Wert abzurufen N Zeitpunkte oder Beobachtungen vor dem aktuellen:

Bei täglichen Zeitreihendaten ist die Verwendung sinnvoll, wenn Sie frühere Werte für einen bestimmten Wochentag, z. B. Montag, erfassen möchten shift(7).

2. Rollmittel (kurzfristige Glättung)

Um lokale Traits zu erfassen oder kurzfristige Schwankungen in den Daten zu glätten, ist es in der Regel praktisch, gleitende Mittelwerte über die Daten hinweg zu verwenden N frühere Beobachtungen, die zur aktuellen Beobachtung führen: Dies ist eine einfache, aber sehr nützliche Methode, um manchmal chaotische Rohzeitreihenwerte über ein bestimmtes Merkmal zu glätten.

In diesem Beispiel wird ein neues Function erstellt, das für jede Beobachtung den gleitenden Mittelwert der drei vorherigen Werte dieses Options in aktuellen Beobachtungen enthält:

3. Rollierende Standardabweichung (lokale Volatilität)

Ähnlich wie bei gleitenden Mittelwerten besteht auch die Möglichkeit, neue Merkmale auf der Grundlage der gleitenden Standardabweichung zu erstellen, was für die Modellierung der Volatilität aufeinanderfolgender Beobachtungen effektiv ist.

In diesem Beispiel wird eine Funktion zum Modellieren der Variabilität der neuesten Werte über ein gleitendes Fenster einer Woche unter der Annahme täglicher Beobachtungen vorgestellt.

4. Erweiterungsmittel (kumulativer Speicher)

Der expandierende Mittelwert berechnet den Mittelwert aller Datenpunkte bis (einschließlich) der aktuellen Beobachtung in der zeitlichen Abfolge. Es handelt sich additionally um einen gleitenden Mittelwert mit ständig wachsender Fenstergröße. Es ist nützlich zu analysieren, wie sich der Mittelwert der Werte in einem Zeitreihenattribut im Laufe der Zeit entwickelt, um so Aufwärts- oder Abwärtstrends langfristig zuverlässiger zu erfassen.

5. Differenzierung (Trendentfernung)

Diese Technik wird verwendet, um langfristige Traits zu entfernen und Änderungsraten hervorzuheben – was in instationären Zeitreihen wichtig ist, um sie zu stabilisieren. Es berechnet die Differenz zwischen aufeinanderfolgenden Beobachtungen (aktuelle und vorherige) eines Zielattributs:

6. Zeitbasierte Funktionen (Zeitkomponentenextraktion)

Einfach, aber in realen Anwendungen sehr nützlich, kann dieser Einzeiler verwendet werden, um relevante Informationen aus der vollständigen Datums-/Uhrzeitfunktion zu zerlegen und zu extrahieren oder Ihre Zeitreihe zu indizieren, um die es geht:

Wichtig: Seien Sie vorsichtig und prüfen Sie, ob in Ihrer Zeitreihe die Datum-Uhrzeit-Informationen in einem regulären Attribut oder als Index der Datenstruktur enthalten sind. Wenn es der Index wäre, müssen Sie möglicherweise stattdessen Folgendes verwenden:

7. Rollende Korrelation (zeitliche Beziehung)

Dieser Ansatz geht einen Schritt über das Rollieren von Statistiken über ein Zeitfenster hinaus, um zu messen, wie aktuelle Werte mit ihren verzögerten Gegenstücken korrelieren, und trägt so dazu bei, sich entwickelnde Autokorrelationen zu entdecken. Dies ist beispielsweise nützlich bei der Erkennung von Regimewechseln, additionally abrupten und anhaltenden Verhaltensänderungen in den Daten im Laufe der Zeit, die auftreten, wenn rollierende Korrelationen irgendwann schwächer werden oder sich umkehren.

8. Fourier-Merkmale (Saisonalität)

Sinusförmige Fourier-Transformationen können in Rohzeitreihenattributen verwendet werden, um zyklische oder saisonale Muster zu erfassen. Durch die Anwendung der Sinus- (oder Kosinus-)Funktion werden beispielsweise zyklische Tagesinformationen, die den Datums-/Uhrzeitmerkmalen zugrunde liegen, in kontinuierliche Merkmale umgewandelt, die zum Erlernen und Modellieren jährlicher Muster nützlich sind.

Erlauben Sie mir, in diesem Beispiel aus gutem Grund einen Zweizeiler anstelle eines Einzeilers zu verwenden: Sinus und Kosinus zusammen erfassen das Gesamtbild möglicher zyklischer Saisonalitätsmuster besser.

9. Exponentiell gewichteter Mittelwert (adaptive Glättung)

Der exponentiell gewichtete Mittelwert – oder kurz EWM – wird angewendet, um exponentiell abfallende Gewichte zu erhalten, die aktuellen Datenbeobachtungen eine höhere Bedeutung verleihen und gleichzeitig das Langzeitgedächtnis bewahren. Es handelt sich um einen adaptiveren und etwas „intelligenteren“ Ansatz, bei dem aktuelle Beobachtungen Vorrang vor der fernen Vergangenheit haben.

10. Rollende Entropie (Informationskomplexität)

Zum Schluss noch ein bisschen Mathe! Die rollierende Entropie eines bestimmten Merkmals über ein Zeitfenster berechnet, wie zufällig oder verteilt die Werte über dieses Zeitfenster sind, und offenbart so die Menge und Komplexität der darin enthaltenen Informationen. Niedrigere Werte der resultierenden rollierenden Entropie weisen auf ein Gefühl von Ordnung und Vorhersagbarkeit hin. Je höher diese Werte sind, desto größer ist das „Chaos und die Unsicherheit“.

Zusammenfassung

In diesem Artikel haben wir 10 Strategien untersucht und veranschaulicht – jeweils über eine einzige Codezeile –, um eine Vielzahl von Mustern und Informationen aus rohen Zeitreihendaten zu extrahieren, von einfacheren Traits bis hin zu anspruchsvolleren Traits wie Saisonalität und Informationskomplexität.

Google AI hat gerade enthüllt Gemini 2.5 Blitzbildein Bildmodell für die neue Era, mit dem Benutzer Bilder generieren und bearbeiten können, indem sie sie einfach beschreiben-und seine wahre Innovation ist, wie es präzise, ​​konsistente und hochgeschwindige Änderungen mit beeindruckender Geschwindigkeit und Skala liefert.

Was macht Gemini 2.5 Flash Picture beeindruckend?

Gemini 2.5 Flash Picture basiert auf der multimodalen, fortschrittlichen Argumentation von Gemini 2.5 (dh es versteht sowohl Bilder als auch Textual content nativ) und ermöglicht nahtlose Workflows für die Erzeugung und Bearbeitung. Diese Architektur ermöglicht Benutzern:

• Mischen Sie mehrere Bilder in eine mit einer einzigen Eingabeaufforderung
• Behalten Sie die Fach- und Charakterkonsistenz über viele Änderungen hinweg bei
• Machen Sie zielgerichtete, natürliche sprachgetriebene Transformationen (z. B. „Ändern Sie die Hemdfarbe“, „Individual vom Foto entfernen“).
• Behalten Sie den Kontext und die visuelle Treue durch iterative Revisionen bei – unabhängig von der Komplexität oder Vielfalt der Änderungen

Dies ist ein Sprung über ältere Bildmodelle hinaus, der häufig Schwierigkeiten hatte, die Identität oder visuelle Kohärenz bei Änderungen oder Kompositierungsszenen zu erhalten.

Wichtige technische Funktionen

• Präzise visuelle Bearbeitung: Das Modell unterstützt hoch genaue, lokalisierte Änderungen, die auf natürlichen Sprachanforderungen basieren, von Hintergrundverschwamm bis hin zu Anpassungen und Objektumbauten.
• Multimodale Fusion: Akzeptiert mehrere Referenzbilder und verschmilzt sie, um beispielsweise komplexe Produktmodelle oder Multi-Charakter-Szenen in der Werbung zu ermöglichen.
• Vorlage/Markenkonsistenz: Gemini 2.5 Flash Picture erhalten Styling, Branding und Charakterkonsistenz über erzeugte Vermögenswerte oder Produktkataloge.
• Fortgeschrittene Argumentation: Zapfteilt in Geminis semantische Weltwissen für Aufgaben wie Diagrammverständnis oder Bildungsannotation – nicht nur fotorealistisches Rendering.
• Skalierbare API -Verfügbarkeit: Entwickler und Unternehmen können über Gemini-API, Google AI Studio und Vertex AI auf das Modell zugreifen-mit eingebauten synthiden Wasserzeichen für AI-Herkunft und regulatorische Einhaltung.

Benchmark -Führung und Neighborhood -Empfang

Gemini 2.5 Flash Picture hat schnell öffentliche Benchmarks geführt und LMARena für eine schnelle Einhaltung und Bearbeitungsqualität übertroffen. Übertreffende Konkurrenten wie die nativen Bildwerkzeuge von GPT-4O und die Bildmodelle von Flux AI. Enthusiasten und Experten heben seinen Fotorealismus hervor, aber auch seine bemerkenswerte semantische Kontrolle – Vernetzungen, die dem Ausgangsmaterial auch über mehrere Iterationen natürlich und treu aussehen.

Preisgestaltung, Zugang und zukünftige Roadmap

Das Modell ist in der Vorschau für 0,039 USD professional Bild über Gemini API, Google AI Studio und Vertex AI erhältlich, wobei Enterprise und Entwicklerintegration dank Partnerschaften mit Plattformen wie OpenRouter und Fal.ai schnell steigt. Alle erzeugten Bilder bieten unsichtbare synthidische Wasserzeichen für Rückverfolgbarkeit und Einhaltung von AI-Ethik, und Google verbessert aktiv die Langform-Textrendern und sogar eine feinere Konsistenz.

Zusammenfassend:

Gemini 2.5 Flash Picture ist nicht nur schneller und kreativer, es ist technisch „a-peeling“, da es schließlich die langjährige Herausforderung einer konsextbewussten Bildbearbeitung in generativer KI löst-unverzerrende leistungsstarke neue Workflows für Schöpfer, Entwickler und Enterprises.

---

FAQs

Was ist Gemini 2.5 Flash Picture?

Gemini 2.5 Flash Picture ist das hochmoderne KI-Modell von Google zum Generieren und Bearbeiten von Bildern mit natürlichen Sprachanforderungen, unterstützt multimodale Fusion und fortgeschrittenes Denken für präzise, ​​konsistente Änderungen.

Wie bearbeiten Sie Bilder mithilfe von Gemini 2.5 Flash Picture?

Beschreiben Sie einfach die Änderungen, die in der natürlichen Sprache benötigt werden, z. B. „Entfernen Sie eine Individual aus dem Foto“ oder „Hemdfarbe ändern“, und das Modell wendet Änderungen an, während die wichtigsten visuellen Particulars und die Szenenkonsistenz erhalten bleiben.

Wo können Benutzer auf das Modell zugreifen?

Gemini 2.5 Flash Picture ist in der Gemini -App, Google AI Studio, Vertex AI und über API für Entwickler und Unternehmen verfügbar. Es ist auch in Plattformen wie Adobe Firefly und Specific integriert.

Welche Dateiformate unterstützt Gemini 2.5 Flash Picture?

Standardmäßig werden Bilder im JPEG -Format anstelle von PNG oder WebP generiert, was die Optimierung für breite Kompatibilität und Dateigröße widerspiegelt.

Gibt es Schutzmaßnahmen für die Bildgenerierung?

Google verwendet strenge Sicherheitsfunktionen und Inhaltsfilter, um die Erstellung schädlicher oder unangemessener Grafiken zu verhindern und die kreative Kontrolle mit verantwortungsbewusster KI -Verwendung in Einklang zu bringen.

---

Schauen Sie sich das an Technische Particulars hier. Fühlen Sie sich frei, unsere zu überprüfen Github -Seite für Tutorials, Codes und Notizbücher. Fühlen Sie sich auch frei, uns zu folgen Twitter Und vergessen Sie nicht, sich unserer anzuschließen 100k+ ml Subreddit und abonnieren Unser Publication.

Die KI-Picture-Generierung, die sich auf neuronale Netzwerke stützt, um neue Bilder aus verschiedenen Eingaben zu erstellen, einschließlich Texteingabeaufforderungen-wird voraussichtlich bis Ende dieses Jahrzehnts zu einer Milliarden-Greenback-Branche werden. Selbst mit der heutigen Technologie, wenn Sie ein phantasievolles Bild von einem Freund machen wollten, der eine Flagge auf dem Mars pflanzt oder ohne Haft in ein schwarzes Loch fliegt, könnte es weniger als eine Sekunde dauern. Bevor sie jedoch solche Aufgaben ausführen können, werden Bildgeneratoren häufig auf massiven Datensätzen geschult, die Millionen von Bildern enthalten, die häufig mit dem zugehörigen Textual content gepaart werden. Das Coaching dieser generativen Modelle kann eine mühsame Aufgabe sein, die Wochen oder Monate dauert und in dem Prozess enorme Rechenressourcen verbraucht.

Aber was wäre, wenn es möglich wäre, Bilder über AI -Methoden zu generieren, ohne überhaupt einen Generator zu verwenden? Diese reale Möglichkeit wurde zusammen mit anderen faszinierenden Ideen in a beschrieben Forschungspapier Präsentiert auf der Internationalen Konferenz über maschinelles Lernen (ICML 2025), das Anfang dieses Sommers in Vancouver, British Columbia, stattfand. Das Papier, in dem neuartige Techniken zum Manipulieren und Generieren von Bildern beschrieben wurden, wurde von Lukas Lao Beyer, einem Scholar -Forscher des MIT -Labors für Data und Entscheidungssysteme (LIDS), geschrieben. Tianhong Li, ein Postdoc im MIT -Labor für Informatik und künstliche Intelligenz (CSAIL); Xinlei Chen von Fb AI Analysis; Sertac Karaman, MIT -Professor für Luftfahrt und Astronautik und Direktor von Lids; und Kaiming HE, ein MIT Affiliate Professor für Elektrotechnik und Informatik.

Diese Gruppenbemühungen hatten seinen Ursprung in einem Klassenprojekt für ein Graduiertenseminar zu Deep Generative Fashions, das Lao Beyer im vergangenen Herbst eingenommen hat. In Gesprächen während des Semesters wurde es sowohl Lao Beyer als auch dem, den das Seminar unterrichtete, deutlich, dass diese Forschung ein echtes Potenzial hatte, das weit über die Grenzen einer typischen Hausaufgabe hinausging. Andere Mitarbeiter wurden bald in das Bestreben gebracht.

Der Ausgangspunkt für die Untersuchung von Lao Beyer struggle ein Papier im Juni 2024, das von Forschern der Technischen Universität von München und dem chinesischen Unternehmen Bytedance verfasst wurde und eine neue Methode zur Vertretung visueller Informationen einführte, die als eindimensionale Tokenzaizer bezeichnet werden. Mit diesem Gerät, bei dem es sich auch um eine Artwork neuronales Netzwerk handelt, kann ein 256×256-Pixel-Bild in eine Sequenz von nur 32 Zahlen übersetzt werden, die als Token bezeichnet werden. „Ich wollte verstehen, wie ein so hohes Komprimierungsgrad erreicht werden konnte und was die Token selbst tatsächlich vertreten“, sagt Lao Beyer.

Die vorherige Technology von Tokenisierern würde in der Regel das gleiche Bild in ein Array von 16×16 -Token zerlegen – wobei jedes Token in stark kondensierter Kind einen bestimmten Teil des Originalbildes entspricht. Die neuen 1D -Tokenizer können ein Bild effizienter codieren, indem sie insgesamt weit weniger Tokens verwenden, und diese Token können Informationen über das gesamte Bild erfassen, nicht nur einen einzelnen Quadranten. Jede dieser Token ist außerdem eine 12-stellige Zahl, die aus 1s und 0s besteht, die 2 ermöglicht¹² (oder ungefähr 4.000) Möglichkeiten insgesamt. „Es ist wie ein Wortschatz von 4.000 Wörtern, die eine abstrakte, verborgene Sprache ausmachen, die vom Pc gesprochen wird“, erklärt er. „Es ist nicht wie eine menschliche Sprache, aber wir können trotzdem versuchen herauszufinden, was es bedeutet.“

Genau das hatte Lao Beyer sich zunächst vorgenommen – Arbeiten, die den Samen für das ICML 2025 -Papier lieferten. Der Ansatz, den er verfolgte, struggle ziemlich einfach. Wenn Sie herausfinden möchten, was ein bestimmtes Token tut, sagt Lao Beyer: „Sie können es einfach herausnehmen, einen zufälligen Wert auszeigen und feststellen, ob sich die Ausgabe zu erkennbaren.“ Er fand einen Token, der die Bildqualität ersetzt und ein Bild mit niedrigem Auflösung in ein hochauflösendes Bild verwandelt oder umgekehrt. Ein weiterer Token beeinflusste die Unschärfe im Hintergrund, während ein anderer die Helligkeit immer noch beeinflusste. Er fand auch ein Token, das mit der „Pose“ zusammenhängt, was bedeutet, dass beispielsweise nach dem Bild eines Robins sich der Kopf des Vogels von rechts nach hyperlinks verlagern könnte.

„Dies struggle ein nie zuvor gesehenes Ergebnis, da niemand visuell identifizierbare Veränderungen aus manipulierenden Token beobachtet hatte“, sagt Lao Beyer. Der Befund erhöhte die Möglichkeit eines neuen Ansatzes zur Bearbeitung von Bildern. Und die MIT -Gruppe hat tatsächlich gezeigt, wie dieser Prozess optimiert und automatisiert werden kann, so dass Token nacheinander nicht von Hand geändert werden müssen.

Er und seine Kollegen erzielten ein noch konsequenteres Ergebnis, das die Bilderzeugung umfasste. Ein System, das Bilder normalerweise erzeugen kann, erfordert normalerweise einen Tokenizer, der visuelle Daten komprimiert und codiert, zusammen mit einem Generator, der diese kompakten Darstellungen kombinieren und anordnen kann, um neue Bilder zu erstellen. Die MIT -Forscher fanden einen Weg, Bilder zu erstellen, ohne überhaupt einen Generator zu verwenden. Ihr neuer Ansatz verwendet einen 1D-Tokenizer und einen sogenannten Detokenisierer (auch als Decoder bezeichnet), der ein Bild von einer Reihe von Token rekonstruieren kann. Mit Anleitungen, die durch ein abgeschaltetes neuronales Netzwerk namens Clip geliefert werden, das nicht selbst Bilder generieren kann, aber messen kann, wie intestine ein bestimmtes Bild mit einer bestimmten Textaufforderung übereinstimmt-konnte das Group beispielsweise ein Bild eines roten Pandas in einen Tiger umwandeln. Darüber hinaus können sie Bilder eines Tigers oder einer anderen gewünschten Kind erstellen, die vollständig von vorne beginnen – aus einer State of affairs, in der allen Token ursprünglich zufällige Werte zugeordnet werden (und dann iterativ operativ so gepoppt werden, dass dem rekonstruierten Bild zunehmend mit der gewünschten Textaufforderung übereinstimmt).

Die Gruppe zeigte, dass mit demselben Setup, der sich auf einen Tokenizer und einen Detokener stützt, aber ohne Generator – auch „Inpainting“ erledigen konnte, was bedeutet, dass Teile von Bildern, die irgendwie ausgeblendet waren, ausfüllen. Die Vermeidung der Verwendung eines Turbines für bestimmte Aufgaben kann zu einer erheblichen Reduzierung der Rechenkosten führen, da Generatoren, wie erwähnt, normalerweise ein umfassendes Coaching erfordern.

Was an den Beiträgen dieses Groups seltsam erscheinen magazine, erklärt er, „ist, dass wir nichts Neues erfunden haben. Wir haben keinen 1D -Tokenizer erfunden, und wir haben das Clip -Modell auch nicht erfunden. Wir haben jedoch festgestellt, dass neue Funktionen entstehen können, wenn Sie all diese Teile zusammenfügen.“

„Diese Arbeit definiert die Rolle von Tokenizern neu“, kommentiert Saining Xie, Informatiker an der New York College. „Es zeigt, dass Bild-Tokenisierer-Werkzeuge, die normalerweise nur zum Komprimieren von Bildern verwendet werden-tatsächlich viel mehr tun können. Die Tatsache, dass ein einfacher (aber hochkomprimierter) 1D-Tokenizer Aufgaben wie Inpfle oder textgesteuerte Bearbeitung erledigen kann, ohne ein volles Generativmodell trainieren zu müssen, ist ziemlich überraschend.“

Zhuang Liu von der Princeton College stimmt zu und sagt, dass die Arbeit der MIT-Gruppe „zeigt, dass wir die Bilder auf eine Weise generieren und manipulieren können, die viel einfacher ist als bisher, im Grunde genommen zeigt es, dass Bildgenerierung ein Nebenprodukt eines sehr effektiven Bildkompressors sein kann, was möglicherweise die Kosten der Generierung von Bildern mehrere Falte einsetzt.“

Es könnte viele Anwendungen außerhalb des Bereichs des Pc Imaginative and prescient geben, schlägt Karaman vor. „Zum Beispiel könnten wir in Betracht ziehen, die Handlungen von Robotern oder selbstfahrenden Autos auf die gleiche Weise zu Tokenisieren, was die Auswirkungen dieser Arbeit schnell erweitern kann.“

Lao Beyer denkt in ähnlicher Weise und stellt fest, dass die excessive Komprimierung von 1D -Tokenizern es Ihnen ermöglicht, „einige erstaunliche Dinge“ zu machen, die auf andere Felder angewendet werden könnten. Zum Beispiel im Bereich selbstfahrender Autos, die eines seiner Forschungsinteressen sind, könnten die Token anstelle von Bildern die verschiedenen Routen darstellen, die ein Fahrzeug aufnehmen könnte.

Xie ist auch fasziniert von den Anwendungen, die aus diesen innovativen Ideen stammen können. „Es gibt einige wirklich coole Anwendungsfälle, die sich freischalten können“, sagt er.

Datensätze und suchen nach schnellen Erkenntnissen ohne zu viel manuellem Schleifen. Sie sind richtig gekommen.

Im Jahr 2025 enthalten Datensätze häufig Millionen von Zeilen und Hunderten von Spalten, was die manuelle Analyse nahe bei unmöglicher macht. Lokale Großsprachenmodelle können Ihre Rohdatenfream -Statistiken in Sekunden in polierte, lesbare Berichte verwandeln – im schlimmsten Fall Minuten. Dieser Ansatz beseitigt den mühsamen Prozess der Analyse von Daten von Hand und dem Schreiben von Exekutivberichten, insbesondere wenn sich die Datenstruktur nicht ändert.

Pandas kümmert sich um das starke Anheben der Datenextraktion, während LLMs Ihre technischen Ausgänge in präsentierbare Berichte umwandeln. Sie müssen noch Funktionen schreiben, die Schlüsselstatistiken aus Ihren Datensätzen ziehen, aber es ist eine einmalige Anstrengung.

In diesem Leitfaden wird davon ausgegangen, dass Ollama lokal installiert ist. Wenn Sie dies nicht tun, können Sie immer noch LLM-Anbieter von Drittanbietern verwenden, aber ich werde nicht erklären, wie man sich mit ihren APIs verbindet.

Inhaltsverzeichnis:

• Datensatzeinführung und Erkundung
• Der langweilige Teil: Extrahieren von Zusammenfassungsstatistiken
• Der coole Teil: Arbeiten mit LLMs
• Was Sie verbessern könnten

Datensatzeinführung und Erkundung

Für diesen Leitfaden benutze ich die MBA -Zulassungsdatensatz von Kaggle. Laden Sie es herunter, wenn Sie folgen möchten.

Der Datensatz ist unter dem lizenziert Apache 2.0 LizenzDies bedeutet, dass Sie es sowohl für persönliche als auch für kommerzielle Projekte frei verwenden können.

Um loszulegen, benötigen Sie ein paar Python -Bibliotheken, die auf Ihrem System installiert sind.

Sobald Sie alles installiert haben, importieren Sie die erforderlichen Bibliotheken in ein neues Skript oder ein Notizbuch:

import pandas as pd
from langchain_ollama import ChatOllama
from typing import Literal

Dataset -Laden und Vorverarbeitung

Beginnen Sie mit dem Laden des Datensatzes mit Pandas. Dieser Snippet lädt die CSV -Datei, druckt grundlegende Informationen zur Datensatzform und zeigt, wie viele fehlende Werte in jeder Spalte vorhanden sind:

df = pd.read_csv("information/MBA.csv")

# Primary dataset information
print(f"Dataset form: {df.form}n")
print("Lacking worth stats:")
print(df.isnull().sum())
print("-" * 25)
df.pattern(5)

Da die Datenreinigung nicht im Mittelpunkt dieses Artikels liegt, werde ich die Vorverarbeitung minimal behalten. Der Datensatz hat nur einige fehlende Werte, die Aufmerksamkeit erfordern:

df("race") = df("race").fillna("Unknown")
df("admission") = df("admission").fillna("Deny")

Das warfare’s! Mal sehen, wie man als nächstes von diesem zu einem aussagekräftigen Bericht wechselt.

Der langweilige Teil: Extrahieren von Zusammenfassungsstatistiken

Selbst mit all den Fortschritten in der KI -Fähigkeit und -verfügbarkeit möchten Sie Ihren gesamten Datensatz wahrscheinlich nicht an einen LLM -Anbieter senden. Es gibt ein paar gute Gründe warum.

Es könnte verbrauchen viel zu viele Tokenwas direkt zu höheren Kosten führt. Verarbeitung großer Datensätze können sich lange Zeit nehmenVor allem, wenn Sie Modelle lokal auf Ihrer eigenen {Hardware} ausführen. Möglicherweise haben Sie es auch zu tun Wise Daten Das sollte Ihre Organisation nicht verlassen.

Einige manuelle Arbeiten sind noch der richtige Weg.

Dieser Ansatz erfordert, dass Sie eine Funktion schreiben, die Schlüsselelemente und Statistiken aus Ihrem Pandas -Datenframe extrahiert. Sie müssen diese Funktion für verschiedene Datensätze von Grund auf schreiben, aber die Kernidee überträgt sich leicht zwischen Projekten.

Der get_summary_context_message() Die Funktion nimmt einen Datenrahmen auf und gibt eine formatierte Multi-Line-Zeichenfolge mit einer detaillierten Zusammenfassung zurück. Folgendes beinhaltet es:

• Gesamtantragszahl und Geschlechtsverteilung
• Internationaler gegen den Inlandsbewerber Zusammenbruch
• GPA- und GMAT -Rating -Quartilstatistik
• Zulassungsquoten nach akademischem Main (sortiert nach Tarif)
• Zulassungsraten der Arbeitsindustrie (Prime 8 Branchen)
• Berufserfahrungsanalyse mit kategorialen Aufschlüssen
• Key-Erkenntnisse, in denen die Prime-Performing-Kategorien hervorgehoben werden

Hier ist der vollständige Quellcode für die Funktion:

def get_summary_context_message(df: pd.DataFrame) -> str:
    """
    Generate a complete abstract report of MBA admissions dataset statistics.
    
    This perform analyzes MBA software information to offer detailed statistics on
    applicant demographics, tutorial efficiency, skilled backgrounds, and
    admission charges throughout varied classes. The abstract consists of gender and
    worldwide standing distributions, GPA and GMAT rating statistics, admission
    charges by tutorial main and work trade, and work expertise impression evaluation.
    
    Parameters
    ----------
    df : pd.DataFrame
        DataFrame containing MBA admissions information with the next anticipated columns:
        - 'gender', 'worldwide', 'gpa', 'gmat', 'main', 'work_industry', 'work_exp', 'admission'
    
    Returns
    -------
    str
        A formatted multi-line string containing complete MBA admissions
        statistics.
    """
    # Primary software statistics
    total_applications = len(df)

    # Gender distribution
    gender_counts = df("gender").value_counts()
    male_count = gender_counts.get("Male", 0)
    female_count = gender_counts.get("Feminine", 0)

    # Worldwide standing
    international_count = (
        df("worldwide").sum()
        if df("worldwide").dtype == bool
        else (df("worldwide") == True).sum()
    )

    # GPA statistics
    gpa_data = df("gpa").dropna()
    gpa_avg = gpa_data.imply()
    gpa_25th = gpa_data.quantile(0.25)
    gpa_50th = gpa_data.quantile(0.50)
    gpa_75th = gpa_data.quantile(0.75)

    # GMAT statistics
    gmat_data = df("gmat").dropna()
    gmat_avg = gmat_data.imply()
    gmat_25th = gmat_data.quantile(0.25)
    gmat_50th = gmat_data.quantile(0.50)
    gmat_75th = gmat_data.quantile(0.75)

    # Main evaluation - admission charges by main
    major_stats = ()
    for main in df("main").distinctive():
        major_data = df(df("main") == main)
        admitted = len(major_data(major_data("admission") == "Admit"))
        complete = len(major_data)
        fee = (admitted / complete) * 100
        major_stats.append((main, admitted, complete, fee))

    # Kind by admission fee (descending)
    major_stats.type(key=lambda x: x(3), reverse=True)

    # Work trade evaluation - admission charges by trade
    industry_stats = ()
    for trade in df("work_industry").distinctive():
        if pd.isna(trade):
            proceed
        industry_data = df(df("work_industry") == trade)
        admitted = len(industry_data(industry_data("admission") == "Admit"))
        complete = len(industry_data)
        fee = (admitted / complete) * 100
        industry_stats.append((trade, admitted, complete, fee))

    # Kind by admission fee (descending)
    industry_stats.type(key=lambda x: x(3), reverse=True)

    # Work expertise evaluation
    work_exp_data = df("work_exp").dropna()
    avg_work_exp_all = work_exp_data.imply()

    # Work expertise for admitted college students
    admitted_students = df(df("admission") == "Admit")
    admitted_work_exp = admitted_students("work_exp").dropna()
    avg_work_exp_admitted = admitted_work_exp.imply()

    # Work expertise ranges evaluation
    def categorize_work_exp(exp):
        if pd.isna(exp):
            return "Unknown"
        elif exp < 2:
            return "0-1 years"
        elif exp < 4:
            return "2-3 years"
        elif exp < 6:
            return "4-5 years"
        elif exp < 8:
            return "6-7 years"
        else:
            return "8+ years"

    df("work_exp_category") = df("work_exp").apply(categorize_work_exp)
    work_exp_category_stats = ()

    for class in ("0-1 years", "2-3 years", "4-5 years", "6-7 years", "8+ years"):
        category_data = df(df("work_exp_category") == class)
        if len(category_data) > 0:
            admitted = len(category_data(category_data("admission") == "Admit"))
            complete = len(category_data)
            fee = (admitted / complete) * 100
            work_exp_category_stats.append((class, admitted, complete, fee))

    # Construct the abstract message
    abstract = f"""MBA Admissions Dataset Abstract (2025)
    
Whole Purposes: {total_applications:,} individuals utilized to the MBA program.

Gender Distribution:
- Male candidates: {male_count:,} ({male_count/total_applications*100:.1f}%)
- Feminine candidates: {female_count:,} ({female_count/total_applications*100:.1f}%)

Worldwide Standing:
- Worldwide candidates: {international_count:,} ({international_count/total_applications*100:.1f}%)
- Home candidates: {total_applications-international_count:,} ({(total_applications-international_count)/total_applications*100:.1f}%)

Tutorial Efficiency Statistics:

GPA Statistics:
- Common GPA: {gpa_avg:.2f}
- twenty fifth percentile: {gpa_25th:.2f}
- fiftieth percentile (median): {gpa_50th:.2f}
- seventy fifth percentile: {gpa_75th:.2f}

GMAT Statistics:
- Common GMAT: {gmat_avg:.0f}
- twenty fifth percentile: {gmat_25th:.0f}
- fiftieth percentile (median): {gmat_50th:.0f}
- seventy fifth percentile: {gmat_75th:.0f}

Main Evaluation - Admission Charges by Tutorial Background:"""

    for main, admitted, complete, fee in major_stats:
        abstract += (
            f"n- {main}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
        )

    abstract += (
        "nnWork Business Evaluation - Admission Charges by Skilled Background:"
    )

    # Present prime 8 industries by admission fee
    for trade, admitted, complete, fee in industry_stats(:8):
        abstract += (
            f"n- {trade}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
        )

    abstract += "nnWork Expertise Affect on Admissions:nnOverall Work Expertise Comparability:"
    abstract += (
        f"n- Common work expertise (all candidates): {avg_work_exp_all:.1f} years"
    )
    abstract += f"n- Common work expertise (admitted college students): {avg_work_exp_admitted:.1f} years"

    abstract += "nnAdmission Charges by Work Expertise Vary:"
    for class, admitted, complete, fee in work_exp_category_stats:
        abstract += (
            f"n- {class}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
        )

    # Key insights
    best_major = major_stats(0)
    best_industry = industry_stats(0)

    abstract += "nnKey Insights:"
    abstract += (
        f"n- Highest admission fee by main: {best_major(0)} at {best_major(3):.1f}%"
    )
    abstract += f"n- Highest admission fee by trade: {best_industry(0)} at {best_industry(3):.1f}%"

    if avg_work_exp_admitted > avg_work_exp_all:
        abstract += f"n- Admitted college students have barely extra work expertise on common ({avg_work_exp_admitted:.1f} vs {avg_work_exp_all:.1f} years)"
    else:
        abstract += "n- Work expertise reveals minimal distinction between admitted and all candidates"

    return abstract

Wenn Sie die Funktion definiert haben, rufen Sie sie einfach auf und drucken Sie die Ergebnisse aus:

print(get_summary_context_message(df))

Lassen Sie uns nun zum lustigen Teil übergehen.

Der coole Teil: Arbeiten mit LLMs

Hier werden die Dinge interessant und Ihre manuelle Datenextraktionsarbeit zahlt sich aus.

Python -Helferfunktion für die Arbeit mit LLMs

Wenn Sie angemessene {Hardware} haben, empfehle ich dringend, lokale LLMs für einfache Aufgaben wie diese zu verwenden. Ich benutze Ollama und die neueste Model der Mistral -Modell Für die tatsächliche LLM -Verarbeitung.

Wenn Sie über OpenAI -API so etwas wie Chatgpt verwenden möchten, können Sie das trotzdem tun. Sie müssen nur die folgende Funktion ändern, um Ihre API -Style einzurichten und die entsprechende Instanz von Langchain zurückzugeben.

Unabhängig von der Possibility, die Sie auswählen, ein Anruf an get_llm() Mit einer Testnachricht sollte kein Fehler zurückgeben:

def get_llm(model_name: str = "mistral:newest") -> ChatOllama:
    """
    Create and configure a ChatOllama occasion for native LLM inference.
    
    This perform initializes a ChatOllama shopper configured to connect with a
    native Ollama server. The shopper is about up with deterministic output
    (temperature=0) for constant responses throughout a number of calls with the
    identical enter.
    
    Parameters
    ----------
    model_name : str, optionally available
        The title of the Ollama mannequin to make use of for chat completions.
        Should be a legitimate mannequin title that's obtainable on the native Ollama
        set up. Default is "mistral:newest".
    
    Returns
    -------
    ChatOllama
        A configured ChatOllama occasion prepared for chat completions.
    """
    return ChatOllama(
        mannequin=model_name, base_url="http://localhost:11434", temperature=0
    )


print(get_llm().invoke("take a look at").content material)

Zusammenfassung

Hier können Sie kreativ werden und ultraspezifische Anweisungen für Ihre LLM schreiben. Ich habe beschlossen, die Dinge für Demonstrationszwecke Licht zu halten, aber ich kann mir gerne hier experimentieren.

Es gibt keine einzige richtige oder falsche Eingabeaufforderung.

Was auch immer Sie tun, stellen Sie sicher, dass die Formatargumente mit lockigen Klammern enthalten sind. Diese Werte werden später dynamisch gefüllt:

SUMMARIZE_DATAFRAME_PROMPT = """
You're an skilled information analyst and information summarizer. Your job is to absorb complicated datasets
and return user-friendly descriptions and findings.

You got this dataset:
- Title: {dataset_name}
- Supply: {dataset_source}

This dataset was analyzed in a pipeline earlier than it was given to you.
These are the findings returned by the evaluation pipeline:

<context>
{context}
</context>

Primarily based on these findings, write an in depth report in {report_format} format.
Give the report a significant title and separate findings into sections with headings and subheadings.
Output solely the report in {report_format} and nothing else.

Report:
"""

Zusammenfassung der Python -Funktion

Mit der Eingabeaufforderung und der get_llm() Funktionen erklärt, das einzige, was noch übrig ist, ist, die Punkte zu verbinden. Der get_report_summary() Funktion nimmt Argumente auf, die die Format -Platzhalter in der Eingabeaufforderung füllen, und ruft dann die LLM mit dieser Eingabeaufforderung auf, einen Bericht zu erstellen.

Sie können zwischen Markdown- oder HTML -Formaten wählen:

def get_report_summary(
    dataset: pd.DataFrame,
    dataset_name: str,
    dataset_source: str,
    report_format: Literal("markdown", "html") = "markdown",
) -> str:
    """
    Generate an AI-powered abstract report from a pandas DataFrame.
    
    This perform analyzes a dataset and generates a complete abstract report
    utilizing a big language mannequin (LLM). It first extracts statistical context
    from the dataset, then makes use of an LLM to create a human-readable report within the
    specified format.
    
    Parameters
    ----------
    dataset : pd.DataFrame
        The pandas DataFrame to research and summarize.
    dataset_name : str
        A descriptive title for the dataset that will likely be included within the
        generated report for context and identification.
    dataset_source : str
        Details about the supply or origin of the dataset.
    report_format : {"markdown", "html"}, optionally available
        The specified output format for the generated report. Choices are:
        - "markdown" : Generate report in Markdown format (default)
        - "html" : Generate report in HTML format
    
    Returns
    -------
    str
        A formatted abstract report.
    
    """
    context_message = get_summary_context_message(df=dataset)
    immediate = SUMMARIZE_DATAFRAME_PROMPT.format(
        dataset_name=dataset_name,
        dataset_source=dataset_source,
        context=context_message,
        report_format=report_format,
    )
    return get_llm().invoke(enter=immediate).content material

Die Verwendung der Funktion ist unkompliziert – geben Sie einfach den Datensatz, seinen Namen und die Quelle über. Das Berichtsformat standardisch für Markdown:

md_report = get_report_summary(
    dataset=df, 
    dataset_name="MBA Admissions (2025)",
    dataset_source="https://www.kaggle.com/datasets/taweilo/mba-admission-dataset"
)
print(md_report)

Der HTML -Bericht ist genauso detailliert, könnte aber ein Styling gebrauchen. Vielleicht könnten Sie die LLM auch darum bitten, damit umzugehen!

Was Sie verbessern könnten

Ich hätte dies leicht in eine 30-minütige Lektüre verwandeln können, indem ich jedes Element der Pipeline optimierte, aber ich habe es für Demonstrationszwecke einfach gehalten. Sie müssen hier jedoch nicht aufhören (und sollten nicht).

Hier sind die Dinge, die Sie verbessern können, um diese Pipeline noch leistungsfähiger zu machen:

• Schreiben Sie eine Funktion, die den Bericht (Markdown oder HTML) direkt in die Festplatte speichert. Auf diese Weise können Sie den gesamten Prozess automatisieren und Berichte nach einem Zeitplan ohne manuelle Intervention erstellen.
• In der Eingabeaufforderung, Bitten Sie das LLM, dem HTML -Bericht das CSS -Styling hinzuzufügen Damit es besser aussehen lässt. Sie können sogar die Markenfarben und Schriftarten Ihres Unternehmens zur Verfügung stellen, um die Konsistenz in allen Ihren Datenberichten aufrechtzuerhalten.
• Erweitern Sie die Eingabeaufforderung, spezifischere Anweisungen zu befolgen. Möglicherweise möchten Sie Berichte, die sich auf bestimmte Geschäftsmetriken konzentrieren, einer bestimmten Vorlage folgen oder Empfehlungen basieren, die auf den Ergebnissen basieren.
• Erweitern get_llm() Funktion, damit es kann Verbinden Sie sich sowohl mit Ollama als auch mit anderen Anbietern Wie OpenAI, Anthropic oder Google. Auf diese Weise können Sie je nach Ihren Anforderungen zwischen lokalen und Cloud-basierten Modellen wechseln.
• Machen Sie buchstäblich alles in der Funktion get_summary_context_message (), da sie als Grundlage für alle dient Kontextdaten, die dem LLM zur Verfügung gestellt wurden. Hier können Sie kreativ mit Function -Engineering, statistischen Analysen und Datenerkenntnissen werden, die für Ihren spezifischen Anwendungsfall von Bedeutung sind.

Ich hoffe, dieses minimale Beispiel hat Sie auf dem richtigen Weg gesetzt, um Ihre eigenen Datenberichterstattungs -Workflows zu automatisieren.

Jedes Unternehmen, für das ich bis heute gearbeitet habe, battle es: die belastbare MS Excel.

Excel wurde erstmals 1985 veröffentlicht und ist bis heute stark geblieben. Es hat den Aufstieg der relationalen Datenbanken, die Entwicklung vieler Programmiersprachen, das Web mit seiner unendlichen Anzahl von On-line -Anwendungen überlebt, und schließlich überlebt es auch die Ära der KI.

Puh!

Haben Sie Zweifel daran, wie belastbar Excel ist? Ich tu nicht.

Ich denke, der Grund dafür ist es Praktikabilität, um ein Dokument schnell zu beginnen und zu manipulieren. Denken Sie über diese Scenario nach: Wir arbeiten in einem Assembly und plötzlich teilt die Führung eine CSV -Datei und fragt nach einer schnellen Berechnung oder einigen wenigen berechneten Zahlen. Jetzt sind die Optionen:

1. Öffnen Sie eine IDE (oder ein Notizbuch) und beginnen Sie mit dem Codieren wie verrückt, um eine einfache Matplotlib -Grafik zu generieren.

2. Open Energy BI, importieren Sie die Daten und erstellen Sie einen Bericht mit dynamischen Grafiken.

3. Öffnen Sie den CSV in Excel, schreiben Sie ein paar Formeln und erstellen Sie eine Grafik.

Ich kann nicht für Sie sprechen, aber oft gehe ich für Possibility 3. vor, vor allem, weil Excel-Dateien mit allem kompatibel sind, leicht gemeinsam nutzbar und anfängerfreundlich sind.

Ich sage all dies als Einführung, um meinen Standpunkt zu verdeutlichen, dass ich nicht glaube, dass Excel -Dateien bald mit der schnellen Entwicklung von KI verschwinden. Viele werden das lieben, viele werden das hassen.

Meine Aktion hier bestand additionally darin, KI zu nutzen, um Excel -Dateien besser dokumentiert zu machen. Eine der Hauptbeschwerden von Datenteams über Excel ist der Mangel an Greatest Practices und Reproduzierbarkeit, da die Namen der Spalten Namen und Datentypen haben können, aber keine Dokumentation.

Ich habe additionally einen KI -Agenten erstellt, der die Excel -Datei liest und diese kleine Dokumentation erstellt hat. So funktioniert es:

1. Die Excel -Datei wird in CSV konvertiert und in das große Sprachmodell (LLM) eingespeist.
2. Der AI -Agent generiert das Datenwörterbuch mit Spalteninformationen (variabler Title, Datentyp, Beschreibung).
3. Das Datenwörterbuch wird als Kommentare zum Header der Excel -Datei hinzugefügt.
4. Ausgabedatei mit Kommentaren gespeichert.

OK. Praktisch jetzt. Lassen Sie uns das in diesem Tutorial erledigen.

Code

Wir werden zunächst eine virtuelle Umgebung einrichten. Erstellen a venv Mit dem Werkzeug Ihrer Wahl wie Poesie, Python Venv, Anaconda oder UV. Ich magazine UV wirklich, da es meiner Meinung nach am schnellsten und einfachsten ist. Wenn Sie UV installiert haben (5)Öffnen Sie ein Terminal und erstellen Sie Ihre venv.

uv init data-docs
cd data-docs
uv venv
uv add streamlit openpyxl pandas agno mcp google-genai

Lassen Sie uns nun die erforderlichen Module importieren. Dieses Projekt wurde mit Python 3.12.1 erstellt, aber ich glaube, Python 3.9 oder höher könnte den Trick bereits tun. Wir werden verwenden:

• Agno: Für die KI -Agentenverwaltung
• Openpyxl: Für die Manipulation von Excel -Dateien
• Straffung: Für die Entrance-Finish-Schnittstelle.
• Pandas, OS, JSON, Dedent und Google Genai als Assist -Module.

# Imports
import os
import json
import streamlit as st
from textwrap import dedent

from agno.agent import Agent
from agno.fashions.google import Gemini
from agno.instruments.file import FileTools

from openpyxl import load_workbook
from openpyxl.feedback import Remark
import pandas as pd

Großartig. Der nächste Schritt besteht darin, die Funktionen zu erstellen, die wir mit den Excel -Dateien verarbeiten und den AI -Agenten erstellen müssen.

Beachten Sie, dass alle Funktionen detailliert sind Docstrings. Dies ist beabsichtigt, da LLMs Docstrings verwenden, um zu wissen, was eine bestimmte Funktion tut, und zu entscheiden, ob sie sie als Werkzeug verwenden oder nicht.

Wenn Sie additionally Python -Funktionen als Instruments für einen KI -Agenten verwenden, sollten Sie detaillierte Dokals verwenden. Heutzutage mit kostenlosen Kopiloten wie Windsurf (6) Es ist noch einfacher, sie zu erstellen.

Konvertierung der Datei in CSV konvertieren

Diese Funktion wird:

• Nehmen Sie die Excel -Datei und lesen Sie nur die ersten 10 Zeilen. Dies reicht für uns aus, um an die LLM zu senden. Wenn wir dies tun, verhindern wir auch, dass zu viele Token als Enter gesendet und dieser Agent zu teuer wird.
• Speichern Sie die Datei als CSV, um sie als Eingabe für den AI -Agenten zu verwenden. Das CSV -Format ist für das Modell leichter, da es sich um eine von Kommas getrennte Texte handelt. Und wir wissen, dass LLMs glänzen, die mit Textual content arbeiten.

Hier ist die Funktion.

def convert_to_csv(file_path:str):
   """
    Use this device to transform the excel file to CSV.

    * file_path: Path to the Excel file to be transformed
    """
   # Load the file  
   df = pd.read_excel(file_path).head(10)

   # Convert to CSV
   st.write("Changing to CSV... :leftwards_arrow_with_hook:")
   return df.to_csv('temp.csv', index=False)

Lass uns weitermachen.

Erstellen des Agenten

Die nächste Funktion erstellt den AI -Agenten. Ich benutze Agno (1), da es sehr vielseitig und einfach zu bedienen ist. Ich habe auch das Modell ausgewählt Gemini 2.0 Flash. Während der Testphase battle dies das bester Modell, das die Datendokumente generierte. Um es zu verwenden, benötigen Sie einen API -Schlüssel von Google. Vergessen Sie nicht, einen hier zu bekommen (7).

Die Funktion:

• Empfängt die CSV -Ausgabe aus der vorherigen Funktion.
• Übergeht den AI -Agenten, der das Datenwörterbuch mit Spaltenname, Beschreibung und Datentyp erzeugt.
• Beachten Sie, dass die description Argument ist die Aufforderung für den Agenten. Machen Sie es detailliert und präzise.
• Das Datenwörterbuch wird als speichert als JSON Datei mit einem Software aufgerufen FileTools Das kann Dateien lesen und schreiben.
• Ich habe eingerichtet retries=2 So können wir bei einem ersten Versuch jeden Fehler umgehen.

def create_agent(apy_key):
    agent = Agent(
        mannequin=Gemini(id="gemini-2.0-flash", api_key=apy_key),
        description= dedent("""
                            You're an agent that reads the temp.csv dataset introduced to you and 
                            based mostly on the title and knowledge sort of every column header, decide the next info:
                            - The info varieties of every column
                            - The outline of every column
                            - The primary column numer is 0

                            Utilizing the FileTools supplied, create a knowledge dictionary in JSON format that features the under info:
                            {<ColNumber>: {ColName: <ColName>, DataType: <DataType>, Description: <Description>}}

                            If you're unable to find out the information sort or description of a column, return 'N/A' for that column for the lacking values.
                            
                            """),
        instruments=( FileTools(read_files=True, save_files=True) ),
        retries=2,
        show_tool_calls=True
        )

    return agent

OK. Jetzt brauchen wir eine andere Funktion, um das Datenwörterbuch in der Datei zu speichern.

Hinzufügen von Datenwörterbuch zum Header der Datei

Dies ist die letzte Funktion, die erstellt wurde. Es wird:

• Holen Sie sich das Datenwörterbuch json Aus dem vorherigen Schritt und der ursprünglichen Excel -Datei.
• Fügen Sie das Datenwörterbuch als Kommentare zum Header der Datei hinzu.
• Speichern Sie die Ausgabedatei.
• Sobald die Datei gespeichert ist, wird eine Obtain -Schaltfläche angezeigt, damit der Benutzer die geänderte Datei abgerufen hat.

def add_comments_to_header(file_path:str, data_dict:dict="data_dict.json"):
    """
    Use this device so as to add the information dictionary {data_dict.json} as feedback to the header of an Excel file and save the output file.

    The perform takes the Excel file path as argument and provides the {data_dict.json} as feedback to every cell
    Begin counting from column 0
    within the first row of the Excel file, utilizing the next format:    
        * Column Quantity: <column_number>
        * Column Title: <column_name>
        * Knowledge Kind: <data_type>
        * Description: <description>

    Parameters
    ----------
    * file_path : str
        The trail to the Excel file to be processed
    * data_dict : dict
        The info dictionary containing the column quantity, column title, knowledge sort, description, and variety of null values

    """
    
    # Load the information dictionary
    data_dict = json.load(open(data_dict))

    # Load the workbook
    wb = load_workbook(file_path)

    # Get the lively worksheet
    ws = wb.lively

    # Iterate over every column within the first row (header)
    for n, col in enumerate(ws.iter_cols(min_row=1, max_row=1)):
        for header_cell in col:
            header_cell.remark = Remark(dedent(f"""
                              ColName: {data_dict(str(n))('ColName')}, 
                              DataType: {data_dict(str(n))('DataType')},
                              Description: {data_dict(str(n))('Description')}
    """),'AI Agent')

    # Save the workbook
    st.write("Saving File... :floppy_disk:")
    wb.save('output.xlsx')

    # Create a obtain button
    with open('output.xlsx', 'rb') as f:
        st.download_button(
            label="Obtain output.xlsx",
            knowledge=f,
            file_name='output.xlsx',
            mime='utility/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        )

OK. Der nächste Schritt besteht darin, all dies auf einem streamlosen Entrance-Finish-Skript zusammenkleben zu können.

Straffes Entrance-Finish

In diesem Schritt hätte ich eine andere Datei für das Entrance-Finish erstellen und die Funktionen dort importieren können. Aber ich habe mich entschlossen, dieselbe Datei zu verwenden, additionally beginnen wir mit dem berühmten:

if __name__ == "__main__":

Zunächst einige Zeilen, um die in der Webanwendung angezeigte Seite und Nachrichten zu konfigurieren. Wir werden den Inhalt verwenden centered Auf der Seite, und es gibt einige Informationen darüber, wie die App funktioniert.

# Config web page Streamlit
    st.set_page_config(structure="centered", 
                       page_title="Knowledge Docs", 
                       page_icon=":paperclip:",
                       initial_sidebar_state="expanded")
    
    # Title
    st.title("Knowledge Docs :paperclip:")
    st.subheader("Generate a knowledge dictionary on your Excel file.")
    st.caption("1. Enter your Gemini API key and the trail of the Excel file on the sidebar.")
    st.caption("2. Run the agent.")
    st.caption("3. The agent will generate a knowledge dictionary and add it as feedback to the header of the Excel file.")
    st.caption("ColName: <ColName> | DataType: <DataType> | Description: <Description>")
    
    st.divider()

Als nächstes richten wir die Seitenleiste ein, in der der Benutzer seine API -Style von Google eingeben kann und a .xlsx Datei zu ändern.

Es gibt eine Schaltfläche, um die Anwendung auszuführen, eine andere zum Zurücksetzen des App -Standing und eine Fortschrittsleiste. Nichts Besonderes.

with st.sidebar:
        # Enter your API key
        st.caption("Enter your API key and the trail of the Excel file.")
        api_key = st.text_input("API key: ", placeholder="Google Gemini API key", sort="password")
        
        # Add file
        input_file = st.file_uploader("File add", 
                                       sort='xlsx')
        

        # Run the agent
        agent_run = st.button("Run")

        # progress bar
        progress_bar = st.empty()
        progress_bar.progress(0, textual content="Initializing...")

        st.divider()

        # Reset session state
        if st.button("Reset Session"):
            st.session_state.clear()
            st.rerun()

Einmal der laufen Die Schaltfläche wird geklickt. Sie löst den Relaxation des Codes aus, um den Agenten auszuführen. Hier ist die Abfolge der ausführten Schritte:

1. Die erste Funktion wird aufgerufen, um die Datei in CSV zu transformieren
2. Der Fortschritt ist in der Fortschrittsleiste registriert.
3. Der Agent wird erstellt.
4. Fortschrittsbalken aktualisiert.
5. Eine Eingabeaufforderung wird in den Agenten eingereicht, um die zu lesen temp.csv Datei, erstellen Sie das Datenwörterbuch und speichern Sie die Ausgabe auf data_dictionary.json.
6. Das Datenwörterbuch wird auf dem Bildschirm gedruckt, sodass der Benutzer sehen kann, was generiert wurde, während es in der Excel -Datei gespeichert wird.
7. Die Excel -Datei wird geändert und gespeichert.

# Create the agent
    if agent_run:
        # Convert Excel file to CSV
        convert_to_csv(input_file)

        # Register progress
        progress_bar.progress(15, textual content="Processing CSV...")

        # Create the agent
        agent = create_agent(api_key)

        # Begin the script
        st.write("Working Agent... :runner:")

        # Register progress
        progress_bar.progress(50, textual content="AI Agent is working...")

        # Run the agent    
        agent.print_response(dedent(f"""
                                1. Use FileTools to learn the temp.csv as enter to create the information dictionary for the columns within the dataset. 
                                2. Utilizing the FileTools device, save the information dictionary to a file named 'data_dict.json'.
                                
                                """),
                        markdown=True)

        # Print the information dictionary
        st.write("Producing Knowledge Dictionary... :page_facing_up:")
        with open('data_dict.json', 'r') as f:
            data_dict = json.load(f)
            st.json(data_dict, expanded=False)

        # Add feedback to header
        add_comments_to_header(input_file, 'data_dict.json')

        # Take away momentary recordsdata
        st.write("Eradicating momentary recordsdata... :wastebasket:")
        os.take away('temp.csv')
        os.take away('data_dict.json')    
    
    # If file exists, present success message
    if os.path.exists('output.xlsx'):
        st.success("Accomplished! :white_check_mark:")
        os.take away('output.xlsx')

    # Progress bar finish
    progress_bar.progress(100, textual content="Accomplished!")

Das battle’s. Hier ist eine Demonstration des Agenten in Aktion.

Schönes Ergebnis!

Versuchen Sie es

Sie können die bereitgestellte App hier ausprobieren: https://excel-datadocs.streamlit.app/

Bevor du gehst

Meiner bescheidenen Meinung nach verschwinden Excel -Dateien nicht so schnell. Wenn wir sie lieben oder hassen, müssen wir uns eine Weile bei ihnen halten.

Excel -Dateien sind vielseitig, einfach zu handhaben und zu teilen, daher sind sie immer noch sehr nützlich für die Routine advert hoc Aufgaben bei der Arbeit.

Jetzt können wir AI jedoch nutzen, um uns zu helfen, diese Dateien zu verarbeiten und sie besser zu machen. Künstliche Intelligenz Berührt so viele Punkte unseres Lebens. Die Routine und die Werkzeuge bei der Arbeit sind nur ein weiterer.

Nutzen wir die KI und arbeiten Sie jeden Tag clever!

Wenn Ihnen dieser Inhalt gefallen hat, finden Sie mehr von meiner Arbeit in meiner Web site und in meiner GitHub, die unten geteilt werden.

Github -Repository

Hier ist das Github -Repository für dieses Projekt.

https://github.com/gurezende/data-dictionary-genai

Finde mich

Sie können mehr über meine Arbeit auf meiner Web site finden.

https://gustavorantos.me

Referenzen

(1. Agno -Dokumente) https://docs.agno.com/inTroduction/brokers

(2. Openpyxl Dokumente) https://openpyxl.readthedocs.io/en/steady/index.html

(3. streamlit -docs) https://docs.streamlit.io/

(4. Datendocs Internet App) https://excel-datadocs.streamlit.app/

(5. UV installieren) https://docs.astral.sh/uv/getting-started/set up/

(6. Windsurf -Codierung Copilot) https://windsurf.com/vscode_tutorial

(7. Google Gemini API -Schlüssel) https://ai.google.dev/gemini-api/docs/api-key

Das letzte Mal, dass OpenAIs Chatgpt ein Bildgenerierungsmodell vorstellte, wurde es schnell viral im Web. Die Menschen waren fasziniert von der Fähigkeit zu schaffen Porträts im Ghibli-Stil von sich selbst, persönliche Erinnerungen in animierte Kunstwerke zu verwandeln. Jetzt geht ChatGPT einen Schritt weiter mit einem neuen nativ multimodalen Modell „GPT-Picture-1“, das die Bildgenerierung direkt innerhalb von ChatGPT versorgt und jetzt über API verfügbar ist. In diesem Artikel werden wir die wichtigsten Merkmale des GPT-Picture-1-Modells von OpenAI und die Verwendung für die Bildgenerierung und -bearbeitung untersuchen.

Was ist GPT-Picture-1?

GPT-Picture-1 ist das neueste und fortschrittlichste multimodale Sprachmodell von OpenAI. Es zeichnet sich aus, um hochwertige Bilder zu generieren und gleichzeitig das Wissen über reale Welt in den visuellen Inhalt einzubeziehen. Während GPT-Picture-1 für seine robuste Leistung empfohlen wird, unterstützt die Bild-API auch andere spezialisierte Modelle wie Dall · E 2 und Dall · e 3.

Die Bild -API bietet drei wichtige Endpunkte, die jeweils für bestimmte Aufgaben ausgelegt sind:

• Generationen: Erstellen Sie Bilder von Grund auf mit einer Textaufforderung.
• Änderungen: Ändern Sie vorhandene Bilder mithilfe einer neuen Eingabeaufforderung entweder teilweise oder vollständig.
• Variationen: Generieren Sie Variationen eines vorhandenen Bildes (nur mit Dall · e 2 verfügbar).

Lesen Sie auch: Imageen 3 gegen Dall-E 3: Welches ist das bessere Modell für Bilder?

Schlüsselmerkmale von GPT-Picture-1

GPT-Picture-1 bietet mehrere wichtige Funktionen:

• Excessive-Constancy-Bilder: Erzeugt detaillierte und genaue Bilder.
• Verschiedene visuelle Stile: Unterstützt eine Reihe von Ästhetik, von Foto realistisch bis abstrakt.
• Präzise Bildbearbeitung: Ermöglicht gezielte Modifikationen zu generierten Bildern.
• Reiches Weltwissen: Versteht komplexe Aufforderungen mit kontextbezogener Genauigkeit.
• Konsistente Textwiedergabe: Rendern Textual content in den Bildern zuverlässig.

Verfügbarkeit

Mit der OpenAI -API können Benutzer Bilder aus Texteingabeaufforderungen unter Verwendung der GPT -Picture oder Dall · e -Modelle generieren und bearbeiten. Derzeit ist die Bildgenerierung ausschließlich durch die Bild -API zugänglich, obwohl die Unterstützung für die Antworten -API aktiv entwickelt wird.

Weitere Informationen zu GPT-Picture-1-Klick Hier.

GPT-Picture-1-Preisgestaltung

Bevor Sie in die Verwendung und Bereitstellung des Modells eintauchen, ist es wichtig, die Preisgestaltung zu verstehen, um die effektive und budgetbewusste Verwendung zu gewährleisten.

Das GPT-Picture-1-Modell kostet professional Token mit unterschiedlichen Raten für Textual content- und Bild-Token:

• Texteingangs -Token (Eingabeaufforderungen): $ 5 professional 1 m Tokens
• Bildeingangs -Token (hochgeladene Bilder): $ 10 professional 1 m Tokens
• Bildausgabe -Token (generierte Bilder): $ 40 professional 1 m Tokens

In praktischer Hinsicht entspricht dies ungefähr:

• ~ $ 0.02 für ein quadratisches Bild von geringer Qualität
• ~ $ 0.07 für ein quadratisches Bild mittelgroß
• ~ 0,19 USD für ein hochwertiges quadratisches Bild

Weitere detailliertere Preise nach Bildqualität und -auflösung finden Sie auf der offiziellen Preisseite Hier.

Notiz: Dieses Modell generiert Bilder, indem zuerst spezielle Bildtoken erstellt werden. Daher hängen sowohl die Latenz als auch die Gesamtkosten von der Anzahl der verwendeten Token ab. Größere Bildabmessungen und Einstellungen mit höherer Qualität erfordern mehr Token, wodurch sowohl die Zeit als auch die Kosten erhöht werden.

Wie kann man GPT-Picture-1 zugreifen?

So generieren Sie den API-Schlüssel für GPT-Picture-1:

1. Melden Sie sich bei der OpenAI -Plattform an
2. Gehen Sie zu Mission> API -Schlüssel
3. Überprüfen Sie Ihr Konto

Zuerst besuchen Sie: https://platform.openai.com/setings/group/basic. Klicken Sie dann auf „Organisation überprüfen“, um den Überprüfungsprozess zu starten. Es ist ähnlich wie bei jeder KYC -Überprüfung, bei der abhängig vom Land aufgefordert wird, eine Foto -ID hochzuladen und sie dann mit einem Selfie zu überprüfen.

Sie können folgen Diese Dokumentation bereitgestellt von Open AI, um den Überprüfungsprozess besser zu verstehen.

Lesen Sie auch: Wie benutze ich Dall-e 3 API für die Bildgenerierung?

GPT-Picture-1: praktische Anwendung

Schließlich ist es Zeit zu sehen, wie wir Bilder mit der GPT-Picture-1-API generieren können.

Wir werden die verwenden Endpunkt der Bildgenerierung So erstellen Sie Bilder basierend auf Texteingabeaufforderungen. Standardmäßig gibt die API ein einzelnes Bild zurück, aber wir können den N -Parameter festlegen, um mehrere Bilder gleichzeitig in einer einzelnen Anforderung zu generieren.

Bevor wir unseren Hauptcode ausführen, müssen wir zuerst den Code für die Set up ausführen und die Umgebung einrichten.

!pip set up openai
import os
os.environ('OPENAI_API_KEY') = "<your-openai-api-key>"

Bilder mit GPT-Picture-1 generieren

Versuchen wir nun, ein Bild mit diesem neuen Modell zu generieren.

Eingabescode:

from openai import OpenAI
import base64
shopper = OpenAI()


immediate = """
A serene, peaceable park scene the place people and pleasant robots are having fun with the
day collectively - some are strolling, others are taking part in video games or sitting on benches
underneath bushes. The ambiance is heat and harmonious, with smooth daylight filtering
by means of the leaves.
"""


consequence = shopper.photographs.generate(
    mannequin="gpt-image-1",
    immediate=immediate
)


image_base64 = consequence.information(0).b64_json
image_bytes = base64.b64decode(image_base64)


# Save the picture to a file
with open("utter_bliss.png", "wb") as f:
    f.write(image_bytes)

Ausgabe:

Bearbeiten von Bildern mit GPT-Picture-1

GPT-Picture-1 bietet eine Reihe von Bildbearbeitungsoptionen. Das Bild bearbeitet Endpunkt lässt uns:

• Bestehende Bilder bearbeiten
• Generieren Sie neue Bilder mit anderen Bildern als Referenz
• Bearbeiten Sie Teile eines Bildes, indem Sie ein Bild und eine Maske hochladen, um anzugeben, welche Bereiche ersetzt werden sollen (ein Prozess, der als Inpacking bekannt ist)

Bearbeiten eines Bildes mit einer Maske

Versuchen wir, ein Bild mit einer Maske zu bearbeiten. Wir werden ein Bild hochladen und eine Maske bereitstellen, um anzugeben, welche Teile davon bearbeitet werden sollen.

Die transparenten Bereiche der Maske werden basierend auf der Eingabeaufforderung ersetzt, während die farbigen Bereiche unverändert bleiben.

Lassen Sie mich nun das Modell bitten, Elon Musk zu meinem hochgeladenen Bild hinzuzufügen.

Eingabescode:

from openai import OpenAI
shopper = OpenAI()


consequence = shopper.photographs.edit(
    mannequin="gpt-image-1",
    picture=open("/content material/analytics_vidhya_1024.png", "rb"),
    masks=open("/content material/mask_alpha_1024.png", "rb"),
    immediate="Elon Musk standing in entrance of Firm Brand"
)


image_base64 = consequence.information(0).b64_json
image_bytes = base64.b64decode(image_base64)


# Save the picture to a file
with open("Elon_AV.png", "wb") as f:
    f.write(image_bytes)

Ausgabe:

Zieh zu beachten, während ein Bild mit GPT-Picture-1 bearbeitet wird:

• Das Bild, das Sie bearbeiten möchten, und die entsprechende Maske muss im gleichen Format und in derselben Abmessungen sein, und jeder sollte weniger als 25 MB an Größe haben.
• Die Eingabeaufforderung, die Sie geben, kann verwendet werden, um das gesamte neue Bild zu beschreiben, nicht nur der Teil, der bearbeitet wird.
• Wenn Sie mehrere Eingangsbilder angeben, wird die Maske nur auf das erste Bild angewendet.
• Das Maskenbild muss einen Alpha -Kanal enthalten. Wenn Sie ein Bildbearbeitungswerkzeug verwenden, um die Maske zu erstellen, stellen Sie sicher, dass es mit einem aktivierten Alpha -Kanal gespeichert wird.
• Wenn Sie ein Schwarz-Weiß-Bild haben, können Sie ein Programm verwenden, um einen Alpha-Kanal hinzuzufügen und es in eine gültige Maske zu konvertieren, wie unten angegeben:

from PIL import Picture
from io import BytesIO


# 1. Load your black & white masks as a grayscale picture
masks = Picture.open("/content material/analytics_vidhya_masked.jpeg").convert("L")


# 2. Convert it to RGBA so it has house for an alpha channel
mask_rgba = masks.convert("RGBA")


# 3. Then use the masks itself to fill that alpha channel
mask_rgba.putalpha(masks)


# 4. Convert the masks into bytes
buf = BytesIO()
mask_rgba.save(buf, format="PNG")
mask_bytes = buf.getvalue()


# 5. Save the ensuing file
img_path_mask_alpha = "mask_alpha.png"
with open(img_path_mask_alpha, "wb") as f:
    f.write(mask_bytes)

Greatest Practices für die Verwendung des Modells

Hier sind einige Tipps und Greatest Practices, denen Sie bei der Verwendung von GPT-Picture-1 zum Generieren oder Bearbeiten von Bildern folgen müssen.

1. Sie können anpassen, wie Ihr Bild aussieht, indem Sie Optionen wie Größe, Qualität, Dateiformat, Komprimierungsstufe und ob der Hintergrund clear ist oder nicht. Diese Einstellungen helfen Ihnen bei der Steuerung der endgültigen Ausgabe, die Ihren spezifischen Anforderungen entspricht.
2. Für schnellere Ergebnisse gehen Sie mit quadratischen Bildern (1024 × 1024) und der Standardqualität. Sie können auch Porträt (1536 × 1024) oder Landschaftsformate (1024 × 1536) auswählen. Die Qualität kann auf niedrig, mittel oder hoch und sowohl die Größe als auch die Qualität des Requirements für automatisch eingestellt werden, wenn nicht angegeben.
3. Beachten Sie, dass die Bild-API die Basis64-kodierten Bilddaten zurückgibt. Das Standardformat ist PNG, aber wir können es auch in JPEG oder WebP anfordern.
4. Wenn Sie JPEG oder WebP verwenden, können Sie auch den Parameter output_compression angeben, um die Komprimierungsstufe (0-100%) zu steuern. Zum Beispiel wird Output_Compression = 50 das Bild um 50percentkomprimieren.

Anwendungen von GPT-Picture-1

GPT-Picture-1 hat eine breite Palette von Anwendungen.

• Spiele: Inhaltserstellung, Sprite -Masken, dynamische Hintergründe, Charaktergenerierung, Konzeptkunst
• Kreative Werkzeuge: Paintings -Generierung, Stilübertragung, Designprototyping, visuelles Geschichtenerzählen
• Ausbildung: visuelle Hilfsmittel, historische Erholungen, interaktive Lerninhalte, Konzeptvisualisierung
• Unternehmenssoftware: Folie-Visuals, Berichtsabbildungen, Daten zu Picture-Bild-Erzeugung, Branding-Vermögenswerte
• Werbung & Advertising: Kampagnen -Visuals, Social -Media -Grafiken, lokalisierte Inhaltserstellung
• Gesundheitspflege: Medizinische Illustration, Visualscan -Scan -Scan, synthetische Bilddaten für das Modelltraining
• Architektur & Immobilien: Innenmodelle, Außendrenderungen, Structure -Vorschau, Renovierungsideen
• Unterhaltung & Medien: Szenenkonzepte, Werbematerial, digitale Doppel

Einschränkungen von GPT-Picture-1

Das GPT-4O-Bildmodell ist ein leistungsstarkes und vielseitiges Werkzeug für die Bildgenerierung, aber es gibt noch einige Einschränkungen:

• Latenz: Die Bearbeitung kann bis zu 2 Minuten dauern.
• Textrendern: Obwohl das Modell wesentlich besser als die Dall · E -Modelle, kann es immer noch Herausforderungen mit präziser Textausrichtung und Klarheit haben.
• Konsistenz: Obwohl es visuell konsistente Bilder erzeugen kann, kann das Modell gelegentlich Schwierigkeiten haben, die Gleichmäßigkeit für wiederkehrende Zeichen oder Markenelemente über mehrere Bilder hinweg aufrechtzuerhalten.
• Kompositionskontrolle: Selbst mit verbesserten Funktionen für Anweisungen platziert das Modell möglicherweise nicht immer Elemente in strukturierten oder layoutempfindlichen Designs.

Modellvergleich

So ist das GPT-Picture-1 von OpenAI mit den beliebten Dall · e-Modellen:

Modell	Endpunkte	Merkmale
Dall · e 2	Generationen, Änderungen, Variationen	Niedrigere Kosten, unterstützt gleichzeitige Anfragen, umfasst die Inpackfunktionen
Dall · e 3	Nur Generationen	Höhere Auflösung und bessere Bildqualität als Dall · e 2
GPT-Picture-1	Generationen, Änderungen (Antworten API, die bald kommt)	Ausgezeichnete Anweisungen, detaillierte Änderungen, Bewusstsein in der Praxis

Abschluss

OpenAIs GPT-Picture-1 zeigt leistungsstarke Bildgenerierungsfunktionen mit Unterstützung für die Erstellung, Bearbeitung und Variationen, die alle aus einfachen Textanforderungen stammen. Während die Era von Bildern einige Zeit in Anspruch nehmen kann, machen die Qualität und die Kontrolle, die sie bietet, es insgesamt sehr praktisch und lohnend.

Modelle für Bildgenerierung wie diese ermöglichen die Erstellung, Personalisierung und das schnellere Prototyping inhaltlicher Inhalte. Mit integrierten Anpassungsoptionen für Größe, Qualität, Format usw. und sogar Einlackierungsfunktionen bietet GPT-Picture-1 Entwicklern die vollständige und transparente Kontrolle über die gewünschte Ausgabe.

Während einige befürchten, dass diese Technologie die menschliche Kreativität ersetzen könnte, ist es wichtig zu beachten, dass solche Instruments darauf abzielen, die menschliche Kreativität zu verbessern und hilfreiche Instrumente für Künstler zu sein. Obwohl wir die Originalität definitiv respektieren sollten, müssen wir auch die Bequemlichkeit, die diese Technologie mit sich bringt, einnehmen. Wir müssen das richtige Gleichgewicht finden, in dem solche Instruments uns helfen, innovativ zu sein, ohne den Wert der authentischen, von Menschen hergestellten Arbeiten wegzunehmen.

Die Videogenerierung aus dem Textual content hat einen langen Weg zurückgelegt, aber es trifft immer noch eine Wand, wenn es darum geht, längere, multiszene Geschichten zu produzieren. Während Diffusionsmodelle mögen SoraAnwesend Veound Filmgengen haben die Messlatte in visueller Qualität erhöht, sie sind in der Regel auf Clips über 20 Sekunden lang beschränkt. Die wahre Herausforderung? Kontext. Wenn Sie ein einminütiges, storysorientiertes Video aus einem Textabsatz erzeugen, müssen Modelle Hunderttausende von Token verarbeiten und gleichzeitig die narrative und visuelle Kohärenz beibehalten. Hier tritt diese neue Forschung von Nvidia, Stanford, UC Berkeley und anderen ein, um eine Technik namens Take a look at-Time Coaching (TTT) einzubringen, um die aktuellen Einschränkungen überschreiten.

Was ist das Downside mit langen Movies?

Transformatoren, insbesondere die in der Videogeneration verwendeten, verlassen sich darauf Selbstanhaltungsmechanismen. Diese skalieren aufgrund ihrer quadratischen Rechenkosten mit der Sequenzlänge schlecht. Der Versuch, eine vollständige Minute hochauflösender Movies mit dynamischen Szenen und konsistenten Charakteren zu generieren, bedeutet, dass über 300.000 Token von Informationen ein Jonglieren ist. Das macht das Modell über lange Strecken ineffizient und oft inkohärent.

Einige Groups haben versucht, dies durch wiederkehrende neuronale Netzwerke zu umgehen ((Rnns) Wie Mamba oder Deltanet, die eine lineare Kontextbearbeitung bieten. Diese Modelle komprimieren den Kontext jedoch in einen versteckten Zustand mit fester Größe, was die Ausdrucksfähigkeit einschränkt. Es ist, als würde man versuchen, einen ganzen Movie in eine Postkarte zu drücken, einige Particulars werden einfach nicht passen.

Wie löst TTT (Take a look at-Time-Coaching) das Downside?

Dieses Papier stammt aus der Idee, den verborgenen Zustand von RNNs ausdrucksvoller zu machen, indem er es in ein trainierbares neuronales Netzwerk selbst verwandelt. Insbesondere schlagen die Autoren vor, TTT-Schichten, im Wesentlichen kleine, zweischichtige MLPs, die sich bei der Verarbeitung von Eingangssequenzen an die Fliege anpassen. Diese Ebenen werden während der Inferenzzeit mit einem selbstbewerteten Verlust aktualisiert, der ihnen hilft, aus dem sich entwickelnden Kontext des Movies dynamisch zu lernen.

Stellen Sie sich ein Modell vor, das sich mitten im Flug anpasst: Wenn sich das Video entfaltet, passt sich sein internes Gedächtnis an, um die Charaktere, Bewegungen und Handlungen besser zu verstehen. Das ist es, was TTT ermöglicht.

Beispiele für einminütige Movies mit Testzeittraining

Hinzufügen von TTT-Schichten zu einem vorgebildeten Transformator

Durch das Hinzufügen von TTT-Schichten in einen vorgeborenen Transformator können ein Minute Movies mit starker zeitlicher Konsistenz und Bewegungsglättung erzeugt werden.

Immediate: “Jerry schnappt sich einen Käsekeil und Rennen um sein Mausloch mit Tom in der Verfolgung. Er schlüpft gerade noch rechtzeitig hinein und lässt Tom in die Wand stürzen. Protected und gemütlich genießt Jerry seinen Preis an einem winzigen Tisch und knabbert glücklich, während die Szene zu schwarz verblasst.“

Baseline -Vergleiche

TTT-MLP übertrifft alle anderen Basislinien in zeitlicher Konsistenz, Bewegungsglättigkeit und allgemeine Ästhetik, gemessen an der ELO-Werte für die menschliche Bewertung.

Immediate: “Tom isst glücklich einen Apfelkuchen am Küchentisch. Jerry sieht sehnsüchtig aus und wünscht, er hätte etwas. Jerry geht vor der Haustür des Hauses und klingelt die Türklingel. Während Tom kommt, um die Tür zu öffnen, rennt Jerry um den Rücken in die Küche. Jerry stiehlt Toms Apfelkuchen. Jerry rennt zu seinem Mausloch mit dem Kuchen, während Tom ihn jagt. Gerade als Tom Jerry fangen will, schafft er es durch das Mausloch und Tom schlägt in die Wand.“

Einschränkungen

Die erzeugten einminütigen Movies zeigen ein klares Potenzial als Proof of Idea, enthalten jedoch bemerkenswerte Artefakte.

Wie funktioniert es?

Das System beginnt mit einem vorgebildeten Diffusionstransformatormodell, Cogvideo-X 5b, das zuvor nur 3-Sekunden-Clips erzeugen konnte. Die Forscher fügten TTT -Schichten in das Modell ein und trainierten sie (zusammen mit lokalen Aufmerksamkeitsblöcken), um längere Sequenzen zu verarbeiten.

Um die Kosten zu verwalten, beschränkte sich die Selbstbekämpfung auf kurze 3-Sekunden-Segmente, während die TTT-Schichten die globale Erzählung in diesen Segmenten übernahmen. Die Architektur umfasst auch Gating -Mechanismen, um sicherzustellen, dass TTT -Schichten die Leistung während des frühen Trainings nicht beeinträchtigen.

Sie verbessern das Coaching weiter, indem sie Sequenzen bidirektional verarbeiten und Movies in kommentierten Szenen unterteilt. Beispielsweise wurde ein Storyboard-Format verwendet, um jedes 3-Sekunden-Phase ausführlich, Hintergründe, Charakterpositionen, Kamerawinkel und Aktionen zu beschreiben.

Der Datensatz: Tom & Jerry mit einer Wendung

Um die Forschung in einem konsistenten, intestine verstandenen visuellen Bereich zu erden, kuratierte das Staff einen Datensatz von über 7 Stunden klassischen Tom- und Jerry-Cartoons. Diese wurden in Szenen unterteilt und in 3-Sekunden-Segmente fein kommentiert. Indem die Forscher sich auf Cartoon -Daten konzentrierten, vermieden sie die Komplexität des Photorealismus und wurden über die Erzählkohärenz und die Bewegungsdynamik ausgerichtet.

Menschliche Annotatoren schrieben beschreibende Absätze für jedes Phase, um sicherzustellen, dass das Modell eine reichhaltige, strukturierte Eingabe hatte, daraus zu lernen. Dies ermöglichte auch ein mehrstufiges Coaching-erstmals in 3-Sekunden-Clips und nach und nach auf längeren Sequenzen bis zu 63 Sekunden.

Leistung: Funktioniert es tatsächlich?

Ja, und so beeindruckend. Als das TTT-MLP-Modell gegen führende Baselines wie Mamba 2, Gated Deltanet und Sliding-Window-Aufmerksamkeit in einer menschlichen Bewertung über 100 Movies übertrifft.

Die in Betracht gezogene Bewertung:

• Textausrichtung: Wie intestine das Video der Eingabeaufforderung folgt
• Bewegung Natürlichkeit: Realismus in Charakterbewegung
• Ästhetik: Beleuchtung, Farbe und visuelle Anziehungskraft
• Zeitliche Konsistenz: Visuelle Kohärenz über Szenen hinweg

TTT-MLP hat in Bewegung und Szenenkonsistenz besonders übertroffen und die logische Kontinuität über dynamische Aktionen hinweg aufrechterhalten-etwas, mit dem andere Modelle zu kämpfen hatten.

Artefakte und Einschränkungen

Trotz der vielversprechenden Ergebnisse gibt es immer noch Artefakte. Die Beleuchtung kann inkonsistent verändern oder Bewegung kann schwebend aussehen (z. B. unnatürlich schweben Käse). Diese Probleme sind wahrscheinlich mit den Einschränkungen des Basismodells Cogvideo-X verbunden. Ein weiterer Engpass ist Effizienz. Während TTT-MLP erheblich schneller ist als vollständige Selbstbekämpfungsmodelle (2,5-fache Beschleunigung), ist es immer noch langsamer als schlanke RNN-Ansätze wie Gated Deltanet. Trotzdem muss TTT nur fein abgestimmt sein-nicht von Grund auf neu trainiert-es für viele Anwendungsfälle praktischer macht.

Was lässt diesen Ansatz auffallen

• Ausdrucksgedächtnis: TTT verwandelt den versteckten Zustand von RNNs in ein trainierbares Netzwerk, was es weitaus ausdrucksvoller macht als eine Matrix mit fester Größe.
• Anpassungsfähigkeit: TTT -Schichten lernen und passen Sie sie während der Inferenz an, sodass sie in Echtzeit auf das entfaltende Video reagieren können.
• Skalierbarkeit: Mit genügend Ressourcen skaliert diese Methode längere und komplexere Videogeschichten.
• Praktische Feinabstimmung: Forscher fein nur die TTT-Schichten und -Tore, die immer wieder leichte und effizientes Coaching ausbilden.

Zukünftige Anweisungen

Das Staff weist auf verschiedene Expansionsmöglichkeiten hin:

• Optimierung des TTT -Kernels für eine schnellere Folgerung
• Experimentieren mit größeren oder verschiedenen Rückgratemodellen
• Erforschen noch komplexere Handlungsstränge und Domänen
• Verwendung von transformatorbasierten versteckten Zuständen anstelle von MLPs für noch mehr Ausdruckskraft

TTT Video Era gegen Mocha gegen Goku gegen Omnihuman1 gegen Dreamactor-M1

Die unten angegebene Tabelle erläutert den Unterschied zwischen diesem Modell und anderen Modellen für Trendungsvideogenerierung:

Lesen Sie auch:

Endnote

Das Take a look at-Time-Coaching bietet ein faszinierendes neues Objektiv für die Bekämpfung der langen Kontext-Videogeneration. Indem es das Modell während der Inferenz lernen und anpassen lässt, überbrückt es eine entscheidende Lücke im Geschichtenerzählen, eine Domäne, in der Kontinuität, Emotionen und Tempo genauso wichtig sind wie die visuelle Treue.

Ob Sie ein Forscher bei sind Generative Aiein kreativer Technologe oder ein Produktführer, das neugierig auf die nächsten A-generierten Medien kommt. Diese Arbeit ist ein Wegweiser, der auf die Zukunft der dynamischen, kohärenten Videosynthese aus Textual content hinweist.

Was sind synthetische Daten?

Daten, die von einem Pc erstellt wurden, der vorhandene Daten replizieren oder erweitert.

Warum ist es nützlich?

Wir alle haben den Erfolg von Chatgpt, Lama und in jüngerer Zeit von Deepseek erlebt. Diese Sprachmodelle werden allgegenwärtig in der gesamten Gesellschaft verwendet und haben viele Behauptungen ausgelöst, dass wir uns schnell künstliche allgemeine Intelligenz nähern – KI, die in der Lage sind, jede menschliche Funktion zu replizieren.

Bevor wir je nach Ihrer Perspektive zu aufgeregt oder verängstigt sind, nähern wir uns auch schnell einer Hürde für die Weiterentwicklung dieser Sprachmodelle. Laut einer von einer Gruppe des Forschungsinstituts, Epoch, veröffentlichten Arbeit (1)Anwesend Wir haben keine Daten mehr. Sie schätzen, dass wir bis 2028 die Obergrenze der möglichen Daten erreicht haben werden, an denen Sprachmodelle geschult sind.

Was passiert, wenn uns die Daten ausgehen?

Nun, wenn uns die Daten ausgehen, werden wir nichts Neues haben, mit dem wir unsere Sprachmodelle trainieren können. Diese Modelle werden dann nicht mehr verbessert. Wenn wir künstliche allgemeine Intelligenz verfolgen wollen, müssen wir neue Möglichkeiten zur Verbesserung der KI finden, ohne nur das Volumen der realen Trainingsdaten zu erhöhen.

Ein potenzieller Retter sind synthetische Daten, die generiert werden können, um vorhandene Daten nachzuahmen, und wurde bereits zur Verbesserung der Leistung von Modellen wie Gemini und DBRX verwendet.

Synthetische Daten jenseits der LLMs

Über die Überwindung der Datenknappheit für Großsprachmodelle hinaus können synthetische Daten in den folgenden Situationen verwendet werden:

• Wise Daten – Wenn wir keine sensiblen Attribute teilen oder verwenden möchten, können synthetische Daten generiert werden, die die Eigenschaften dieser Merkmale nachahmen und gleichzeitig die Anonymität aufrechterhalten.
• Teure Daten-Wenn das Sammeln von Daten teuer ist, können wir ein großes Volumen von synthetischen Daten aus einer kleinen Menge an realen Daten erzeugen.
• Datenmangel– Datensätze sind voreingenommen, wenn es eine unverhältnismäßig niedrige Anzahl einzelner Datenpunkte aus einer bestimmten Gruppe gibt. Synthetische Daten können verwendet werden, um einen Datensatz auszugleichen.

Unausgewogene Datensätze

Unausgeglichene Datensätze können (*, aber nicht immer*) problematisch sein, da sie möglicherweise nicht genügend Informationen enthalten, um ein prädiktives Modell effektiv zu schulen. Wenn beispielsweise ein Datensatz viel mehr Männer als Frauen enthält, kann unser Modell darauf verzerrt sein, Männer zu erkennen und zukünftige weibliche Proben als Männer falsch zu klassifizieren.

In diesem Artikel zeigen wir das Ungleichgewicht in der beliebten UCI Erwachsenen Datensatz (2), und wie wir a verwenden können Variations-Auto-Coder zu erzeugen Synthetische Daten Verbesserung der Klassifizierung in diesem Beispiel.

Wir laden zuerst den Datensatz für Erwachsene herunter. Dieser Datensatz enthält Funktionen wie Alter, Bildung und Beruf, mit denen das Zielergebnis „Einkommen“ vorhergesagt werden kann.

# Obtain dataset right into a dataframe
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/grownup/grownup.knowledge"
columns = (
   "age", "workclass", "fnlwgt", "schooling", "education-num", "marital-status",
   "occupation", "relationship", "race", "intercourse", "capital-gain",
   "capital-loss", "hours-per-week", "native-country", "earnings"
)
knowledge = pd.read_csv(url, header=None, names=columns, na_values=" ?", skipinitialspace=True)

# Drop rows with lacking values
knowledge = knowledge.dropna()

# Break up into options and goal
X = knowledge.drop(columns=("earnings"))
y = knowledge('earnings').map({'>50K': 1, '<=50K': 0}).values

# Plot distribution of earnings
plt.determine(figsize=(8, 6))
plt.hist(knowledge('earnings'), bins=2, edgecolor="black")
plt.title('Distribution of Revenue')
plt.xlabel('Revenue')
plt.ylabel('Frequency')
plt.present()

Im Datensatz für Erwachsene ist das Einkommen eine binäre Variable, die Personen, die oben und darunter 50.000 US -Greenback verdienen, repräsentiert. Wir zeichnen die Einkommensverteilung über den gesamten Datensatz unten dar. Wir können sehen, dass der Datensatz mit einer weitaus größeren Anzahl von Personen, die weniger als 50.000 US -Greenback verdienen, stark unausgewogen ist.

Trotz dieses Ungleichgewichts können wir immer noch einen Klassifizierer für maschinelles Lernen für den Datensatz für Erwachsene schulen, mit dem wir feststellen können, ob unsichtbare oder Assessments Einzelpersonen wie oben oder unter 50 km klassifiziert werden sollten.

# Preprocessing: One-hot encode categorical options, scale numerical options
numerical_features = ("age", "fnlwgt", "education-num", "capital-gain", "capital-loss", "hours-per-week")
categorical_features = (
   "workclass", "schooling", "marital-status", "occupation", "relationship",
   "race", "intercourse", "native-country"
)

preprocessor = ColumnTransformer(
   transformers=(
       ("num", StandardScaler(), numerical_features),
       ("cat", OneHotEncoder(), categorical_features)
   )
)

X_processed = preprocessor.fit_transform(X)

# Convert to numpy array for PyTorch compatibility
X_processed = X_processed.toarray().astype(np.float32)
y_processed = y.astype(np.float32)
# Break up dataset in practice and check units
X_model_train, X_model_test, y_model_train, y_model_test = train_test_split(X_processed, y_processed, test_size=0.2, random_state=42)


rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.match(X_model_train, y_model_train)

# Make predictions
y_pred = rf_classifier.predict(X_model_test)

# Show confusion matrix
plt.determine(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt="d", cmap="YlGnBu", xticklabels=("Destructive", "Constructive"), yticklabels=("Destructive", "Constructive"))
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix")
plt.present()

Das Ausdrucken der Verwirrungsmatrix unseres Klassifikators zeigt, dass unser Modell trotz des Ungleichgewichts ziemlich intestine funktioniert. Unser Modell hat eine Gesamtfehlerrate von 16%, aber die Fehlerrate für die optimistic Klasse (Einkommen> 50.000) beträgt 36%, wobei die Fehlerrate für die destructive Klasse (Einkommen <50K) 8% beträgt.

Diese Diskrepanz zeigt, dass das Modell tatsächlich in der negativen Klasse voreingenommen ist. Das Modell klassifiziert häufig Personen, die mehr als 50.000 als weniger als 50.000 verdienen.

Im Folgenden zeigen wir, wie wir a verwenden können Variations -Autocoder So generieren synthetische Daten der positiven Klasse, um diesen Datensatz auszugleichen. Anschließend trainieren wir das gleiche Modell mit dem synthetisch ausgeglichenen Datensatz und reduzieren Modellfehler im Testsatz.

Wie können wir synthetische Daten generieren?

Es gibt viele verschiedene Methoden zum Generieren von synthetischen Daten. Diese können traditionellere Methoden wie Smote und Gaußsche Rauschen umfassen, die neue Daten erzeugen, indem vorhandene Daten geändert werden. Alternativ generative Modelle wie variationsübergreifende Autoencoder oder allgemeine kontroverse Netzwerke sind prädisponiert, um neue Daten zu generieren, wenn ihre Architekturen die Verteilung realer Daten lernen und diese verwenden, um synthetische Proben zu generieren.

In diesem Tutorial verwenden wir einen variativen AutoCodierer, um synthetische Daten zu generieren.

Variations Autoencoder

Variational Autocoders (VAEs) eignen sich hervorragend für die Erzeugung der synthetischen Daten, da sie reale Daten verwenden, um einen kontinuierlichen latenten Raum zu erlernen. Wir können diesen latenten Raum als einen magischen Eimer betrachten, aus dem wir synthetische Daten probieren können, die den vorhandenen Daten stark ähneln. Die Kontinuität dieses Raums ist eines ihrer großen Verkaufsargumente, da das Modell das Modell intestine verallgemeinert und sich nicht nur den latenten Raum spezifischer Eingaben auswendig merkt.

Ein VAE besteht aus einer Encoder die Eingabedaten in eine Wahrscheinlichkeitsverteilung (Mittelwert und Varianz) und a abbilden Decoder die die Daten aus dem latenten Raum rekonstruiert.

Für diesen kontinuierlichen latenten Raum verwenden Vaes einen Reparameterizing -TrickAnwesend wobei ein zufälliger Rauschvektor unter Verwendung des gelernten Mittelwerts und der Varianz skaliert und verschoben wird, um reibungslose und kontinuierliche Darstellungen im latenten Raum zu gewährleisten.

Unten konstruieren wir a Basicvae Klasse, der diesen Prozess mit einer einfachen Architektur implementiert.

• Der EncoderKomprimiert die Eingabe in eine kleinere, verborgene Darstellung und erzeugt sowohl eine Mittelwert- als auch eine logarithmische Varianz, die eine Gaußsche Verteilung definiert, auch wenn wir unseren magischen Stichproben -Eimer erstellen. Anstelle einer direkten Abtastung wendet das Modell den Reparameterisierungstrick an, um latente Variablen zu erzeugen, die dann an den Decoder übergeben werden.
• Der DecoderRekonstruiert die ursprünglichen Daten aus diesen latenten Variablen und stellt sicher, dass die generierten Daten die Eigenschaften des ursprünglichen Datensatzes beibehalten.

class BasicVAE(nn.Module):
   def __init__(self, input_dim, latent_dim):
       tremendous(BasicVAE, self).__init__()
       # Encoder: Single small layer
       self.encoder = nn.Sequential(
           nn.Linear(input_dim, 8),
           nn.ReLU()
       )
       self.fc_mu = nn.Linear(8, latent_dim)
       self.fc_logvar = nn.Linear(8, latent_dim)
      
       # Decoder: Single small layer
       self.decoder = nn.Sequential(
           nn.Linear(latent_dim, 8),
           nn.ReLU(),
           nn.Linear(8, input_dim),
           nn.Sigmoid()  # Outputs values in vary (0, 1)
       )

   def encode(self, x):
       h = self.encoder(x)
       mu = self.fc_mu(h)
       logvar = self.fc_logvar(h)
       return mu, logvar

   def reparameterize(self, mu, logvar):
       std = torch.exp(0.5 * logvar)
       eps = torch.randn_like(std)
       return mu + eps * std

   def decode(self, z):
       return self.decoder(z)

   def ahead(self, x):
       mu, logvar = self.encode(x)
       z = self.reparameterize(mu, logvar)
       return self.decode(z), mu, logvar

Angesichts unserer BasicVae -Architektur konstruieren wir unsere Verlustfunktionen und unsere Modelltraining unten.

def vae_loss(recon_x, x, mu, logvar, tau=0.5, c=1.0):
   recon_loss = nn.MSELoss()(recon_x, x)
 
   # KL Divergence Loss
   kld_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
   return recon_loss + kld_loss / x.measurement(0)

def train_vae(mannequin, data_loader, epochs, learning_rate):
   optimizer = optim.Adam(mannequin.parameters(), lr=learning_rate)
   mannequin.practice()
   losses = ()
   reconstruction_mse = ()

   for epoch in vary(epochs):
       total_loss = 0
       total_mse = 0
       for batch in data_loader:
           batch_data = batch(0)
           optimizer.zero_grad()
           reconstructed, mu, logvar = mannequin(batch_data)
           loss = vae_loss(reconstructed, batch_data, mu, logvar)
           loss.backward()
           optimizer.step()
           total_loss += loss.merchandise()

           # Compute batch-wise MSE for comparability
           mse = nn.MSELoss()(reconstructed, batch_data).merchandise()
           total_mse += mse

       losses.append(total_loss / len(data_loader))
       reconstruction_mse.append(total_mse / len(data_loader))
       print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss:.4f}, MSE: {total_mse:.4f}")
   return losses, reconstruction_mse

combined_data = np.concatenate((X_model_train.copy(), y_model_train.cop
y().reshape(26048,1)), axis=1)

# Prepare-test break up
X_train, X_test = train_test_split(combined_data, test_size=0.2, random_state=42)

batch_size = 128

# Create DataLoaders
train_loader = DataLoader(TensorDataset(torch.tensor(X_train)), batch_size=batch_size, shuffle=True)
test_loader = DataLoader(TensorDataset(torch.tensor(X_test)), batch_size=batch_size, shuffle=False)

basic_vae = BasicVAE(input_dim=X_train.form(1), latent_dim=8)

basic_losses, basic_mse = train_vae(
   basic_vae, train_loader, epochs=50, learning_rate=0.001,
)

# Visualize outcomes
plt.determine(figsize=(12, 6))
plt.plot(basic_mse, label="Fundamental VAE")
plt.ylabel("Reconstruction MSE")
plt.title("Coaching Reconstruction MSE")
plt.legend()
plt.present()

VAE_LOSS besteht aus zwei Komponenten: Wiederaufbauverlustwas misst, wie intestine die generierten Daten mit dem ursprünglichen Eingang mit dem mittleren Quadratfehler (MSE) übereinstimmen, und KL -Divergenzverlustwas sicherstellt, dass der gelehrte latente Raum einer Normalverteilung folgt.

Train_vaeOptimiert die VAE mit dem Adam -Optimierer über mehrere Epochen. Während des Trainings nimmt das Modell Minibatches von Daten, rekonstruiert sie und berechnet den Verlust mithilfe VAE_LOSS. Diese Fehler werden dann über die Backpropagation korrigiert, bei der die Modellgewichte aktualisiert werden. Wir trainieren das Modell für 50 Epochen und zeichnen, wie der Rekonstruktionsmittel -quadratische Fehler beim Coaching abnimmt.

Wir können sehen, dass unser Modell schnell lernt, wie wir unsere Daten rekonstruieren und ein effizientes Lernen belegen.

Jetzt haben wir unsere Basicvae geschult, um den Datensatz für Erwachsene genau zu rekonstruieren, den wir jetzt verwenden können, um synthetische Daten zu generieren. Wir möchten mehr Proben der positiven Klasse (Personen, die über 50.000 verdienen) generieren, um die Klassen auszugleichen und die Verzerrung aus unserem Modell zu entfernen.

Dazu wählen wir alle Stichproben aus unserem VAE -Datensatz aus, in dem das Einkommen die optimistic Klasse ist (verdienen mehr als 50.000). Anschließend codieren wir diese Proben in den latenten Raum. Da wir nur Proben der positiven Klasse ausgewählt haben, um zu codieren, spiegelt dieser latente Raum die Eigenschaften der positiven Klasse wider, aus der wir synthetische Daten erstellen können.

Wir probieren 15000 neue Proben aus diesem latenten Raum und dekodieren diese latenten Vektoren als unsere synthetischen Datenpunkte wieder in den Eingangsdatenraum.

# Create column names
col_number = sample_df.form(1)
col_names = (str(i) for i in vary(col_number))
sample_df.columns = col_names

# Outline the function worth to filter
feature_value = 1.0  # Specify the function worth - right here we set the earnings to 1

# Set all earnings values to 1 : Over 50k
selected_samples = sample_df(sample_df(col_names(-1)) == feature_value)
selected_samples = selected_samples.values
selected_samples_tensor = torch.tensor(selected_samples, dtype=torch.float32)

basic_vae.eval()  # Set mannequin to analysis mode
with torch.no_grad():
   mu, logvar = basic_vae.encode(selected_samples_tensor)
   latent_vectors = basic_vae.reparameterize(mu, logvar)

# Compute the imply latent vector for this function
mean_latent_vector = latent_vectors.imply(dim=0)


num_samples = 15000  # Variety of new samples
latent_dim = 8
latent_samples = mean_latent_vector + 0.1 * torch.randn(num_samples, latent_dim)

with torch.no_grad():
   generated_samples = basic_vae.decode(latent_samples)

Jetzt haben wir synthetische Daten der positiven Klasse generiert. Wir können diese mit den ursprünglichen Trainingsdaten kombinieren, um einen ausgewogenen synthetischen Datensatz zu generieren.

new_data = pd.DataFrame(generated_samples)

# Create column names
col_number = new_data.form(1)
col_names = (str(i) for i in vary(col_number))
new_data.columns = col_names

X_synthetic = new_data.drop(col_names(-1),axis=1)
y_synthetic = np.asarray((1 for _ in vary(0,X_synthetic.form(0))))

X_synthetic_train = np.concatenate((X_model_train, X_synthetic.values), axis=0)
y_synthetic_train = np.concatenate((y_model_train, y_synthetic), axis=0)

mapping = {1: '>50K', 0: '<=50K'}
map_function = np.vectorize(lambda x: mapping(x))
# Apply mapping
y_mapped = map_function(y_synthetic_train)

plt.determine(figsize=(8, 6))
plt.hist(y_mapped, bins=2, edgecolor="black")
plt.title('Distribution of Revenue')
plt.xlabel('Revenue')
plt.ylabel('Frequency')
plt.present()

Wir können jetzt unseren ausgewogenen Trainings -synthetischen Datensatz verwenden, um unseren zufälligen Waldklassifizierer zu übertreffen. Anschließend können wir dieses neue Modell für die ursprünglichen Testdaten bewerten, um zu sehen, wie effektiv unsere synthetischen Daten bei der Reduzierung der Modellverzerrung sind.

rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.match(X_synthetic_train, y_synthetic_train)

# Step 5: Make predictions
y_pred = rf_classifier.predict(X_model_test)

cm = confusion_matrix(y_model_test, y_pred)

# Create heatmap
plt.determine(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt="d", cmap="YlGnBu", xticklabels=("Destructive", "Constructive"), yticklabels=("Destructive", "Constructive"))
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix")
plt.present()

Unser neuer Klassifizierer, der auf dem ausgewogenen synthetischen Datensatz trainiert wurde, macht weniger Fehler im Authentic -Testsatz als unser ursprünglicher Klassifikator, der auf dem unausgeglichenen Datensatz trainiert wurde, und unsere Fehlerrate wird nun auf 14percentreduziert.

Wir konnten jedoch nicht die Diskrepanz der Fehler um einen signifikanten Betrag reduzieren. Unsere Fehlerrate für die optimistic Klasse beträgt immer noch 36%. Dies könnte an die folgenden Gründe zurückzuführen sein:

• Wir haben diskutiert, wie einer der Vorteile von Vaes das Erlernen eines kontinuierlichen latenten Raums ist. Wenn die Mehrheitsklasse jedoch dominiert, kann der latente Raum der Mehrheitsklasse zugute kommen.
• Das Modell hat aufgrund des Mangels an Daten möglicherweise keine eindeutige Darstellung für die Minderheitenklasse richtig gelernt, wodurch es schwierig ist, aus diesem Bereich genau zu probieren.

In diesem Tutorial haben wir eine BasicVae -Architektur eingeführt und erstellt, mit der synthetische Daten generiert werden können, die die Klassifizierungsgenauigkeit auf einem unausgeglichenen Datensatz verbessert.

Folgen Sie zukünftigen Artikeln, in denen ich zeigen werde, wie wir anspruchsvollere VAE -Architekturen aufbauen können, die die oben genannten Probleme mit unausgeglichener Stichproben und vielem mehr angehen.

(1) Villalobos, P., Ho, A., Sevilla, J., Besiroglu, T., Heim, L. & Hobbhahn, M. (2024). Werden uns die Daten ausgehen? Grenzen der LLM-Skalierung basierend auf Daten von Menschen erzeugten Daten. Arxiv Preprint Arxiv: 2211.04325Anwesend 3.

(2) Becker, B. & Kohavi, R. (1996). Erwachsener (Datensatz). UCI maschinelles Lernen Repository. https://doi.org/10.24432/c5xw20.