Nutzen Sie die Leistung von LLMs auf Intel® Arc™ GPUs

Einfache lokale Ausführung einer Vielzahl von LLMs mit Intel® Arc™ GPUs

Generative KI hat die Landschaft der Möglichkeiten für die Erstellung von Inhalten verändert. Diese Technologie hat das Potenzial, bisher ungeahnte Bilder, Videos und Texte zu liefern. Große Sprachmodelle (LLMs) haben im Zeitalter der KI für Schlagzeilen gesorgt. Sie ermöglichen es jedem, mit Hilfe von Souffleuren Songtexte zu erstellen, Antworten auf komplexe physikalische Fragen zu erhalten oder eine Gliederung für eine Folienpräsentation zu entwerfen. Und diese KI-Funktionen müssen nicht mehr mit einer Cloud oder einem Abonnementdienst verbunden sein. Sie können lokal auf Ihrem eigenen PC ausgeführt werden, wo Sie die volle Kontrolle über das Modell haben, um seine Ausgabe anzupassen.

In diesem Artikel zeigen wir Ihnen, wie Sie beliebte große Sprachmodelle (LLMs) auf einem PC mit der Intel® Arc™ A770 16GB Grafikkarte einrichten und damit experimentieren können. In diesem Tutorial wird zwar das Mistral-7B-Instruct LLM verwendet, aber dieselben Schritte können auch mit einem PyTorch LLM Ihrer Wahl wie Phi2, Llama2, etc. durchgeführt werden. Und ja, auch mit dem neuesten Llama3-Modell!

IPEX-LLM

Der Grund dafür, dass wir eine Vielzahl von Modellen mit der gleichen Basisinstallation betreiben können, ist IPEX-LLMeine LLM-Bibliothek für PyTorch. Sie ist auf der Grundlage von Intel®-Erweiterung für PyTorch und enthält modernste LLM-Optimierungen und Low-Bit (INT4/FP4/INT8/FP8)-Gewichtskompression - mit allen aktuellen Leistungsoptimierungen für Intel-Hardware. IPEX-LLM nutzt die Vorteile des X^e-cores XMX AI-Beschleunigung auf diskreten Intel-GPUs wie Grafikkarten der Arc A-Serie für eine verbesserte Leistung. Es unterstützt Intel Arc A-Serien-Grafikkarten auf Windows Subsystem für Linux Version 2, native Windows-Umgebungen und natives Linux.

Und da es sich dabei um natives PyTorch handelt, können Sie die PyTorch-Modelle und Eingabedaten problemlos austauschen, um sie auf einem Intel Arc-Grafikprozessor mit hoher Leistungsbeschleunigung auszuführen. Dieses Experiment wäre ohne einen Leistungsvergleich nicht vollständig gewesen. Anhand der nachstehenden Anleitungen für Intel Arc und der allgemein verfügbaren Anleitungen für die Konkurrenz haben wir zwei diskrete GPUs in einem ähnlichen Preissegment untersucht.

Wenn beispielsweise das Modell Mistral 7B mit der IPEX-LLM-Bibliothek ausgeführt wird, kann die Arc A770-Grafikkarte mit 16 GB 70 Token pro Sekunde (TPS) verarbeiten, d. h. 70% mehr TPS als die GeForce RTX 4060 mit 8 GB und CUDA. Was bedeutet das? Eine allgemeine Faustregel besagt, dass 1 Token 0,75 eines Wortes entspricht, und ein guter Vergleich ist die durchschnittliche menschliche Lesegeschwindigkeit von 4 Wörtern pro Sekunde oder 5,3 TPS. Die Arc A770 16GB Grafikkarte kann Wörter viel schneller erzeugen, als der Durchschnittsmensch sie lesen kann!

Unsere internen Tests zeigen, dass die Arc A770-Grafikkarte mit 16 GB diese Fähigkeit und eine im Vergleich zur RTX 4060 konkurrenzfähige oder führende Leistung über eine breite Palette von Modellen bieten kann, was die Intel Arc-Grafikkarte zu einer hervorragenden Wahl für die lokale LLM-Ausführung macht.

Kommen wir nun zu den Einrichtungsanweisungen, die Ihnen den Einstieg in die LLMs auf Ihrer Arc A-Series GPU erleichtern.

Einbauanleitung

Wir können auch auf diese Seite verweisen, um die Umgebung einzurichten: IPEX-LLM unter Windows mit Intel GPU installieren - IPEX-LLM aktuelle Dokumentation

1. Deaktivieren Sie den integrierten Grafikprozessor im Gerätemanager.

2. Herunterladen und installieren Anakonda.

3. Nach Abschluss der Installation öffnen Sie das Startmenü, suchen Sie nach Anaconda Prompt, führen Sie es als Administrator aus und erstellen Sie eine virtuelle Umgebung mit den folgenden Befehlen. Geben Sie jeden Befehl einzeln ein:

conda create -n llm python=3.10.6

conda llm aktivieren

conda install libuv

pip install dpcpp-cpp-rt==2024.0.2 mkl-dpcpp==2024.0.0 onednn==2024.0.0 gradio

pip install --pre --upgrade ipex-llm[xpu] --extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/

pip install transformers==4.38.0

4. Erstellen Sie ein Textdokument mit dem Namen demo.py und speichern Sie es unter C:\Benutzer\Ihr_Benutzername\Dokumente oder in einem Verzeichnis Ihrer Wahl.

5. Öffnen Sie demo.py mit Ihrem Lieblingseditor und kopieren Sie das folgende Codebeispiel hinein:

from transformers import AutoTokenizer
von ipex_llm.transformers importieren AutoModelForCausalLM
importieren torch
importieren intel_erweiterung_für_pytorch

