GPT-Lokalisierungsbereitstellungspraxis für das große Sprachmodell Alpaca-lora

Modelleinführung

Das Alpaca-Modell ist ein LLM-Open-Source-Modell (Large Language Model, große Sprache), das von der Stanford University entwickelt wurde. Es handelt sich um ein 7-Milliarden-Modell, das auf der Grundlage des LLaMA 7B-Modells (Open Source 7B von Meta Company) verfeinert wurde 52K-Anweisungen (je größer die Modellparameter, desto stärker ist die Argumentationsfähigkeit des Modells und desto höher sind natürlich die Kosten für das Training des Modells).

LoRA, der vollständige englische Name lautet Low-Rank Adaptation of Large Language Models, wörtlich übersetzt als Low-Level-Adaption großer Sprachmodelle. Dabei handelt es sich um eine von Microsoft-Forschern entwickelte Technologie zur Lösung der Feinabstimmung großer Sprachmodelle. Wenn Sie möchten, dass ein vorab trainiertes großes Sprachmodell Aufgaben in einem bestimmten Bereich ausführen kann, müssen Sie im Allgemeinen eine Feinabstimmung vornehmen. Die Parameterdimensionen großer Sprachmodelle mit guten Inferenzeffekten sind jedoch sehr, sehr groß Einige umfassen sogar Hunderte von Milliarden Dimensionen. Wenn Sie eine Feinabstimmung an einem großen Sprachmodell durchführen, sind sehr viele Berechnungen und sehr hohe Kosten erforderlich. Die Methode von

’LoRA besteht darin, die vorab trainierten Modellparameter einzufrieren und dann trainierbare Schichten in jeden Transformer-Block einzufügen. Da der Gradient der Modellparameter nicht neu berechnet werden muss, wird der Berechnungsaufwand erheblich reduziert.

Wie in der folgenden Abbildung dargestellt, besteht die Kernidee darin, dem ursprünglichen vorab trainierten Modell einen Bypass hinzuzufügen und eine Dimensionsreduktion und anschließend eine Dimensionsoperation durchzuführen. Während des Trainings werden die Parameter des vorab trainierten Modells festgelegt und nur die Dimensionsreduktionsmatrix A und die Dimensionsverbesserungsmatrix B trainiert. Die Eingabe- und Ausgabedimensionen des Modells bleiben unverändert und der BA und die Parameter des vorab trainierten Sprachmodells werden der Ausgabe überlagert.

Initialisieren Sie A mit einer zufälligen Gaußschen Verteilung und initialisieren Sie B mit einer 0-Matrix. Dadurch wird sichergestellt, dass der neue Bypass BA=0 während des Trainings ist und somit keinen Einfluss auf die Modellergebnisse hat. Während der Argumentation werden die Ergebnisse des linken und rechten Teils addiert, d. h. h = Wx + BAx = (W + BA) x. Fügen Sie daher nach dem Training einfach das Matrixprodukt BA und die ursprüngliche Gewichtsmatrix W als neue hinzu Die Parameter können durch W des ursprünglichen vorab trainierten Sprachmodells ersetzt werden, und es werden keine zusätzlichen Rechenressourcen hinzugefügt. Der größte Vorteil von LoRA besteht darin, dass es schneller trainiert und weniger Speicher verbraucht.

Das Alpaca-Lora-Modell, das in diesem Artikel für die lokalisierte Bereitstellungspraxis verwendet wird, ist eine angepasste Version des Alpaca-Modells niedriger Ordnung. In diesem Artikel werden der Lokalisierungseinsatz, die Feinabstimmung und der Inferenzprozess des Alpaca-Lora-Modells geübt und die relevanten Schritte beschrieben.

Bereitstellung einer GPU-Serverumgebung

Der in diesem Artikel eingesetzte GPU-Server verfügt über 4 unabhängige GPUs. Die Rechenleistung eines einzelnen P40 entspricht der Rechenleistung von 60 CPUs mit derselben Hauptfrequenz.

Wenn Sie der Meinung sind, dass die physische Karte nur zum Testen zu teuer ist, können Sie auch die „Ersatzversion“ verwenden – den GPU-Cloud-Server. Im Vergleich zu physischen Karten gewährleistet die Verwendung von GPU-Cloud-Servern zum Aufbau nicht nur flexibles Hochleistungsrechnen, sondern bietet auch die folgenden Vorteile:

• Hohe Kostenleistung: Stundenweise abgerechnet, nur ein Dutzend Yuan pro Stunde, und kann entsprechend bereitgestellt werden Sie können sich jederzeit an Ihre Bedürfnisse anpassen; Cloud-Computing-Vorteile wie flexibles Ressourcenmanagement, Skalierbarkeit und elastische Skalierung können die Computerressourcen schnell an geschäftliche oder persönliche Schulungsanforderungen anpassen.
• Offenheit: Die Offenheit von Cloud Computing ermöglicht es Benutzern, mehr Ressourcen zu teilen und gemeinsam daran zu arbeiten, was umfassendere Kooperationsmöglichkeiten für die Forschung und Anwendung von KI-Modellen bietet Cloud Maßgeschneiderte Entwicklung und Integration verschiedener Dienste und Funktionen der Plattform.
• Der GPU-Cloud-Host von JD Cloud führt derzeit das 618-Ereignis aus, was sehr kostengünstig ist Was wir tun müssen, ist die Installation des Grafikkartentreibers und des CUDA-Treibers (eine vom Grafikkartenhersteller NVIDIA eingeführte Computerplattform. CUDA ist eine von NVIDIA eingeführte allgemeine parallele Computerarchitektur, die es der GPU ermöglicht, komplexe Computerprobleme zu lösen).

Der Grafikkartentreiber muss auf der offiziellen Website von NVIDIA nach dem entsprechenden Grafikkartenmodell und der angepassten CUDA-Version suchen:
https://www.nvidia.com/Download/index.aspx und die entsprechenden Grafiken auswählen Karte und CUDA-Version können Sie die Treiberdatei herunterladen.

Die Datei, die ich heruntergeladen habe, ist

NVIDIA-Linux-x86_64-515.105.01.run, dies ist eine ausführbare Datei, Sie können sie mit Root-Berechtigungen ausführen. Beachten Sie, dass während des Treiberinstallationsprozesses keine laufenden NVIDIA-Prozesse ausgeführt werden können Die Installation schlägt fehl, wie im Bild unten gezeigt:

Fahren Sie dann mit dem nächsten Schritt fort. Wenn kein Fehler gemeldet wird, ist die Installation erfolgreich. Um die Grafikkartenressourcen später zu überprüfen, installieren Sie am besten ein anderes Grafikkartenüberwachungstool, z. B. nvitop. Verwenden Sie dazu einfach pip install nvitop. Beachten Sie hier, dass es am besten ist, Anaconda zu installieren, da die Python-Versionen verschiedener Server unterschiedlich sind So stellen Sie Ihren eigenen privaten Python-Bereich bereit, um zu verhindern, dass beim Ausführen verschiedene seltsame Fehler auftreten:

1. Installieren Sie Anaconda .0-Linux-x86_64.sh. Installationsbefehl: sh Anaconda3-5.3.0-Linux-x86_64.sh Geben Sie für jeden Installationsschritt „Ja“ ein und schließen Sie die Installation schließlich nach conda init ab, sodass Sie jedes Mal, wenn Sie die Sitzung des Installationsbenutzers betreten, direkt Ihre eigene eingeben Python-Umgebung. Wenn Sie im letzten Schritt der Installation „Nein“ auswählen, d. h. die Conda-Init wird nicht ausgeführt, können Sie später über die Quelle /home/jd_ad_sfxn/anaconda3/bin/activate auf die private Python-Umgebung zugreifen.

2. Setuptools installieren Als nächstes müssen Sie das Verpackungs- und Verteilungstool Setuptools installieren, Download-Adresse: wget

https://files.pythonhosted.org/packages/26/e5/9897eee1100b166a61f91b68528cb692e8887300d9cbdaa1a349f6304b79/setuptool s-40 .5.0.zip-Installation Befehl: unzip setuptools-40.5.0.zip cd setuptools-40.5.0/ python setup.py install

3. Installieren Sie pip Download-Adresse: wget

https://files.pythonhosted.org/packages/45/ae/8a0ad77defb7cc903f09e551d88b443304a9bd6e6f12 4e75c0fbbf 6de8f7/pip- 18.1.tar.gz Installationsbefehl: tar -xzf pip-18.1.tar.gz cd pip-18.1 python setup.py install

