Einführung

Mistral AI ist bekannt für seine fortschrittlichen Sprachmodelle, die in vielen Bereichen Anwendung finden. Mit der Veröffentlichung von Mistral-7B-v0.3 und Mistral-7B-Instruct-v0.3 bringt das Unternehmen seine Modelle auf das nächste Level. Die neuen Versionen bieten eine erweiterte Wortschatzunterstützung und die Fähigkeit, externe Funktionen zu nutzen, was die Integration in verschiedene Anwendungen erleichtert. In diesem Artikel werde ich dir einen detaillierten Überblick über die neuen Funktionen und die Anwendungsmöglichkeiten der Modelle geben.

Unterschiede zwischen Mistral-7B und Mistral-7B-Instruct

Beide Modelle verfügen über die gleiche Intelligenz, jedoch ist das Mistral-7B-Instruct-Modell darauf optimiert, Anweisungen zu folgen. Dies ermöglicht es, Aufgaben und Fragen natürlicher zu beantworten. Das Basismodell hingegen besitzt diese Fähigkeit nicht.

Was ist neu?

Verbesserungen im Überblick

Das Mistral-7B-v0.3-Modell bietet im Vergleich zu seinen Vorgängern signifikante Verbesserungen. Dazu gehört ein erweiterter Wortschatz und die Unterstützung des v3 Tokenizers, was das Sprachverständnis und die Textgenerierung verbessert. Die Möglichkeit, externe Funktionen aufzurufen, eröffnet viele neue Integrationsmöglichkeiten.

Änderungen im Mistral-7B-v0.3-Instruct gegenüber Mistral-7B-v0.2-Instruct:

• Erweiterter Wortschatz auf 32.768 Tokens
• Unterstützung des v3 Tokenizers
• Unterstützung für Funktionsaufrufe

Änderungen im Mistral-7B-v0.3 gegenüber Mistral-7B-v0.2:

• Erweiterter Wortschatz auf 32.768 Tokens

Erweiterter Wortschatz

Eine der wichtigsten Verbesserungen in der neuesten Version ist der erweiterte Wortschatz. Das Modell unterstützt nun 32.768 Tokens, was eine erhebliche Steigerung gegenüber der vorherigen Version darstellt. Dieser erweiterte Wortschatz ermöglicht es Mistral-7B-Instruct-v0.3, eine größere Vielfalt an Wörtern und Phrasen zu verstehen und zu generieren, wodurch komplexere und vielfältigere Sprachaufgaben bewältigt werden können.

Unterstützung für den v3 Tokenizer

Eine weitere bemerkenswerte Neuerung ist die Unterstützung für den v3 Tokenizer. Tokenisierung ist ein entscheidender Schritt in der natürlichen Sprachverarbeitung, bei dem Text in kleinere Einheiten, sogenannte Tokens, zerlegt wird. Der v3 Tokenizer bietet verbesserte Leistung und Kompatibilität, was sicherstellt, dass das Modell den Eingabetext effizienter verarbeiten und verstehen kann.

Funktionsaufruf-Fähigkeit

Die vielleicht spannendste Funktion des Mistral-7B-Instruct-v0.3 ist die Unterstützung für Funktionsaufrufe. Dies bedeutet, dass das Modell nun mit externen Funktionen und APIs interagieren kann, was seine Fähigkeiten erheblich erweitert. Durch die Nutzung von Funktionsaufrufen können Entwickler das Modell in verschiedene Anwendungen integrieren, wodurch es Aufgaben weit über die einfache Textgenerierung hinaus ausführen kann.

Zugang zu Mistral-7B-Instruct-v0.3

Es gibt verschiedene Methoden, um die Mistral-Modelle zu installieren und zu nutzen. Im Folgenden werde ich einige der beliebtesten Optionen vorstellen.

Option 1: ChatLabs

ChatLabs ist ein All-in-One-GenAI-Playground, der Zugang zu über 30 der besten KI-Modelle bietet. ChatLabs macht es einfach, Mistral-7B-v0.3, Mistral-7B-Instruct-v0.3 und viele andere Modelle zu verwenden.

So nutzt du ChatLabs:

1. Besuche die ChatLabs-Website und logge dich ein.
2. Wähle dein Modell: Klicke auf das Dropdown-Menü oben rechts und wähle das Mistral 7B-Modell.
3. Nutze die Power der Modelle: Beginne mit der Nutzung des ausgewählten Modells.

Mit einem ChatLabs Pro-Konto erhältst du Zugang zu Modellen wie Gemini 1.5 Pro, GPT-4 Turbo, Meta AI LLaMA 3, Opus Claude 3 und vielen mehr. Zudem kannst du im Web suchen, Bilder erstellen, die Prompt-Bibliothek erkunden und benutzerdefinierte KI-Assistenten bauen. Eine praktische Split-Screen-Funktion ermöglicht es dir, zwei Modelle gleichzeitig zu verwenden und zu vergleichen.

Option 2: Mistral-Inference auf Hugging Face

Wenn du Zugang zu Mistral-7B v0.3 möchtest, kannst du die offizielle mistral_inference-Bibliothek verwenden, die eine bequeme Option darstellt.

Installation von Hugging Face:

pip install mistral_inference

