Revolutionér kundetilfredsheden med skræddersyede belønningsmodeller til din virksomhed på Amazon SageMaker | Amazon Web Services

Da mere kraftfulde store sprogmodeller (LLM'er) bruges til at udføre en række opgaver med større nøjagtighed, vil antallet af applikationer og tjenester, der bygges med generativ kunstig intelligens (AI) vokser også. Med stor magt følger ansvar, og organisationer ønsker at sikre, at disse LLM'er producerer svar, der stemmer overens med deres organisatoriske værdier og giver den samme unikke oplevelse, som de altid havde tiltænkt deres slutkunder.

Evaluering af AI-genererede svar giver udfordringer. Dette indlæg diskuterer teknikker til at tilpasse dem til virksomhedens værdier og opbygge en tilpasset belønningsmodel ved hjælp af Amazon SageMaker. Ved at gøre det kan du levere skræddersyede kundeoplevelser, der unikt afspejler din organisations brandidentitet og etos.

Udfordringer med out-of-the-box LLM'er

Out-of-the-box LLM'er giver høj nøjagtighed, men mangler ofte tilpasning til en organisations specifikke behov og slutbrugere. Menneskelig feedback varierer i subjektivitet på tværs af organisationer og kundesegmenter. Indsamling af forskelligartet, subjektiv menneskelig feedback for at forfine LLM'er er tidskrævende og uskalerbar.

Dette indlæg viser en belønningsmodelleringsteknik til effektivt at tilpasse LLM'er til en organisation ved programmæssigt at definere belønningsfunktioner, der fanger præferencer for modeladfærd. Vi demonstrerer en tilgang til at levere LLM-resultater skræddersyet til en organisation uden intensiv, konstant menneskelig dømmekraft. Teknikkerne sigter mod at overvinde tilpasnings- og skalerbarhedsudfordringer ved at indkode en organisations subjektive kvalitetsstandarder til en belønningsmodel, der guider LLM til at generere foretrukne output.

Objektiv vs. subjektiv menneskelig feedback

Ikke al menneskelig feedback er den samme. Vi kan kategorisere menneskelig feedback i to typer: objektiv og subjektiv.

Ethvert menneske, der bliver bedt om at bedømme farven på de følgende kasser, vil bekræfte, at den venstre er en hvid boks, og den højre er en sort boks. Dette er objektivt, og der er ingen ændringer overhovedet.

Det er i sagens natur subjektivt at bestemme, om en AI-models output er "stort". Overvej følgende farvespektrum. Hvis de blev bedt om at beskrive farverne på enderne, ville folk give forskellige, subjektive svar baseret på deres opfattelser. En persons hvide kan være en andens grå.

Denne subjektivitet udgør en udfordring for at forbedre AI gennem menneskelig feedback. I modsætning til objektiv rigtig/forkert feedback er subjektive præferencer nuanceret og personaliseret. Det samme output kunne fremkalde ros fra én person og kritik fra en anden. Nøglen er at anerkende og redegøre for den grundlæggende subjektivitet af menneskelige præferencer i AI-træning. I stedet for at søge uhåndgribelige objektive sandheder, må vi give modeller eksponering for den farverige mangfoldighed af menneskelig subjektiv dømmekraft.

I modsætning til traditionelle modelopgaver såsom klassificering, der pænt kan benchmarkes på testdatasæt, er vurdering af kvaliteten af ​​en spredt samtaleagent yderst subjektiv. Et menneskes medrivende prosa er et andets formålsløse drilleri. Så hvordan skal vi forfine disse ekspansive sprogmodeller, når mennesker iboende er uenige om kendetegnene for en "god" reaktion?

Nøglen er at indsamle feedback fra en mangfoldig skare. Med nok subjektive synspunkter opstår mønstre på engagerende diskurs, logisk sammenhæng og harmløst indhold. Modeller kan derefter tunes baseret på bredere menneskelige præferencer. Der er en generel opfattelse af, at belønningsmodeller ofte kun er forbundet med Reinforcement Learning from Human Feedback (RLHF). Belønningsmodellering går faktisk ud over RLHF og kan være et effektivt værktøj til at tilpasse AI-genererede svar med en organisations specifikke værdier og brandidentitet.

Belønningsmodellering

Du kan vælge en LLM og få den til at generere adskillige svar på forskellige prompter, og så vil dine menneskelige etiketter rangere disse svar. Det er vigtigt at have mangfoldighed i menneskelige etiketter. Klare mærkningsretningslinjer er kritiske. Uden eksplicitte kriterier kan domme blive vilkårlige. Nyttige dimensioner omfatter sammenhæng, relevans, kreativitet, faktuel korrekthed, logisk konsistens og mere. Menneskelige etiketter placerer disse svar i kategorier og mærker dem som favorit til mindst favorit, som vist i følgende eksempel. Dette eksempel viser, hvordan forskellige mennesker opfatter disse mulige svar fra LLM i form af deres mest foretrukne (mærket som 1 i dette tilfælde) og mindst favorit (mærket som 3 i dette tilfælde). Hver kolonne er mærket 1, 2 eller 3 fra hvert menneske for at angive deres mest foretrukne og mindst foretrukne respons fra LLM.

Ved at kompilere disse subjektive vurderinger opstår mønstre på, hvad der giver genlyd på tværs af læsere. Den samlede menneskelige feedback træner i det væsentlige en separat belønningsmodel på skrivekvaliteter, der appellerer til folk. Denne teknik til at destillere publikumsperspektiver til en AI-belønningsfunktion kaldes belønningsmodellering. Det giver en metode til at forbedre LLM-outputkvaliteten baseret på forskellige subjektive synspunkter.

Løsningsoversigt

I dette indlæg beskriver vi, hvordan man træner en belønningsmodel baseret på organisationsspecifik menneskelig mærkningsfeedback indsamlet for forskellige prompter testet på basis-FM. Følgende diagram illustrerer løsningsarkitekturen.

For flere detaljer, se den medfølgende notesbog.

Forudsætninger

For at kunne træne en belønningsmodel skal du have følgende:

Start SageMaker Studio

Udfør følgende trin for at starte SageMaker Studio:

1. Vælg på SageMaker-konsollen studie i navigationsruden.
2. På Studio-landingssiden skal du vælge domænet og brugerprofilen for at starte Studio.
3. Vælg Åben Studio.
4. Vælg for at starte SageMaker Studio Start personligt Studio.

Lad os se, hvordan du opretter en belønningsmodel lokalt i et SageMaker Studio-notebook-miljø ved at bruge en allerede eksisterende model fra Hugging Face-modelhubben.

Forbered et menneskemærket datasæt og træne en belønningsmodel

Når man laver belønningsmodellering, kan det være dyrt at få feedback-data fra mennesker. Dette skyldes, at belønningsmodellering kræver feedback fra andre menneskelige arbejdere i stedet for kun at bruge data indsamlet under almindelig systembrug. Hvor godt din belønningsmodel opfører sig afhænger af kvaliteten og mængden af ​​feedback fra mennesker.

Vi anbefaler at bruge AWS-administrerede tilbud som f.eks Amazon SageMaker Ground Truth. Det tilbyder det mest omfattende sæt af human-in-the-loop-funktioner, der giver dig mulighed for at udnytte kraften fra menneskelig feedback på tværs af machine learning (ML) livscyklussen for at forbedre nøjagtigheden og relevansen af ​​modeller. Du kan fuldføre en række menneske-i-løkken-opgaver med SageMaker Ground Truth, fra datagenerering og annotering til modelgennemgang, tilpasning og evaluering, enten gennem et selvbetjenings- eller AWS-administreret tilbud.

Til dette indlæg bruger vi IMDB-datasættet til at træne en belønningsmodel, der giver en højere score for tekst, som mennesker har stemplet som positiv, og en lavere score for negativ tekst.

Vi forbereder datasættet med følgende kode:

def create_custom_dataset(raw_dataset):
    df = raw_dataset.to_pandas()
    negative_df = df[df['label']==0]
    positive_df = df[df['label']==1]
    negative_df = negative_df.drop(
        columns=['label']).rename(
        columns={'text': 'rejected'})
    # shuffle the data
    positive_df = positive_df.sample(
        frac=1, random_state=0).reset_index(
        drop=True).drop(columns=['label']).rename(
        columns={'text': 'chosen'})
    joined_df = negative_df.join(positive_df)

    def tokenize_fn(texts, max_length=args.seq_length):
        encoded = tokenizer(
            texts,
            padding='max_length',
            max_length=max_length,
            truncation=True,
            add_special_tokens=False,
        )
        return encoded

    rejected_encoded = tokenize_fn(joined_df.rejected.values.tolist())
    joined_df['rejected_input_ids'] = rejected_encoded['input_ids']
    joined_df['rejected_attention_mask'] = rejected_encoded['attention_mask']
    encoded_chosen = tokenize_fn(joined_df.chosen.values.tolist())
    joined_df['chosen_input_ids'] = encoded_chosen['input_ids']
    joined_df['chosen_attention_mask'] = encoded_chosen['attention_mask']
    
    train_dataset = Dataset.from_pandas(joined_df, preserve_index=False)
    
    return train_dataset.with_format("torch")

Følgende eksempel viser en prøvepost fra det forberedte datasæt, som inkluderer referencer til afviste og valgte svar. Vi har også indlejret input-id'et og opmærksomhedsmasken for de valgte og afviste svar.

{'rejected': "If only to avoid making this type of film in the future. This film is interesting as an experiment but tells no cogent story.<br /><br />One might feel virtuous for sitting thru it because it touches on so many IMPORTANT issues but it does so without any discernable motive. The viewer comes away with no new perspectives (unless one comes up with one while one's mind wanders, as it will invariably do during this pointless film).<br /><br />One might better spend one's time staring out a window at a tree growing.<br /><br />",
 'chosen': "This is a great movie. I love it more each time i watch. Most comedies can get pretty lame because you know all the gags, but mystery men has so much integrity in the writing and characterization that watching once again -- as Ben Stiller tears at the hood ornament of the limo, or Hank Azaria says good-bye to Louise Lasser, or Geoffrey Rush flashes his fuhrer choreography, or Tom Waits mumbles while he watches the news report, or Janeane Garofalo refuses a kiss from Paul Reubens -- is a pleasure. This is pitch perfect ensemble acting. The story develops directly and consistently, the action sequences are creative and not too dominant, all the set-ups payoff by the end. Seriously, if you've seen it and it's been a while, watch it again, and if you haven't then get started. You can't watch it again until you've seen it the first time. (Wes Studi, William H. Macy, the tryouts scene. Too much good stuff!)",
 'rejected_input_ids': tensor([1106,  129,    7,  ...,    1,    1,    1]),
 'rejected_attention_mask': tensor([1, 1, 1,  ..., 0, 0, 0]),
 'chosen_input_ids': tensor([713,  16,  10,  ...,   1,   1,   1]),
 'chosen_attention_mask': tensor([1, 1, 1,  ..., 0, 0, 0])}

Indlæs den fortrænede model

I dette tilfælde bruger vi OPT-1.3b (Åben Pre-trained Transformer Language Model) model i Amazon SageMaker JumpStart fra Hugging Face. Hvis du vil udføre al træning lokalt på din notebook i stedet for distribueret træning, skal du bruge en instans med tilstrækkelig acceleratorhukommelse. Vi kører følgende træning på en notesbog, der kører på instanstypen ml.g4dn.xlarge:

from transformers import( 
      AutoModelForSequenceClassification, 
      AutoTokenizer, 
      set_seed, 
      ) 
from datasets import Dataset, load_dataset 
import torch
       
model = AutoModelForSequenceClassification.from_pretrained( 
       'facebook/opt-1.3b',
       torch_dtype=torch.bfloat16, 
       device_map="auto", 
       num_labels=1, 
 )

Definer den tilpassede trænerfunktion

I det følgende kodestykke opretter vi en tilpasset træner, der beregner, hvor godt en model klarer sig på en opgave:

from torch import nn 
from transformers import Trainer 
import torch.nn.functional as F 

class CustomTrainer(Trainer): 
def compute_loss(self, model, inputs, return_outputs=False): 

chosen_input_ids = inputs['chosen_input_ids'] chosen_attention_mask = inputs['chosen_attention_mask'] rejected_input_ids = inputs['rejected_input_ids'] rejected_attention_mask = inputs['rejected_attention_mask'] 
r_w = model(chosen_input_ids, chosen_attention_mask).logits 
r_l = model(rejected_input_ids, rejected_attention_mask).logits outputs = (r_w, r_l) 
loss = -F.logsigmoid(r_w - r_l).mean() 
return (loss, outputs) if return_outputs else loss

Den sammenligner modellens resultater for to sæt inputdata: et sæt der blev valgt og et andet sæt der blev afvist. Underviseren bruger derefter disse resultater til at finde ud af, hvor god modellen er til at skelne mellem de valgte og afviste data. Dette hjælper træneren med at justere modellen for at forbedre dens præstation på opgaven. Det CustomTrainer klasse bruges til at oprette en specialiseret træner, der beregner tabsfunktionen for en specifik opgave, der involverer valgte og afviste inputsekvenser. Denne brugerdefinerede træner udvider funktionaliteten af ​​standard Trainer-klassen leveret af transformatorbiblioteket, hvilket giver mulighed for en skræddersyet tilgang til håndtering af modeloutput og tabsberegning baseret på de specifikke krav til opgaven. Se følgende kode:

from transformers import TrainingArguments

training_args = TrainingArguments(output_dir="reward_model",
                                  overwrite_output_dir=True,
                                 do_train=True,
                                 do_eval=False,
                                 do_predict=False,
                                 evaluation_strategy="no",
                                 learning_rate=5e-5,
                                 num_train_epochs=1,
                                 per_device_train_batch_size=2,
                                 gradient_accumulation_steps=32,
                                 remove_unused_columns=False)
trainer = CustomTrainer( 
          model=model, 
          args=training_args, 
          train_dataset=train_dataset 
          )
trainer.train()
trainer.save_model()

TrainingArguments i det medfølgende kodestykke bruges til at konfigurere forskellige aspekter af træningsprocessen for en ML-model. Lad os nedbryde formålet med hver parameter, og hvordan de kan påvirke træningsresultatet:

• output_dir – Angiver den mappe, hvor den trænede model og tilknyttede filer vil blive gemt. Denne parameter hjælper med at organisere og gemme den trænede model til fremtidig brug.
• overskriv_output_dir – Bestemmer, om outputbiblioteket skal overskrives, hvis det allerede eksisterer. Indstilling af dette til True giver mulighed for at genbruge den samme mappe uden manuel sletning.
• do_train – Angiver, om der skal udføres træning. Hvis den er indstillet til True, trænes modellen ved hjælp af det medfølgende træningsdatasæt.
• do_eval og do_predict – Kontroller, om der skal udføres henholdsvis evaluerings- og forudsigelsesopgaver. I dette tilfælde er begge indstillet til Falsk, hvilket betyder, at kun træning vil blive gennemført.
• evalueringsstrategi – Definerer, hvornår evaluering skal udføres under træning. At sætte det til "nej" betyder, at evaluering ikke vil blive udført under træning.
• learning_rate – Specificerer indlæringshastigheden for optimeringsværktøjet, hvilket påvirker, hvor hurtigt eller langsomt modellen lærer af dataene.
• antal_tog_epoker – Indstiller det antal gange, modellen vil gennemgå hele træningsdatasættet under træning. Én epoke betyder en komplet gennemgang af alle træningsprøver.
• pr_device_train_batch_size – Bestemmer, hvor mange prøver der behandles i hver batch under træning på hver enhed (f.eks. GPU). En mindre batchstørrelse kan føre til langsommere, men mere stabil træning.
• gradient_akkumulation_trin – Styrer hvor ofte gradienter akkumuleres før opdatering af modellens parametre. Dette kan hjælpe med at stabilisere træning med store batchstørrelser.
• fjern_ubrugte_kolonner – Angiver, om ubrugte kolonner i datasættet skal fjernes før behandling, hvilket optimerer hukommelsesforbruget.

Ved at konfigurere disse parametre i TrainingArguments, kan du påvirke forskellige aspekter af træningsprocessen, såsom modelydelse, konvergenshastighed, hukommelsesforbrug og det overordnede træningsresultat baseret på dine specifikke krav og begrænsninger.

Når du kører denne kode, træner den belønningsmodellen baseret på den numeriske repræsentation af subjektiv feedback, du har indsamlet fra de menneskelige etiketter. En trænet belønningsmodel vil give en højere score til LLM-svar, som mennesker er mere tilbøjelige til at foretrække.

Brug belønningsmodellen til at evaluere basis LLM

Du kan nu feed svaret fra din LLM til denne belønningsmodel, og den numeriske score, der produceres som output, informerer dig om, hvor godt svaret fra LLM stemmer overens med de subjektive organisationspræferencer, der var indlejret i belønningsmodellen. Følgende diagram illustrerer denne proces. Du kan bruge dette nummer som tærskel for at beslutte, om svaret fra LLM kan deles med slutbrugeren.

Lad os f.eks. sige, at vi har oprettet en belønningsmodel for at undgå giftigt, skadeligt eller upassende indhold. Hvis en chatbot drevet af en LLM producerer et svar, kan belønningsmodellen derefter score chatbottens svar. Svar med scorer over en forudbestemt tærskel anses for acceptable at dele med brugere. Scorer under tærsklen betyder, at indholdet skal blokeres. Dette lader os automatisk filtrere chatbot-indhold, der ikke opfylder de standarder, vi ønsker at håndhæve. For at udforske mere, se den medfølgende notesbog.

Ryd op

For at undgå fremtidige gebyrer skal du slette alle de ressourcer, du har oprettet. Slet de implementerede SageMaker-modeller, hvis nogen, og stop den SageMaker Studio notesbog, du lancerede til denne øvelse.

Konklusion

I dette indlæg viste vi, hvordan man træner en belønningsmodel, der forudsiger en menneskelig præferencescore ud fra LLM's svar. Dette gøres ved at generere flere output for hver prompt med LLM og derefter bede menneskelige annotatorer om at rangere eller score svarene på hver prompt. Belønningsmodellen trænes derefter til at forudsige den menneskelige præferencescore ud fra LLM's svar. Efter at belønningsmodellen er trænet, kan du bruge belønningsmodellen til at evaluere LLM's svar i forhold til dine subjektive organisatoriske standarder.

Efterhånden som en organisation udvikler sig, skal belønningsfunktionerne udvikle sig sammen med ændrede organisationsværdier og brugerforventninger. Det, der definerer et "stort" AI-output, er subjektivt og transformerende. Organisationer har brug for fleksible ML-pipelines, der løbende omskoler belønningsmodeller med opdaterede belønninger, der afspejler de seneste prioriteter og behov. Dette rum udvikler sig løbende: direkte præferencebaseret politikoptimering, værktøjsudvidet belønningsmodelleringog eksempelbaseret kontrol er andre populære alternative teknikker til at tilpasse AI-systemer til menneskelige værdier og mål.

Vi inviterer dig til at tage det næste skridt i at tilpasse dine AI-løsninger ved at engagere dig i de forskellige og subjektive perspektiver af menneskelig feedback. Omfavn kraften i belønningsmodellering for at sikre, at dine AI-systemer resonerer med din brandidentitet og leverer de exceptionelle oplevelser, dine kunder fortjener. Begynd at forfine dine AI-modeller i dag med Amazon SageMaker, og vær med i fortroppen af ​​virksomheder, der sætter nye standarder inden for personlig kundeinteraktion. Hvis du har spørgsmål eller feedback, bedes du efterlade dem i kommentarfeltet.

Om forfatteren

Dinesh Kumar Subramani er en Senior Solutions Architect med base i Edinburgh, Skotland. Han har specialiseret sig i kunstig intelligens og maskinlæring og er medlem af det tekniske feltfællesskab hos Amazon. Dinesh arbejder tæt sammen med britiske centralregeringskunder for at løse deres problemer ved hjælp af AWS-tjenester. Uden for arbejdet nyder Dinesh at tilbringe kvalitetstid med sin familie, spille skak og udforske en bred vifte af musik.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/revolutionize-customer-satisfaction-with-tailored-reward-models-for-your-business-on-amazon-sagemaker/