In dit bericht laten we het verfijnen van een Llama 2-model zien met behulp van een Parameter-Efficient Fine-Tuning (PEFT)-methode en implementeren we het verfijnde model op AWS Inferentie2. Wij gebruiken de AWS-neuron software development kit (SDK) om toegang te krijgen tot het AWS Inferentia2-apparaat en te profiteren van de hoge prestaties. Vervolgens gebruiken we een groot model inferentiecontainer, mogelijk gemaakt door Diepe Java-bibliotheek (DJLServing) als onze modelservingoplossing.

Overzicht oplossingen

Efficiënte afstemming van Llama2 met QLoRa

De Llama 2-familie van grote taalmodellen (LLM's) is een verzameling vooraf getrainde en verfijnde generatieve tekstmodellen, variërend in schaal van 7 miljard tot 70 miljard parameters. Llama 2 was vooraf getraind op 2 biljoen tokens aan gegevens uit openbaar beschikbare bronnen. AWS-klanten kiezen er soms voor om Llama 2-modellen te verfijnen met behulp van de eigen gegevens van klanten om betere prestaties te bereiken voor downstream-taken. Vanwege het grote aantal parameters van het Llama 2-model kan volledige fijnafstemming echter onbetaalbaar en tijdrovend zijn. Parameter-Efficient Fine-Tuning (PEFT)-benadering kan dit probleem aanpakken door slechts een klein aantal extra modelparameters te verfijnen, terwijl de meeste parameters van het vooraf getrainde model worden bevroren. Voor meer informatie over PEFT kunt u dit lezen post. In dit bericht gebruiken we QLoRa om een ​​Llama 2 7B-model te verfijnen.

Implementeer een verfijnd model op Inf2 met behulp van Amazon SageMaker

AWS Inferentia2 is een speciaal gebouwde machine learning (ML)-versneller die is ontworpen voor inferentie-workloads en levert hoge prestaties tegen tot 40% lagere kosten voor generatieve AI- en LLM-workloads ten opzichte van andere voor inferentie geoptimaliseerde instanties op AWS. In dit bericht gebruiken we Amazon Elastic Compute Cloud (Amazon EC2) Inf2-instantie, met AWS Inferentia2, de Inferentia2-accelerators van de tweede generatie, die elk twee NeuronCores-v2. Elke NeuronCore-v2 is een onafhankelijke, heterogene rekeneenheid, met vier hoofdmotoren: Tensor-, Vector-, Scalar- en GPSIMD-engines. Het bevat een on-chip softwarebeheerd SRAM-geheugen voor het maximaliseren van de gegevenslocatie. Omdat er meerdere blogs over Inf2 zijn gepubliceerd, kan de lezer hiernaar verwijzen post en onze documentatie voor meer informatie over Inf2.

Om modellen op Inf2 te implementeren, hebben we AWS Neuron SDK nodig als softwarelaag die bovenop de Inf2-hardware draait. AWS Neuron is de SDK die wordt gebruikt om deep learning-workloads uit te voeren op AWS Inferentia en AWS Trainium gebaseerde exemplaren. Het maakt een end-to-end ML-ontwikkelingslevenscyclus mogelijk om nieuwe modellen te bouwen, deze modellen te trainen en te optimaliseren, en ze in te zetten voor productie. AWS Neuron bevat een diep leren compiler, runtime en tools die native zijn geïntegreerd met populaire frameworks zoals TensorFlow en PyTorch. In deze blog gaan we gebruik maken van transformers-neuronx, dat deel uitmaakt van de AWS Neuron SDK voor inferentieworkflows voor transformatordecoder. Het ondersteunt een reeks populaire modellen, waaronder Llama 2.

Om modellen op te implementeren Amazon Sage Maker, gebruiken we meestal een container die de vereiste bibliotheken bevat, zoals Neuron SDK en transformers-neuronx evenals de modelbedieningscomponent. Amazon SageMaker onderhoudt deep learning-containers (DLC's) met populaire open source-bibliotheken voor het hosten van grote modellen. In dit bericht gebruiken we de Grote modelinferentiecontainer voor neuron. Deze container heeft alles wat je nodig hebt om je Llama 2-model op Inf2 te implementeren. Voor bronnen om aan de slag te gaan met LMI op Amazon SageMaker, verwijzen wij u naar veel van onze bestaande berichten (blog 1, blog 2, blog 3) over dit onderwerp. Kortom, u kunt de container uitvoeren zonder aanvullende code te schrijven. U kunt gebruik maken van de standaard handler voor een naadloze gebruikerservaring en geef een van de ondersteunde modelnamen en eventuele configureerbare laadtijdparameters door. Hiermee wordt een LLM gecompileerd en weergegeven op een Inf2-instantie. Om bijvoorbeeld in te zetten OpenAssistant/llama2-13b-orca-8k-3319, kunt u de volgende configuratie opgeven (zoals serving.properties bestand). In serving.properties, specificeren we het modeltype als llama2-13b-orca-8k-3319, de batchgrootte als 4, de tensor parallelle graad als 2, en dat is alles. Voor de volledige lijst met configureerbare parameters raadpleegt u Alle DJL-configuratieopties.

# Engine to use: MXNet, PyTorch, TensorFlow, ONNX, PaddlePaddle, DeepSpeed, etc.
engine = Python 
# default handler for model serving
option.entryPoint = djl_python.transformers_neuronx
# The Hugging Face ID of a model or the s3 url of the model artifacts. 
option.model_id = meta-llama/Llama-2-7b-chat-hf
#the dynamic batch size, default is 1.
option.batch_size=4
# This option specifies number of tensor parallel partitions performed on the model.
option.tensor_parallel_degree=2
# The input sequence length
option.n_positions=512
#Enable iteration level batching using one of "auto", "scheduler", "lmi-dist"
option.rolling_batch=auto
# The data type to which you plan to cast the model default
option.dtype=fp16
# worker load model timeout
option.model_loading_timeout=1500

Als alternatief kunt u uw eigen modelhandlerbestand schrijven, zoals hier wordt weergegeven voorbeeld, maar daarvoor is het implementeren van de modellaad- en inferentiemethoden vereist om als brug tussen de DJLServing API's te dienen.

Voorwaarden

In de volgende lijst worden de vereisten beschreven voor het implementeren van het model dat in deze blogpost wordt beschreven. U kunt een van beide implementeren vanuit de AWS-beheerconsole of gebruik de nieuwste versie van de AWS-opdrachtregelinterface (AWS CLI).

walkthrough

In de volgende sectie zullen we de code in twee delen doornemen:

1. Een Llama2-7b-model verfijnen en de modelartefacten uploaden naar een opgegeven Amazon S3-bucketlocatie.
2. Implementeer het model in een Inferentia2 met behulp van een DJL-serveercontainer die wordt gehost in Amazon SageMaker.

De volledige codevoorbeelden met instructies zijn hierin te vinden GitHub repository.

Deel 1: Verfijn een Llama2-7b-model met behulp van PEFT

We gaan de onlangs geïntroduceerde methode in het artikel gebruiken QLoRA: kwantiseringsbewuste low-rank adapterafstemming voor taalgeneratie door Tim Dettmers et al. QLoRA is een nieuwe techniek om de geheugenvoetafdruk van grote taalmodellen tijdens het afstemmen te verkleinen, zonder dat dit ten koste gaat van de prestaties.

Opmerking: De hieronder weergegeven verfijning van het lama2-7b-model is getest op een Amazon SageMaker Studio-notitieboekje met Python 2.0 GPU-geoptimaliseerde kernel met behulp van een ml.g5.2xgroot exemplaartype. Als best practice adviseren wij het gebruik van een Amazon SageMaker Studio Integrated Development Environment (IDE) gelanceerd in uw eigen omgeving Amazon virtuele privécloud (Amazon-VPC). Hierdoor kunt u het netwerkverkeer binnen en buiten uw VPC controleren, monitoren en inspecteren met behulp van standaard AWS-netwerk- en beveiligingsmogelijkheden. Voor meer informatie, zie Amazon SageMaker Studio-connectiviteit beveiligen met behulp van een privé-VPC.

Kwantificeer het basismodel

We laden eerst een gekwantiseerd model met 4-bit kwantisering met behulp van Knuffelgezichtstransformatoren bibliotheek als volgt:

# The base pretrained model for fine-tuning
model_name = "NousResearch/Llama-2-7b-chat-hf"

# The instruction dataset to use
dataset_name = "mlabonne/guanaco-llama2-1k"

#Activate 4-bit precision base model loading
use_4bit = True
bnb_4bit_compute_dtype = "float16"
bnb_4bit_quant_type = "nf4"
use_nested_quant = False

compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

bnb_config = BitsAndBytesConfig(
load_in_4bit=use_4bit,
bnb_4bit_quant_type=bnb_4bit_quant_type,
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=use_nested_quant,
)

# Load base model and tokenizer
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=bnb_config,
device_map=device_map
)
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

Trainingsgegevensset laden

Vervolgens laden we de dataset om het model te voeden voor de verfijningsstap, zoals weergegeven:

# Load dataset (you can process it here)
dataset = load_dataset(dataset_name, split="train")

Bevestig een adapterlaag

Hier bevestigen we een kleine, trainbare adapterlaag, geconfigureerd als LoraConfig gedefinieerd in het knuffelgezicht peft bibliotheek.

# include linear layers to apply LoRA to.
modules = find_all_linear_names(model)

## Setting up LoRA configuration
lora_r = 64

# Alpha parameter for LoRA scaling
lora_alpha = 16

# Dropout probability for LoRA layers
lora_dropout = 0.1

peft_config = LoraConfig(
lora_alpha=lora_alpha,
lora_dropout=lora_dropout,
r=lora_r,
bias="none",
task_type="CAUSAL_LM",
target_modules=modules)

Train een model

Met behulp van de hierboven weergegeven LoRA-configuratie zullen we het Llama2-model samen met hyperparameters verfijnen. Hieronder ziet u een codefragment voor het trainen van het model:

# Set training parameters
training_arguments = TrainingArguments(...)

trainer = SFTTrainer(
model=model,
train_dataset=dataset,
peft_config=peft_config, # LoRA config
dataset_text_field="text",
max_seq_length=max_seq_length,
tokenizer=tokenizer,
args=training_arguments,
packing=packing,
)

# Train model
trainer.train()

# Save trained model
trainer.model.save_pretrained(new_model)

Modelgewicht samenvoegen

Het hierboven uitgevoerde verfijnde model creëerde een nieuw model met de getrainde LoRA-adaptergewichten. In het volgende codefragment voegen we de adapter samen met het basismodel, zodat we het verfijnde model voor gevolgtrekking kunnen gebruiken.

# Reload model in FP16 and merge it with LoRA weights
base_model = AutoModelForCausalLM.from_pretrained(
model_name,
low_cpu_mem_usage=True,
return_dict=True,
torch_dtype=torch.float16,
device_map=device_map,
)
model = PeftModel.from_pretrained(base_model, new_model)
model = model.merge_and_unload()

save_dir = "merged_model"
model.save_pretrained(save_dir, safe_serialization=True, max_shard_size="2GB")

# Reload tokenizer to save it
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
tokenizer.save_pretrained(save_dir)

Upload het modelgewicht naar Amazon S3

In de laatste stap van deel 1 slaan we de samengevoegde modelgewichten op een opgegeven Amazon S3-locatie op. Het modelgewicht wordt gebruikt door een modelserveercontainer in Amazon SageMaker om het model te hosten met behulp van een Inferentia2-instantie.

model_data_s3_location = "s3://<bucket_name>/<prefix>/"
!cd {save_dir} && aws s3 cp —recursive . {model_data_s3_location}

Deel 2: Host QLoRA-model voor gevolgtrekking met AWS Inf2 met behulp van SageMaker LMI Container

In dit gedeelte doorlopen we de stappen voor het implementeren van een verfijnd QLoRA-model in een Amazon SageMaker-hostingomgeving. We gebruiken een DJL-bediening container van SageMaker DLC, die integreert met de transformatoren-neuronx bibliotheek om dit model te hosten. De opzet vergemakkelijkt het laden van modellen op AWS Inferentia2-accelerators, parallelliseert het model over meerdere NeuronCores en maakt bediening via HTTP-eindpunten mogelijk.

Bereid modelartefacten voor

DJL ondersteunt veel deep learning-optimalisatiebibliotheken, waaronder diepe snelheid, SnellereTransformer en meer. Voor modelspecifieke configuraties bieden wij een serving.properties met belangrijke parameters, zoals tensor_parallel_degree en model_id om de laadopties voor het model te definiëren. De model_id kan een Hugging Face-model-ID zijn, of een Amazon S3-pad waar de modelgewichten zijn opgeslagen. In ons voorbeeld geven we de Amazon S3-locatie van ons verfijnde model. Het volgende codefragment toont de eigenschappen die worden gebruikt voor de modelweergave:

%%writefile serving.properties
engine=Python
option.entryPoint=djl_python.transformers_neuronx
option.model_id=<model data s3 location>
option.batch_size=4
option.neuron_optimize_level=2
option.tensor_parallel_degree=8
option.n_positions=512
option.rolling_batch=auto
option.dtype=fp16
option.model_loading_timeout=1500

Gelieve hiernaar te verwijzen documentatie voor meer informatie over de configureerbare opties die beschikbaar zijn via serving.properties. Houd er rekening mee dat we gebruiken option.n_position=512 in deze blog voor snellere AWS Neuron-compilatie. Als u een grotere invoertokenlengte wilt proberen, raden we de lezer aan om het model vooraf te compileren (zie AOT Pre-compileermodel op EC2). Anders kunt u een time-outfout tegenkomen als de compilatietijd te lang is.

Na het serving.properties bestand is gedefinieerd, verpakken we het bestand in een tar.gz formaat, als volgt:

%%sh
mkdir mymodel
mv serving.properties mymodel/
tar czvf mymodel.tar.gz mymodel/
rm -rf mymodel

Vervolgens uploaden we tar.gz naar een Amazon S3-bucketlocatie:

s3_code_prefix = "large-model-lmi/code"
bucket = sess.default_bucket()  # bucket to house artifacts
code_artifact = sess.upload_data("mymodel.tar.gz", bucket, s3_code_prefix)
print(f"S3 Code or Model tar ball uploaded to --- > {code_artifact}")

Maak een Amazon SageMaker-modeleindpunt

Om een ​​Inf2-instantie te gebruiken voor het serveren, gebruiken we een Amazon SageMaker LMI-container met DJL neuronX-ondersteuning. Raadpleeg dit post voor meer informatie over het gebruik van een DJL NeuronX-container voor gevolgtrekking. De volgende code laat zien hoe u een model implementeert met behulp van Amazon SageMaker Python SDK:

# Retrieves the DJL-neuronx docker image URI
image_uri = image_uris.retrieve(
framework="djl-neuronx",
region=sess.boto_session.region_name,
version="0.24.0"
)

# Define inf2 instance type to use for serving
instance_type = "ml.inf2.48xlarge"

endpoint_name = sagemaker.utils.name_from_base("lmi-model")

# Deploy the model for inference
model.deploy(initial_instance_count=1,
instance_type=instance_type,
container_startup_health_check_timeout=1500,
volume_size=256,
endpoint_name=endpoint_name)

# our requests and responses will be in json format so we specify the serializer and the deserializer
predictor = sagemaker.Predictor(
endpoint_name=endpoint_name,
sagemaker_session=sess,
serializer=serializers.JSONSerializer(),
)

Eindpunt van het testmodel

Nadat het model met succes is geïmplementeerd, kunnen we het eindpunt valideren door een voorbeeldverzoek naar de voorspeller te sturen:

prompt="What is machine learning?"
input_data = f"<s>[INST] <<SYS>>nAs a data scientistn<</SYS>>n{prompt} [/INST]"

response = predictor.predict(
{"inputs": input_data, "parameters": {"max_new_tokens":300, "do_sample":"True"}}
)

print(json.loads(response)['generated_text'])

De voorbeelduitvoer wordt als volgt weergegeven:

In de context van data-analyse verwijst Machine Learning (ML) naar een statistische techniek die voorspellende kracht uit een dataset kan halen met een toenemende complexiteit en nauwkeurigheid door de reikwijdte van een statistiek iteratief te beperken.

Machine Learning is geen nieuwe statistische techniek, maar eerder een combinatie van bestaande technieken. Bovendien is het niet ontworpen om te worden gebruikt met een specifieke dataset of om een ​​specifiek resultaat te bereiken. Het is eerder zo ontworpen dat het flexibel genoeg is om zich aan elke dataset aan te passen en voorspellingen te doen over elke uitkomst.

Opruimen

Als u besluit dat u het SageMaker-eindpunt niet langer actief wilt houden, kunt u het verwijderen met AWS SDK voor Python (boto3), AWS CLI of Amazon SageMaker Console. Bovendien kunt u ook sluit de Amazon SageMaker Studio-bronnen af die niet langer nodig zijn.

Conclusie

In dit bericht hebben we je laten zien hoe je een Llama2-7b-model kunt verfijnen met behulp van de LoRA-adapter met 4-bit kwantisering met behulp van een enkele GPU-instantie. Vervolgens hebben we het model geïmplementeerd op een Inf2-instantie die wordt gehost in Amazon SageMaker met behulp van een DJL-serveercontainer. Ten slotte hebben we het eindpunt van het Amazon SageMaker-model gevalideerd met een voorspelling voor het genereren van tekst met behulp van de SageMaker Python SDK. Probeer het eens, we horen graag uw feedback. Blijf op de hoogte voor updates over meer mogelijkheden en nieuwe innovaties met AWS Inferentia.

Voor meer voorbeelden over AWS Neuron, zie aws-neuron-monsters.

Over de auteurs

Wei Teh is een Senior AI/ML Specialist Solutions Architect bij AWS. Hij heeft een passie voor het helpen van klanten bij het bevorderen van hun AWS-traject, waarbij hij zich richt op Amazon Machine Learning-services en op machine learning gebaseerde oplossingen. Buiten zijn werk houdt hij van buitenactiviteiten zoals kamperen, vissen en wandelen met zijn gezin.

Qingweik Li is Machine Learning Specialist bij Amazon Web Services. Hij behaalde zijn Ph.D. in Operations Research nadat hij de onderzoeksbeursrekening van zijn adviseur had verbroken en de beloofde Nobelprijs niet kon leveren. Momenteel helpt hij klanten in de financiële dienstverlening en de verzekeringssector bij het bouwen van machine learning-oplossingen op AWS. In zijn vrije tijd houdt hij van lezen en lesgeven.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/fine-tune-llama-2-using-qlora-and-deploy-it-on-amazon-sagemaker-with-aws-inferentia2/