Condivisione della tecnologia

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

I. Introduzione

C'è un termine speciale "LoRA" che appare spesso nel campo AIGC. Sembra un po' il nome di una persona, ma è un metodo di formazione del modello. Il nome completo di LoRA è Adattamento di basso rango di modelli linguistici di grandi dimensioni, come viene chiamato in cineseAdattamento di basso livello di grandi modelli linguistici . Oggigiorno viene utilizzato molto frequentemente in diffusione stabile.

A causa dell'enorme numero di parametri dei modelli linguistici di grandi dimensioni, molte grandi aziende necessitano di corsi di formazione per diversi mesi. Pertanto, sono stati proposti vari metodi di formazione con un minor consumo di risorse e LoRA è uno di questi.

Questo articolo introdurrà il principio di LoRA in dettaglio e utilizzerà PyTorch per implementare l'addestramento LoRA di piccoli modelli.

2. Formazione modello

La maggior parte dell'addestramento dei modelli ora utilizza l'algoritmo di discesa del gradiente. L’algoritmo di discesa del gradiente può essere suddiviso nei seguenti 4 passaggi:

1. La propagazione diretta calcola il valore della perdita
2. La propagazione inversa calcola i gradienti
3. Aggiorna i parametri utilizzando i gradienti
4. Ripetere i passaggi 1, 2 e 3 fino ad ottenere una perdita minore

Prendendo come esempio il modello lineare, i parametri del modello sono W, l'input e l'output sono x, y e la funzione di perdita è l'errore quadratico medio. Quindi il calcolo di ciascun passaggio è il seguente. Il primo è la propagazione in avanti. Per i modelli lineari, è una moltiplicazione di matrici:

L = MSE(Wx,y)L = MSE(Wx,y)L = MSE(Wx,y)

Dopo aver trovato la perdita, è possibile calcolare il gradiente di L rispetto a W per ottenere dW:

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

dW è una matrice che punta nella direzione in cui L aumenta più velocemente, ma il nostro obiettivo è far diminuire L, quindi lasciamo W meno dW. Per regolare il ritmo degli aggiornamenti, viene anche moltiplicato un tasso di apprendimento η, calcolato come segue:

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

Ripeti tutto il tempo alla fine. Lo pseudocodice per i tre passaggi precedenti è il seguente:

# 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

Al termine dell'aggiornamento si ottiene il nuovo parametro W'. Quando utilizziamo la previsione del modello in questo momento, il calcolo è il seguente:

pred=W′xpred = W'xpred=W′x

3. Presentazione di LoRA

Possiamo pensare alla relazione tra W e W'. W di solito si riferisce ai parametri del modello base e W' si ottiene dopo diverse addizioni e sottrazioni di matrice basate sul modello base. Supponiamo che venga aggiornato 10 volte durante il processo di addestramento e ogni volta che dW è dW1, dW2,..., dW10, quindi l'intero processo di aggiornamento può essere scritto come un'unica operazione:

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

dove dW è una matrice con la stessa forma di W'. Scriviamo -ηdW come matrice R, quindi i parametri aggiornati sono:

W′=W+RW' = W + RW′=W+R

A questo punto, il processo di addestramento viene semplificato utilizzando la matrice originale più un'altra matrice R. Tuttavia, risolvere la matrice R non è più semplice e non fa risparmiare risorse. In questo momento viene introdotta l’idea di LoRA.

Una matrice completamente addestrata ha solitamente il rango completo o sostanzialmente soddisfa il rango, ovvero nessuna colonna nella matrice è ridondante. Nel documento "Scaling Laws for Neural Language Model", viene proposta la relazione tra il set di dati e la dimensione dei parametri. Se questa relazione è soddisfatta e l'addestramento è buono, il modello risultante è sostanzialmente a rango completo. Durante la messa a punto del modello, selezioneremo un modello base, che sostanzialmente ha il rango completo. Qual è la situazione dell'aggiornamento del rango della matrice R?

Assumiamo che la matrice R sia una matrice di rango basso. Una matrice di rango basso ha molte colonne ripetute e quindi può essere scomposta in due matrici più piccole. Se la forma di W è m×n, allora anche la forma di A è m×n. Scomponiamo la matrice R in AB (dove la forma di A è m×r e la forma di B è r×N). solitamente sceglie un valore molto più piccolo di m, il valore di n, come mostrato in figura:

La scomposizione di una matrice di rango basso in due matrici presenta diversi vantaggi. Il primo è che il numero di parametri è significativamente ridotto. Supponiamo che la forma della matrice R sia 100×100, quindi il numero di parametri di R è 10000. Quando selezioniamo il rango 10, la forma della matrice A è 100×10 e la forma della matrice B è 10×100. Il numero di parametri è 2000, ovvero l'80% in meno rispetto alla matrice R.

E poiché R è una matrice di rango basso, con un addestramento sufficiente, le matrici A e B possono ottenere l’effetto di R. La matrice AB qui è ciò che spesso chiamiamo modello LoRA.

Dopo aver introdotto LoRA, la nostra previsione deve inserire x rispettivamente in W e AB. A questo punto, il calcolo della previsione è:

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

Sarà leggermente più lento rispetto al modello originale durante la previsione, ma la differenza sostanzialmente non si avverte nei modelli di grandi dimensioni.

4. Combattimento reale

Per cogliere tutti i dettagli, non utilizziamo un modello di grandi dimensioni come il combattimento reale di Lora, scegliamo invece di utilizzare una piccola rete come vgg19 per addestrare il modello di Lora. Importa i moduli richiesti:

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 Preparazione del set di dati

In questo caso, i pesi pre-addestrati di vgg19 su imagenet vengono utilizzati come modello di base, quindi è necessario preparare un set di dati di classificazione.Per comodità, qui sono preparate solo una categoria e 5 immagini. Le immagini sono sotto il progettodata/goldfishGiù:

La categoria dei pesci rossi è inclusa in imagenet, ma la versione illustrata dei pesci rossi è selezionata qui. Dopo il test, il modello pre-addestrato non è in grado di classificare correttamente le immagini sopra. Il nostro scopo è addestrare LoRA e classificare correttamente il modello.

Creiamo un 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 Creare il modello LoRA

Incapsuliamo LoRA in un livello Ci sono solo due matrici che devono essere addestrate in LoRA. Il codice di LoRA è il seguente:

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

Dove m è la dimensione dell'input, n è la dimensione dell'output, rango è la dimensione del rango, possiamo impostare un valore più piccolo.

Quando inizializziamo i pesi, inizializziamo A con rumore gaussiano e inizializziamo B con una matrice 0. Questo per garantire che l'addestramento inizi dal modello inferiore. Poiché AB è una matrice 0, LoRA non funziona nello stato iniziale.

4.3 Impostare gli iperparametri ed eseguire il training

Il passaggio successivo è l'addestramento. Questo è sostanzialmente lo stesso del normale codice di addestramento di PyTorch. Diamo prima un'occhiata al codice:

# 加载底模和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

Ci sono due punti da notare qui. Il primo punto è che impostiamo il peso di vgg19 in modo che non sia addestrabile. Questo è molto simile al trasferimento dell'apprendimento, ma in realtà è diverso.

Il secondo punto è che durante la propagazione in avanti utilizziamo il seguente codice:

pred = vgg19(image) + lora(image)

1
2

4.4 Test

Facciamo un semplice 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

L'output è il seguente:

goldfish
goldfish
goldfish
goldfish
goldfish

1
2
3
4
5
6

La previsione di base è corretta, ma il risultato del test non significa nulla. Infine, abbiamo salvato un modello LoRA da 5 milioni, che è molto piccolo rispetto alle decine di MB di vgg19.

5. Riepilogo

LoRA è un metodo di training efficiente per modelli di grandi dimensioni e questo articolo utilizza LoRA in una piccola rete di classificazione per offrire ai lettori una comprensione più chiara dell'implementazione dettagliata di LoRA (ma anche perché non può eseguire modelli di grandi dimensioni). A causa del volume limitato di dati, questioni come l'accuratezza e l'efficienza di LoRA non vengono discusse in dettaglio. I lettori possono fare riferimento ai materiali pertinenti per una comprensione approfondita.

Come apprendere modelli di intelligenza artificiale di grandi dimensioni?

Ho lavorato in prima linea in aziende Internet per più di dieci anni e ho fatto da mentore a molti colleghi junior. Ha aiutato molte persone a imparare e crescere.

