TinyLlama 1.1B – Die Größe spielt keine Rolle

Einleitung

In der schnell wachsenden Landschaft der künstlichen Intelligenz und des maschinellen Lernens erweist sich TinyLlama 1.1B als bemerkenswerte Entwicklung. In einer Zeit, in der rechnerische Einschränkungen eine Herausforderung für die Ausführung komplexerer Modelle darstellen, zeichnet sich TinyLlama dadurch aus, dass es alle Erwartungen übertrifft. Es zeigt die bemerkenswerte Leistung kompakter Modelle.

Ziel dieses Artikels ist es, eine Analyse von TinyLlama 1.1B bereitzustellen, einem kompakten großen Sprachmodell. Wir werden uns mit den Kernaspekten befassen, beispielsweise mit der Schulung in Leistungsbenchmarks und der praktischen Umsetzung mithilfe der Hugging Face-Plattform. Wir werden dieses Modell sogar auf dem kostenlosen Google Colab ausführen und seine mathematischen und logischen Fähigkeiten testen.

Lernziele

• Gewinnen Sie ein umfassendes Verständnis von TinyLlama 1.1B
• Entdecken Sie den komplizierten Trainingsprozess, den das Modell durchlaufen hat
• Analysieren Sie die Leistung und vergleichen Sie die Ergebnisse, um die Wirksamkeit zu beurteilen
• Lernen Sie anhand von Codierungsbeispielen die praktischen Schritte zur Implementierung von TinyLlama 1.1B

Dieser Artikel wurde als Teil des veröffentlicht Data Science-Blogathon.

Was ist TinyLlama 1.1B?

TinyLlama 1.1B, ein Teil des umfassenderen Llama-Projekts, ist ein Beweis für die Fortschritte bei der Sprachmodellierung. Es handelt sich um ein Modell mit 1.1 Milliarden Parametern, das auf unglaublichen 3 Billionen Token trainiert wurde, was ihm eine einzigartige Position in der KI-Landschaft verschafft. Im Gegensatz zu seinen größeren Gegenstücken ist TinyLlama 1.1B effizienter und besser verwaltbar, was es zu einer guten Wahl für Anwendungen mit begrenzten Rechenressourcen macht.

Dieses Open-Source-Modell demokratisiert den Zugang zu modernster KI-Technologie und ermöglicht vielen Entwicklern und Forschern die Erforschung und Innovation im Bereich der Verarbeitung natürlicher Sprache. Es handelt sich um ein Modell, das für seine Fähigkeit bekannt ist, Leistung und Ressourcenverbrauch in Einklang zu bringen, was in den heutigen vielfältigen Computerumgebungen ein entscheidender Faktor ist.

Trainingsprozess von TinyLlama 1.1B

Der Trainingsprozess von TinyLlama 1.1B ist faszinierend, ebenso wie das Modell selbst. Das Training von TinyLlama fand nur 90 Tage lang statt und wurde auf den 16 A100-40G-GPUs trainiert. Das Vortraining wurde auf 3 Billionen Token durchgeführt, und das TinyLlama-Team hat das Zwischenmodell zwischen jeweils einer halben Billion veröffentlicht. 

Was die Daten betrifft, so wurden Slimpajama und Starcoderdata mit einer kombinierten Datensatzgröße von 950 Milliarden Tokens erfasst. Das Verhältnis von natürlicher Sprache zu Code wurde bei 7:3 gehalten, d. h. 70 % der Daten waren natürliche Sprache und 30 % Code. Um die 3-Billionen-Token-Marke für die Feinabstimmung zu erreichen, durchlief das TinyLlama drei Trainingsepochen für diesen Datensatz. 

Es gibt sogar eine Chat-Version von TinyLlama namens TinyLlama-Chat. Zunächst wurde dieses Modell anhand des UltraChat-Datensatzes verfeinert, der verschiedene von ChatGPT generierte synthetische Konversationen enthält. Dieser Schritt war entscheidend, um das Modell so zu gestalten, dass es mit unterschiedlichen Gesprächskontexten und -stilen umgehen kann.

Eine weitere Verfeinerung wurde mithilfe des DPOTrainer für den UltraFeedback-Datensatz erreicht. In dieser Trainingsphase lag der Schwerpunkt darauf, die Reaktionen des Modells an menschenähnliche Gesprächsmuster anzupassen. Das Ergebnis ist ein Modell, das nicht nur Informationen zu verschiedenen Themen erfasst, sondern auch auf natürliche und ansprechende Weise interagiert.

Sie können auch lesen: Erste Schritte mit LlaMA 2: Ein Leitfaden für Anfänger

Leistung und Benchmark-Ergebnisse