Download von Hugging Face:

from huggingface_hub import snapshot_download
from pathlib import Path

# Definiere den Pfad zum Speichern des Modells
mistral_models_path = Path.home().joinpath('mistral_models', '7B-Instruct-v0.3')
mistral_models_path.mkdir(parents=True, exist_ok=True)

# Lade das Modell herunter
snapshot_download(repo_id="mistralai/Mistral-7B-Instruct-v0.3",
                  allow_patterns=["params.json", "consolidated.safetensors", "tokenizer.model.v3"],
                  local_dir=mistral_models_path)

Mehr Informationen dazu findest du auf der Hugging Face Website.

Option 3: OLLaMA

OLLaMA ist eine Open-Source-Bibliothek, die die Nutzung großer Sprachmodelle erleichtert. Sie bietet eine einheitliche Schnittstelle für Modelle wie GPT-4, LLaMA und T5, was die Bedienung vereinfacht.

Wichtige Funktionen von OLLaMA:

• Einheitliche Schnittstelle: Bietet eine konsistente und benutzerfreundliche Schnittstelle für verschiedene Modelle.
• Modellkompatibilität: Unterstützt eine Vielzahl beliebter Sprachmodelle, was Entwicklern die nötige Flexibilität gibt.
• Vereinfachtes Modell-Loading: Streamlined den Prozess des Ladens und Initialisierens von Modellen, was Zeit und Mühe spart.

Nutzung von OLLaMA:

pip install ollama

Lade das benötigte Modell:

from ollama import OLLaMA

model = OLLaMA("gpt-3")

prompt = "Was ist Künstliche Intelligenz?"
response = model.generate(prompt)
print(response)

Mehr Informationen zu OLLaMA findest du auf deren GitHub-Seite.

Option 4: LM Studio

LM Studio ist eine weitere hervorragende Plattform für die Arbeit mit großen Sprachmodellen. Sie bietet eine benutzerfreundliche Oberfläche und Funktionen wie Feinabstimmung, Prompt-Engineering und Modellauswertung.

Wichtige Funktionen von LM Studio:

• Benutzerfreundliche Oberfläche: Bietet eine intuitive webbasierte Oberfläche, die für Nutzer mit unterschiedlichem technischen Hintergrund zugänglich ist.
• Feinabstimmung: Ermöglicht Nutzern die Feinabstimmung von Modellen auf ihren Datensätzen für spezifische Aufgaben.
• Prompt-Engineering: Hilft, effektive Prompts zu entwerfen, um die Ausgabequalität des Modells zu verbessern.
• Modellauswertung: Bietet integrierte Metriken und Visualisierungen zur Bewertung der Modellleistung.

Nutzung von LM Studio:

1. Melde dich auf der LM Studio-Website an.
2. Lade LM Studio für dein Gerät herunter.
3. Erstelle ein neues Projekt und wähle ein Sprachmodell.
4. Lade deinen Datensatz zur Feinabstimmung hoch oder nutze die bereitgestellten Datensätze.
5. Konfiguriere die Modelleinstellungen wie die Anzahl der Epochen, Batch-Größe und Lernrate.
6. Trainiere das Modell und bewerte seine Leistung mit den bereitgestellten Tools.
7. Nutze das trainierte Modell für verschiedene Aufgaben wie Textgenerierung und Beantwortung von Fragen.

Während mistral_inference speziell für Mistral-Modelle entwickelt wurde, bieten OLLaMA und LM Studio mehr Flexibilität in Bezug auf die Modellauswahl und Anpassungsmöglichkeiten. Entwickler können das beste Tool basierend auf Benutzerfreundlichkeit, Modellkompatibilität, erforderlichen Funktionen und Leistungsanforderungen auswählen.

Fazit

Mistral-7B-Instruct-v0.3 stellt einen bedeutenden Fortschritt bei großen Sprachmodellen dar. Mit seinem erweiterten Wortschatz, der Unterstützung des v3 Tokenizers und der Fähigkeit, Funktionen aufzurufen, bietet es verbesserte Leistung und Vielseitigkeit. Entwickler haben mehrere Optionen, um Mistral-7B-Instruct-v0.3 zu nutzen, sei es über die mistral_inference-Bibliothek oder flexible Alternativen wie ChatLabs, OLLaMA und LM Studio. Durch die Berücksichtigung von Benutzerfreundlichkeit, Kompatibilität, Funktionen und Leistung können Entwickler das beste Tool für ihre Projekte auswählen.

Zitat des Tages

„Die besten Lösungen entstehen durch Zusammenarbeit und Innovation.“ – Alex

FAQs

Was sind die Hauptunterschiede zwischen Mistral-7B und Mistral-7B-Instruct?

• Das Mistral-7B-Instruct-Modell ist darauf optimiert, Anweisungen zu folgen und Aufgaben natürlicher zu erledigen, während das Basismodell diese Fähigkeit nicht besitzt.

Welche neuen Funktionen bietet Mistral-7B-Instruct-v0.3?

• Das Modell unterstützt jetzt einen erweiterten Wortschatz von 32.768 Tokens, den v3 Tokenizer und die Fähigkeit, externe Funktionen aufzurufen.

Wie kann ich Mistral-7B-Instruct-v0.3 verwenden?

