Nesta lição, mostramos o quão bom o modelo LLAMA-2 BOD da geração de Python usa estratégias avançadas como o Qlora, bem importante para o gradiente e boas direções com a SFTTrainer. Conjunto de dados do Nevenlag Alpach-14K, estamos definindo a natureza do LORA e usa parâmetros do LORA e usa planos de memória para treinar o modelo por python de alta qualidade. Este guia passo a passo destina-se a médicos que desejam combinar o poder do LLMS com uma pequena breve sobrecarga computacional.
!pip install -q accelerate
!pip install -q peft
!pip install -q transformers
!pip install -q trlPrimeiro, insira as bibliotecas necessárias do nosso projeto. Inclui aceleração, PEFT, Transformers e o TRL do Índice de Pacote Python. O sinalizador Q (modo silencioso) termina um nível mínimo.
import os
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
HfArgumentParser,
TrainingArguments,
pipeline,
logging,
)
from peft import LoraConfig, PeftModel
from trl import SFTTrainerImporte nossos módulos essenciais para a configuração do treinamento. Incluindo serviços de upload de dados, modelo / tokenzer, questões de treinamento, medicamentos, configuração do LORA e SFTRAIDER.
# The model to train from the Hugging Face hub
model_name = "NousResearch/llama-2-7b-chat-hf"
# The instruction dataset to use
dataset_name = "user/minipython-Alpaca-14k"
# Fine-tuned model name
new_model = "/kaggle/working/llama-2-7b-codeAlpaca"Especificamos o modelo básico de abraçar abraços, dados do tutorial e um novo nome de modelo.
# QLoRA parameters
# LoRA attention dimension
lora_r = 64
# Alpha parameter for LoRA scaling
lora_alpha = 16
# Dropout probability for LoRA layers
lora_dropout = 0.1Descreva os parâmetros LORA com nosso modelo. `Lora_r` define o tamanho da LORA,` lora_alpa` lora escala as atualizações e `lor_dropout` controla controvs oportunidades para sair.
# TrainingArguments parameters
# Output directory where the model predictions and checkpoints will be stored
output_dir = "/kaggle/working/llama-2-7b-codeAlpaca"
# Number of training epochs
num_train_epochs = 1
# Enable fp16 training (set to True for mixed precision training)
fp16 = True
# Batch size per GPU for training
per_device_train_batch_size = 8
# Batch size per GPU for evaluation
per_device_eval_batch_size = 8
# Number of update steps to accumulate the gradients for
gradient_accumulation_steps = 2
# Enable gradient checkpointing
gradient_checkpointing = True
# Maximum gradient norm (gradient clipping)
max_grad_norm = 0.3
# Initial learning rate (AdamW optimizer)
learning_rate = 2e-4
# Weight decay to apply to all layers except bias/LayerNorm weights
weight_decay = 0.001
# Optimizer to use
optim = "adamw_torch"
# Learning rate schedule
lr_scheduler_type = "constant"
# Group sequences into batches with the same length
# Saves memory and speeds up training considerably
group_by_length = True
# Ratio of steps for a linear warmup
warmup_ratio = 0.03
# Save checkpoint every X updates steps
save_steps = 100
# Log every X updates steps
logging_steps = 10Esses parâmetros preparam um processo de treinamento. Incluindo métodos de saída, a quantidade de recomendações, precisão (FP16), tamanhos de lote, coleta de qualificações e avaliação. Configurações adicionais, como nível de aprendizado, otimizador e assistência, ajuda a um bom desempenho de treinamento. O calor e o login são governados pela maneira como o modelo começa a treinar e como vemos o progresso.
import torch
print("PyTorch Version:", torch.__version__)
print("CUDA Version:", torch.version.cuda)Importe o pytroch e imprima o composto Pytro e a versão compatível do CUDA.
Este comando mostra as informações da GPU, incluindo a versão do driver, uma versão do cliente e as despesas atuais da GPU.
# SFT parameters
# Maximum sequence length to use
max_seq_length = None
# Pack multiple short examples in the same input sequence to increase efficiency
packing = False
# Load the entire model on the GPU 0
device_map = {"": 0}Descreva os parâmetros SFT, como a sequência máxima, mesmo que empacote muitos exemplos, e lista o mapa todo o modelo na GPU 0.
# SFT parameters
# Maximum sequence length to use
max_seq_length = None
# Pack multiple short examples in the same input sequence to increase efficiency
packing = False
# Load dataset
dataset = load_dataset(dataset_name, split="train")
# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
# Load base model with 8-bit quantization
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.float16,
device_map="auto",
)
# Prepare model for training
model.gradient_checkpointing_enable()
model.enable_input_require_grads()
Defina alguns parâmetros suaves e faça o upload de nossos dados e token. Nós nos preparamos para os tokens de preenchimento do tokenzer e carregamos o modelo básico com capacidade de 8 bits. Finalmente, capacitamos o gradiente e garantimos que o modelo exija treinamento profissional.
from peft import get_peft_modelImportar trabalho `get_peft_model`, eficiente com o ajuste de parâmetros (PEFT) em nosso modelo básico.
# Load LoRA configuration
peft_config = LoraConfig(
lora_alpha=lora_alpha,
lora_dropout=lora_dropout,
r=lora_r,
bias="none",
task_type="CAUSAL_LM",
)
# Apply LoRA to the model
model = get_peft_model(model, peft_config)
# Set training parameters
training_arguments = TrainingArguments(
output_dir=output_dir,
num_train_epochs=num_train_epochs,
per_device_train_batch_size=per_device_train_batch_size,
gradient_accumulation_steps=gradient_accumulation_steps,
optim=optim,
save_steps=save_steps,
logging_steps=logging_steps,
learning_rate=learning_rate,
weight_decay=weight_decay,
fp16=fp16,
max_grad_norm=max_grad_norm,
warmup_ratio=warmup_ratio,
group_by_length=True,
lr_scheduler_type=lr_scheduler_type,
)
# Set supervised fine-tuning parameters
trainer = SFTTrainer(
model=model,
train_dataset=dataset,
dataset_text_field="text",
max_seq_length=max_seq_length,
tokenizer=tokenizer,
args=training_arguments,
packing=packing,
)
Prepare e use o Lora em nosso modelo usando `loraconfig` e` get_peft_model`. Somos `Treinamento exemplar de treinamento antigo ', que especifica o cálculo da época, os tamanhos dos lote e as configurações de bom uso. Por fim, colocamos o `sfftraer`, transferindo o modelo, o conjunto de dados, o tokenzer e a oposição ao treinamento.
# Train model
trainer.train()
# Save trained model
trainer.model.save_pretrained(new_model)
Inicie o melhor processo de planejamento (`Train.Train () e salve o modelo LORA treinado na identificação especificada.
# Run text generation pipeline with the fine-tuned model
prompt = "How can I write a Python program that calculates the mean, standard deviation, and coefficient of variation of a dataset from a CSV file?"
pipe = pipeline(task="text-generation", model=trainer.model, tokenizer=tokenizer, max_length=400)
result = pipe(f"[INST] {prompt} [/INST]")
print(result[0]['generated_text'])Crie um pipeline de geração de texto usando nosso modelo e token bem organizado. Depois disso, oferecemos rapidamente, produzimos texto usando um tubo e imprimimos o resultado.
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_value_0 = user_secrets.get_secret("HF_TOKEN")Acesse os segredos Kaggle para encontrar um token de rosto salvo (`hf_token`). Esta nota é usada para verificação da face da face.
# Empty VRAM
# del model
# del pipe
# del trainer
# del dataset
del tokenizer
import gc
gc.collect()
gc.collect()
torch.cuda.empty_cache()
O trecho acima indica como usar a memória da GPU removendo as relações de confiança e limpando os caches. Removemos o tokenzer, executamos a coleta de lixo e não temos nada para o cache do CUDA para reduzir o uso do VRAM.
import torch
# Check the number of GPUs available
num_gpus = torch.cuda.device_count()
print(f"Number of GPUs available: {num_gpus}")
# Check if CUDA device 1 is available
if num_gpus > 1:
print("cuda:1 is available.")
else:
print("cuda:1 is not available.")Importamos pytroch e verificamos o valor das GPUs encontradas. Em seguida, imprimimos o número e relatamos situações que a GPU tem um ID 1 disponível.
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
# Specify the device ID for your desired GPU (e.g., 0 for the first GPU, 1 for the second GPU)
device_id = 1 # Change this based on your available GPUs
device = f"cuda:{device_id}"
# Load the base model on the specified GPU
base_model = AutoModelForCausalLM.from_pretrained(
model_name,
low_cpu_mem_usage=True,
return_dict=True,
torch_dtype=torch.float16,
device_map="auto", # Use auto to load on the available device
)
# Load the LoRA weights
lora_model = PeftModel.from_pretrained(base_model, new_model)
# Move LoRA model to the specified GPU
lora_model.to(device)
# Merge the LoRA weights with the base model weights
model = lora_model.merge_and_unload()
# Ensure the merged model is on the correct device
model.to(device)
# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"Selecione um dispositivo GPU (A Device_ID 1) e faça o upload do modelo básico com precisão especificada e memória de memória. Em seguida, carregue e integra os instrumentos LORA no modelo básico, confirme que o modelo combinado é enviado à GPU especificado. Finalmente, faça o upload do token e prepare -o com as configurações de desperdício apropriadas.
Na conclusão, após esta lição, editou com sucesso o modelo do modelo de bate-papo Lllama-2 7B para ser forte na autenticação do código Python. A Qlora correspondente, uma haste e o sfttraider indica uma maneira prática de gerenciar as restrições de aplicativos enquanto atinge o alto desempenho.
Baixar notebook Colab aqui. Todo o crédito deste estudo é pesquisado para este projeto. Além disso, não se esqueça de seguir Sane e junte -se ao nosso Estação de telégrafo incluindo LinkedIn grtópico. Não se esqueça de se juntar ao nosso 75k + ml subreddit.
🚨 O Marktechpost está gritando para as empresas / inicialização / grupos cooperarem com as próximas revistas da IA a seguinte 'Fonte AI na produção' e 'e' Agentic AI '.
O Asphazzaq é um Markteach Media Inc. De acordo com um negócio e desenvolvedor de visualização, a ASIFI está comprometida em integrar uma boa inteligência social. Sua última tentativa é lançada pelo lançamento do Plano de Química para uma Inteligência, Marktechpost, uma prática íntima devastadora de um aprendizado de máquina e problemas de aprendizado profundo que são de forma clara e facilmente compreendida. A plataforma está aderindo a mais de dois milhões de visitas à lua, indicando sua popularidade entre o público.
✅ [Recommended] Junte -se ao nosso canal de telégrafo
