Partage de technologie

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

Introduction

Il existe un terme spécial « LoRA » qui apparaît fréquemment dans le domaine AIGC. Il ressemble un peu au nom d'une personne, mais il s'agit d'une méthode de formation de modèles. Le nom complet de LoRA est Adaptation de bas rang de grands modèles linguistiques, appelé en chinoisAdaptation de bas niveau de grands modèles de langage . De nos jours, il est utilisé très fréquemment en diffusion stable.

En raison du grand nombre de paramètres des grands modèles de langage, de nombreuses grandes entreprises doivent se former pendant plusieurs mois. Par conséquent, diverses méthodes de formation consommant moins de ressources ont été proposées, et LoRA en fait partie.

Cet article présentera le principe de LoRA en détail et utilisera PyTorch pour mettre en œuvre la formation LoRA de petits modèles.

2. Formation sur modèle

La plupart des formations de modèles utilisent désormais l'algorithme de descente de gradient. L’algorithme de descente de gradient peut être divisé en 4 étapes :

1. La propagation vers l'avant calcule la valeur de la perte
2. La rétropropagation calcule les gradients
3. Mettre à jour les paramètres à l'aide de dégradés
4. Répétez les étapes 1, 2 et 3 jusqu'à ce qu'une perte plus petite soit obtenue

En prenant le modèle linéaire comme exemple, les paramètres du modèle sont W, les entrées et sorties sont x, y et la fonction de perte est l'erreur quadratique moyenne. Ensuite, le calcul de chaque étape est le suivant. La première est la propagation vers l'avant. Pour les modèles linéaires, il s'agit d'une multiplication matricielle :

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

Après avoir trouvé la perte, le gradient de L par rapport à W peut être calculé pour obtenir dW :

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

dW est une matrice qui pointe dans la direction où L augmente le plus rapidement, mais notre objectif est de faire chuter L, alors laissez W moins dW. Afin d'ajuster le rythme des mises à jour, un taux d'apprentissage η est également multiplié, calculé comme suit :

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

Répétez tout le temps à la fin. Le pseudocode pour les trois étapes ci-dessus est le suivant :

# 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

Une fois la mise à jour terminée, le nouveau paramètre W' est obtenu. Lorsque nous utilisons la prédiction du modèle à ce moment-là, le calcul est le suivant :

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

3. Présentation de LoRA

Nous pouvons réfléchir à la relation entre W et W'. W fait généralement référence aux paramètres du modèle de base, et W' est obtenu après plusieurs ajouts et soustractions matriciels basés sur le modèle de base. Supposons qu'il soit mis à jour 10 fois au cours du processus de formation, et chaque fois que dW est dW1, dW2,..., dW10, alors le processus de mise à jour complet peut être écrit en une seule opération :

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

où dW est une matrice de même forme que W'. On écrit -ηdW comme matrice R, alors les paramètres mis à jour sont :

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

À ce stade, le processus de formation est simplifié à la matrice originale plus une autre matrice R. Cependant, résoudre la matrice R n’est pas plus simple et n’économise pas de ressources. À l’heure actuelle, l’idée de​​LoRA est introduite.

Une matrice entièrement formée est généralement de rang complet ou satisfait essentiellement au rang, c'est-à-dire qu'aucune colonne de la matrice n'est redondante. Dans l'article "Scaling Laws for Neural Language Model", la relation entre l'ensemble de données et la taille des paramètres est proposée. Si cette relation est satisfaite et que la formation est bonne, le modèle résultant est fondamentalement de rang complet. Lors du réglage fin du modèle, nous sélectionnerons un modèle de base, qui est essentiellement un rang complet. Quelle est la situation de la mise à jour du rang de la matrice R ?

Nous supposons que la matrice R est une matrice de bas rang. Une matrice de bas rang comporte de nombreuses colonnes répétées et peut donc être décomposée en deux matrices plus petites. Si la forme de W est m×n, alors la forme de A est également m×n. Nous décomposons la matrice R en AB (où la forme de A est m×r et la forme de B est r×N). choisit généralement une valeur bien inférieure à m , la valeur de n, comme le montre la figure :