Die Bewertung der Leistung von TinyLlama 1.1B zeigt seine Fähigkeit, schnell qualitativ hochwertige Antworten zu liefern. Durch seine Ausbildung ist es in der Lage, mehrsprachige Anwendungen zu bedienen, ein wichtiges Merkmal in unserer globalisierten Welt. Trotz seiner geringeren Größe holt TinyLlama 1.1B in Bezug auf Reaktionsqualität und Geschwindigkeit immer noch mit seinen größeren Gegenstücken auf, was es zu einem leistungsstarken Werkzeug für verschiedene KI-Anwendungen macht.

Die Benchmarks für TinyLlama 1.1B sind zwar weniger umfangreich als die für größere Modelle, zeigen aber dennoch seine Kompetenz bei der Bewältigung komplexer Sprachaufgaben. Besonders beeindruckend ist die Fähigkeit, kohärente und kontextrelevante Antworten in mehreren Sprachen zu generieren. Das Modell wurde auf verschiedenen Benchmarks wie HellaSwag, WinoGrande, ARC, MMLU und anderen getestet. Der kombinierte Durchschnittswert betrug 52.99. Das ist viel besser als das andere 1-Milliarden-Parameter-Modell, also das Pythia 1B, das einen durchschnittlichen Wert von 48.3 erreichte. Die Tabelle zeigt die einzelnen Ergebnisse jedes Benchmarks

TinyLlama – Erste Schritte

In diesem Abschnitt laden wir die quantisierte Version von TinyLlama Chat herunter und führen sie in Google Colab aus. Bevor wir das Modell herunterladen, müssen wir die folgenden Python-Pakete herunterladen und installieren

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 

• Das CMAKE_ARGS=“-DLLAMA_CUBLAS=on“ und FORCE_CMAKE=1ermöglicht es llama_cpp_python, die Nvidia-GPU zu nutzen, die in der kostenlosen Colab-Version verfügbar ist.
• Dann installieren wir das llama_cpp_python Paket über den pip3
• Wir laden sogar das herunter Huggingface-Hub, mit dem wir den quantisierten TinyLlama 1.1B Chat herunterladen werden

Um das TinyLlama 1.1B Chat-Modell zu testen, müssen wir zunächst die quantisierte Version davon herunterladen. Um es herunterzuladen, führen wir den folgenden Code aus

from huggingface_hub import hf_hub_download

# specifying the model name
model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
# specifying the type of quantization of the model
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# download the model by specifying the model name and quantized model name
model_path = hf_hub_download(model_name, filename=model_file)

Hier, die Hugging_face_hub Die Bibliothek kümmert sich um den Download des quantisierten Modells. Dazu importieren wir die hf_hub_download das die folgenden Parameter berücksichtigt:

• Modellname: An diese Variable übergeben wir das Modell, das wir herunterladen möchten. Hier möchten wir das TinyLlama 1.1B Chat GGUF-Modell herunterladen.
• Modelldatei: Hier geben wir den Typ des quantisierten Modells an, das wir herunterladen möchten. Hier laden wir die 8-Bit-quantisierte Version des TinyLlama 1.1B Chat herunter.
• Abschließend übergeben wir diese Parameter an den hf_hub_download, das diese Parameter übernimmt und das angegebene Modell herunterlädt. Nach dem Herunterladen wird der Pfad zurückgegeben, in den das Modell heruntergeladen wurde.
• Dieser zurückgegebene Pfad wird im gespeichert Modellpfad variabel.

Jetzt können wir dieses Modell über laden llama_cpp_python Bibliothek. Der Code zum Laden des Modells sieht wie folgt aus.

from llama_cpp import Llama
llm = Llama(
    model_path=model_path,
    n_ctx=512,  # the number of i/p tokens the model can take
    n_threads=8, # the number of threads to use
    n_gpu_layers=40# how many layers of the model to offload to the GPU
)

Wir importieren die Lama Klasse aus der llama_cpp, das die folgenden Parameter übernimmt

• model_path: Diese Variable übernimmt den Pfad, in dem unser Modell gespeichert ist. Wir haben den Pfad aus dem vorherigen Schritt erhalten, den wir hier bereitstellen werden
• n_ctx: Hier geben wir die Kontextlänge für das Modell an. Derzeit stellen wir 512 Token als Kontextlänge bereit
• n_Threads: Hier geben wir die Anzahl der Threads an, die von verwendet werden sollen Lama Klasse
• n_gpu_layers: Wir geben dies an, wenn wir eine laufende GPU haben, was wir im Fall des kostenlosen Colab tun. Dazu übergeben wir 40, was bedeutet, dass wir das gesamte Modell in die GPU verlagern wollen und nicht wollen, dass irgendein Teil davon im System-RAM läuft
• Abschließend erstellen wir daraus ein Objekt Lama Klasse und übergeben Sie es an die Variable llm

