Övrigt
AI i praktiken
Ladda ner AI-föreläsningen här ->
Praktisk programmering: träning av LLM
Förträning och finjustering:
Förträning: GPT-modellen tränas först på en stor mängd textdata från internet. Under denna fas lär sig modellen språkliga mönster, grammatik, fakta och olika sätt att formulera svar. Detta kallas för förträning, och syftet är att utveckla en generell förståelse för språket.
Finjustering: Efter förträningen kan modellen finjusteras med specifika datasets för att anpassa dess svar för specifika uppgifter eller domäner, till exempel att svara på frågor eller skriva kod. Detta steg är inte alltid nödvändigt, men det kan förbättra modellens prestanda inom specifika områden.
Genereringsprocessen:
När modellen ska generera text, sker det genom en sekvensiell process där varje nytt ord eller tecken väljs baserat på de ord som redan genererats. Processen kan delas in i följande steg:
Tokenisering: Inmatad text bryts ner i mindre enheter, så kallade tokens. Dessa tokens kan vara ord, delar av ord eller till och med enskilda tecken, beroende på modellens design.
Transformerarkitektur: Modellen använder sin transformerarkitektur för att analysera tokens och deras relationer till varandra. Den transformerbaserade modellen har flera lager av transformerblock som bearbetar textsekvensen parallellt, vilket gör den mycket effektiv för att förstå komplexa språkliga mönster och sammanhang.
Självuppmärksamhet: En viktig del av transformermodellen är mekanismen för självuppmärksamhet. Denna mekanism gör det möjligt för modellen att väga in olika delar av inmatningstexten när den genererar varje nytt token, vilket hjälper till att upprätthålla sammanhang i den genererade texten.
Generering: När modellen väljer nästa token tar den hänsyn till de redan genererade "tokensen" och använder en sannolikhetsfördelning för att bestämma vilket token som ska läggas till härnäst. Denna process upprepas tills en avslutningstoken genereras eller tills en viss längd på texten uppnås.
Decodning: Slutligen omvandlas de genererade "tokensen" till läsbar text. Detta kan innebära att konvertera tokens tillbaka till ord eller tecken och sammansätta dem till en sammanhängande textsträng.
Sammanfattning:
ChatGPT:s förmåga att generera textsträngar bygger alltså på en transformerbaserad modell som har tränats på stora mängder text. Genom processer som tokenisering, självuppmärksamhet och sekventiell generering kan modellen skapa text som är sammanhängande, relevant och ofta förvånansvärt mänsklig i tonen. Modellens förmåga att förstå sammanhang och generera text baserat på tidigare information gör den till ett kraftfullt verktyg för att generera naturligt språk.
Så har vi den praktiska aspekten och vi tar det verkligen steg för steg och börjar med indata (det verkar vara en naturlig startpunkt.) 1. Hur går det till när man inhämtar data. 2. Förbehandlas indata på något sätt i själva träningen av modellen?
För att förstå den praktiska aspekten av träningen av en modell som ChatGPT, kan vi dela upp processen i två huvudsteg: inhämtning av data och förbehandling av indata. Dessa steg är kritiska för att förbereda den stora mängd textdata som behövs för att träna modellen effektivt.
1. Inhämtning av Data:
Inhämtningen av data är ett fundamentalt steg där målet är att samla en omfattande och diversifierad (varierad) textkorpus som modellen kan lära sig från. Datakällorna kan variera stort, men de inkluderar ofta:
Webbtext: Stora mängder text extraheras från internet, inklusive artiklar, blogginlägg, forumdiskussioner och mer, för att få en bred representation av naturligt språk.
Böcker och publikationer: Text från böcker, vetenskapliga artiklar och andra publikationer används för att ge modellen tillgång till ett brett spektrum av språkstilar och ämnesområden.
Specialiserade Datasets: För vissa applikationer kan data också inhämtas från specialiserade källor för att säkerställa att modellen tränas på relevant material.
Datainhämtning måste göras med hänsyn till licenser, upphovsrätt och etiska överväganden för att undvika användning av upphovsrättsskyddat material utan tillstånd.
2. Förbehandling av Indata:
Efter att datan har inhämtats, måste den förbehandlas innan den kan användas för att träna modellen. Förbehandlingen innebär flera viktiga steg:
Rensning: Datan rensas för att avlägsna irrelevant information, såsom HTML-koder, onödig formatering, störande tecken och annat brus som kan försämra modellens träning.
Tokenisering: Texten delas upp i mindre enheter, kallade tokens, vilka kan vara ord, delar av ord eller tecken. Detta gör det möjligt för modellen att behandla och generera text mer effektivt.
Normalisering: Texten kan normaliseras genom att omvandla all text till små bokstäver, korrigera stavfel, och expandera förkortningar för att minska variationen i data.
Segmentering: Längre texter kan delas upp i mindre segment eller "chunks" för att underlätta bearbetningen och förbättra modellens förmåga att hantera stora mängder information.
Efter förbehandlingen omvandlas texten till ett format som är lämpligt för modellens arkitektur, ofta genom att omvandla tokens till numeriska ID:n som representerar deras position i ett ordlexikon. Denna omvandlade data matas sedan in i modellen under träningen, där modellen gradvis lär sig att förstå och generera text baserat på de mönster och samband som finns i data.
Kan detta ordlexikon liknas vid en vektor?
Ja, ordlexikonet i sammanhanget av en transformerbaserad modell som ChatGPT kan liknas vid ett inledande steg i att representera ord som vektorer. Processen börjar med att varje unikt token (som kan vara ett ord, del av ett ord, eller ett tecken beroende på tokeniseringsmetoden) tilldelas ett unikt numeriskt ID. Denna mappning av tokens till numeriska ID:n utgör grunden för ordlexikonet.
Dessa numeriska ID:n används sedan för att konstruera vektorrepresentationer av orden i form av så kallade inbäddningar (eng. embeddings). I denna process:
Varje numeriskt ID omvandlas till en högdimensionell vektor. Detta görs med hjälp av en inbäddningsmatris, som är en del av modellens parametrar och lär sig under träningen.
Inbäddningsmatrisen innehåller en unik vektor för varje token i ordlexikonet. När ett token-ID matas in i modellen, returnerar inbäddningsmatrisen motsvarande vektor. Dessa vektorer är vad modellen faktiskt bearbetar, och de innehåller de lärda representationerna av tokensen.
Dessa inbäddningar är grundläggande för att modellen ska kunna bearbeta och förstå text. De fungerar som en bro mellan de diskreta tokenen och modellens kontinuerliga, differentierbara arkitektur. Genom träningen anpassas vektorerna för att bära semantisk och syntaktisk information om sina motsvarande ord eller tokens, vilket möjliggör att modellen kan utföra komplexa uppgifter som språkförståelse och textgenerering.
Så ja, i detta sammanhang kan ordlexikonet ses som ett inledande steg mot att representera ord som vektorer, där varje ord eller token associeras med en unik vektor som fångar dess betydelse och användning i språket.
Kan det här liknas vid en 3 - 4 - 5 ... dimensionell array i programmeringssammanhang?
Ja, termen "högdimensionell vektor" kan i viss mån liknas vid en flerdimensionell array, men det finns några viktiga skillnader att förstå.
När vi talar om en "högdimensionell vektor" i sammanhanget av ordinbäddningar eller vektorrepresentationer av ord, syftar vi vanligtvis på en endimensionell array (i matematiska termer kallad en vektor) som innehåller ett stort antal element. Varje element i denna vektor representerar en dimension. Så en "högdimensionell vektor" kan ha hundratals eller till och med tusentals dimensioner, men dessa dimensioner lagras sekventiellt i en endimensionell struktur.
Flerdimensionella arrayer, å andra sidan, har flera axlar eller "nivåer" av indexering. Till exempel:
En 2D-array kan liknas vid en matris och har rader och kolumner.
En 3D-array kan tänkas som en "kub" av data, med djup utöver rader och kolumner.
4D-arrays och högre blir svårare att visualisera men bygger på samma princip med ytterligare nivåer av indexering.
När vi diskuterar ordinbäddningar och högdimensionella vektorer inom NLP (Natural language processing) och maskininlärning, refererar vi vanligtvis till endimensionella vektorer där "högdimensionell" hänvisar till antalet element (dimensioner) i vektorn, snarare än flera nivåer av indexering som i flerdimensionella arrayer.
Så även om konceptuellt kan en högdimensionell vektor tänkas ha likheter med en flerdimensionell array genom att de båda kan hantera data i flera "dimensioner", så är de tekniskt och strukturellt olika i hur de lagrar och organiserar denna data.
Låt oss titta på ett förenklat exempel på en högdimensionell vektor som representerar en ordvektor eller en ordinbäddning.
Antag att vi har en ordinbäddning i ett 5-dimensionellt vektorutrymme. Det betyder att varje ord i vår modell representeras av en vektor med 5 element. Varje element i vektorn är ett reellt tal som kan ha olika värden. Dessa tal representerar olika aspekter eller "funktioner" av ordet, även om den exakta betydelsen av varje dimension oftast är svår att tolka.
Ett exempel på en sådan vektor kan vara:
Ord: "Katt"
Vektor: [0.2, -1.3, 0.7, 0.4, -0.8]
I detta exempel representeras ordet "Katt" av vektorn [0.2, -1.3, 0.7, 0.4, -0.8]. Varje siffra i vektorn är ett värde i en dimension i vektorrummet. Även om detta är en endimensionell vektor (eftersom det bara är en rad av tal), beskrivs den som "högdimensionell" på grund av att den innehåller flera dimensioner (i detta fall 5).
Det är viktigt att notera att detta är ett mycket förenklat exempel. I praktiska tillämpningar är dimensionen av ordinbäddningar ofta mycket större, vanligen i storleksordningen hundratals till tusentals, vilket gör dem kapabla att bära mycket mer komplex och nyanserad information om ordets egenskaper och relationer till andra ord.
Kureringen av indata och valet av lagringsformat för dessa data är avgörande delar av processen att bygga och träna en effektiv maskininlärningsmodell, särskilt inom områden som naturlig språkbehandling (NLP).
Kurering av Indata
Kureringen av indata innebär noggrant urval och förberedelse av de data som ska användas för att träna modellen. Detta steg omfattar:
Val av datakällor: Att identifiera och samla in data från pålitliga och relevanta källor som ger en rik och mångsidig textkorpus. Detta kan inkludera böcker, artiklar, webbsidor och andra textbaserade material.
Rensning och normalisering: Rensa bort oönskat innehåll som HTML-taggar, specialtecken, och normalisera texten för att minska variationen (t.ex. genom att omvandla all text till små bokstäver, korrigera stavfel, och standardisera terminologi).
Balans och diversitet: Se till att datamängden innehåller en balanserad och diversifierad (mångsidig) representation av olika språk, ämnen, och stilar för att undvika snedvridningar och öka modellens generaliserbarhet (alltså förmågan att svara på frågor inom en mängd olika ämnen).
Lagringsformat
Valet av lagringsformat för data är också kritiskt, eftersom det påverkar hur effektivt och effektivt data kan bearbetas och användas av modellen:
Tokenisering: Bryta ner texten till meningsfulla enheter (tokens) som kan vara ord, delar av ord, eller till och med enskilda tecken. Detta steg är fundamentalt för att omvandla “rå” text till en form som maskininlärningsmodeller kan arbeta med.
Vektorrepresentationer: Omvandla tokens till numeriska vektorer genom inbäddningar. Detta steg innebär att representera varje token som en punkt i ett högdimensionellt vektorrum, där liknande ord hamnar nära varandra, vilket möjliggör att modellen kan dra slutsatser om ordens betydelser och relationer.
Effektivitet och skalbarhet: Val av datastrukturer och lagringsformat som optimerar både lagringsutrymme och åtkomsttider, vilket är särskilt viktigt när man hanterar stora datamängder.
Dessa steg är kritiska för att bygga en robust NLP-modell eftersom kvaliteten och relevansen av träningsdata direkt påverkar modellens förmåga att lära sig och utföra uppgifter korrekt. En välkurerad och effektivt lagrad datamängd bidrar till en mer träffsäker, mångsidig och effektiv modell.”
När vi fått in all vår kurerade data till modellen, vad händer då?
När all kurerad data har förberetts och är redo, inleds träningen av modellen. Denna process är kärnan i att utveckla en maskininlärningsmodell som ChatGPT. Träningen involverar flera viktiga steg:
Initialisering
Först initialiseras modellens parametrar, ofta slumpmässigt. Detta inkluderar vikterna i de olika lagren av modellen. Dessa initiala vikter kommer successivt att justeras genom träningen för att minimera skillnaden mellan modellens förutsägelser och de faktiska resultaten.
Framåtpass (Forward Pass)
Under ett framåtpass matas indata (i detta fall, tokeniserade och vektoriserade textsegment) in i modellen. Modellen bearbetar denna indata genom dess olika lager, från inmatningslagret till det sista utmatningslagret, och producerar en utdata. För en språkmodell som ChatGPT är denna utdata ofta en sannolikhetsfördelning över möjliga nästa tokens givet den inmatade texten.
Förlustberäkning (Loss Calculation)
När modellen har genererat sin utdata, beräknas ett "förlustvärde" (eller "kostnad") som mäter skillnaden mellan modellens förutsägelser och de faktiska önskade resultaten (ofta kallade "etiketter" eller "sanna värden"). Denna förlustfunktion är central för att bedöma modellens prestanda.
Bakåtpass (Backward Pass) och Optimering
Under bakåtpasset beräknas gradienter för varje parameter i modellen med avseende på förlustfunktionen, vilket vanligtvis görs genom en teknik som kallas för bakåtpropagering (backpropagation). Dessa gradienter används sedan av en optimeringsalgoritm (till exempel Adam, SGD, etc.) för att göra små justeringar på modellens parametrar (vikter) i syfte att minska förlustvärdet.
Iteration och Konvergens
Träningsprocessen består av flera iterationer av framåt- och bakåtpass, där modellen gradvis förbättras genom att justera sina parametrar för att minska förlustvärdet. Varje fullständig genomgång av träningsdata kallas för en epok. Träningen fortsätter över många epoker tills modellen når en punkt där förlustvärdet inte minskar signifikant längre eller tillfredsställer andra förutbestämda stoppkriterier.
Validering och Justering
Under och efter träningen är det viktigt att regelbundet testa modellens prestanda på en separat valideringsdataset som inte användes under träningen. Detta hjälper till att identifiera och korrigera problem som överanpassning, där modellen presterar väl på träningsdata men dåligt på ny, osedd data. Baserat på valideringsresultaten kan ytterligare justeringar och finjusteringar göras för att förbättra modellens generaliseringsförmåga.
Genom denna iterativa process av framåtpass, förlustberäkning, bakåtpass och optimering, lär sig modellen successivt de komplexa mönstren i träningsdatan och blir allt bättre på att förutse nästa token i en sekvens, vilket är kärnan i dess förmåga att generera sammanhängande och relevanta texter.
Hyperparametrar är inställningar som används för att styra träningsprocessen för modellen men de är mer tekniska och matematiska till sin natur.
De inkluderar saker som inlärningstakt, storleken på modellen (antal lager och noder), batchstorlek under träning och så vidare.
Hyperparametrar påverkar modellens prestanda, hur snabbt den lär sig och hur väl den generaliserar från träningsdata till ny, osedd data.
Efter att data har kurerats, omvandlas den till ett format som modellen kan arbeta med, ofta genom en process som kallas tokenisering, där texten bryts ner i mindre enheter som ord eller ordfragment. Dessa tokeniserade data används sedan för att träna modellen, där den gradvis lär sig att förstå och generera text baserat på de mönster och den struktur den observerar i indata.
Den här sidan designades av 21C: