In diesem Schritt-für-Schritt-Tutorial erfahren Sie, wie Sie mithilfe großer Sprachmodelle (LLMs) eine genaue und zuverlässige Textklassifizierungspipeline erstellen. LLMs sind leistungsstarke, generalistische Modelle, die bei verschiedenen Aufgaben der Verarbeitung natürlicher Sprache bemerkenswerte Fähigkeiten bewiesen haben und in vielen KI-Anwendungen zunehmend Spezialmodelle ersetzen. Allerdings kann die Verwendung von LLMs zur Klassifizierung schwierig sein, wenn sie nicht sorgfältig angegangen wird.

Ein häufiges Downside bei der Anwendung von LLMs zur Klassifizierung besteht darin, dass das Modell möglicherweise nicht mit der erwarteten Ausgabe oder dem erwarteten Format reagiert, was zu einer zusätzlichen Nachbearbeitung führt, die komplex und zeitintensiv sein kann. In diesem Beitrag behandeln wir praktische Tipps und Techniken zur Bewältigung dieser Herausforderungen. Jede dieser Strategien ist einfach zu implementieren, kann jedoch sowohl die Genauigkeit als auch die Benutzerfreundlichkeit von LLMs als Textklassifikatoren erheblich verbessern. Lassen Sie uns eintauchen, um Ihr LLM-Textklassifizierungssystem sowohl effizient als auch zuverlässig zu machen.

In diesem Tutorial werden wir drei Schlüsseltechniken untersuchen, die LLMs als Textklassifikatoren weitaus effektiver und effizienter machen können. Auf die Feinabstimmung gehen wir nicht ein…

Giant Language Fashions (LLMs) sind großartig, wenn es darum geht, Textual content zu generieren, aber um strukturierte Ausgabe wie JSON zu erhalten, muss man normalerweise geschickt vorgehen und hoffen, dass das LLM es versteht. Glücklicherweise JSON-Modus wird in LLM-Frameworks und -Diensten immer häufiger verwendet. Damit können Sie das gewünschte Ausgabeschema genau definieren.

Dieser Beitrag befasst sich mit der eingeschränkten Generierung im JSON-Modus. Wir verwenden ein komplexes, verschachteltes und realistisches JSON-Schemabeispiel, um LLM-Frameworks/APIs wie Llama.cpp oder Gemini API bei der Generierung strukturierter Daten, insbesondere touristischer Standortinformationen, anzuleiten. Dies baut auf einem früheren Beitrag über die eingeschränkte Generierung mit Anleitungkonzentriert sich aber auf den weiter verbreiteten JSON-Modus.

Zwar eingeschränkter als Anleitungdie breitere Unterstützung des JSON-Modus macht ihn zugänglicher, insbesondere bei Cloud-basierten LLM-Anbietern.

Während eines persönlichen Projekts habe ich festgestellt, dass der JSON-Modus mit Llama.cpp zwar unkompliziert struggle, aber einige zusätzliche Schritte erforderlich waren, um ihn mit der Gemini-API zum Laufen zu bringen. In diesem Beitrag werden diese Lösungen vorgestellt, damit Sie den JSON-Modus effektiv nutzen können.

Unser Beispielschema stellt ein TouristLocation. Es ist eine nicht triviale Struktur mit verschachtelten Objekten, Pay attention, Enumerationen und verschiedenen Datentypen wie Zeichenfolgen und Zahlen.

Hier ist eine vereinfachte Model:

{
"identify": "string",
"location_long_lat": ("quantity", "quantity"),
"climate_type": {"kind": "string", "enum": ("tropical", "desert", "temperate", "continental", "polar")},
"activity_types": ("string"),
"attraction_list": (
{
"identify": "string",
"description": "string"
}
),
"tags": ("string"),
"description": "string",
"most_notably_known_for": "string",
"location_type": {"kind": "string", "enum": ("metropolis", "nation", "institution", "landmark", "nationwide park", "island", "area", "continent")},
"mother and father": ("string")
}

Sie können dieses Schema von Hand schreiben oder mithilfe der Pydantic-Bibliothek generieren. Hier sehen Sie anhand eines vereinfachten Beispiels, wie Sie es machen können:

from typing import Record
from pydantic import BaseModel, Area
class TouristLocation(BaseModel):
"""Mannequin for a vacationer location"""
high_season_months: Record(int) = Area(
(), description="Record of months (1-12) when the situation is most visited"
)
tags: Record(str) = Area(
...,
description="Record of tags describing the situation (e.g. accessible, sustainable, sunny, low cost, expensive)",
min_length=1,
)
description: str = Area(..., description="Textual content description of the situation")
# Instance utilization and schema output
location = TouristLocation(
high_season_months=(6, 7, 8),
tags=("seaside", "sunny", "family-friendly"),
description="A stupendous seaside with white sand and clear blue water.",
)
schema = location.model_json_schema()
print(schema)