Durch Ausführen dieses Codes wird das quantisierte TinyLlama 1.1B Chat-Modell auf die GPU geladen und die entsprechende Kontextlänge festgelegt. Jetzt ist es an der Zeit, einige Schlussfolgerungen zu diesem Modell zu ziehen. Dazu arbeiten wir mit dem folgenden Code

output = llm(
  "<|im_start|>usernWho are you?<|im_end|>n<|im_start|>assistantn", # User Prompt
  max_tokens=512,  # Number of output tokens generated
  stop=["</s>"],   # Token which tells the LLM to stop
)
print(output['choices'][0]['text']) # Model generated text

Um das Modell abzuleiten, übergeben wir die folgenden Parameter an das LLM:

• Eingabeaufforderung/Chat-Vorlage: Dies ist die Eingabeaufforderungsvorlage, die zum Chatten mit dem Modell benötigt wird. Die oben genannte Vorlage(dh , ) ist diejenige, die für das TinyLlama 1.1B Chat-Modell funktioniert. In der Vorlage ist der Satz nach dem Benutzer die Benutzeraufforderung, und die Generierung wird nach dem Assistenten generiert.
• max_tokens: An diese Variable übergeben wir einen Wert, der die maximale Anzahl an Token definiert, die ein Large Language Model ausgeben kann, wenn eine Eingabeaufforderung gegeben wird. Derzeit beschränken wir die Anzahl auf 512 Token.
• hör auf An diese Variable übergeben wir das Stopp-Token. Der Stopp-Token weist das Large Language Model an, die Generierung weiterer Token zu stoppen. Für TinyLlama 1.1B Chat lautet das Stopp-Token

Der generierte Text wird in der Ausgabevariablen gespeichert, wenn wir dies ausführen. Das Ergebnis wird in einem Format generiert, das dem OpenAI-API-Aufruf ähnelt. Daher können wir über die angegebene print-Anweisung auf die Generierung zugreifen, ähnlich wie wir über die OpenAI-Antworten auf die Generierung zugreifen. Die generierte Ausgabe ist unten zu sehen

Für ein Modell dieser Größe ist die erzeugte Reaktion erstklassig. Dies ist bei einem Modell dieser Größe unerwartet; Grammatik und Tonfall sehen vollkommen in Ordnung aus und es gibt keine Anzeichen für Wiederholungen von Sätzen. Versuchen wir, die Argumentationsfähigkeiten des Modells zu testen