An diesem Punkt ist der lange Installationsprozess endlich zu Ende Erstellen Sie einen privaten Python-Bereich und führen Sie

conda create -n alpaca pythnotallow=3.9conda activate alpaca

aus. Überprüfen Sie dann, wie im Bild unten gezeigt, dass es erfolgreich erstellt wurde.

Modelltraining

Die Grundumgebung des GPU-Servers wurde oben installiert. Jetzt beginnen wir mit dem spannenden Modelltraining (aufregend). Vor dem Training müssen wir zuerst die Modelldatei herunterladen, Adresse herunterladen:

https ://github.com/tloen/alpaca-lora, das gesamte Modell ist Open Source, was großartig ist! Laden Sie zunächst die Modelldatei lokal herunter und führen Sie git clone https://github.com/tloen/alpaca-lora.git aus.

Es wird lokal einen Ordner alpaca-lora geben und dann cd alpaca-lora zur Ausführung innerhalb des Ordners

pip install -r requirements.txt

Dieser Vorgang kann langsam sein und erfordert das Herunterladen einer großen Anzahl abhängiger Pakete aus dem Internet. Es können auch verschiedene Paketkonflikte auftreten Während des Vorgangs wurde berichtet, dass es kein Problem mit Abhängigkeiten gibt, Sie können also nur versuchen, das zu installieren, was fehlt (das Auflösen von Paketabhängigkeiten und Versionskonflikten bereitet zwar Kopfschmerzen, aber wenn Sie diesen Schritt nicht gut ausführen, wird das Modell nicht ausgeführt , Sie können es also nur nach und nach lösen. Ich werde hier nicht näher auf den schmerzhaften Prozess eingehen, da verschiedene Maschinen auf unterschiedliche Probleme stoßen können und die Referenzbedeutung nicht sehr groß ist.

Wenn der Installationsvorgang abgeschlossen ist und keine Fehlermeldungen mehr angezeigt werden und die Meldung „Erfolgreich“ angezeigt wird, dann sind Sie auf halbem Weg. Wenn Sie noch etwas länger durchhalten, sind Sie sehr wahrscheinlich um Erfolg zu haben. La :).

Da unser Ziel die Feinabstimmung des Modells ist, müssen wir ein Feinabstimmungsziel haben. Da das ursprüngliche Modell Chinesisch nicht gut unterstützt, besteht unser Ziel darin, das Modell mithilfe des chinesischen Korpus zu verbessern . Diese Community hat es auch für mich vorbereitet. Wir können das chinesische Korpus einfach direkt herunterladen und wget lokal ausführen

https://github.com/LC1332/Chinese-alpaca-lora/blob/main/data/ trans_chinese_alpaca_data.json?raw =true, laden Sie den für das Modelltraining verwendeten Korpus später in das Stammverzeichnis von alpaca-lora herunter (zur späteren einfacheren Verwendung).

Der Inhalt des Korpus besteht aus vielen Tripeln (Anweisung, Eingabe, Ausgabe, wie in der Abbildung unten gezeigt). Anweisung ist die Anweisung, das Modell etwas tun zu lassen, Eingabe ist die Eingabe und Ausgabe ist die Ausgabe des Welche Informationen soll das Modell entsprechend den Anweisungen und Eingaben ausgeben, damit sich das Modell besser an Chinesisch anpassen kann?

好的，到现在为止，万里长征已经走完2/3了，别着急训练模型，我们现在验证一下GPU环境和CUDA版本信息，还记得之前我们安装的nvitop嘛，现在就用上了，在本地直接执行nvitop，我们就可以看到GPU环境和CUDA版本信息了，如下图：

在这里我们能够看到有几块显卡，驱动版本和CUDA版本等信息，当然最重要的我们还能看到GPU资源的实时使用情况。

怎么还没到模型训练呢，别着急呀，这就来啦。

我们先到根目录下然后执行训练模型命令：

如果是单个GPU，那么执行命令即可：

python finetune.py \--base_model 'decapoda-research/llama-7b-hf' \--data_path 'trans_chinese_alpaca_data.json' \--output_dir './lora-alpaca-zh'

如果是多个GPU，则执行：