Dieser Code definiert eine vereinfachte Model von TouristLocation Datenklasse mit Pydantic. Sie hat drei Felder:

• high_season_months: Eine Liste von Ganzzahlen, die die Monate des Jahres (1-12) darstellen, in denen der Ort am häufigsten besucht wird. Standardmäßig ist die Liste leer.
• tags: Eine Liste von Zeichenfolgen, die den Standort mit Tags wie „zugänglich“, „nachhaltig“ usw. beschreiben. Dieses Feld ist erforderlich (...) und muss mindestens ein Component (min_length=1).
• description: Ein Zeichenfolgenfeld mit einer Textbeschreibung des Standorts. Dieses Feld ist ebenfalls erforderlich.

Der Code erstellt dann eine Instanz des TouristLocation Klasse und Verwendungen model_json_schema() um die JSON-Schemadarstellung des Modells zu erhalten. Dieses Schema definiert die Struktur und Typen der für diese Klasse erwarteten Daten.

model_json_schema() Rückgabewerte:

{'description': 'Mannequin for a vacationer location',
'properties': {'description': {'description': 'Textual content description of the '
'location',
'title': 'Description',
'kind': 'string'},
'high_season_months': {'default': (),
'description': 'Record of months (1-12) '
'when the situation is '
'most visited',
'gadgets': {'kind': 'integer'},
'title': 'Excessive Season Months',
'kind': 'array'},
'tags': {'description': 'Record of tags describing the situation '
'(e.g. accessible, sustainable, sunny, '
'low cost, expensive)',
'gadgets': {'kind': 'string'},
'minItems': 1,
'title': 'Tags',
'kind': 'array'}},
'required': ('tags', 'description'),
'title': 'TouristLocation',
'kind': 'object'}

Nachdem wir nun unser Schema haben, schauen wir, wie wir es durchsetzen können. Zuerst in Llama.cpp mit seinem Python-Wrapper und dann mit der API von Gemini.

Llama.cpp, eine C++-Bibliothek zum lokalen Ausführen von Llama-Modellen. Sie ist anfängerfreundlich und hat eine aktive Group. Wir werden sie über ihren Python-Wrapper verwenden.

So generieren Sie TouristLocation Daten damit:

# Imports and stuff
# Mannequin init:
checkpoint = "lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF"
mannequin = Llama.from_pretrained(
repo_id=checkpoint,
n_gpu_layers=-1,
filename="*Q4_K_M.gguf",
verbose=False,
n_ctx=12_000,
)
messages = (
{
"position": "system",
"content material": "You're a useful assistant that outputs in JSON."
f"Observe this schema {TouristLocation.model_json_schema()}",
},
{"position": "person", "content material": "Generate details about Hawaii, US."},
{"position": "assistant", "content material": f"{location.model_dump_json()}"},
{"position": "person", "content material": "Generate details about Casablanca"},
)
response_format = {
"kind": "json_object",
"schema": TouristLocation.model_json_schema(),
}
begin = time.time()
outputs = mannequin.create_chat_completion(
messages=messages, max_tokens=1200, response_format=response_format
)
print(outputs("selections")(0)("message")("content material"))
print(f"Time: {time.time() - begin}")

Der Code importiert zunächst die erforderlichen Bibliotheken und initialisiert das LLM-Modell. Anschließend definiert er eine Liste von Nachrichten für eine Konversation mit dem Modell, darunter eine Systemnachricht, die das Modell anweist, gemäß einem bestimmten Schema im JSON-Format auszugeben, Benutzeranfragen nach Informationen über Hawaii und Casablanca und eine Assistentenantwort unter Verwendung des angegebenen Schemas.

Llama.cpp verwendet im Hintergrund kontextfreie Grammatiken, um die Struktur einzuschränken und gültige JSON-Ausgabe für eine neue Stadt zu generieren.

In der Ausgabe erhalten wir den folgenden generierten String:

{'activity_types': ('buying', 'meals and wine', 'cultural'),
'attraction_list': ({'description': 'One of many largest mosques on the planet '
'and a logo of Moroccan structure',
'identify': 'Hassan II Mosque'},
{'description': 'A historic walled metropolis with slim '
'streets and conventional outlets',
'identify': 'Previous Medina'},
{'description': 'A historic sq. with a phenomenal '
'fountain and surrounding buildings',
'identify': 'Mohammed V Sq.'},
{'description': 'A stupendous Catholic cathedral in-built '
'the early twentieth century',
'identify': 'Casablanca Cathedral'},
{'description': 'A scenic waterfront promenade with '
'lovely views of town and the ocean',
'identify': 'Corniche'}),
'climate_type': 'temperate',
'description': 'A big and bustling metropolis with a wealthy historical past and tradition',
'location_type': 'metropolis',
'most_notably_known_for': 'Its historic structure and cultural '
'significance',
'identify': 'Casablanca',
'mother and father': ('Morocco', 'Africa'),
'tags': ('metropolis', 'cultural', 'historic', 'costly')}