output = llm(
  "<|im_start|>usernIf all students who study hard get good grades, 
  and John got good grades, can we conclude that John studied hard?
  <|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernHow fast can a snake fly?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

So weit, ist es gut. Aus den Beispielen, die wir gesehen haben, generiert das Modell gute Antworten. Dies trifft jedoch möglicherweise nicht in allen Fällen zu, da wir es nur anhand einer begrenzten Anzahl von Fragen testen. Lassen Sie uns das Modell sogar auf seine mathematischen Denkfähigkeiten testen

output = llm(
  "<|im_start|>usernJohn is twice as old as Sarah, and Sarah is three years 
  older than Mary. If Mary is 10 years old, how old is John?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernWhat is the missing number in this pattern: 
  1, 4, 9, 16, __, 36?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Aus den Beispielen, die wir gesehen haben, geht hervor, dass TinyLlamaChat bei der Beantwortung einfacher Eignungsfragen in Mathematik äußerst schlecht abschneidet. Dies ist zu erwarten, da das Modell nicht anhand eines Mathematikdatensatzes vorab trainiert wurde. Die Qualität der Generierung kann durch eine Feinabstimmung am mathematischen Datensatz verbessert werden

Was die Feinabstimmung betrifft, ist TinyLlama die erste Wahl für diejenigen, die nur begrenzte Hardware zur Verfügung haben und große Sprachmodelle für ihren spezifischen Datensatz optimieren möchten

Mögliche Anwendungsfälle und Anwendungen

Angesichts der kompakten Größe von TinyLlamaMit 1.1 Milliarden Parametern eignen sich seine Anwendungen vor allem für Umgebungen, in denen größere Modelle aufgrund von Hardwareeinschränkungen oder höherer Effizienz möglicherweise nicht so realisierbar sind. Hier sind einige spezifische Anwendungsfälle unter Berücksichtigung der Größe:

Mobile Anwendungen: Die geringere Größe von TinyLlama macht es zu einer guten Wahl für die Integration in mobile Apps, bei denen eine Verarbeitung auf dem Gerät erforderlich ist. Dazu gehören Sprachübersetzungs-Apps, persönliche Assistentenfunktionen und Chatbots, die effizient auf Smartphones arbeiten können.

Eingebettete Systeme in IoT-Geräten: Im Bereich Internet der Dinge (IoT) sind die Rechenressourcen oft begrenzt; TinyLlama kann verwendet werden, um verschiedenen Geräten wie Smart-Home-Assistenten, tragbaren Geräten und anderen vernetzten Geräten intelligente Sprachverarbeitungsfunktionen hinzuzufügen.

Edge-Computing: Für Anwendungen, die davon profitieren, Daten näher an der Quelle zu verarbeiten als in einer zentralen Cloud-Umgebung, kann TinyLlama effektiv eingesetzt werden. Dazu gehört die Echtzeit-Sprachverarbeitung in Automobilsystemen, Fertigungsanlagen und anderen Edge-Geräten.

Ressourcenarme Sprachforschung: Aufgrund seiner geringeren Größe und des geringeren Rechenaufwands kann TinyLlama ein wertvolles Werkzeug in der Sprachforschung sein, insbesondere für Sprachen mit geringen Ressourcen, bei denen ein groß angelegtes Modelltraining nicht möglich ist.

Lehrmittel: In Bildungseinrichtungen, insbesondere solchen mit begrenztem Zugriff auf High-End-Computerressourcen, kann TinyLlama zur Entwicklung von Sprachlern-Apps, interaktiven Bildungstools und anderen Lernhilfen verwendet werden.

Content-Generierung für kleine Unternehmen: Kleine Unternehmen mit begrenzten Ressourcen können TinyLlama zum Generieren von Inhalten wie Produktbeschreibungen, Marketingtexten und Kundenkorrespondenz verwenden, ohne dass dafür umfangreiche Rechenleistung erforderlich ist.

Prototyping und Experimente: Entwickler und Forscher, die mit Sprachmodellen experimentieren möchten, aber keinen Zugang zu leistungsstarken Computerressourcen haben, können TinyLlama verwenden, um Prototypen zu erstellen und neue NLP-Anwendungen zu entwickeln.

Effiziente Datenanalyse: TinyLlama kann zur Textanalyse und Datenextraktion in Szenarien verwendet werden, in denen eine schnelle und effiziente Verarbeitung erforderlich ist, z. B. bei der Analyse von Kundenfeedback, Umfrageantworten oder Social-Media-Interaktionen.

Zusammenfassung

TinyLlama 1.1B ist ein Beweis für die Fortschritte im Bereich der KI und der Verarbeitung natürlicher Sprache. Seine Entwicklung und weit verbreitete Verfügbarkeit sind für die Erstellung effizienterer, kleinerer und schnellerer Inferenzsprachmodelle von entscheidender Bedeutung. Indem TinyLlama 1.1B einen kleineren Parameter-Footprint mit robuster Leistung in Einklang bringt, erfüllt es den dringenden Bedarf an leistungsstarken und praktischen Modellen für eine Vielzahl von Anwendungen. Seine Fähigkeit, Sprache auf menschenähnliche Weise zu verstehen und zu generieren und gleichzeitig leicht genug für verschiedene Computerumgebungen zu sein, macht es zur ersten Wahl für Menschen, die Schwierigkeiten haben, große Sprachmodelle auf ihren Computern auszuführen. Das Modell lässt sich leicht an einem Datensatz anpassen und kann mit begrenzten Rechenressourcen trainiert werden. 

Zu den wichtigsten Erkenntnissen aus diesem Artikel gehören:

• TinyLlama 1.1B ist auf Effizienz ausgelegt und steht einem breiteren Publikum zur Verfügung, auch solchen mit begrenzten Rechenressourcen, wodurch es für mehrere Anwendungen geeignet ist.
• Das Modell durchlief einen umfangreichen Trainingsprozess, einschließlich des Trainings auf 3 Billionen Token über 90 Tage mit 16 A100-40G-GPUs.
• Trotz seiner geringeren Größe liefert TinyLlama 1.1B qualitativ hochwertige, kontextrelevante Antworten in mehreren Sprachen, was es zu einem Modell macht, das man in Betracht ziehen sollte.
• Es ist eine gute Wahl für mobile Anwendungen, IoT-Geräte, Lehrmittel und mehr, seine kompakte Größe und Effizienz ermöglichen vielfältige Einsatzmöglichkeiten.
• Sein geringerer Rechenaufwand macht es zu einem wertvollen Werkzeug in der Sprachforschung, insbesondere für Sprachen mit geringen Ressourcen.
• Das Modell ist eine gute Wahl für diejenigen, die mit Sprachmodellen experimentieren oder neue NLP-Apps entwickeln, hauptsächlich in Umgebungen mit begrenzter Rechenleistung.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Verbunden

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://www.analyticsvidhya.com/blog/2024/01/tinyllama-1-1b-size-doesnt-matter/