• Es gibt mehrere Methoden zur Nutzung des Modells, einschließlich ChatLabs, Hugging Face, OLLaMA und LM Studio.

Warum ist die Unterstützung des v3 Tokenizers wichtig?

• Der v3 Tokenizer bietet verbesserte Leistung und Kompatibilität, was die Effizienz bei der Verarbeitung und dem Verständnis von Eingabetexten erhöht.

Welche Vorteile bietet die Funktionsaufruf-Fähigkeit?

• Durch die Unterstützung von Funktionsaufrufen kann das Modell mit externen APIs interagieren und seine Fähigkeiten erheblich erweitern, was die Integration in verschiedene Anwendungen erleichtert.

Wo finde ich weitere Informationen zu Mistral-7B-Instruct-v0.3?

• Weitere Informationen findest du in der offiziellen Dokumentation von Mistral AI und den Repositories auf Hugging Face.

Teste den Chat mit Mistral

Einführung in Hugging Face’s Auto Train Bibliothek

Hallo liebe Leser von Einfach.Alex,

Habt ihr schon einmal von Hugging Face’s Auto Train Bibliothek gehört? Es ist ein leistungsstarkes Tool, das es uns ermöglicht, Modelle mit nur einer Codezeile fein abzustimmen. Klingt beeindruckend, oder? Heute möchte ich euch eine Methode vorstellen, mit der ihr das LLAMA-2 Modell ganz einfach auf eure eigenen Daten anpassen könnt. Und das Beste daran? Es benötigt nur eine einzige Codezeile!

Vorbereitung

Bevor wir loslegen, stellt sicher, dass ihr Python 3.8 oder höher installiert habt. Für diejenigen, die keine Nvidia GPU besitzen: Keine Sorge! Ihr könnt das kostenlose Google Colab nutzen. Es bietet eine hervorragende Plattform, um eure Modelle ohne Hardware-Einschränkungen zu trainieren.

Installation

Als Nächstes installiert das Auto Train Advanced Paket von Hugging Face’s GitHub Repository. Ein einfacher Befehl in eurer Konsole genügt:

pip install AutoTrain-Advanced

Feinabstimmung mit Google Colab

Geht zu “Laufzeit” in Google Colab und stellt sicher, dass ihr die GPU-Laufzeit verwendet. Führt die erste Zelle aus, um die benötigten Pakete zu installieren. Dies ist ein wichtiger Schritt, um sicherzustellen, dass alles reibungslos läuft.

Token von Hugging Face

Als Nächstes benötigt ihr einen Hugging Face Token. Holt euch diesen aus eurem Konto und fügt ihn in euer Google Colab Notebook ein. Dieser Token ist der Schlüssel, um auf die erweiterten Funktionen von Hugging Face zuzugreifen.

Start der Feinabstimmung

Jetzt beginnt der spannende Teil! Verwendet die bereitgestellte Codezeile, um das Modell auf euren Daten fein abzustimmen. Ihr könnt jedes Modell von Hugging Face auswählen und den gleichen Code verwenden. Hier ein Beispiel:

hier ist ein Beispielcode zur Feinabstimmung des LLAMA-2 Modells mit Hugging Face’s Auto Train Bibliothek in Google Colab:

```python
# Installation der benötigten Pakete
!pip install AutoTrain-Advanced

# Importieren der notwendigen Bibliotheken
from huggingface_hub import login
from autotrain import AutoTrain

# Hugging Face Token einfügen
login('Dein_Hugging_Face_Token')

# Definition der Parameter
dataset_id = 'dein_dataset_id'  # Ersetze dies durch die ID deines Datensatzes auf Hugging Face
model_name = 'LLAMA-2'  # Ersetze dies durch den Namen des Modells, das du verwenden möchtest
output_dir = 'output'  # Verzeichnis, in dem die Ergebnisse gespeichert werden sollen

# Initialisieren und Starten des Trainings
AutoTrain(
    project_name='Dein_Projektname',
    train_dataset=dataset_id,
    model=model_name,
    output_dir=output_dir,
    task='text-classification',
    alpaca_format=True
).train()
```

Datenformat

Das Modell erwartet Daten im Alpaca-Format. Dies bedeutet, dass ihr eine einzelne Spalte haben solltet, die alles zusammenfasst. Die Struktur eurer Daten spielt eine entscheidende Rolle für den Erfolg des Trainings.

Du musst auch torch, torchaudio und torchvision installieren.

Der beste Weg, autotrain auszuführen, ist in einer Conda-Umgebung. Du kannst eine neue Conda-Umgebung mit folgendem Befehl erstellen:

conda create -n autotrain python=3.10
conda activate autotrain
pip install autotrain-advanced
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
conda install -c "nvidia/label/cuda-12.1.0" cuda-nvcc

Sobald dies erledigt ist, kannst du die Anwendung starten mit:

autotrain app --port 8080 --host 127.0.0.1

Wenn du keine Benutzeroberfläche magst, kannst du AutoTrain Configs verwenden, um über die Befehlszeile zu trainieren, oder einfach das AutoTrain CLI.

Um eine Konfigurationsdatei für das Training zu verwenden, kannst du den folgenden Befehl nutzen:

autotrain --config <pfad_zur_config_datei>

Beispiel-Konfigurationsdateien findest du im Verzeichnis configs dieses Repositorys.

Colabs

Dokumentation

Die Dokumentation ist verfügbar unter https://hf.co/docs/autotrain/.

Abschluss des Trainings

Nach Abschluss des Trainings könnt ihr das Modell und den Tokenizer herunterladen und Vorhersagen auf eurem lokalen Rechner treffen. Dies ermöglicht es euch, die Leistung des Modells in eurer eigenen Umgebung zu testen.

Abschließende Gedanken

Das Feintuning von großen Sprachmodellen war noch nie so einfach. Mit der Auto Train Bibliothek könnt ihr eure eigenen Modelle erstellen und sie für eure spezifischen Anforderungen anpassen. Ich hoffe, dieser Beitrag war hilfreich für dich. Wenn du Fragen hast oder weitere Informationen benötigst, zögere nicht, einen Kommentar zu hinterlassen oder mich direkt zu kontaktieren. Lasst uns gemeinsam die Welt der KI erkunden und Trends setzen, anstatt ihnen zu folgen! Bis zum nächsten Mal.

LINKS QUELLE:

Hugging Face Auto Train | Auto Train GitHub

Ich hoffe, du hast jetzt eine klare Vorstellung davon, wie einfach es ist, das LLAMA-2 Modell auf deine eigenen Daten abzustimmen. Probier es aus und teile deine Erfahrungen mit uns! Bleib dran für weitere spannende Einblicke in die Welt der KI auf Einfach.Alex.

FAQs

Brauche ich eine spezielle Hardware, um das LLAMA-2 Modell zu trainieren?

Nein, du brauchst keine spezielle Hardware. Wenn du keine Nvidia GPU hast, kannst du Google Colab nutzen, das kostenlose GPU-Ressourcen zur Verfügung stellt.

Muss ich programmieren können, um die Feinabstimmung durchzuführen?

Ein grundlegendes Verständnis von Python ist hilfreich, aber die Feinabstimmung selbst erfordert nur das Ausführen einer Codezeile, was den Prozess sehr zugänglich macht.

Wie lange dauert die Feinabstimmung des Modells?

Die Dauer hängt von der Größe deines Datensatzes und der gewählten Modellkonfiguration ab. Mit Google Colab und einer guten Internetverbindung kann es jedoch überraschend schnell gehen.

Kann ich jedes Modell von Hugging Face für die Feinabstimmung verwenden?

Ja, du kannst jedes Modell von Hugging Face wählen. Die Bibliothek bietet eine breite Palette an Modellen für verschiedene Anwendungen.

Wo finde ich meinen Hugging Face Token?

Deinen Hugging Face Token findest du in deinem Account auf der Hugging Face-Website. Er ist notwendig, um auf bestimmte Funktionen der Auto Train Bibliothek zuzugreifen.

Zitat des Tages

„Die Zukunft gehört denen, die an die Schönheit ihrer Träume glauben.“ – Eleanor Roosevelt

Hey, schön, dass Du wieder dabei bist! Heute sprechen wir über ein super spannendes Thema, das unsere digitale Welt verändert: die Fusion von sozialen Medien und Künstlicher Intelligenz (KI). Soziale Medien sind heute das Rückgrat unserer Online-Kommunikation. Sie formen unsere Beziehungen, beeinflussen unsere Meinungen und gestalten unsere Informationslandschaft. Doch mit der Einführung von KI in die Moderation dieser Plattformen betreten wir ein neues Kapitel. Das bringt faszinierende Möglichkeiten, aber auch bedeutende ethische Herausforderungen mit sich.

Einfach.Die Rolle der KI in der Moderation

Stell Dir vor, Du scrollst durch Deinen Feed und siehst, dass problematische Inhalte blitzschnell entfernt werden. Das ist die Macht der KI! Die Integration von KI in die Moderation von sozialen Medien markiert einen Paradigmenwechsel in der Verwaltung und Überwachung von Inhalten. Durch ihre blitzschnelle Datenverarbeitung bietet KI die Chance, die Effizienz der Moderation zu erhöhen und ein sichereres Online-Umfeld zu schaffen. Doch wie bei jedem Fortschritt gibt es auch hier eine Kehrseite.

Einfach.Vorteile der KI-gesteuerten Moderation

Dank KI können potenziell schädliche oder beleidigende Inhalte schneller erkannt und behandelt werden. Das ist ein bedeutsamer Schritt hin zu einer respektvolleren Online-Gemeinschaft. Du hast sicher schon bemerkt, dass bestimmte beleidigende Kommentare oder Beiträge schneller verschwinden. Das ist kein Zufall, sondern das Werk von KI, die in Echtzeit moderiert.

Einfach.Mögliche Verzerrungen und Herausforderungen

Aber, und das ist ein großes Aber, KI-Algorithmen haben oft Schwierigkeiten, die Feinheiten von Sprache und Kontext zu erfassen. Stell Dir vor, Du machst einen ironischen Kommentar, und die KI versteht den Sarkasmus nicht – schon bist Du geblockt. Diese Limitationen können zu Verzerrungen und ungenauen Moderationsentscheidungen führen.