Décomposer une matrice de bas rang en deux matrices présente plusieurs avantages. Le premier est que le nombre de paramètres est considérablement réduit. Supposons que la forme de la matrice R soit de 100 × 100, alors le nombre de paramètres de R est de 10 000. Lorsque nous sélectionnons le rang 10, la forme de la matrice A est de 100×10 et la forme de la matrice B est de 10×100. Le nombre de paramètres est de 2000, soit 80 % de moins que la matrice R.

Et comme R est une matrice de bas rang, avec un entraînement suffisant, les matrices A et B peuvent obtenir l'effet de R. La matrice AB est ici ce que nous appelons souvent le modèle LoRA.

Après avoir introduit LoRA, notre prédiction doit saisir x dans W et AB respectivement. À ce stade, le calcul de la prédiction est :

préd=Wx+ABxpréd = Wx + ABxpréd=Wx+ABx

Il sera légèrement plus lent que le modèle original lors de la prévision, mais la différence ne se fait fondamentalement pas sentir dans les grands modèles.

4. Combats réels

Afin de saisir tous les détails, nous n'utilisons pas un grand modèle comme combat réel de lora, mais choisissons d'utiliser un petit réseau tel que vgg19 pour entraîner le modèle lora. Importez les modules requis :

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 Préparation de l'ensemble de données

Ici, les poids pré-entraînés de vgg19 sur imagenet sont utilisés comme modèle de base, un ensemble de données de classification doit donc être préparé.Pour plus de commodité, une seule catégorie et 5 images sont préparées ici. Les images sont sous le projet.data/goldfishVers le bas:

La catégorie des poissons rouges est incluse dans imagenet, mais la version illustrée du poisson rouge est sélectionnée ici. Après les tests, le modèle pré-entraîné ne peut pas classer correctement les images ci-dessus. Notre objectif est de former LoRA et de classer correctement le modèle.

Nous créons 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 Créer un modèle LoRA

Nous encapsulons LoRA dans une couche. Il n'y a que deux matrices qui doivent être entraînées dans LoRA. Le code de LoRA est le suivant :

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

Où m est la taille de l'entrée, n est la taille de la sortie, rang est la taille du rang, nous pouvons définir une valeur plus petite.

Lors de l'initialisation des poids, nous initialisons A avec un bruit gaussien et initialisons B avec une matrice 0 afin de garantir que la formation commence à partir du modèle inférieur. Parce que AB est une matrice 0, LoRA ne fonctionne pas dans l'état initial.

4.3 Définir les hyperparamètres et entraîner

La prochaine étape est la formation. C'est fondamentalement la même chose que le code de formation habituel de PyTorch. Examinons d'abord le code :

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

Il y a deux points à noter ici. Le premier point est que nous avons défini le poids de vgg19 pour qu'il ne puisse pas être entraîné. Ceci est très similaire à l'apprentissage par transfert, mais c'est en fait différent.

Le deuxième point est que lors de la propagation vers l'avant, nous utilisons le code suivant :

pred = vgg19(image) + lora(image)

1
2

4.4 Tests

Faisons un test simple :

# 测试  
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

Le résultat est le suivant :

goldfish
goldfish
goldfish
goldfish
goldfish

1
2
3
4
5
6

La prédiction de base est correcte, mais le résultat de ce test ne veut rien dire. Enfin, nous avons sauvegardé un modèle LoRA de 5 M, ce qui est très petit par rapport aux dizaines de Mo de vgg19.

5. Résumé