device = "xpu" # das Gerät, in das das Modell geladen wird

model_id = "mistralai/Mistral-7B-Instruct-v0.2" # Umarmungsgesicht-Modell-ID

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, load_in_4bit=True, torch_dtype=torch.float16)
model = model.to(device)

messages = [
    {"role": "user", "content": "Was ist Ihr Lieblingsgewürz?"},
    {"Rolle": "assistant", "content": "Nun, ich habe eine Vorliebe für einen guten Spritzer frischen Zitronensaft. Er verleiht allem, was ich in der Küche zubereite, genau die richtige Menge an pikantem Geschmack!"},
    {"role": "user", "content": "Habt ihr Mayonnaise-Rezepte?"}
]

encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt")

model_inputs = encodeds.to(device)
model.to(gerät)

generated_ids = model.generate(model_inputs, max_new_tokens=1000, do_sample=True)
decoded = tokenizer.batch_decode(generated_ids)
print(decoded[0])

Aus dem Beispielcode erstellter Code in diesem Repository.

6. Speichern Sie demo.py. Wechseln Sie in Anaconda mit dem cd-Befehl in das Verzeichnis, in dem sich demo.py befindet, und führen Sie in der Anaconda-Eingabeaufforderung den folgenden Befehl aus:

python demo.py

Jetzt können Sie ein schönes Rezept für Mayonnaise bekommen!

Wechselnde Modelle

Mit der gleichen Umgebung, die wir oben eingerichtet haben, können Sie mit anderen beliebten Modellen von Hugging Face experimentieren, wie z.B. llama2-7B-chat-hf, llama3-8B-it, phi-2, gemma-7B-i und stablelm2, indem Sie das Hugging Face-Modell id oben in demo.py ersetzen.

model_id = "mistralai/Mistral-7B-Instruct-v0.2" # huggingface model id

an

model_id = "stabilityai/stablelm-2-zephyr-1_6b" # Umarmungsgesicht model id

Wenn Sie beim Starten von demo.py auf Fehler stoßen, befolgen Sie die folgenden Schritte, um ein Upgrade/Downgrade von transformers durchzuführen:

1. Anaconda-Eingabeaufforderung öffnen
2. conda aktiviert llm
3. pip install transformers==4.37.0

Geprüfte Versionen von Transformatoren:

Die Speicheranforderungen können je nach Modell und Framework variieren. Für den Intel Arc A750 8GB, der mit IPEX-LLM läuft, empfehlen wir die Verwendung von Llama-2-7B-chat-hf, Mistral-7B-Instruct-v0.2, phi-2 oder chatglm3-6B.

Implementierung einer ChatBot-WebUI

Lassen Sie uns nun zur Implementierung eines Gradio Chatbot-Webui übergehen, um eine bessere Erfahrung mit Ihrem Webbrowser zu machen. Weitere Informationen zur Implementierung eines interaktiven Chatbots mit LLMs finden Sie unter https://www.gradio.app/guides/creating-a-chatbot-fast

1. Erstellen Sie ein Dokument namens chatbot_gradio.py in einem Texteditor Ihrer Wahl.

2. Kopiere den folgenden Codeschnipsel und füge ihn in chatbot_gradio.py ein:

importiere gradio als gr
importieren torch
importiere intel_erweiterung_für_pytorch
von ipex_llm.transformers importieren AutoModelForCausalLM
from transformers import AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
from threading import Thread

model_id = "mistralai/Mistral-7B-Instruct-v0.2"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, optimize_model=True, load_in_4bit=True, torch_dtype=torch.float16)
model = model.half()
model = model.to("xpu")
class StopOnTokens(StoppingCriteria):
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
        stop_ids = [29, 0]
        for stop_id in stop_ids:
            if input_ids[0][-1] == stop_id:
                return True
        return False

def predict(message, history):
    stop = StopOnTokens()
    history_format = []
    for human, assistant in history:
        history_format.append({"role": "user", "content": human })
        history_format.append({"Rolle": "Assistent", "Inhalt":Assistent})
    history_format.append({"Rolle": "Benutzer", "Inhalt": Nachricht})

    prompt = tokenizer.apply_chat_template(history_format, tokenize=False, add_generation_prompt=True)
    model_inputs = tokenizer(prompt, return_tensors="pt").to("xpu")
    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
    generate_kwargs = dict(
        model_inputs,
        streamer=streamer,
        max_new_tokens=300,
        do_sample=True,
        top_p=0,95,
        top_k=20,
        Temperatur=0,8,
        num_beams=1,
        pad_token_id=tokenizer.eos_token_id,
        stoppen_kriterien=StoppkriterienListe([stoppen])
        )
    t = Thread(target=model.generate, kwargs=generate_kwargs)
    t.start()

    partial_message = ""
    for new_token in streamer:
        if new_token != '<':
            partial_message += new_token
            yield partial_message

gr.ChatInterface(predict).launch()

3. Öffnen Sie eine neue Anaconda-Eingabeaufforderung und geben Sie die folgenden Befehle ein:

• pip install gradio
• conda aktiviert llm
• cd in das Verzeichnis, in dem sich chat_gradio.py befindet
• python chatbot_gradio.py

4. Öffnen Sie Ihren Webbrowser und navigieren Sie zu 127.0.0.1:7860. Sie sollten einen Chatbot sehen, der mit dem Sprachmodell mistral-7b-instruct-v0.2 eingerichtet ist! Du hast nun ein schickes Webui für deinen Chatbot.

5. Stellen Sie eine Frage, um ein Gespräch mit Ihrem Chatbot zu beginnen.

Hinweise und Haftungsausschlüsse