Dieses kann dann in eine Instanz unserer Pydantic-Klasse analysiert werden.

Gemini API, der von Google verwaltete LLM-Dienst, behauptet in seiner Dokumentation, dass der JSON-Modus für Gemini Flash 1.5 nur eingeschränkt unterstützt wird. Mit ein paar Anpassungen lässt sich dies jedoch zum Laufen bringen.

Hier sind die allgemeinen Anweisungen, damit es funktioniert:

schema = TouristLocation.model_json_schema()
schema = replace_value_in_dict(schema.copy(), schema.copy())
del schema("$defs")
delete_keys_recursive(schema, key_to_delete="title")
delete_keys_recursive(schema, key_to_delete="location_long_lat")
delete_keys_recursive(schema, key_to_delete="default")
delete_keys_recursive(schema, key_to_delete="default")
delete_keys_recursive(schema, key_to_delete="minItems")
print(schema)
messages = (
ContentDict(
position="person",
elements=(
"You're a useful assistant that outputs in JSON."
f"Observe this schema {TouristLocation.model_json_schema()}"
),
),
ContentDict(position="person", elements=("Generate details about Hawaii, US.")),
ContentDict(position="mannequin", elements=(f"{location.model_dump_json()}")),
ContentDict(position="person", elements=("Generate details about Casablanca")),
)
genai.configure(api_key=os.environ("GOOGLE_API_KEY"))
# Utilizing `response_mime_type` with `response_schema` requires a Gemini 1.5 Professional mannequin
mannequin = genai.GenerativeModel(
"gemini-1.5-flash",
# Set the `response_mime_type` to output JSON
# Move the schema object to the `response_schema` subject
generation_config={
"response_mime_type": "software/json",
"response_schema": schema,
},
)
response = mannequin.generate_content(messages)
print(response.textual content)

So überwinden Sie die Einschränkungen von Gemini:

1. Ersetzen $ref mit vollständigen Definitionen: Gemini stolpert über Schemareferenzen ($ref). Diese werden verwendet, wenn Sie eine verschachtelte Objektdefinition haben. Ersetzen Sie sie durch die vollständige Definition aus Ihrem Schema.

def replace_value_in_dict(merchandise, original_schema):
# Supply: https://github.com/pydantic/pydantic/points/889
if isinstance(merchandise, checklist):
return (replace_value_in_dict(i, original_schema) for i in merchandise)
elif isinstance(merchandise, dict):
if checklist(merchandise.keys()) == ("$ref"):
definitions = merchandise("$ref")(2:).break up("/")
res = original_schema.copy()
for definition in definitions:
res = res(definition)
return res
else:
return {
key: replace_value_in_dict(i, original_schema)
for key, i in merchandise.gadgets()
}
else:
return merchandise

1. Nicht unterstützte Schlüssel entfernen: Gemini verarbeitet noch keine Schlüssel wie „title“, „AnyOf“ oder „minItems“. Entfernen Sie diese aus Ihrem Schema. Dies hat zur Folge, dass das Schema weniger lesbar und weniger restriktiv ist, aber wir haben keine andere Wahl, wenn wir auf der Verwendung von Gemini bestehen.

def delete_keys_recursive(d, key_to_delete):
if isinstance(d, dict):
# Delete the important thing if it exists
if key_to_delete in d:
del d(key_to_delete)
# Recursively course of all gadgets within the dictionary
for ok, v in d.gadgets():
delete_keys_recursive(v, key_to_delete)
elif isinstance(d, checklist):
# Recursively course of all gadgets within the checklist
for merchandise in d:
delete_keys_recursive(merchandise, key_to_delete)

1. One-Shot- oder Few-Shot-Eingabeaufforderung für Enums: Gemini hat manchmal Probleme mit Enums und gibt alle möglichen Werte aus, anstatt einer einzigen Auswahl. Die Werte werden außerdem durch „|” in einer einzigen Saite, wodurch sie ungültig gemäß unserem Schema. Verwenden Sie einmalige Eingabeaufforderungen und geben Sie ein korrekt formatiertes Beispiel an, um das gewünschte Verhalten zu erreichen.