LoRA est une méthode de formation efficace pour les grands modèles, et cet article utilise LoRA dans un petit réseau de classification pour donner aux lecteurs une compréhension plus claire de la mise en œuvre détaillée de LoRA (mais aussi parce qu'il ne peut pas exécuter de grands modèles). En raison du volume limité de données, des questions telles que l'exactitude et l'efficacité de LoRA ne sont pas abordées en détail. Les lecteurs peuvent se référer aux documents pertinents pour une compréhension approfondie.

Comment apprendre les grands modèles d’IA ?

J'ai travaillé dans des sociétés Internet de première ligne pendant plus de dix ans et j'ai encadré de nombreux jeunes collègues. A aidé de nombreuses personnes à apprendre et à grandir.

Je me rends compte qu'il y a beaucoup d'expériences et de connaissances qui valent la peine d'être partagées avec tout le monde, et nous pouvons également utiliser nos capacités et notre expérience pour répondre à bon nombre de vos confusions dans l'apprentissage de l'intelligence artificielle, j'insiste donc toujours sur l'organisation et le partage de diverses choses même si je suis occupé au travail. Cependant, en raison des canaux limités de diffusion des connaissances, de nombreux amis de l'industrie Internet ne sont pas en mesure d'obtenir le matériel correct pour améliorer leur apprentissage. Par conséquent, les matériaux importants pour les grands modèles d'IA comprennent les cartes mentales d'introduction à l'apprentissage des grands modèles d'IA et l'apprentissage des grands modèles d'IA de haute qualité. des livres et des manuels, ainsi que des didacticiels vidéo, des apprentissages pratiques et d'autres vidéos enregistrées sont partagés gratuitement.

La première étape : Commencer par la conception de systèmes de grands modèles et expliquer les principales méthodes des grands modèles ;

La deuxième étape : à travers le grand projet de mots d'invite de modèle, commencer du point de vue des invites pour mieux utiliser le rôle du modèle ;

La troisième étape : le développement d'applications de plate-forme à grande échelle utilise la plate-forme Alibaba Cloud PAI pour créer un système d'ajustement virtuel dans le domaine du commerce électronique ;

La quatrième étape : le développement d'une application de base de connaissances à grande échelle prend le cadre LangChain comme exemple pour créer un système intelligent de questions et réponses pour la consultation de l'industrie de la logistique ;

La cinquième étape : affiner le développement de grands modèles en utilisant les domaines de la grande santé, du nouveau commerce de détail et des nouveaux médias pour construire de grands modèles adaptés au domaine actuel ;

La sixième étape : sur la base du grand modèle multimodal SD, un cas d'applet de diagramme Wensheng a été construit ;

La septième étape : se concentrer sur l'application et le développement de plates-formes de grands modèles et créer des applications industrielles de grands modèles à travers de grands modèles matures tels que le grand modèle Xinghuo et le grand modèle Wenxin.

👉学会后的收获：👈
• Basé sur la mise en œuvre d'une ingénierie full-stack de grands modèles (front-end, back-end, chef de produit, conception, analyse de données, etc.), différentes compétences peuvent être acquises grâce à ce cours ;

• Capable d'utiliser de grands modèles pour répondre aux besoins réels des projets : à l'ère du Big Data, de plus en plus d'entreprises et d'institutions doivent traiter des quantités massives de données. L'utilisation de la technologie de grands modèles peut mieux traiter ces données et améliorer la précision de l'analyse des données. et la prise de décision. Par conséquent, la maîtrise des compétences en développement d’applications de grands modèles peut permettre aux programmeurs de mieux répondre aux besoins réels du projet ;

• Basé sur le développement d'applications d'IA de grands modèles et de données d'entreprise, mettre en œuvre la théorie des grands modèles, maîtriser la puissance de calcul GPU, le matériel, le cadre de développement LangChain et les compétences pratiques de projet, et apprendre à affiner la formation verticale des grands modèles (préparation des données, distillation des données, grand déploiement du modèle) Maîtrise à guichet unique ;

• Capacité à compléter les capacités populaires de formation de modèles de champ vertical de grand modèle et à améliorer les capacités de codage des programmeurs : le développement d'applications de grand modèle nécessite la maîtrise des algorithmes d'apprentissage automatique, des cadres d'apprentissage profond et d'autres technologies. La maîtrise de ces technologies peut améliorer les capacités de codage et d'analyse des programmeurs, ce qui permet aux programmeurs. pour devenir plus compétent dans l’écriture de code de haute qualité.

1. Feuille de route pour l'apprentissage des grands modèles d'IA
2. Plan de mise en œuvre commerciale pour 100 ensembles de grands modèles d'IA
3.100 épisodes de tutoriels vidéo grand modèle
4.200 livres PDF grand modèle
5. Collecte de questions d'entretien LLM
6.Collection de ressources du chef de produit IA

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