Mi rendo conto che c'è molta esperienza e conoscenza che vale la pena condividere con tutti, e possiamo anche usare le nostre capacità ed esperienza per rispondere a molte delle vostre confusioni nell'apprendimento dell'intelligenza artificiale, quindi insisto ancora nell'organizzare e condividere varie cose anche se sono impegnato a lavoro. Tuttavia, a causa dei canali limitati per la diffusione della conoscenza, molti amici nel settore Internet non sono in grado di ottenere materiali corretti per migliorare il loro apprendimento. Pertanto, importanti materiali per modelli di grandi dimensioni dell'intelligenza artificiale includono mappe mentali per l'apprendimento introduttivo di modelli di grandi dimensioni dell'intelligenza artificiale, apprendimento di modelli di grandi dimensioni dell'intelligenza artificiale di alta qualità libri e manuali, tutorial video, apprendimento pratico e altri video registrati sono condivisi gratuitamente.

La prima fase: iniziare con la progettazione di sistemi di modelli di grandi dimensioni e spiegare i metodi principali dei modelli di grandi dimensioni;

La seconda fase: attraverso il grande progetto di parole di prompt del modello, iniziare dalla prospettiva dei suggerimenti per utilizzare meglio il ruolo del modello;

La terza fase: lo sviluppo di applicazioni per piattaforme di grandi dimensioni utilizza la piattaforma Alibaba Cloud PAI per creare un sistema di adattamento virtuale nel campo dell'e-commerce;

La quarta fase: lo sviluppo di applicazioni di base di conoscenza di grandi dimensioni prende il framework LangChain come esempio per costruire un sistema intelligente di domande e risposte per la consultazione del settore logistico;

La quinta fase: mettere a punto lo sviluppo di modelli di grandi dimensioni utilizzando i settori della grande salute, della nuova vendita al dettaglio e dei nuovi media per costruire modelli di grandi dimensioni adatti al campo attuale;

La sesta fase: sulla base del grande modello multimodale SD, è stato costruito un caso di applet con diagramma Wensheng;

La settima fase: concentrarsi sull'applicazione e sullo sviluppo di piattaforme di modelli di grandi dimensioni e creare applicazioni di settore di modelli di grandi dimensioni attraverso modelli di grandi dimensioni maturi come il modello di grandi dimensioni Xinghuo e il modello di grandi dimensioni Wenxin.

👉学会后的收获：👈
• Basandosi sull'implementazione ingegneristica full-stack di modelli di grandi dimensioni (front-end, back-end, product manager, progettazione, analisi dei dati, ecc.), attraverso questo corso si possono acquisire diverse abilità;

• In grado di utilizzare modelli di grandi dimensioni per risolvere le esigenze reali dei progetti: nell'era dei big data, sempre più imprese e istituzioni hanno bisogno di elaborare enormi quantità di dati. L'utilizzo della tecnologia dei modelli di grandi dimensioni può elaborare meglio questi dati e migliorare l'accuratezza dell'analisi dei dati e processo decisionale. Pertanto, padroneggiare le competenze di sviluppo di applicazioni di modelli di grandi dimensioni può consentire ai programmatori di affrontare meglio le effettive esigenze del progetto;

• Basato sullo sviluppo di applicazioni AI per modelli di grandi dimensioni e dati aziendali, implementare la teoria dei modelli di grandi dimensioni, padroneggiare la potenza di calcolo della GPU, l'hardware, il framework di sviluppo LangChain e le competenze pratiche di progetto e apprendere la messa a punto della formazione verticale di modelli di grandi dimensioni (preparazione dei dati, distillazione dei dati, grandi distribuzione del modello) Padronanza unica;

• Capacità di completare le popolari capacità di formazione del modello di campo verticale di grandi dimensioni e di migliorare le capacità di codifica dei programmatori: lo sviluppo di applicazioni di modelli di grandi dimensioni richiede la padronanza di algoritmi di apprendimento automatico, framework di deep learning e altre tecnologie. La padronanza di queste tecnologie può migliorare le capacità di codifica e analisi dei programmatori, consentendo ai programmatori diventare più abili nella scrittura di codice di alta qualità.

1. Roadmap per l’apprendimento di modelli di grandi dimensioni dell’IA
2. Piano di implementazione commerciale per 100 set di grandi modelli di IA
3.100 episodi di video tutorial su modelli di grandi dimensioni
4.200 libri in formato PDF di grandi dimensioni
5. Raccolta di domande per l'intervista LLM
6.Raccolta di risorse del product manager AI

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