Indem Sie diese Transformationen anwenden und klare Beispiele angeben, können Sie mit der Gemini-API erfolgreich strukturierte JSON-Ausgaben generieren.

Im JSON-Modus können Sie strukturierte Daten direkt aus Ihren LLMs abrufen, wodurch diese für praktische Anwendungen nützlicher werden. Während Frameworks wie Llama.cpp unkomplizierte Implementierungen bieten, können bei Cloud-Diensten wie Gemini API Probleme auftreten.

Hoffentlich hat Ihnen dieser Weblog ein besseres praktisches Verständnis dafür vermittelt, wie der JSON-Modus funktioniert und wie Sie ihn auch bei Verwendung der API von Gemini nutzen können, die bisher nur teilweise unterstützt wird.

Nachdem ich Gemini nun einigermaßen im JSON-Modus zum Laufen bringen konnte, kann ich die Implementierung meines LLM-Workflows abschließen, bei dem eine bestimmte Datenstrukturierung erforderlich ist.

Den Hauptcode dieses Beitrags finden Sie hier: https://gist.github.com/CVxTz/8eace07d9bd2c5123a89bf790b5cc39e

Die meisten Tutorials zum maschinellen Lernen konzentrieren sich auf synchrones Serving in Echtzeit, das sofortige Antworten auf Vorhersageanfragen ermöglicht. Dieser Ansatz kann jedoch bei Datenverkehrsspitzen Probleme bereiten und ist für Aufgaben mit langer Laufzeit nicht preferrred. Außerdem sind leistungsstärkere Maschinen erforderlich, um schnell reagieren zu können, und wenn der Shopper oder Server ausfällt, geht das Vorhersageergebnis normalerweise verloren.

In diesem Blogbeitrag zeigen wir, wie man ein Machine-Studying-Modell als asynchronen Employee mit Celery und Redis ausführt. Wir verwenden das Florence-2-Basismodell, ein Imaginative and prescient-Sprachmodell, das für seine beeindruckende Leistung bekannt ist. Dieses Tutorial bietet ein minimales, aber funktionales Beispiel, das Sie für Ihre eigenen Anwendungsfälle anpassen und erweitern können.

Sie können hier eine Demo der App ansehen: https://caption-app-dfmj3maizq-ew.a.run.app/

Der Kern unserer Lösung basiert auf Celery, einer Python-Bibliothek, die diese Shopper/Employee-Logik für uns implementiert. Sie ermöglicht es uns, die Rechenarbeit auf viele Employee zu verteilen und so die Skalierbarkeit Ihres ML-Inferenz-Anwendungsfalls auf hohe und unvorhersehbare Lasten zu verbessern.

Der Ablauf funktioniert folgendermaßen:

1. Der Shopper übermittelt eine Aufgabe mit einigen Parametern an eine vom Dealer verwaltete Warteschlange (in unserem Beispiel Redis).
2. Ein (oder mehrere) Employee überwacht kontinuierlich die Warteschlange und nimmt eingehende Aufgaben auf. Anschließend führt er sie aus und speichert das Ergebnis im Backend-Speicher.
3. Der Shopper kann das Ergebnis der Aufgabe anhand seiner ID abrufen, indem er entweder das Backend abfragt oder den Kanal der Aufgabe abonniert.

Beginnen wir mit einem vereinfachten Beispiel:

Führen Sie zuerst Redis aus:

docker run -p 6379:6379 redis

Hier ist der Employee-Code:

from celery import Celery
# Configure Celery to make use of Redis because the dealer and backend
app = Celery(
"duties", dealer="redis://localhost:6379/0", backend="redis://localhost:6379/0"
)
# Outline a easy activity
@app.activity
def add(x, y):
return x + y
if __name__ == "__main__":
app.worker_main(("employee", "--loglevel=information"))

Und der Clientcode:

from celery import Celery
app = Celery("duties", dealer="redis://localhost:6379/0", backend="redis://localhost:6379/0")
print(f"{app.management.examine().lively()=}")
task_name = "duties.add"
add = app.signature(task_name)
print("Gotten Process")
# Ship a activity to the employee
outcome = add.delay(4, 6)
print("Ready for Process")
outcome.wait()
# Get the outcome
print(f"Consequence: {outcome.outcome}")

Dies ergibt das erwartete Ergebnis: „Ergebnis: 10“

Kommen wir nun zum eigentlichen Anwendungsfall: Bereitstellung von Florence 2.

Wir werden eine Multi-Container-Bildunterschriftsanwendung erstellen, die Redis für die Aufgabenwarteschlange, Celery für die Aufgabenverteilung und ein lokales Quantity oder Google Cloud Storage für die potenzielle Bildspeicherung verwendet. Die Anwendung besteht aus wenigen Kernkomponenten: Modellinferenz, Aufgabenverteilung, Shopper-Interaktion und Dateispeicherung.

