minhas informações de contato
Correspondência[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Um termo especial "LoRA" aparece frequentemente no campo do AIGC. Parece um pouco com o nome de uma pessoa, mas é um método de treinamento de modelo. O nome completo de LoRA é Adaptação de baixo nível de modelos de linguagem grande, que é chamado em chinêsAdaptação de baixo nível de grandes modelos de linguagem . Hoje em dia, é usado com muita frequência em difusão estável.
Devido ao grande número de parâmetros de grandes modelos de linguagem, muitas grandes empresas precisam treinar por vários meses. Portanto, vários métodos de treinamento com menor consumo de recursos foram propostos, e o LoRA é um deles.
Este artigo apresentará detalhadamente o princípio do LoRA e usará o PyTorch para implementar o treinamento LoRA de pequenos modelos.
A maior parte do treinamento de modelo agora usa o algoritmo de descida gradiente. O algoritmo de descida gradiente pode ser dividido nas 4 etapas a seguir:
Tomando o modelo linear como exemplo, os parâmetros do modelo são W, a entrada e a saída são x, y e a função de perda é o erro quadrático médio. Então o cálculo de cada etapa é o seguinte. O primeiro é a propagação direta. Para modelos lineares, é uma multiplicação de matrizes:
L=MSE(Lx,y)L = MSE(Lx, y)L=MSE(Lx,y)
Depois de encontrar a perda, o gradiente de L versus W pode ser calculado para obter dW:
dW=∂L∂WdW = frac{parcial L}{parcial W}dW=∂W∂L
dW é uma matriz que aponta na direção onde L aumenta mais rápido, mas nosso objetivo é fazer L cair, então seja W menos dW. Para ajustar o ritmo das atualizações, também é multiplicada uma taxa de aprendizagem η, calculada da seguinte forma:
W′=W−ηdWW' = W - ηdWW′=W−ηdW
Repita o tempo todo no final. O pseudocódigo para as três etapas acima é o seguinte:
# 4、重复1、2、3
for i in range(10000):
# 1、正向传播计算损失
L = MSE(Wx, y)
# 2、反向传播计算梯度
dW = gradient(L, W)
# 3、利用梯度更新参数
W -= lr * dW
Após a atualização ser concluída, o novo parâmetro W' é obtido. Quando usamos a previsão do modelo neste momento, o cálculo é o seguinte:
pred=W′x pred = W'x pred=W′x
Podemos pensar na relação entre W e W'. W geralmente se refere aos parâmetros do modelo básico, e W' é obtido após diversas adições e subtrações de matrizes com base no modelo básico. Suponha que ele seja atualizado 10 vezes durante o processo de treinamento, e cada vez que dW for dW1, dW2,..., dW10, então o processo completo de atualização pode ser escrito como uma operação:
W′=W−ηdW1−ηdW2−…−ηdW10 Seja: dW=∑i=110dWiW′=W−ηdWW' = W - ηdW_1 - ηdW_2 - … - ηdW_{10} \ Deixe: dW = soma_{i=1} ^{10}dW_i \ W' = W - ηdW W′=W−ηdW1−ηdW2−…−ηdW10Deixe: dW=i=1∑10dWiW′=W−ηdW
onde dW é uma matriz com a mesma forma que W'. Escrevemos -ηdW como matriz R, então os parâmetros atualizados são:
L′=L+RW' = L + RW′=L+R
Neste momento, o processo de treinamento é simplificado para a matriz original mais outra matriz R. Porém, resolver a matriz R não é mais simples e não economiza recursos. Neste momento, a ideia de LoRA é introduzida.
Uma matriz totalmente treinada geralmente é de classificação completa ou basicamente satisfaz a classificação, ou seja, nenhuma coluna da matriz é redundante. No artigo "Leis de escala para modelo de linguagem neural", a relação entre o conjunto de dados e o tamanho dos parâmetros é proposta. Se essa relação for satisfeita e o treinamento for bom, o modelo resultante será basicamente de classificação completa. Ao ajustar o modelo, selecionaremos um modelo básico, que é basicamente de classificação completa. Qual é a situação de atualização do posto da matriz R?
Assumimos que a matriz R é uma matriz de classificação baixa. Uma matriz de classificação baixa possui muitas colunas repetidas e, portanto, pode ser decomposta em duas matrizes menores. Se a forma de W é m×n, então a forma de A também é m×n. Decompomos a matriz R em AB (onde a forma de A é m×r e a forma de B é r×R). geralmente escolhe um valor bem menor que m , o valor de n, conforme mostrado na figura:
A decomposição de uma matriz de classificação baixa em duas matrizes tem várias vantagens. A primeira é que o número de parâmetros é significativamente reduzido. Suponha que a forma da matriz R seja 100×100, então o número de parâmetros de R é 10.000. Quando selecionamos a classificação 10, o formato da matriz A é 100×10 e o formato da matriz B é 10×100. O número de parâmetros é 2.000, que é 80% menor que a matriz R.
E como R é uma matriz de classificação baixa, com treinamento suficiente, as matrizes A e B podem atingir o efeito de R. A matriz AB aqui é o que costumamos chamar de modelo LoRA.
Após a introdução do LoRA, nossa previsão precisa inserir x em W e AB, respectivamente. Neste momento, o cálculo da previsão é:
pred=Wx+ABxpred = Wx + ABxpred=Wx+ABx
Será um pouco mais lento do que o modelo original na previsão, mas a diferença basicamente não é sentida em modelos grandes.
Para compreender todos os detalhes, não usamos um modelo grande como o combate real de lora. Em vez disso, optamos por usar uma rede pequena como vgg19 para treinar o modelo lora. Importe os módulos necessários:
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
Aqui, os pesos pré-treinados de vgg19 no imagenet são usados como modelo base, portanto, um conjunto de dados de classificação precisa ser preparado.Por conveniência, apenas uma categoria e 5 fotos são preparadas aqui. As fotos estão no projeto.data/goldfishAbaixo:
A categoria peixinho dourado está incluída no imagenet, mas a versão ilustrada do peixinho dourado é selecionada aqui. Após o teste, o modelo pré-treinado não consegue classificar corretamente as imagens acima. Nosso objetivo é treinar LoRA e fazer com que o modelo seja classificado corretamente.
Criamos um 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)
Encapsulamos o LoRA em uma camada. Existem apenas duas matrizes que precisam ser treinadas no LoRA. O código do LoRA é o seguinte:
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)
Onde m é o tamanho da entrada, n é o tamanho da saída, classificação é o tamanho da classificação, podemos definir um valor menor.
Ao inicializar os pesos, inicializamos A com ruído gaussiano e inicializamos B com uma matriz 0. Isso é para garantir que o treinamento comece a partir do modelo inferior. Como AB é uma matriz 0, LoRA não funciona no estado inicial.
A próxima etapa é o treinamento. É basicamente igual ao código de treinamento normal do PyTorch. Vejamos o código primeiro:
# 加载底模和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()}")
Há dois pontos a serem observados aqui. O primeiro é que definimos o peso do vgg19 como não treinável. Isso é muito semelhante ao aprendizado por transferência, mas na verdade é diferente.
O segundo ponto é que durante a propagação direta, usamos o seguinte código:
pred = vgg19(image) + lora(image)
Vamos fazer um teste simples:
# 测试
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')
A saída é a seguinte:
goldfish
goldfish
goldfish
goldfish
goldfish
A previsão básica está correta, mas o resultado do teste não significa nada. Por fim, salvamos um modelo LoRA de 5M, que é muito pequeno comparado às dezenas de MB do vgg19.
LoRA é um método de treinamento eficiente para modelos grandes, e este artigo usa LoRA em uma pequena rede de classificação para dar aos leitores uma compreensão mais clara da implementação detalhada do LoRA (mas também porque ele não pode executar modelos grandes). Devido ao volume limitado de dados, questões como a precisão e a eficiência do LoRA não são discutidas em detalhes. Os leitores podem consultar materiais relevantes para uma compreensão aprofundada.
Trabalhei em empresas de Internet da linha de frente por mais de dez anos e orientei muitos colegas juniores. Ajudou muitas pessoas a aprender e crescer.
Sei que há muita experiência e conhecimento que vale a pena compartilhar com todos, e também podemos usar nossas habilidades e experiência para responder muitas de suas confusões no aprendizado de inteligência artificial, por isso ainda insisto em organizar e compartilhar várias coisas mesmo sendo ocupado no trabalho. No entanto, devido aos canais limitados para disseminação de conhecimento, muitos amigos na indústria da Internet não conseguem obter materiais corretos para melhorar seu aprendizado. Portanto, materiais importantes de modelos grandes de IA incluem mapas mentais de aprendizagem introdutória de modelos grandes de IA e aprendizagem de modelos grandes de IA de alta qualidade. livros e manuais e tutoriais em vídeo, aprendizado prático e outros vídeos gravados são compartilhados gratuitamente.
A primeira etapa: comece com o projeto de sistemas de modelos grandes e explique os principais métodos de modelos grandes;
A segunda etapa: por meio do projeto de prompt de modelo grande, comece a partir da perspectiva dos prompts para melhor utilizar a função do modelo;
A terceira etapa: O desenvolvimento de aplicativos de plataforma de modelo grande usa a plataforma Alibaba Cloud PAI para construir um sistema de adaptação virtual na área de comércio eletrônico;
A quarta etapa: O desenvolvimento de aplicativos de base de conhecimento de grandes modelos toma a estrutura LangChain como exemplo para construir um sistema inteligente de perguntas e respostas para consulta ao setor de logística;
A quinta fase: aperfeiçoar o desenvolvimento de grandes modelos utilizando as áreas da grande saúde, novo retalho e novos meios de comunicação para construir grandes modelos adequados para o campo actual;
A sexta etapa: Com base no grande modelo multimodal SD, foi construído um caso de miniaplicativo de diagrama de Wensheng;
A sétima etapa: Concentre-se na aplicação e desenvolvimento de plataformas de grandes modelos e construa aplicações da indústria de grandes modelos por meio de grandes modelos maduros, como o modelo grande Xinghuo e o modelo grande Wenxin.
👉学会后的收获：👈
• Baseado na implementação de engenharia full-stack de grandes modelos (front-end, back-end, gerente de produto, design, análise de dados, etc.), diferentes habilidades podem ser adquiridas através deste curso;
• Capaz de usar grandes modelos para resolver necessidades reais relevantes do projeto: Na era do big data, cada vez mais empresas e instituições precisam processar grandes quantidades de dados. O uso da tecnologia de grandes modelos pode processar melhor esses dados e melhorar a precisão da análise de dados. e tomada de decisão. Portanto, dominar as habilidades de desenvolvimento de aplicativos de modelos grandes pode permitir que os programadores lidem melhor com as necessidades reais do projeto;
• Com base no desenvolvimento de aplicativos de IA de grandes modelos e dados corporativos, implemente a teoria de grandes modelos, domine o poder de computação da GPU, hardware, estrutura de desenvolvimento LangChain e habilidades práticas de projeto, e aprenda treinamento vertical de ajuste fino de grandes modelos (preparação de dados, destilação de dados, grande implantação de modelo) Domínio completo;
• Capacidade de completar recursos populares de treinamento de modelos de campo verticais de grandes modelos e melhorar as capacidades de codificação dos programadores: O desenvolvimento de aplicativos de modelos grandes requer o domínio de algoritmos de aprendizado de máquina, estruturas de aprendizado profundo e outras tecnologias. O domínio dessas tecnologias pode melhorar as capacidades de codificação e análise dos programadores, permitindo aos programadores. para se tornar mais proficiente na escrita de código de alta qualidade.
1. Roteiro de aprendizagem de grandes modelos de IA
2. Plano de implementação comercial para 100 conjuntos de grandes modelos de IA
3.100 episódios de tutoriais em vídeo de modelos grandes
4.200 livros em PDF em modelos grandes
5. Coleção de perguntas da entrevista LLM
6. Coleta de recursos do gerente de produto AI
👉获取方式：
😝有需要的小伙伴，可以保存图片到wx扫描二v码免费领取【保证100%免费】🆓
Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.
Correspondência[email protected]