Einfach.Die Auswirkungen auf LGBTQ+-Nutzer

Eine interessante Beobachtung: Seit der Einführung von KI-gesteuerter Moderation in LGBTQ+-Communitys ist die Nutzung von diskriminierender Sprache um 27% zurückgegangen. Das zeigt, dass KI unsere Kommunikation und Wortwahl maßgeblich beeinflussen kann. Das ist ein großer Schritt nach vorn für eine respektvollere Online-Welt.

Einfach.Ethik und KI: Ein Balanceakt

Die Herausforderung liegt darin, KI so zu gestalten, dass sie die Moderation verbessert, ohne dabei ethische Grundsätze zu untergraben. Hier kommt die menschliche Überwachung ins Spiel. Sie ist unerlässlich, um Voreingenommenheit zu vermeiden und die Vielfalt der Stimmen zu gewährleisten. Stell Dir vor, ein Algorithmus entscheidet, was Du sagen darfst und was nicht – ein beängstigender Gedanke, oder?

Einfach.Vorurteile und Diskriminierung durch KI

Eine unbeabsichtigte Konsequenz der KI-Moderation kann die Diskriminierung bestimmter Gruppen sein. Das könnte zur Zensur marginalisierter Stimmen und zur Verstärkung von Vorurteilen führen. Wir müssen sicherstellen, dass die KI fair und unvoreingenommen bleibt.

Einfach.Die Bedeutung des kontextuellen Verständnisses

KI-Systeme, die den tiefen Kontext nicht verstehen, können bestimmte Sprachformen fälschlicherweise zensieren und somit die Meinungsfreiheit beeinträchtigen. Ein Beispiel: Ein harmloser Witz unter Freunden könnte als beleidigend eingestuft und gelöscht werden. Das ist nicht nur ärgerlich, sondern auch ein Eingriff in die Meinungsfreiheit.

Einfach.Negative Reputation und ihre Folgen

Die Zensur bestimmter demografischer Gruppen kann zu einem negativen Ruf von sozialen Medienplattformen führen. Stell Dir vor, Deine Lieblingsplattform wird plötzlich als voreingenommen und diskriminierend wahrgenommen – das Vertrauen der Nutzer wäre dahin.

Einfach.Die Rolle der Daten in der KI-Moderation

Da KI auf Daten trainiert wird, die oft gesellschaftliche Vorurteile widerspiegeln, entsteht die Herausforderung, wie diese Vorurteile in der Moderation vermieden werden können. Hier müssen wir besonders vorsichtig sein und sicherstellen, dass die Datenbasis fair und repräsentativ ist.

Einfach.Schlussfolgerung: Eine Balance finden

Während KI zweifellos das Potenzial hat, die Moderation in sozialen Medien zu revolutionieren, dürfen wir nicht zulassen, dass sie unsere Online-Erfahrungen uneingeschränkt beeinflusst. Es liegt in unserer Verantwortung, sicherzustellen, dass KI als Werkzeug dient, das die ethischen Grundlagen unserer Interaktionen unterstützt.

Einfach.Zitat

„Merk Dir das: Die Evolution der Online-Kommunikation erfordert nicht nur technologische Fortschritte, sondern auch ein tieferes Verständnis für Ethik und Menschlichkeit.“

Bis zum nächsten Mal auf Einfach.Alex – bleib neugierig und kritisch!

Code Llama ist eine Familie von hochmodernen, frei zugänglichen Versionen von Llama 2, die sich auf Code-Aufgaben spezialisiert haben. Wir freuen uns, die Integration in das Hugging Face-Ökosystem bekannt zu geben! Code Llama wurde unter der gleichen freizügigen Community-Lizenz wie Llama 2 veröffentlicht und ist auch für die kommerzielle Nutzung verfügbar.

Heute haben wir einige aufregende Neuigkeiten zu teilen:

• Modelle auf dem Hub: Verfügbar mit ihren Modellkarten und Lizenzen.
• Integration von Transformatoren: Für eine schnelle und effiziente produktionsbereite Inferenz.
• Integration mit Textgenerierungsinferenz: Optimiert für schnelle Produktion.
• Inferenzendpunkte: Bereit für den Einsatz in der Praxis.
• Code-Benchmarks: Zur Leistungsbewertung der Modelle.

Inhaltsverzeichnis

1. Einleitung
2. Was ist Code Llama?
3. Wie benutzt man Code Llama?
4. Demo
5. Transformatoren
6. Code-Vervollständigung
7. Code-Füllung
8. Konversationsanweisungen
9. 4-Bit-Laden
10. Verwenden von Textgenerierungsinferenz und Inferenzendpunkten
11. Auswertung
12. Zusätzliche Ressourcen

Was ist Code Llama?

Die Code-Llama-Version führt eine Modellfamilie mit 7, 13 und 34 Milliarden Parametern ein. Diese Basismodelle wurden von Llama 2 initialisiert und dann mit 500 Milliarden Token an Codedaten trainiert. Meta hat diese Basismodelle für zwei verschiedene Varianten optimiert: einen Python-Spezialisten (100 Milliarden zusätzliche Token) und eine fein abgestimmte Version mit Anweisungen, die Anweisungen in natürlicher Sprache verstehen kann.