Architekturübersicht:

1. Klient: Initiiert Bildbeschriftungsanfragen, indem diese (über den Dealer) an den Employee gesendet werden.
2. Arbeiter: Empfängt Anfragen, lädt Bilder herunter, führt Inferenzen mithilfe des vortrainierten Modells durch und gibt Ergebnisse zurück.
3. Redis: Fungiert als Nachrichtenbroker und erleichtert die Kommunikation zwischen Shopper und Employee.
4. Dateispeicher: Temporärer Speicher für Bilddateien

Komponentenaufschlüsselung:

1. Modellinferenz (mannequin.py):

• Abhängigkeiten und Initialisierung:

import os
from io import BytesIO
import requests
from google.cloud import storage
from loguru import logger
from modeling_florence2 import Florence2ForConditionalGeneration
from PIL import Picture
from processing_florence2 import Florence2Processor
mannequin = Florence2ForConditionalGeneration.from_pretrained(
"microsoft/Florence-2-base-ft"
)
processor = Florence2Processor.from_pretrained("microsoft/Florence-2-base-ft")

• Importiert die erforderlichen Bibliotheken für die Bildverarbeitung, Webanforderungen, Google Cloud Storage-Interaktion und Protokollierung.
• Initialisiert das vortrainierte Florence-2-Modell und den Prozessor zur Bildunterschriftengenerierung.
• Bild-Obtain (download_image):

def download_image(url):
if url.startswith("http://") or url.startswith("https://"):
# Deal with HTTP/HTTPS URLs
# ... (code to obtain picture from URL) ...
elif url.startswith("gs://"):
# Deal with Google Cloud Storage paths
# ... (code to obtain picture from GCS) ...
else:
# Deal with native file paths
# ... (code to open picture from native path) ...

• Lädt das Bild von der angegebenen URL herunter.
• Unterstützt HTTP/HTTPS-URLs, Google Cloud Storage-Pfade (gs://) und lokale Dateipfade.
• Inferenzausführung (run_inference):

def run_inference(url, task_prompt):
# ... (code to obtain picture utilizing download_image perform) ...
attempt:
# ... (code to open and course of the picture) ...
inputs = processor(textual content=task_prompt, pictures=picture, return_tensors="pt")
besides ValueError:
# ... (error dealing with) ...
# ... (code to generate captions utilizing the mannequin) ...
generated_ids = mannequin.generate(
input_ids=inputs("input_ids"),
pixel_values=inputs("pixel_values"),
# ... (mannequin technology parameters) ...
)
# ... (code to decode generated captions) ...
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)(0)
# ... (code to post-process generated captions) ...
parsed_answer = processor.post_process_generation(
generated_text, activity=task_prompt, image_size=(picture.width, picture.peak)
)
return parsed_answer

Orchestriert den Bildbeschriftungsprozess:

• Lädt das Bild herunter mit download_image.
• Bereitet das Bild und die Aufgabenaufforderung für das Modell vor.
• Generiert Untertitel mithilfe des geladenen Florence-2-Modells.
• Dekodiert und bearbeitet die generierten Untertitel nach.
• Gibt die endgültige Beschriftung zurück.

2. Aufgabenverteilung (employee.py):

import os
from celery import Celery
# ... different imports ...
# Get Redis URL from surroundings variable or use default
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
# Configure Celery to make use of Redis because the dealer and backend
app = Celery("duties", dealer=REDIS_URL, backend=REDIS_URL)
# ... (Celery configurations) ...

• Richtet Celery so ein, dass Redis als Nachrichtenbroker für die Aufgabenverteilung verwendet wird.
• Aufgabendefinition (inference_task):

@app.activity(bind=True, max_retries=3)
def inference_task(self, url, task_prompt):
# ... (logging and error dealing with) ...
return run_inference(url, task_prompt)

• Definiert die inference_task die von Celery-Mitarbeitern ausgeführt werden.
• Diese Aufgabe ruft den run_inference Funktion von mannequin.py.
• Ausführung durch den Arbeiter:

if __name__ == "__main__":
app.worker_main(("employee", "--loglevel=information", "--pool=solo"))

• Startet einen Celery-Employee, der auf Aufgaben wartet und diese ausführt.

3. Shopper-Interaktion (consumer.py):

import os
from celery import Celery
# Get Redis URL from surroundings variable or use default
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
# Configure Celery to make use of Redis because the dealer and backend
app = Celery("duties", dealer=REDIS_URL, backend=REDIS_URL)

• Stellt eine Verbindung zu Celery her und verwendet dabei Redis als Nachrichtenbroker.
• Aufgabenübermittlung (send_inference_task):

