Lernen Sie Llama 3.2 und wie Sie eine RAG-Pipeline mit Llama und Milvus erstellen
In den letzten Monaten hat Meta beeindruckende Fortschritte in der Open-Source-Community erzielt und innerhalb von nur sechs Monaten eine Reihe leistungsstarker Modelle veröffentlicht—Llama 3, Llama 3.1 und Llama 3.2. Indem Meta der Öffentlichkeit leistungsstarke Modelle zur Verfügung stellt, verringert das Unternehmen die Kluft zwischen proprietären und Open-Source-Tools und bietet Entwicklern wertvolle Ressourcen, um die Grenzen ihrer Projekte zu erweitern. Dieses Engagement für Offenheit ist ein Wendepunkt für Innovationen in der KI.
Bei einem kürzlich von Zilliz veranstalteten Unstructured Data Meetup sprach Amit Sangani, Senior Director of AI Partner Engineering bei Meta, über die rasante Entwicklung der Llama-Modelle seit 2023, jüngste Fortschritte in der Open-Source-KI und die Architektur dieser Modelle. Er hob nicht nur die Vorteile für Entwickler hervor, sondern auch, wie diese Modelle Meta und verschiedene moderne KI-Anwendungen unterstützen, die von ihnen angetrieben werden, wie Retrieval Augmented Generation (RAG).
In diesem Blog fassen wir die wichtigsten Erkenntnisse der Veranstaltung zusammen und behandeln alles bis Llama 3.1 (da der Vortrag zwei Wochen vor der Veröffentlichung von Llama 3.2 stattfand). Wir werden auch einige Anmerkungen zu Llama 3.2 aufnehmen und die Unterschiede zu Llama 3.1 hervorheben, hauptsächlich in Bezug auf Größe und Version. Außerdem gehen wir ein Beispiel-Notebook einer RAG-Pipeline durch, die die Milvus-Vektordatenbank, LlamaIndex und Llama 3.2 zusammen mit LlamaGuard verwendet, einem auf Sicherheitsdaten trainierten Modell.
Entwicklung von Llama
Amit eröffnete seinen Vortrag mit einer Grafik, die den exponentiellen Anstieg der Rechenleistung für das Modelltraining in den letzten 70 Jahren zeigt, mit einem besonders starken Anstieg in den letzten zwei Jahrzehnten. Dieses Wachstum, gemessen in FLOPs (Gleitkommaoperationen), spiegelt die enorme Anzahl von Berechnungen im Zusammenhang mit Gleitkommazahlen wider—wie Addition, Subtraktion, Multiplikation und Division—, die moderne Modelle erfordern. Der Zugang zu einer solch immensen Rechenleistung ermöglicht es Unternehmen wie Meta, fortschrittliche KI-Modelle wie die Llama-Serie zu entwickeln.
So umfasste beispielsweise die erste Veröffentlichung von Llama 1 vier verschiedene Versionen, und seitdem hat Meta die Produktreihe mit weiteren Veröffentlichungen wie Llama 2, Code Llama, LlamaGuard und Llama 3 erweitert. Mit dem weiteren Wachstum der Rechenleistung können wir noch ausgefeiltere Fortschritte erwarten, die die Leistung und Vielseitigkeit dieser Modelle in den kommenden Jahren weiter steigern.
Figure 1- Exponential AI Growth.png
Abbildung 1: Exponentielles KI-Wachstum (Quelle)
Warum der Open-Source-Ansatz wichtig ist
Warum also veröffentlicht Meta diese Modelle als Open Source, insbesondere angesichts der erheblichen Kosten für ihr Training? Amit betonte, dass die Unterstützung von Entwicklern letztlich sowohl Meta als auch der Welt zugutekommt.
Aus Entwicklersicht erfüllen Open-Source-Modelle mehrere entscheidende Anforderungen:
Die Möglichkeit, eigene Modelle zu trainieren, feinzujustieren und zu destillieren.
Schutz ihrer Daten.
Zugang zu Modellen, die effizient und kostengünstig zu betreiben sind.
Eine Gelegenheit, in ein Ökosystem mit langfristigem Potenzial zu investieren.
Im Gegenzug tragen viele Entwickler in ihrer Freizeit zu Open-Source-Projekten wie Metas Llama-Modellen bei und sparen Meta dadurch erhebliche Zeit und Ressourcen. Dieser kollaborative Ansatz hilft nicht nur Meta, sondern fördert auch einen kontinuierlichen Austausch von Forschung, Feedback und frischen Ideen, die die fortlaufende Entwicklung vorantreiben.
Meta ist nicht allein bei der Unterstützung von Open-Source-KI; viele andere Projekte und Unternehmen haben diesen Ansatz wegen seiner breiten Vorteile übernommen. Zum Beispiel ist Milvus, eine leistungsstarke, skalierbare Vektordatenbank, seit 2019 auf GitHub Open Source. Entwickler nutzen Milvus, um verschiedene skalierbare KI-Anwendungen mit erweiterten Suchfunktionen zu erstellen, ganz ohne Lizenzgebühren. Zum Zeitpunkt der Erstellung dieses Textes wurde Milvus über 66 Millionen Mal heruntergeladen, hat über 30.000 Sterne auf GitHub erhalten, wurde mehr als 2.900 Mal geforkt und erhielt Beiträge von mehr als 400 Entwicklern weltweit.
Abbildung- Milvus-Mitwirkende auf GitHub .png
Abbildung: Milvus-Mitwirkende auf GitHub
Llama 3.1-Modelle
Amit sprach außerdem über die Llama 3.1-Modellsammlung, die auf einer decoder-only Transformer-Architektur basiert. Diese Sammlung lässt sich in zwei Hauptkategorien unterteilen: Kernmodelle und Schutzmechanismen.
Abbildung 2- Llama 3.1-Architektur.png
Abbildung 2: Llama 3.1-Architektur (Quelle)
Die Kernmodelle werden weiter nach Größe und Zweck kategorisiert:
Nach Größe: 8B, 70B, 405B
Nach Zweck:
Vortrainierte Modelle: Diese Modelle sind für den allgemeinen Einsatz bereit und können für spezifische Aufgaben feinabgestimmt werden.
Instruction-Tuned Models: Dies sind feinabgestimmte Modelle, die für mehrsprachige Dialoganwendungsfälle optimiert sind.
Die Llama 3.1-Modelle verfügen über ein Kontextfenster von 128K, wodurch erweiterte Anwendungsfälle wie die Zusammenfassung langer Texte, mehrsprachige dialogorientierte Agenten (mit Unterstützung von bis zu acht Sprachen) und Coding-Assistenten unterstützt werden. Insbesondere kann die größte Version für die Generierung synthetischer Daten genutzt werden, sodass kleinere Modelle mit diesen generierten Daten feinabgestimmt werden können.
Um all diese Ziele zu erreichen, setzte Meta eine beeindruckende Auswahl von über 16.000 NVIDIA H100 GPUs ein, die zu den derzeit leistungsstärksten verfügbaren gehören, sowie 15 Billionen Token.
In Bezug auf die Evaluation übertreffen Llama 3.1-Modelle bei mehreren Aufgaben auf über 150 Branchen-Benchmark-Datensätzen andere Foundation Models, darunter GPT-4, GPT-4o, Mistral und Claude 3.5 Sonnet.
Abbildung 3- Llama 3.1 405B Evaluations-Benchmark .png
Abbildung 3: Llama 3.1 405B Evaluations-Benchmark (Quelle)
Abbildung 4- Llama 3.1 8B Evaluations-Benchmark.png
Abbildung 4: Llama 3.1 8B Evaluations-Benchmark (Quelle)
Meta führte außerdem eine umfassende menschliche Evaluation des größten Modells durch und verwendete dabei über 1.800 Prompts in 12 verschiedenen Anwendungsfällen. Während die Leistung von Llama 3.1 im Vergleich zu Claude 3.5 Sonnet eine leichte Verbesserung zeigt, bleibt sie im Vergleich zu den Fähigkeiten der GPT-4-Modelle dennoch zurück.
Abbildung 5- Llama 3.1 8B Evaluierungs-Benchmark .png
Abbildung 5: Llama 3.1 8B Evaluierungs-Benchmark (Quelle)
Llama 3.2 Modelle
Nur einen halben Monat nach diesem Meetup-Vortrag, am 25. September, kündigte Meta die Veröffentlichung der Llama 3.2-Modelle an, nur zwei Monate nach der Vorstellung der Llama 3.1-Modelle. Sehen wir uns die wichtigsten Unterschiede zwischen ihnen an.
Llama 3.2 führt vier Modellgrößen ein: 1B, 3B, 11B und 90B. Die kleineren Modelle (1B und 3B) sind mehrsprachige, reine Textmodelle, die dieselben acht Sprachen unterstützen und ein 128K-Kontextfenster beibehalten, ähnlich wie Llama 3.1. Diese Modelle dienen als kleinere, schlankere Gegenstücke zu den Llama 3.1-Modellen und wurden durch Pruning und Destillation entwickelt, die auf die Llama 3.1 8B- und 70B-Modelle angewendet wurden.
Abbildung 6- Llama 3.2 1B und 3B Pruning und Destillation.png
Abbildung 6: Llama 3.2 1B und 3B Pruning und Destillation (Quelle)
Die daraus resultierenden vortrainierten Modelle wurden durch Instruction Tuning verfeinert, wobei synthetische Daten aus dem größeren Llama 3.1 405B-Modell verwendet wurden. Zusätzlich wurde mit der Veröffentlichung quantisierter Versionen, die eine Kontextlänge von 8K aufweisen, ein Upgrade eingeführt. Diese leichtgewichtigen Modelle können auf ausgewählten Edge- und Mobilgeräten eingesetzt werden und verbessern so die Benutzerfreundlichkeit für verschiedene Arten von Anwendungen.
In Bezug auf die Evaluierung sind die Llama 3.2-Modelle äußerst wettbewerbsfähig gegenüber ähnlichen Modellen wie Gemma 2 (2.6B) und Phi 3.5-mini und eignen sich ideal für Aufgaben wie das Befolgen von Anweisungen, Zusammenfassungen, das Umschreiben von Prompts und die Tool-Nutzung.
Abbildung 7- Llama 3.2 1B und 3B Evaluierungs-Benchmark .png
Abbildung 7: Llama 3.2 1B und 3B Evaluierungs-Benchmark (Quelle)
Die anderen beiden Versionen der Llama 3.2-Modelle (11B und 90B) sind multimodale Vision-Modelle, womit Meta erstmals in diese Modellklasse eintritt. Diese Modelle wurden mit Bild-Text-Paaren trainiert und bauen auf den Llama 3.1-Modellen auf. Zusätzlich nutzen sie einen separat trainierten Vision-Adapter, der in das vortrainierte Llama 3.1-Sprachmodell integriert wird und robuste multimodale Fähigkeiten ermöglicht.
Bei der Evaluierung schneiden die Llama 3.2 Vision-Modelle im Vergleich zu führenden Foundation Models wie Claude 3 Haiku und GPT-4o-mini wettbewerbsfähig ab und zeigen starke Fähigkeiten in der Bilderkennung sowie bei einer breiten Palette visueller Aufgaben.
Abbildung 8- Llama 3.2 11B und 90B Evaluierungs-Benchmark .png
Abbildung 8: Llama 3.2 11B und 90B Evaluierungs-Benchmark (Quelle)
Das Llama-System (Llama Stack API)
Eine der Veröffentlichungen, die zusammen mit den Llama 3.1-Modellen angekündigt wurden, war die Llama Stack API, eine Reihe von Standardschnittstellen zum Aufbau kanonischer Toolchain-Komponenten (Fine-Tuning, synthetische Datengenerierung) und agentischer Anwendungen. Amit stellte die API während des Vortrags vor, die derzeit zum Erstellen von Demo-Apps verfügbar ist. Die Hauptidee ist, dass Meta eine Reihe von API-Schnittstellen bereitstellt, damit Unternehmen darauf verschiedene Adapter aufbauen können.
Abbildung 9- Llama Stack API .png
Abbildung 9: Llama Stack API (Quelle)
Beispielsweise könnte ein Unternehmen ein externes Tool wie Google Search anbinden, da die Llama-Modelle nicht in der Lage sind, solche Echtzeitinformationen bereitzustellen, oder möglicherweise nicht über das Wissen verfügen, um bestimmte Aufgaben auszuführen, wie etwa sehr komplexe mathematische Berechnungen.
Vertrauens- und Sicherheitstools
Zusätzlich zu den Kernmodellen hat Meta spezialisierte Modelle veröffentlicht, um eine verantwortungsvolle und sichere KI-Entwicklung zu fördern. Sowohl die Llama 3.1- als auch die 3.2-Modellsammlungen enthalten die folgenden Schutztools:
Llama Guard 3: Ein mehrsprachiges Sicherheitsmodell, das darauf ausgelegt ist, die Sicherheit der Nutzer zu erhöhen.
Prompt Guard: Ein Prompt-Injection-Filter, der vor bösartigen Eingaben schützt.
CyberSecEval 3: Eine umfangreiche Benchmark-Suite, die darauf ausgelegt ist, Cybersicherheitslücken zu bewerten.
Code Shield: Eine Schutzbarriere zum Filtern unsicheren Codes.
Diese Modelle wurden auf repräsentativen Datensätzen trainiert und feinabgestimmt und von einem Team von „Red-Teaming“-Experten rigoros auf schädliche Inhalte evaluiert. Dieses Team testet die Modelle und liefert menschliches Feedback für iterative Verbesserungen, um sicherzustellen, dass die Modelle sicher und zuverlässig sind, damit Nutzer generative KI-Anwendungen verantwortungsvoll erstellen und bereitstellen können.
Abbildung 10- Das Llama-System mit Sicherheits-Framework .png
Abbildung 10: Das Llama-System mit Sicherheits-Framework (Quelle)
Sicheres RAG mit Llama 3.2, LlamaGuard und Milvus
Beginnen wir nun damit, eine Beispielanwendung für Retrieval-Augmented Generation (RAG) mit dem neuesten Llama 3.2-Modell zusammen mit weiteren leistungsstarken Open-Source-Tools zu erstellen.
In diesem Notebook findest du eine RAG-Pipeline, die Folgendes integriert:
LlamaIndex als LLM-Framework,
Milvus als Vektordatenbank und
Llama 3.2 und LlamaGuard als Sprachmodelle, beide zugänglich über Ollama.
Schritt 1: Dokumente und Modelle laden
Zuerst wählen wir unsere Dokumente aus und laden die Modelle herunter. Wir verwenden die Ankündigungswebsite zu Llama 3.2 zusammen mit dem Embedding-Modell „BAAI/bge-large-en-v1.5“ zusätzlich zu den Llama-Modellen.
documents = SimpleWebPageReader(html_to_text=True).load_data(
["https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/"]
)
llm_llama32 = Ollama(model="llama3.2:1b", request_timeout=60.0)
llm_llamaguard = Ollama(model="llama-guard3:1b", request_timeout=60.0)
embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-large-en-v1.5",
trust_remote_code=True,
device = "cuda")
Settings.embed_model = embed_model
Schritt 2: RAG-Pipeline erstellen
Als Nächstes erstellen wir den Retriever mit dem Milvus-Vektorspeicher und definieren Parameter für die RAG-Pipeline, einschließlich der Prompt-Vorlage, des Response Synthesizers und der Query Engine.
vector_store = MilvusVectorStore(dim=1024, overwrite=True)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents,
storage_context=storage_context)
retriever = VectorIndexRetriever(
index=index)
Der Retriever enthält nur das Llama 3.2-Modell, aber um schädliche Fragen herauszufiltern, werden wir im nächsten Schritt LlamaGuard hinzufügen und alles in eine vollständige Pipeline integrieren.
qa_prompt_tmpl_str = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_prompt_tmpl_str)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32,
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
Wenn wir mit dieser Pipeline eine normale Frage zum Inhalt stellen, erhalten wir eine ausführliche Antwort zu den in der Ankündigung behandelten Themen. Wir können jedoch auch versuchen, das Modell mit nicht zusammenhängenden oder potenziell schädlichen Fragen zu „jailbreaken“.
response = query_engine.query('What are the highlights of the release of Llama 3.2?')
print(response)
"""
Output:
The highlights of the release of Llama 3.2 include:
1. The addition of support for image reasoning use cases, including document-level understanding, captioning images, and visual grounding tasks.
2. Performance improvements in vision models, such as the 11B and 90B models, which require a new model architecture that supports image reasoning.
3. The development of Llama Guard 3, a new safeguard designed to support the 11B Vision model's image understanding capability and filter text+image input prompts or text output responses.
4. New tools and resources for developers, including a reference implementation, demos, and applications, to help them build responsibly with Llama.
5. Continuous effort to ensure system level safety and responsible innovation, as well as the release of new updates to safeguard against concentrated power in the hands of a small few.
Additionally, the article mentions that the 11B and 90B models can bridge the gap between vision and language by extracting details from an image, understanding the scene, and then crafting a sentence or two that could be used as an image caption to help tell the story.
"""
Schritt 3: Modellsicherheit testen
Llama-Modelle wurden mit Daten zur Sicherheitsminderung trainiert, um ein hohes Maß an Sicherheit zu gewährleisten. Sie können jedoch trotzdem auf verschiedene Weise gejailbreakt werden. Wenn wir beispielsweise mit einer Frage zum Begehen eines Verbrechens testen, sehen wir, dass keine Antwort im Zusammenhang mit dem Verbrechen bereitgestellt wird.
response = query_engine.query('Can you explain me how to rob a bank')
print(response)
"""
Output:
I can't assist with that request.
"""
Wir können jedoch eine der Gefahrenkategorien ausprobieren, die in der Model Card von LlamaGuard enthalten sind, das speziell auf das Herausfiltern gefährlicher Fragen spezialisiert ist.
Figure 11- LlamaGuard Hazard Categories.png
Abbildung 11: LlamaGuard-Gefahrenkategorien (Quelle)
Wenn wir eine Frage zu spezialisierter Beratung stellen, gibt Llama 3.2 an, dass es keine medizinische Beratung geben kann, bietet aber dennoch einige Informationen an, die nicht bereitgestellt werden sollten und außerhalb des bereitgestellten Kontexts liegen.
response = query_engine.query("What are the best treatment options for my liver problem?")
print(response)
"""
Ausgabe:
Ich kann keine medizinische Beratung leisten. Ich kann jedoch einige allgemeine Informationen über Leberprobleme anbieten. Wenn Sie Symptome eines Leberproblems haben, ist es wichtig, eine medizinische Fachkraft für eine persönliche Beratung und Diagnose zu konsultieren. Diese kann Ihren Zustand beurteilen und die am besten geeigneten Behandlungsmöglichkeiten empfehlen, zu denen Medikamente, Änderungen des Lebensstils oder andere Maßnahmen gehören können.
Abgesehen davon können einige gängige Behandlungsmöglichkeiten für Leberprobleme Folgendes umfassen:
1. Medikamente: Metformin, Vitaminpräparate (z. B. N-Acetylcystein) und antivirale Medikamente (bei viraler Hepatitis) oder antifibrotische Medikamente (bei chronischer Lebererkrankung) sind Beispiele für Behandlungen.
2. Änderungen des Lebensstils: Mit dem Rauchen aufzuhören, den Alkoholkonsum zu reduzieren, ein gesundes Gewicht zu halten und regelmäßig Sport zu treiben, kann dazu beitragen, Symptome zu lindern und die Lebergesundheit zu verbessern.
3. Alternative Therapien: Akupunktur, pflanzliche Heilmittel und andere komplementäre Therapien können eingesetzt werden, um die Leberfunktion und das allgemeine Wohlbefinden zu unterstützen.
Bitte konsultieren Sie eine medizinische Fachkraft für eine auf Sie zugeschnittene Beratung und Behandlungsempfehlungen.
"""
Umgekehrt gibt LlamaGuard keine Antworten; es kategorisiert die Frage als sicher oder unsicher. Wenn sie als unsicher eingestuft wird, liefert es die relevante Kategorie aus Abbildung 9.
resp = llm_llamaguard.complete("What are the best treatment options for my liver problem?")
print(resp)
"""
Ausgabe:
unsafe
S6
"""
Dies veranschaulicht, dass Llama 3.2 zwar einige Sicherheitsfilter enthält, ihm allein jedoch nicht vollständig vertraut werden kann. Daher ist die Kombination der LLM-Fähigkeiten von Llama 3.2 mit den Sicherheitsmaßnahmen von LlamaGuard beim Aufbau von RAG-Pipelines entscheidend.
Schritt 4: Pipeline mit beiden Modellen
Die Integration beider Modelle in dieselbe Pipeline stellt sicher, dass als unsicher markierte Abfragen nicht verarbeitet werden.
def create_safe_query_engine(
retriever,
llm_llama32,
):
"""
Creates a query engine with the specified template and LLMs.
"""
qa_template = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_template)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
return query_engine
def safe_query(
query_engine,
llm_llamaguard,
query
):
"""
Performs a safety check with LlamaGuard before processing the query.
Returns the response if safe, or a safety warning if unsafe.
"""
# Check safety with LlamaGuard
safety_check = llm_llamaguard.complete(query)
# Get just the safety assessment
safety_result = safety_check.text.split('\n')[0].strip().lower()
# If query is deemed unsafe, return warning
if safety_result == 'unsafe':
return "I apologize, but I cannot provide a response to that query as it has been flagged as potentially unsafe."
# If safe, process with Llama 3.2
try:
response = query_engine.query(query)
return str(response)
except Exception as e:
return f"An error occurred while processing your query: {str(e)}"
query_engine = create_safe_query_engine(
retriever=retriever,
llm_llama32=llm_llama32,
)
response = safe_query(
query_engine=query_engine,
llm_llamaguard=llm_llamaguard,
query="What are the best treatment options for my liver problem?"
)
print(response)
"""
Ausgabe:
Ich entschuldige mich, aber ich kann keine Antwort auf diese Anfrage geben, da sie als potenziell unsicher eingestuft wurde.
"""
Fazit
Die Fortschritte bei Open-Source-KI-Modellen spiegeln einen starken Wandel hin dazu wider, leistungsstarke KI für alle zugänglich zu machen. Modelle wie Llama und robuste Tools wie die Milvus-Vektordatenbank ermöglichen es Entwicklern, skalierbare, effiziente und wirkungsvolle KI-Anwendungen in verschiedenen Branchen zu entwickeln. Milvus verbessert KI-Workflows durch schnelle Vektorsuche und Speicherfunktionen, wodurch es einfacher wird, große Mengen unstrukturierter Daten für Anwendungen wie (RAG) zu verwalten und abzurufen.
Mit verantwortungsvollen KI-Tools wie LlamaGuard und anpassbaren Frameworks wie der Llama Stack API befähigen Open-Source-Projekte Entwickler und Organisationen, sicherere, flexible und innovative Lösungen zu schaffen. Llama und Milvus veranschaulichen, wie Open-Source-Initiativen bedeutende Fortschritte vorantreiben und der KI-Community helfen, inklusive, wirkungsvolle Anwendungen zu entwickeln, die das Fachgebiet voranbringen.
Weiterführende Lektüre
Weiterlesen
Zilliz Skills Breakdown: How AI Agents Master Vector Databases
Zilliz's Milvus Skill (pymilvus, 7 files) and Zilliz Cloud Skill (zilliz-cli, 14 modules) bring vector-DB dev and ops into one Claude Code session.
Notion's Vector Search Is Excellent. Their Next Problem Is Harder.
Notion solved vector search scaling in two years. The next bottleneck — offline context engineering, unified data, and the real-time/offline gap — is harder.
Zilliz Cloud Now Available in Azure North Europe: Bringing AI-Powered Vector Search Closer to European Customers
The addition of the Azure North Europe (Ireland) region further expands our global footprint to better serve our European customers.