Die Modelle zeigen herausragende Leistungen in mehreren Programmiersprachen wie Python, C++, Java, PHP, C#, TypeScript und Bash. Die Basis- und Instruct-Varianten 7B und 13B unterstützen das Infill auf der Grundlage des umgebenden Inhalts und eignen sich daher ideal für den Einsatz als Code-Assistenten. Code Llama wurde mit einem 16k-Kontextfenster trainiert und verfügt über eine zusätzliche Long-Context-Feinabstimmung, die es ermöglicht, ein Kontextfenster von bis zu 100.000 Token zu verwalten.

Wie benutzt man Code Llama?

Code Llama ist im Hugging Face Ökosystem verfügbar, beginnend mit Version 4.33. Bis Version 4.33 veröffentlicht wird, kannst du es vom main branch installieren:

!pip install git+https://github.com/huggingface/transformers.git@main

Demo

Du kannst das Code Llama Model (13 Milliarden Parameter!) in diesem Space oder im eingebetteten Playground ausprobieren:

from transformers import AutoTokenizer, pipeline
import torch

tokenizer = AutoTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
pipeline = transformers.pipeline(
    "text-generation", model="codellama/CodeLlama-7b-hf",
    torch_dtype=torch.float16, device_map="auto",
)

sequences = pipeline(
    'def fibonacci(', do_sample=True, temperature=0.2, top_p=0.9,
    num_return_sequences=1, eos_token_id=tokenizer.eos_token_id,
    max_length=100,
)

for seq in sequences:
    print(f"Result: {seq['generated_text']}")

Code-Vervollständigung

Die 7B und 13B Modelle können für Text-/Code-Vervollständigung oder Infilling verwendet werden. Hier ein Beispiel:

from transformers import AutoTokenizer, pipeline
import torch

tokenizer = AutoTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
pipeline = transformers.pipeline(
    "text-generation", model="codellama/CodeLlama-7b-hf",
    torch_dtype=torch.float16, device_map="auto",
)

sequences = pipeline(
    'def fibonacci(', do_sample=True, temperature=0.2, top_p=0.9,
    num_return_sequences=1, eos_token_id=tokenizer.eos_token_id,
    max_length=100,
)

for seq in sequences:
    print(f"Result: {seq['generated_text']}")

Code-Füllung

Dieses spezialisierte Feature ist besonders für Code-Modelle relevant. Es generiert den Code, der am besten zu einem gegebenen Präfix und Suffix passt. Hier ein Beispiel:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

prefix = 'def remove_non_ascii(s: str) -> str:\n """ '
suffix = "\n return result\n"
prompt = f" <PRE> {prefix} <SUF>{suffix} <MID>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
output = model.generate(inputs["input_ids"], max_new_tokens=200, do_sample=False)
output = output[0].to("cpu")
print(tokenizer.decode(output))

Konversationsanweisungen

Die Basis-Modelle können sowohl für Completion als auch für Infilling genutzt werden. Die Code Llama Veröffentlichung enthält auch ein fein abgestimmtes Instruktionsmodell, das in Konversationsschnittstellen verwendet werden kann. Hier ein Beispiel:

from transformers import AutoTokenizer, pipeline
import torch

tokenizer = AutoTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
pipeline = transformers.pipeline(
    "text-generation", model="codellama/CodeLlama-7b-hf",
    torch_dtype=torch.float16, device_map="auto",
)

user = 'In Bash, how do I list all text files in the current directory (excluding subdirectories) that have been modified in the last month?'
prompt = f"<s>[INST] {user.strip()} [/INST]"

inputs = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).to("cuda")

4-Bit-Laden

Die Integration von Code Llama in Transformers ermöglicht sofortigen Zugriff auf fortgeschrittene Features wie das 4-Bit-Laden. Damit kannst du die großen 32B-Parameter-Modelle auf Consumer-GPUs wie der Nvidia 3090 laufen lassen! Hier ein Beispiel:

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import torch

model_id = "codellama/CodeLlama-34b-hf"
quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16)
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config, device_map="auto")

prompt = 'def remove_non_ascii(s: str) -> str:\n """ '
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
output = model.generate(inputs["input_ids"], max_new_tokens=200, do_sample=True, top_p=0.9, temperature=0.1)
output = output[0].to("cpu")
print(tokenizer.decode(output))

Verwenden von Textgenerierungsinferenz und Inferenzendpunkten

Text Generation Inference ist ein produktionsreifer Inferenz-Container, entwickelt von Hugging Face, der eine einfache Bereitstellung großer Sprachmodelle ermöglicht. Du kannst mehr darüber lernen, wie du LLMs mit Hugging Face Inference Endpoints bereitstellst, indem du deren Blog besuchst.

Auswertung

Sprachmodelle für Code werden typischerweise auf Datensätzen wie HumanEval bewertet. Dieser Ansatz ermöglicht eine ganzheitliche Bewertung, indem HumanEval in über ein Dutzend Sprachen übersetzt wird.

Hier eine Übersicht der Modelle und deren Bewertungen:

Modell	Lizenz	Datensatz	Kommerzielle Nutzung	Pretraining Länge [Tokens]	Python	JavaScript	Durchschnittliche Bewertung
CodeLlaMa-34B	Llama 2 Lizenz			2,500B	45.11	33.57	30.79

