Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

I. Einleitung

Ein spezieller Begriff „LoRA“ taucht im Bereich AIGC häufig auf. Er klingt ein wenig wie ein Personenname, ist aber eine Methode des Modelltrainings. Der vollständige Name von LoRA lautet „Low-Rank Adaptation of Large Language Models“, was auf Chinesisch heißtLow-Level-Anpassung großer Sprachmodelle . Heutzutage wird es sehr häufig in der stabilen Diffusion eingesetzt.

Aufgrund der großen Anzahl von Parametern großer Sprachmodelle müssen viele große Unternehmen mehrere Monate lang trainieren. Daher wurden verschiedene Trainingsmethoden mit geringerem Ressourcenverbrauch vorgeschlagen, und LoRA ist eine davon.

In diesem Artikel wird das Prinzip von LoRA ausführlich vorgestellt und PyTorch verwendet, um das LoRA-Training kleiner Modelle zu implementieren.

2. Modellschulung

Die meisten Modelltrainings verwenden jetzt den Gradientenabstiegsalgorithmus. Der Gradientenabstiegsalgorithmus kann in die folgenden 4 Schritte unterteilt werden:

1. Die Vorwärtsausbreitung berechnet den Verlustwert
2. Backpropagation berechnet Gradienten
3. Aktualisieren Sie Parameter mithilfe von Farbverläufen
4. Wiederholen Sie die Schritte 1, 2 und 3, bis ein geringerer Verlust erzielt wird

Am Beispiel des linearen Modells sind die Modellparameter W, die Eingabe und Ausgabe sind x, y und die Verlustfunktion ist der mittlere quadratische Fehler. Dann ist die Berechnung jedes Schritts wie folgt. Bei linearen Modellen handelt es sich um eine Matrixmultiplikation.

L = MSE(Bx, y)L = MSE(Bx, y)L = MSE(Bx, y)

Nachdem der Verlust ermittelt wurde, kann der Gradient von L gegenüber W berechnet werden, um dW zu erhalten:

dW=∂L∂WdW = frac{partielles L}{partielles W}dW=∂W∂L​

dW ist eine Matrix, die in die Richtung zeigt, in der L am schnellsten ansteigt, aber unser Ziel ist es, L fallen zu lassen, also sei W minus dW. Um das Aktualisierungstempo anzupassen, wird außerdem eine Lernrate η multipliziert, die wie folgt berechnet wird:

W′=W−ηdWW' = W - ηdWW′=W−ηdW

Am Ende immer wiederholen. Der Pseudocode für die oben genannten drei Schritte lautet wie folgt:

# 4、重复1、2、3
for i in range(10000):
    # 1、正向传播计算损失
    L = MSE(Wx, y)
    # 2、反向传播计算梯度
    dW = gradient(L, W)
    # 3、利用梯度更新参数
    W -= lr * dW

1
2
3
4
5
6
7
8
9

Nach Abschluss der Aktualisierung wird der neue Parameter W' erhalten. Wenn wir zu diesem Zeitpunkt die Modellvorhersage verwenden, lautet die Berechnung wie folgt:

pred=W′xpred = W‘xpred=W′x

3. Einführung von LoRA

Wir können über die Beziehung zwischen W und W' nachdenken. W bezieht sich normalerweise auf die Parameter des Basismodells, und W' wird nach mehreren Matrixadditionen und -subtraktionen basierend auf dem Basismodell erhalten. Angenommen, es wird während des Trainingsprozesses zehnmal aktualisiert und jedes Mal, wenn dW dW1, dW2, ..., dW10 ist, kann der gesamte Aktualisierungsprozess als eine Operation geschrieben werden:

W′=W−ηdW1−ηdW2−…−ηdW10 Sei: dW=∑i=110dWiW′=W−ηdWW' = W - ηdW_1 - ηdW_2 - … - ηdW_{10} \ Sei: dW = sum_{i=1} ^{10}dW_i \ W' = W - ηdW W′=W−ηdW1​−ηdW2​−…−ηdW10​Es sei: dW=i=1∑10​dWi​W′=W−ηdW

wobei dW eine Matrix mit der gleichen Form wie W' ist. Wir schreiben -ηdW als Matrix R, dann sind die aktualisierten Parameter:

W′=W+RW‘ = W + RW′=W+R

Zu diesem Zeitpunkt wird der Trainingsprozess auf die ursprüngliche Matrix plus eine weitere Matrix R vereinfacht. Das Lösen der Matrix R ist jedoch nicht einfacher und spart keine Ressourcen. Zu diesem Zeitpunkt wird die Idee von LoRA eingeführt.

Eine vollständig trainierte Matrix hat normalerweise den vollen Rang oder erfüllt grundsätzlich den Rang, das heißt, keine Spalte in der Matrix ist redundant. In der Arbeit „Skalierungsgesetze für neuronale Sprachmodelle“ wird die Beziehung zwischen dem Datensatz und der Parametergröße vorgeschlagen. Wenn diese Beziehung erfüllt ist und das Training gut ist, hat das resultierende Modell im Grunde den vollen Rang. Bei der Feinabstimmung des Modells wählen wir ein Basismodell aus, das im Wesentlichen den vollen Rang aufweist. Wie ist die Situation bei der Aktualisierung des Rangs der Matrix R?

Wir gehen davon aus, dass die R-Matrix eine Matrix mit niedrigem Rang ist. Eine Matrix mit niedrigem Rang hat viele wiederholte Spalten und kann daher in zwei kleinere Matrizen zerlegt werden. Wenn die Form von W m×n ist, dann ist die Form von A auch m×n. Wir zerlegen die Matrix R in AB (wobei die Form von A m×r und die Form von B r×r ist). Wählt normalerweise einen Wert, der weitaus kleiner als m ist, der Wert von n, wie in der Abbildung gezeigt:

Die Zerlegung einer Matrix mit niedrigem Rang in zwei Matrizen hat mehrere Vorteile. Der erste besteht darin, dass die Anzahl der Parameter erheblich reduziert wird. Angenommen, die Form der R-Matrix beträgt 100 × 100, dann beträgt die Anzahl der Parameter von R 10.000. Wenn wir Rang 10 auswählen, beträgt die Form der Matrix A 100×10 und die Form der Matrix B 10×100. Die Anzahl der Parameter beträgt 2000, was 80 % weniger als die R-Matrix ist.

Und da R eine Matrix mit niedrigem Rang ist, können die A- und B-Matrizen bei ausreichendem Training den Effekt von R erzielen. Die Matrix AB hier ist das, was wir oft als LoRA-Modell bezeichnen.

Nach der Einführung von LoRA muss unsere Vorhersage x in W bzw. AB eingeben. Zu diesem Zeitpunkt lautet die Vorhersageberechnung:

pred=Wx+ABxpred = Wx + ABxpred=Wx+ABx

Bei der Vorhersage ist es etwas langsamer als das Originalmodell, bei großen Modellen ist der Unterschied jedoch grundsätzlich nicht zu spüren.

4. Tatsächlicher Kampf

Um alle Details zu erfassen, verwenden wir kein großes Modell als eigentlichen Kampf von Lora, sondern verwenden stattdessen ein kleines Netzwerk wie vgg19, um das Lora-Modell zu trainieren. Importieren Sie die erforderlichen Module:

import os  
import torch  
from torch import optim, nn  
from PIL import Image  
from torch.utils import data  
from torchvision import models  
from torchvision.transforms import transforms

1
2
3
4
5
6
7
8

4.1 Vorbereitung des Datensatzes

Hier werden die vorab trainierten Gewichte von vgg19 auf Imagenet als Basismodell verwendet, sodass ein Klassifizierungsdatensatz erstellt werden muss.Der Einfachheit halber werden hier nur eine Kategorie und 5 Bilder vorbereitet. Die Bilder befinden sich unter dem Projektdata/goldfishRunter:

Die Kategorie „Goldfisch“ ist in Imagenet enthalten, hier wird jedoch die abgebildete Version von „Goldfisch“ ausgewählt. Nach dem Testen kann das vorab trainierte Modell die oben genannten Bilder nicht korrekt klassifizieren. Unser Ziel ist es, LoRA zu trainieren und das Modell korrekt zu klassifizieren.

Wir erstellen ein LoraDataset:

transform = transforms.Compose([  
    transforms.Resize(256),  
    transforms.CenterCrop(224),  
    transforms.ToTensor(),  
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  
])  
  
  
class LoraDataset(data.Dataset):  
    def __init__(self, data_path="datas"):  
        categories = models.VGG19_Weights.IMAGENET1K_V1.value.meta["categories"]  
        self.files = []  
        self.labels = []  
        for dir in os.listdir(data_path):  
            dirname = os.path.join(data_path, dir)  
            for file in os.listdir(dirname):  
                self.files.append(os.path.join(dirname, file))  
                self.labels.append(categories.index(dir))  
  
    def __getitem__(self, item):  
        image = Image.open(self.files[item]).convert("RGB")  
        label = torch.zeros(1000, dtype=torch.float64)  
        label[self.labels[item]] = 1.  
        return transform(image), label  
  
    def __len__(self):  
        return len(self.files)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

4.2 LoRA-Modell erstellen

Wir kapseln LoRA in eine Ebene. Es gibt nur zwei Matrizen, die in LoRA trainiert werden müssen. Der Code von LoRA lautet wie folgt:

class Lora(nn.Module):  
    def __init__(self, m, n, rank=10):  
        super().__init__()  
        self.m = m  
        self.A = nn.Parameter(torch.randn(m, rank))  
        self.B = nn.Parameter(torch.zeros(rank, n))  
  
    def forward(self, inputs):  
        inputs = inputs.view(-1, self.m)  
        return torch.mm(torch.mm(inputs, self.A), self.B)

1
2
3
4
5
6
7
8
9
10
11

Dabei ist m die Größe der Eingabe, n die Größe der Ausgabe und rank die Größe des Ranges. Wir können einen kleineren Wert festlegen.

Bei der Initialisierung der Gewichte initialisieren wir A mit Gaußschem Rauschen und B mit einer 0-Matrix. Dies soll sicherstellen, dass das Training vom unteren Modell aus beginnt. Da AB eine 0-Matrix ist, funktioniert LoRA im Ausgangszustand nicht.

4.3 Hyperparameter einstellen und trainieren

Der nächste Schritt ist das Training. Dies ist im Grunde dasselbe wie der reguläre Trainingscode von PyTorch. Schauen wir uns zuerst den Code an:

# 加载底模和lora  
vgg19 = models.vgg19(models.VGG19_Weights.IMAGENET1K_V1)  
for params in vgg19.parameters():  
    params.requires_grad = False  
vgg19.eval()  
lora = Lora(224 * 224 * 3, 1000)  
# 加载数据  
lora_loader = data.DataLoader(LoraDataset(), batch_size=batch_size, shuffle=True)  
# 加载优化器  
optimizer = optim.Adam(lora.parameters(), lr=lr)  
# 定义损失  
loss_fn = nn.CrossEntropyLoss()  
# 训练  
for epoch in range(epochs):  
    for image, label in lora_loader:  
        # 正向传播  
        pred = vgg19(image) + lora(image)  
        loss = loss_fn(pred, label)  
        # 反向传播  
        loss.backward()  
        # 更新参数  
        optimizer.step()  
        optimizer.zero_grad()  
        print(f"loss: {loss.item()}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Hier sind zwei Punkte zu beachten. Der erste Punkt ist, dass wir das Gewicht von vgg19 als nicht trainierbar festlegen. Dies ist dem Transferlernen sehr ähnlich, aber es ist tatsächlich anders.

Der zweite Punkt ist, dass wir während der Vorwärtsausbreitung den folgenden Code verwenden:

pred = vgg19(image) + lora(image)

1
2

4.4 Testen

Machen wir einen einfachen Test:

# 测试  
for image, _ in lora_loader:  
    pred = vgg19(image) + lora(image)  
    idx = torch.argmax(pred, dim=1).item()  
    category = models.VGG19_Weights.IMAGENET1K_V1.value.meta["categories"][idx]  
    print(category)
torch.save(lora.state_dict(), 'lora.pth')

1
2
3
4
5
6
7
8

Die Ausgabe ist wie folgt:

goldfish
goldfish
goldfish
goldfish
goldfish

1
2
3
4
5
6

Die grundlegende Vorhersage ist richtig, aber dieses Testergebnis bedeutet nichts. Schließlich haben wir ein 5-M-LoRA-Modell gespeichert, was im Vergleich zu den mehreren zehn MB von vgg19 sehr klein ist.

5. Zusammenfassung

LoRA ist eine effiziente Trainingsmethode für große Modelle. In diesem Artikel wird LoRA in einem kleinen Klassifizierungsnetzwerk verwendet, um den Lesern ein klareres Verständnis der detaillierten Implementierung von LoRA zu vermitteln (aber auch, weil damit keine großen Modelle ausgeführt werden können). Aufgrund des begrenzten Datenvolumens werden Themen wie die Genauigkeit und Effizienz von LoRA nicht im Detail besprochen. Leser können zum tieferen Verständnis auf relevante Materialien zurückgreifen.

Wie lernt man große KI-Modelle?

Ich habe mehr als zehn Jahre lang in führenden Internetunternehmen gearbeitet und viele junge Kollegen betreut. Hat vielen Menschen geholfen, zu lernen und zu wachsen.

Mir ist klar, dass es eine Menge Erfahrung und Wissen gibt, die es wert sind, mit allen geteilt zu werden, und wir können unsere Fähigkeiten und Erfahrungen auch nutzen, um viele Ihrer Verwirrungen beim Lernen mit künstlicher Intelligenz zu beantworten, deshalb bestehe ich immer noch darauf, verschiedene Dinge zu organisieren und zu teilen, auch wenn ich es bin auf der Arbeit beschäftigt. Aufgrund der begrenzten Kanäle zur Wissensverbreitung sind viele Freunde in der Internetbranche jedoch nicht in der Lage, die richtigen Materialien zur Verbesserung ihres Lernens zu erhalten. Daher gehören zu den wichtigen KI-Großmodell-Materialien Einführungs-Mindmaps und hochwertiges KI-Großmodell-Lernen Bücher und Handbücher sowie Video-Tutorials, praktische Lernvideos und andere aufgezeichnete Videos werden kostenlos geteilt.

Die erste Stufe: Beginnen Sie mit dem Entwurf großer Modellsysteme und erläutern Sie die Hauptmethoden großer Modelle.

Die zweite Stufe: Durch das große Modell-Prompt-Word-Projekt beginnen Sie aus der Perspektive von Prompts, um die Rolle des Modells besser zu nutzen.

Die dritte Stufe: Die Anwendungsentwicklung für große Modellplattformen nutzt die Alibaba Cloud PAI-Plattform, um ein virtuelles Anpassungssystem im E-Commerce-Bereich aufzubauen.

Die vierte Stufe: Die Entwicklung einer großen Modell-Wissensdatenbankanwendung verwendet das LangChain-Framework als Beispiel, um ein intelligentes Frage- und Antwortsystem für die Beratung in der Logistikbranche aufzubauen.

Die fünfte Stufe: Feinabstimmung der Entwicklung großer Modelle durch Nutzung der Bereiche Big Health, New Retail und New Media, um große Modelle zu erstellen, die für den aktuellen Bereich geeignet sind;

Die sechste Stufe: Basierend auf dem multimodalen SD-Großmodell wurde ein Wensheng-Diagramm-Applet-Gehäuse erstellt.

Die siebte Stufe: Konzentrieren Sie sich auf die Anwendung und Entwicklung großer Modellplattformen und erstellen Sie Anwendungen für die Industrie großer Modelle mithilfe ausgereifter großer Modelle wie dem großen Xinghuo-Modell und dem großen Wenxin-Modell.

👉学会后的收获：👈
• Basierend auf der Full-Stack-Engineering-Implementierung großer Modelle (Front-End, Back-End, Produktmanager, Design, Datenanalyse usw.) können durch diesen Kurs unterschiedliche Fähigkeiten erworben werden;

• Kann große Modelle verwenden, um relevante tatsächliche Projektanforderungen zu lösen: Im Zeitalter von Big Data müssen immer mehr Unternehmen und Institutionen riesige Datenmengen verarbeiten. Durch die Verwendung großer Modelltechnologie können diese Daten besser verarbeitet und die Genauigkeit der Datenanalyse verbessert werden und Entscheidungsfindung. Daher kann die Beherrschung der Fähigkeiten zur Entwicklung großer Modellanwendungen es Programmierern ermöglichen, den tatsächlichen Projektanforderungen besser gerecht zu werden.

• Basierend auf der Entwicklung von KI-Anwendungen für große Modelle und Unternehmensdaten, Implementierung der Theorie großer Modelle, Beherrschung der GPU-Rechenleistung, Hardware, LangChain-Entwicklungsframework und praktischer Projektfähigkeiten sowie Erlernen der Feinabstimmung des vertikalen Trainings großer Modelle (Datenvorbereitung, Datendestillation, groß). Modellbereitstellung) Beherrschung aus einer Hand;

• Fähigkeit, beliebte vertikale Feldmodelltrainingsfunktionen für große Modelle zu vervollständigen und die Programmierfähigkeiten von Programmierern zu verbessern: Die Entwicklung großer Modellanwendungen erfordert die Beherrschung von Algorithmen für maschinelles Lernen, Deep-Learning-Frameworks und anderen Technologien. Die Beherrschung dieser Technologien kann die Programmier- und Analysefähigkeiten von Programmierern verbessern um das Schreiben von qualitativ hochwertigem Code besser zu beherrschen.

1. Roadmap für das Lernen großer KI-Modelle
2. Kommerzieller Implementierungsplan für 100 Sätze großer KI-Modelle
3.100 Episoden mit Video-Tutorials für große Modelle
4.200 große Modell-PDF-Bücher
5. Sammlung von LLM-Interviewfragen
6. Ressourcensammlung für KI-Produktmanager

👉获取方式：
😝有需要的小伙伴，可以保存图片到wx扫描二v码免费领取【保证100%免费】🆓