WORLD_SIZE=2 CUDA_VISIBLE_DEVICES=0,1 torchrun \--nproc_per_node=2 \--master_port=1234 \finetune.py \--base_model 'decapoda-research/llama-7b-hf' \--data_path 'trans_chinese_alpaca_data.json' \--output_dir './lora-alpaca-zh'

如果可以看到进度条在走，说明模型已经启动成功啦。

在模型训练过程中，每迭代一定数量的数据就会打印相关的信息，会输出损失率，学习率和代信息，如上图所示，当loss波动较小时，模型就会收敛，最终训练完成。

我用的是2块GPU显卡进行训练，总共训练了1904分钟，也就是31.73个小时，模型就收敛了，模型训练是个漫长的过程，所以在训练的时候我们可以适当的放松一下，做点其他的事情：）。

模型推理

模型训练好后，我们就可以测试一下模型的训练效果了，由于我们是多个GPU显卡，所以想把模型参数加载到多个GPU上，这样会使模型推理的更快，需要修改

generate.py 文件，添加下面这样即可。

然后我们把服务启起来，看看效果，根目录执行：

python generate.py --base_model "decapoda-research/llama-7b-hf" \--lora_weights './lora-alpaca-zh' \--load_8bit

其中./lora-alpaca-zh目录下的文件，就是我们刚刚fine tuning模型训练的参数所在位置，启动服务的时候把它加载到内存（这个内存指的是GPU内存）里面。

如果成功，那么最终会输出相应的IP和Port信息，如下图所示：

我们可以用浏览器访问一下看看，如果能看到页面，就说明服务已经启动成功啦。

激动ing，费了九牛二虎之力，终于成功啦！！

因为我们目标是让模型说中文，所以我们测试一下对中文的理解，看看效果怎么样？

简单的问题，还是能给出答案的，但是针对稍微复杂一点的问题，虽然能够理解中文，但是并没有用中文进行回答，训练后的模型还是不太稳定啊。

在推理的时候我们也可以监控一下GPU的变化，可以看到GPU负载是比较高的，说明GPU在进行大量的计算来完成推理。

总结

1.效果问题：由于语料库不够丰富，所以目前用社区提供的语料库训练的效果并不是很好，对中文的理解力有限，如果想训练出能够执行特定领域的任务，则需要大量的语料支持，同时训练时间也会更长；

2. Inferenzzeitproblem: Da der aktuell eingesetzte GPU-Server über 4 GPUs verfügt, ist es immer noch ziemlich schwierig, eine Interaktion auszuführen, die auf 3 GPUs basiert Zeitrückgabe wie chatGPT erfordert viel Rechenleistung zur Unterstützung. Daraus lässt sich schließen, dass das Backend von chatGPT von einem großen Cluster an Rechenleistung unterstützt werden muss. Wenn Sie es also zu einem Dienst machen möchten, sind Kosteninvestitionen ein Problem muss berücksichtigt werden;

3. Wenn die Eingabe chinesisch ist, wird vermutet, dass die zurückgegebenen Ergebnisse mit der Wortsegmentierung zusammenhängen Wie Englisch, daher wird es möglicherweise auch eine gewisse Menge an verstümmeltem Code geben. AI-APIs werden diese Situation auch haben, und wir werden später sehen, ob die Community entsprechende Lösungen hat Derzeit relativ aktiv, ändern sich auch die Generierung und Änderungen von Modellen mit jedem Tag. Aufgrund der Zeiteile untersuchen wir derzeit nur den lokalisierten Einsatz des Alpaca-Lora-Modells, um eine bessere und kostengünstigere Implementierung zu ermöglichen Es ist notwendig, die Entwicklung der Community weiterhin zu verfolgen und geeignete Open-Source-Lösungen auszuwählen.

Die [ChatGLM-Sprachmodell]-Praxis der JD Cloud P40-Modell-GPU finden Sie im Detail unter:

https://www.php.cn/link/f044bd02e4fe1aa3315ace7645f8597a

Autor: JD Retail Luo Yongjian

Inhaltsquelle: JD Cloud Developer Gemeinschaft

Das obige ist der detaillierte Inhalt vonGPT-Lokalisierungsbereitstellungspraxis für das große Sprachmodell Alpaca-lora. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!