StarCoderBase-15B | BigCode-OpenRail-M | | | 1,000B | 30.35 | 31.72 | 22.4 |
| WizardCoder-15B | BigCode-OpenRail-M | | | 1,035B | 58.12 | 41.91 | 32.07 |
| OctoCoder-15B | BigCode-OpenRail-M | | | 1,000B | 45.33 | 32.82 | 24.01 |
| CodeGeeX-2-6B | CodeGeeX Lizenz | | | 2,000B | 33.49 | 29.92 | 21.23 |
| CodeGen-2.5-7B-Mono | Apache-2.0 | | | 14B | | | |

Zusätzliche Ressourcen

• Hugging Face Blog
• Llama 2 Paper
• HumanEval Dataset

Hier sind einige häufig gestellte Fragen (FAQ) zum Thema Code Llama und dessen Anwendung:

FAQ

1. Was ist Code Llama?

Code Llama ist eine spezialisierte Version von Llama 2, die sich auf Code-Aufgaben konzentriert. Es bietet hochmoderne, frei zugängliche Modelle zur Code-Vervollständigung und anderen Coding-Aufgaben und ist im Hugging Face-Ökosystem integriert.

2. Welche Programmiersprachen werden von Code Llama unterstützt?

Code Llama unterstützt mehrere Programmiersprachen, darunter Python, C++, Java, PHP, C#, TypeScript und Bash.

3. Wie kann ich Code Llama nutzen?

Code Llama kann im Hugging Face Ökosystem genutzt werden. Installiere es über die Hauptversion der Transformers-Bibliothek und nutze es in deinen Projekten für Text- und Code-Vervollständigung sowie andere Inferenzaufgaben.

4. Was sind die Hauptvorteile von Code Llama?

Die Hauptvorteile von Code Llama sind die verbesserte Produktivität durch Code-Vervollständigung in IDEs, die Automatisierung sich wiederholender Aufgaben wie das Schreiben von Docstrings oder Unit-Tests, und die Unterstützung für große Kontextfenster bis zu 100.000 Token.

5. Welche Modellvarianten gibt es bei Code Llama?

Es gibt mehrere Varianten von Code Llama, darunter Basismodelle und fein abgestimmte Modelle mit 7, 13 und 34 Milliarden Parametern. Einige Modelle sind speziell für Python optimiert, während andere allgemeiner für verschiedene Programmiersprachen angepasst sind.

6. Wie unterscheidet sich Code Llama von anderen Code-LLMs?

Code Llama zeichnet sich durch seine hochmoderne Performance und seine Integration in das Hugging Face-Ökosystem aus, das eine einfache Nutzung und Implementierung ermöglicht. Zudem bietet es spezialisierte Funktionen wie das Infilling von Code und Unterstützung für lange Kontextfenster.

Willkommen bei der umfassenden und exzellenten Next.js Tutorial-Serie auf Deutsch! Wenn Sie sich mit der Entwicklung von hochleistungsfähigen Webanwendungen mit Next.js auseinandersetzen möchten, sind Sie hier genau richtig. In dieser Serie werde ich Ihnen Schritt für Schritt die wichtigsten Funktionen und Konzepte von Next.js näherbringen, um Ihre Fähigkeiten auf ein unvergleichliches Niveau zu heben. Also, lass uns direkt loslegen und die Grenzen der Webentwicklung mit Next.js erkunden!

Was ist Next.js?

Next.js ist ein revolutionäres Framework für serverseitig gerenderte React-Anwendungen, das Entwicklern wie Ihnen und mir eine effiziente Möglichkeit bietet, hochperformante Webanwendungen zu erstellen, die die Grenzen der modernen Webentwicklung neu definieren. Mit Funktionen wie serverseitigem Rendering und statischer Seitengenerierung ermöglicht Next.js eine schnellere Initialisierung und verbesserte SEO-Leistung, die Ihre Webanwendungen auf ein neues Level hebt.

Tutorial-Reihe

In dieser Tutorial-Reihe werden wir gemeinsam die wichtigsten Funktionen und Konzepte von Next.js erkunden, um Ihre Fähigkeiten auf ein unvergleichliches Niveau zu heben. Wir werden uns mit Themen wie serverseitigem Rendering, statischer Seitengenerierung, Routing, API-Routing und vielem mehr auseinandersetzen, um Ihnen die notwendigen Werkzeuge an die Hand zu geben, um Ihre eigenen hochleistungsfähigen Webanwendungen mit Next.js zu erstellen.

02. Hallo Welt

Willkommen zur ersten Lektion unserer Next.js Tutorial-Reihe! In diesem Abschnitt werden wir eine einfache „Hallo Welt“-Anwendung erstellen, um uns mit der grundlegenden Struktur von Next.js vertraut zu machen.

import React from 'react';

function HomePage() {
  return <div>Hallo Welt</div>;
}

export default HomePage;

Speichere diese Datei als index.js im Ordner pages. Starte dann deine Anwendung mit npm run dev und öffne http://localhost:3000 in deinem Browser. Voilà, deine erste Next.js-Seite!

03. Projektstruktur

In dieser Lektion werden wir die Projektstruktur von Next.js untersuchen. Du wirst lernen, wie die Dateien und Ordner organisiert sind und wie du deine Next.js-Anwendung effizient strukturieren kannst.

• pages: Enthält alle deine Seiten. Jede Datei im Ordner pages entspricht einer Route.
• public: Statische Dateien wie Bilder und Schriftarten.
• components: Wiederverwendbare UI-Komponenten.

04/05. Routen & Seiten

Next.js ermöglicht uns die einfache Erstellung von Routen und Seiten für unsere Anwendung. In diesem Abschnitt werden wir lernen, wie wir verschiedene Seiten erstellen und wie wir zwischen ihnen navigieren können.

• Erstellen einer neuen Seite: Erstelle eine neue Datei im pages-Ordner, z.B. about.js.
• Navigieren zwischen Seiten: Verwende das Link-Modul von next/link.

import Link from 'next/link';

function HomePage() {
  return (
    <div>
      <h1>Hallo Welt</h1>
      <Link href="/about">Über uns</Link>
    </div>
  );
}

export default HomePage;

06. Verschachtelte Routen

Manchmal möchten wir verschachtelte Routen in unserer Anwendung haben. Hier werden wir lernen, wie wir in Next.js verschachtelte Routen erstellen können, um komplexe Anwendungen zu realisieren.

Erstelle einen Unterordner im pages-Ordner, z.B. blog, und füge darin Dateien hinzu, z.B. post.js.

07. Dynamische Routen

Dynamische Routen sind ein leistungsstarkes Feature von Next.js. In dieser Lektion werden wir lernen, wie wir dynamische Routen verwenden können, um Daten basierend auf dem Pfad der URL abzurufen und anzuzeigen.

import { useRouter } from 'next/router';

function Post() {
  const router = useRouter();
  const { id } = router.query;

  return <div>Post ID: {id}</div>;
}

export default Post;

Speichere diese Datei als [id].js im pages-Ordner. Jetzt kannst du auf http://localhost:3000/123 zugreifen, und die Seite zeigt „Post ID: 123“ an.

08. API

Next.js ermöglicht es dir, API-Routen innerhalb deiner Anwendung zu erstellen. Diese API-Routen können serverseitige Logik enthalten und Daten an deine Frontend-Komponenten senden.

// pages/api/hello.js
export default function handler(req, res) {
  res.status(200).json({ text: 'Hello' });
}

09. API Anfrage erhalten

Um eine Anfrage an deine API-Routen zu senden, kannst du die fetch-Methode verwenden.

async function fetchData() {
  const res = await fetch('/api/hello');
  const data = await res.json();
  console.log(data);
}

10. API Anfrage senden

Sende Daten an deine API-Routen, indem du eine POST-Anfrage verwendest.

async function sendData() {
  const res = await fetch('/api/hello', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ text: 'Hello' }),
  });
  const data = await res.json();
  console.log(data);
}

11. Styles

In Next.js kannst du CSS-Module und globale CSS-Dateien verwenden, um deine Anwendung zu stylen.

• Globale CSS-Datei: Erstelle eine styles/global.css Datei und importiere sie in deiner _app.js Datei.
• CSS-Module: Erstelle eine CSS-Datei mit .module.css und importiere sie in deiner Komponente.

import styles from './Home.module.css';

function HomePage() {
  return <div className={styles.container}>Hallo Welt</div>;
}

export default HomePage;

12. Export Static HTML

Next.js ermöglicht es dir, deine Anwendung als statische HTML-Dateien zu exportieren, die auf jedem Webserver bereitgestellt werden können.

next build
next export

13. NextAuth

NextAuth.js ist eine Authentifizierungsbibliothek für Next.js-Anwendungen. Sie ermöglicht es dir, Authentifizierungslösungen schnell und einfach zu implementieren.

14. NextAuth einrichten

Installiere NextAuth.js und richte es in deiner Anwendung ein.

npm install next-auth

Erstelle eine API-Route für die Authentifizierung und konfiguriere die Anmeldemethoden.

15. Login / Logout

Erstelle Anmelde- und Abmeldefunktionen in deiner Anwendung.

import { signIn, signOut } from 'next-auth/react';

function HomePage() {
  return (
    <div>
      <button onClick={() => signIn()}>Login</button>
      <button onClick={() => signOut()}>Logout</button>
    </div>
  );
}

export default HomePage;

16. Deploy Vercel

Next.js wurde von Vercel entwickelt, und die Bereitstellung deiner Anwendung auf Vercel ist ein Kinderspiel. Melde dich bei Vercel an und importiere dein Repository. Vercel kümmert sich um den Rest!

Ich hoffe, diese Tutorial-Reihe hat dir geholfen, Next.js besser zu verstehen und deine eigene Next.js-Anwendung zu erstellen. Wenn du Fragen hast oder Unterstützung benötigst, zögere nicht, mich zu kontaktieren. Ich stehe dir gerne zur Verfügung, um dir zu helfen, deine Webentwicklungsziele zu erreichen. Viel Spaß beim Coden!

Hier geht’s zu den Docs für dich zum Nachlesen: Next.js Docs.

Quellen:

• Next.js Dokumentation
• Vercel

Viel Erfolg bei deiner Next.js-Reise und happy coding!