def send_inference_task(url, task_prompt):
activity = inference_task.delay(url, task_prompt)
print(f"Process despatched with ID: {activity.id}")
# Anticipate the outcome
outcome = activity.get(timeout=120)
return outcome

• Sendet eine Bildbeschriftungsaufgabe (inference_task) an den Celery-Employee.
• Wartet, bis der Employee die Aufgabe abgeschlossen hat, und ruft das Ergebnis ab.

Docker-Integration (docker-compose.yml):

• Definiert ein Multi-Container-Setup mit Docker Compose:
• Redis: Führt den Redis-Server für die Nachrichtenvermittlung aus.
• Modell: Erstellt und implementiert den Modellinferenz-Employee.
• App: Erstellt und stellt die Clientanwendung bereit.

• Blume: Führt ein webbasiertes Celery-Tasküberwachungstool aus.

Sie können den vollständigen Stapel mit Folgendem ausführen:

docker-compose up

Und da haben Sie es! Wir haben gerade eine umfassende Anleitung zum Erstellen eines asynchronen Machine-Studying-Inferenzsystems mit Celery, Redis und Florence 2 erkundet. Dieses Tutorial hat gezeigt, wie Sie Celery effektiv für die Aufgabenverteilung, Redis für die Nachrichtenvermittlung und Florence 2 für die Bildbeschriftung verwenden. Durch die Nutzung asynchroner Workflows können Sie große Anfragemengen verarbeiten, die Leistung verbessern und die allgemeine Belastbarkeit Ihrer ML-Inferenzanwendungen erhöhen. Mit dem bereitgestellten Docker Compose-Setup können Sie das gesamte System mit einem einzigen Befehl selbst ausführen.

Bereit für den nächsten Schritt? Die Bereitstellung dieser Architektur in der Cloud kann ihre eigenen Herausforderungen mit sich bringen. Lassen Sie mich in den Kommentaren wissen, ob Sie einen Folgebeitrag zur Cloud-Bereitstellung sehen möchten!

Code: https://github.com/CVxTz/celery_ml_deploy
Demo: https://caption-app-dfmj3maizq-ew.a.run.app/

Microsoft hat kürzlich Phi-3 veröffentlicht, ein leistungsstarkes Sprachmodell, mit einer neuen Imaginative and prescient-Language-Variante namens Phi-3-vision-128k-instruct. Dieses 4B-Parametermodell erzielte beeindruckende Ergebnisse bei öffentlichen Benchmarks, übertraf in einigen Fällen sogar GPT-4V und übertraf Gemini 1.0 Professional V in allen Punkten außer MMMU.

In diesem Blogbeitrag erfahren Sie, wie Sie Phi-3-vision-128k-instruct als robustes Imaginative and prescient- und Textmodell in Ihrem Knowledge Science-Toolkit nutzen können. Wir demonstrieren seine Fähigkeiten anhand verschiedener Anwendungsfälle, darunter:

• Optische Zeichenerkennung (OCR)
• Bildbeschriftung
• Tabellenanalyse
• Figurenverständnis
• Leseverständnis gescannter Dokumente
• Markierungssatz-Aufforderung

Wir beginnen mit einem einfachen Codeausschnitt, um dieses Modell lokal mithilfe von Transformatoren und Bitsandbytes auszuführen. Anschließend zeigen wir für jeden der oben aufgeführten Anwendungsfälle ein Beispiel.

Lokales Ausführen des Modells:

Erstellen Sie eine Conda Python-Umgebung und installieren Sie Torch und andere Python-Abhängigkeiten:

conda set up pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
pip set up git+https://github.com/huggingface/transformers.git@60bb571e993b7d73257fb64044726b569fef9403 pillow==10.3.0 chardet==5.2.0 flash_attn==2.5.8 speed up==0.30.1 bitsandbytes==0.43.1

Dann können wir dieses Skript ausführen:

# Instance impressed from https://huggingface.co/microsoft/Phi-3-vision-128k-instruct
# Import obligatory libraries
from PIL import Picture
import requests
from transformers import AutoModelForCausalLM
from transformers import AutoProcessor
from transformers import BitsAndBytesConfig
import torch
# Outline mannequin ID
model_id = "microsoft/Phi-3-vision-128k-instruct"
# Load processor
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
# Outline BitsAndBytes configuration for 4-bit quantization
nf4_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_use_double_quant=True,
bnb_4bit_compute_dtype=torch.bfloat16,
)
# Load mannequin with 4-bit quantization and map to CUDA
mannequin = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="cuda",
trust_remote_code=True,
torch_dtype="auto",
quantization_config=nf4_config,
)
# Outline preliminary chat message with picture placeholder
messages = (image_1)
# Obtain picture from URL
url = "https://photographs.unsplash.com/photo-1528834342297-fdefb9a5a92b?ixlib=rb-4.0.3&q=85&fm=jpg&crop=entropy&cs=srgb&dl=roonz-nl-vjDbHCjHlEY-unsplash.jpg&w=640"
picture = Picture.open(requests.get(url, stream=True).uncooked)
# Put together immediate with picture token
immediate = processor.tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)
# Course of immediate and picture for mannequin enter
inputs = processor(immediate, (picture), return_tensors="pt").to("cuda:0")
# Generate textual content response utilizing mannequin
generate_ids = mannequin.generate(
**inputs,
eos_token_id=processor.tokenizer.eos_token_id,
max_new_tokens=500,
do_sample=False,
)
# Take away enter tokens from generated response
generate_ids = generate_ids(:, inputs("input_ids").form(1) :)
# Decode generated IDs to textual content
response = processor.batch_decode(
generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)(0)
# Print the generated response
print(response)

Dieser Code lädt das Phi-3-Modell wie jedes andere transfomersModell. Wir fügen hinzu bitsandbytes damit es in einen GPU-Speicher der Verbraucherklasse passt.
Wir verwenden eine einfache Eingabeaufforderung `<|image_1|>nWas ist auf diesem Bild zu sehen?`, in der wir auf das Bild verweisen und nach einer Beschreibung des Inhalts fragen. Diese Eingabeaufforderung wird mit dem Bild verarbeitet (dasselbe Bild wie das Miniaturbild dieses Blogs) und durch das Modell geleitet. Dies führt zu folgender Ausgabe:

Das Bild zeigt eine einzelne gelbe Blume mit einem grünen Stiel vor einem blauen Hintergrund.

Sobald das Modell geladen ist, dauerte die Verarbeitung und Vorhersage auf einem RTX3080 2 Sekunden.

Nachdem wir nun alles eingerichtet haben, können wir einige Anwendungsfälle untersuchen:

Optische Zeichenerkennung (OCR)

Wir möchten den Textual content aus einem Bild transkribieren. Ändern Sie dazu die Nachrichtenzeile und die Bild-URL-Zeilen im obigen Codeausschnitt mit:

messages = (>nOCR the textual content of the picture as is. OCR:")
url = "https://i.postimg.cc/fRFvFVyv/Screenshot-from-2024-05-22-20-55-43.png"

Eingang:

Ausgabe:

3 EXPERIMENTE
Wir zeigen, dass Place Interpolation das Kontextfenster effektiv auf das 32-fache der ursprünglichen Größe erweitern kann und dass eine solche Erweiterung mit nur einigen hundert Trainingsschritten möglich ist. Wir zeigen, dass die resultierenden Modelle starke LLMs mit voll wirksamen langen Kontextfenstern sind. Wir demonstrieren ihre Leistung in einer Reihe von Aufgaben, darunter Sprachmodellierung, Passkey-Abruf und lange Dokument-
Zusammenfassung des Projekts. Wir präsentieren auch Benchmark-Ergebnisse der erweiterten Modelle anhand der ursprünglichen LLaMA-Evaluierungsbenchmarks.

Das Ergebnis ist wie erwartet! Die Volltexttranskription dauerte 6 Sekunden, was im Vergleich zur normalen OCR etwas langsam ist.

Bildbeschriftung

Das Ziel besteht hier darin, ein natürliches Bild zu beschriften:

messages = (>nWhat is that this picture of?")
url = "https://i.postimg.cc/q7Wjtj3n/Screenshot-from-2024-05-22-20-56-56.png"

Eingang:

Ausgabe:

Dieses Bild zeigt ein Plüschtier, das einer Figur aus einer beliebten Zeichentrickserie ähnelt. Das Spielzeug hat einen runden Körper mit einer Kapuze und trägt eine Brille. Das Gesicht der Figur ist auf dem Bild nicht sichtbar.

Größtenteils richtig (keine Brille ). Trotzdem ist es beeindruckend, dass es Kenny aus einer Zeichentrickserie erkannt hat.

Tabellenanalyse

Wir möchten sehen, ob das Modell die Tabelle in ein maschinenlesbares Format analysieren kann:

messages = (image_1)
url = "https://i.postimg.cc/W1YwqXk8/Screenshot-from-2024-05-22-21-41-03.png"

Eingang:

Ausgabe:

```json
(
{
"Benchmark": "Phi-3 Imaginative and prescient-128K-In1",
"MMMU": 40.2,
"MMBench": 80.5,
"ScienceQA": 90.8
},
{
"Benchmark": "LlaVA-1.6 Vicuna-7B",
"MMMU": 34.2,
"MMBench": 76.3,
"ScienceQA": 70.6
},
{
"Benchmark": "QWEN-VI Chat",
"MMMU": 39.0,
"MMBench": 75.8,
"ScienceQA": 67.2
}
)
```

Es ist tatsächlich möglich, den Inhalt der Tabelle in strukturiertem Format direkt aus dem Screenshot zu extrahieren.

Figurenverständnis

Wir fordern das Modell auf, eine Figur zu beschreiben:

messages = (image_1)
url = "https://i.postimg.cc/Y0sRQR4Q/Screenshot-from-2024-05-22-21-47-39.png"

Eingang:

Ausgabe:

Die Abbildung ist ein Balkendiagramm, das die Leistung verschiedener Modelle des maschinellen Lernens vergleicht. Jedes Modell wird durch ein Paar gestapelter Balken dargestellt, die die Leistung des Basismodells und des fein abgestimmten Modells angeben.

Kurz aber richtig!

Leseverständnis bei gescannten Dokumenten

Ziel ist es, Fragen zu gescanntem oder fotografiertem Textual content zu stellen. Der Unterschied zur optischen Zeichenerkennung (OCR) besteht darin, dass wir nicht daran interessiert sind, den Textual content einfach zu transkribieren. Stattdessen möchten wir beurteilen, ob das Modell den geschriebenen Inhalt verstehen und Fragen dazu direkt beantworten kann.

messages = (image_1)
url = "https://i.postimg.cc/rmHxPbQY/Screenshot-from-2024-05-22-20-56-21.png"

Eingang:

Ausgabe:

Das Bild zeigt das Cowl eines Buches mit dem Titel „SAM TALLENT RUNNING THE LIGHT“ mit einer Inhaltsangabe, die die Geschichte eines Komikers namens Billy Ray Schafer beschreibt, der mit persönlichen und beruflichen Herausforderungen konfrontiert ist. Das Buch scheint ein fiktives Werk zu sein, möglicherweise ein Roman, da es ein Zitat von DOUG STANHOPE, ICONOCLAST, enthält, der das Buch als brillant und als beste fiktionale Darstellung von Comedy lobt.

Der Buchtitel ist falsch, aber das MLLM konnte den Inhalt des Bildtextes verstehen und in einer Aufnahme zusammenfassen.

Markierungssatz-Aufforderung

Bei der Set-of-Mark (SoM)-Eingabeaufforderung werden interaktive Segmentierungsmodelle verwendet, um ein Bild in Regionen zu unterteilen und diese mit Symbolen zu markieren. Dadurch können große multimodale Modelle visuell fundierte Fragen besser verstehen und beantworten.

Um die Dinge in diesem Beispiel zu vereinfachen, habe ich die Objekte manuell markiert, anstatt ein Modell zu verwenden, und dann die Markierung referenziert (4) in meiner Eingabeaufforderung:

messages = (>nWhat is object quantity 4? ")
url = "https://i.postimg.cc/fy0Lz798/scott-webb-p-0l-WFknspg-unsplash-2.jpg"

Eingang:

Objekt Nummer 4 ist ein Kaktus mit orangen Blüten in einem Topf.

Das MLLM konnte meinen Hinweis verstehen und meine Frage entsprechend beantworten.

Additionally, da haben Sie es! Phi-3-Imaginative and prescient ist ein leistungsstarkes Modell für die Arbeit mit Bildern und Textual content, das Bildinhalte verstehen, Textual content aus Bildern extrahieren und sogar Fragen zu dem, was es sieht, beantworten kann. Während seine geringe Größe mit nur 4 Milliarden Parametern seine Eignung für Aufgaben, die starke Sprachkenntnisse erfordern, einschränken kann, sind die meisten Modelle seiner Klasse mit 8 Milliarden Parametern oder mehr mindestens doppelt so groß, was es zu einem herausragenden Modell seiner Effizienz macht. Es glänzt in Anwendungen wie Dokumentanalyse, Tabellenstrukturverständnis und OCR in der Praxis. Seine Kompaktheit macht es ideally suited für den Einsatz auf Edge-Geräten oder lokalen GPUs für Verbraucher, insbesondere nach der Quantisierung. Es wird mein bevorzugtes Modell für alle Dokumentanalyse- und -verständnis-Pipelines sein, da seine Zero-Shot-Fähigkeiten es zu einem leistungsfähigen Werkzeug machen, insbesondere für seine bescheidene Größe. Als Nächstes werde ich auch an einigen LoRA-Feinabstimmungsskripten für dieses Modell arbeiten, um zu sehen, wie weit ich es bei spezialisierteren Aufgaben bringen kann.

Verweise: