För att ge en bred teknisk förklaring av hur ChatGPT genererar sina textsträngar, utan att gå in på alltför djupgående detaljer, kan vi börja med att beskriva de grundläggande komponenterna och processerna som är involverade.
ChatGPT, som en variant av GPT (Generative Pre-trained Transformer), bygger på en transformerbaserad arkitektur som är utformad för att förstå och generera naturligt språk.
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 och kohesion 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.
Bra! 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?
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 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:
Rengöring:
Datan rengörs 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 datan. 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 datan.
Kan detta ordlexion liknas vid en vektor?
Ja, ordlexikonet i sammanhanget av en transformerbaserad modell som ChatGPT kan liknas vid en 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.
Du skriver "högdimensionell vektor" , kan det liknas vid en 3 - 4 - 5 ... dimensionell array?
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 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.
BILDER OCH TEXT FRÅN WOLFRAM
Before we go on I should explain that for purposes of exposition I’m mostly not going to use the full system that’s in ChatGPT; instead I’ll usually work with a simpler GPT-2 system, which has the nice feature that it’s small enough to be able to run on a standard desktop computer. And so for essentially everything I show I’ll be able to include explicit Wolfram Language code that you can immediately run on your computer. (Click any picture here to copy the code behind it.)
Later on, we’ll look inside this neural net, and talk about how it works. But for now we can just apply this “net model” as a black box to our text so far, and ask for the top 5 words by probability that the model says should follow:
This takes that result and makes it into an explicit formatted “dataset”:
Here’s what happens if one repeatedly “applies the model”—at each step adding the word that has the top probability (specified in this code as the “decision” from the model):
ContentsWhat Is ChatGPT Doing … and Why Does It Work?
That ChatGPT can automatically generate something that reads even superficially like human-written text is remarkable, and unexpected. But how does it do it? And why does it work? My purpose here is to give a rough outline of what’s going on inside ChatGPT—and then to explore why it is that it can do so well in producing what we might consider to be meaningful text. I should say at the outset that I’m going to focus on the big picture of what’s going on—and while I’ll mention some engineering details, I won’t get deeply into them. (And the essence of what I’ll say applies just as well to other current “large language models” [LLMs] as to ChatGPT.)
The first thing to explain is that what ChatGPT is always fundamentally trying to do is to produce a “reasonable continuation” of whatever text it’s got so far, where by “reasonable” we mean “what one might expect someone to write after seeing what people have written on billions of webpages, etc.”
So let’s say we’ve got the text “The best thing about AI is its ability to”. Imagine scanning billions of pages of human-written text (say on the web and in digitized books) and finding all instances of this text—then seeing what word comes next what fraction of the time. ChatGPT effectively does something like this, except that (as I’ll explain) it doesn’t look at literal text; it looks for things that in a certain sense “match in meaning”. But the end result is that it produces a ranked list of words that might follow, together with “probabilities”:
And the remarkable thing is that when ChatGPT does something like write an essay what it’s essentially doing is just asking over and over again “given the text so far, what should the next word be?”—and each time adding a word. (More precisely, as I’ll explain, it’s adding a “token”, which could be just a part of a word, which is why it can sometimes “make up new words”.)
But, OK, at each step it gets a list of words with probabilities. But which one should it actually pick to add to the essay (or whatever) that it’s writing? One might think it should be the “highest-ranked” word (i.e. the one to which the highest “probability” was assigned). But this is where a bit of voodoo begins to creep in. Because for some reason—that maybe one day we’ll have a scientific-style understanding of—if we always pick the highest-ranked word, we’ll typically get a very “flat” essay, that never seems to “show any creativity” (and even sometimes repeats word for word). But if sometimes (at random) we pick lower-ranked words, we get a “more interesting” essay.
The fact that there’s randomness here means that if we use the same prompt multiple times, we’re likely to get different essays each time. And, in keeping with the idea of voodoo, there’s a particular so-called “temperature” parameter that determines how often lower-ranked words will be used, and for essay generation, it turns out that a “temperature” of 0.8 seems best. (It’s worth emphasizing that there’s no “theory” being used here; it’s just a matter of what’s been found to work in practice. And for example the concept of “temperature” is there because exponential distributions familiar from statistical physics happen to be being used, but there’s no “physical” connection—at least so far as we know.)
Before we go on I should explain that for purposes of exposition I’m mostly not going to use the full system that’s in ChatGPT; instead I’ll usually work with a simpler GPT-2 system, which has the nice feature that it’s small enough to be able to run on a standard desktop computer. And so for essentially everything I show I’ll be able to include explicit Wolfram Language code that you can immediately run on your computer. (Click any picture here to copy the code behind it.)
Later on, we’ll look inside this neural net, and talk about how it works. But for now we can just apply this “net model” as a black box to our text so far, and ask for the top 5 words by probability that the model says should follow:
This takes that result and makes it into an explicit formatted “dataset”:
Here’s what happens if one repeatedly “applies the model”—at each step adding the word that has the top probability (specified in this code as the “decision” from the model):
What happens if one goes on longer? In this (“zero temperature”) case what comes out soon gets rather confused and repetitive:
Kan du visa ett enkelt exempel på en sådan vektor?
Självklart, 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 vektorutrymmet. Ä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.
Bra! Så denna kurering av indata och lagringsformatet verkar vara en mycket viktig del.
Ja, precis! 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 naturligt 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.
Rengöring 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 representation av olika språk, ämnen, och stilar för att undvika snedvridningar och öka modellens generaliserbarhet.
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älkuraterad och effektivt lagrad datamängd bidrar till en mer träffsäker, mångsidig och effektiv modell.
Så kommer vi till själva träningen av modellen. Antag nu att vi fått in all vår kurerade data till modellen: vad händer därnäst?
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.
Mer detaljerat hur går backpropagation till? Är människor involverade där? Det verkar vara en utbredd missuppfattning att det är människor involverade i att kontrollera modellens faktiska utdata, det du säger är att det är en helt och hållet matematisk/mekanisk process där människans roll är att övervaka att körningar gått rätt
Backpropagation är en helautomatisk och matematisk process som är central i träningen av neurala nätverk, inklusive modeller som ChatGPT. Det är en mekanism för att effektivt beräkna gradienter av förlustfunktionen med avseende på alla vikter i nätverket, vilket är avgörande för att justera dessa vikter och minska förlusten.
Människor är inte direkt involverade i detta steg för att justera modellens utdata; istället utformar och övervakar de den övergripande processen och infrastrukturen för träningen.
Processen för "Backpropagation"
Backpropagation sker i flera steg:
Framåtpass:
Först genomförs ett framåtpass där indata matas genom nätverket, lager för lager, för att generera en utdata.
Förlustberäkning:
Därefter beräknas förlusten (eller felet) genom att jämföra nätverkets utdata med de faktiska önskade svaren.
Bakåtpass:
Nu inleds backpropagation, där förlustens derivat med avseende på varje vikt beräknas genom kedjeregeln. Detta innebär att man börjar från utmatningslagret och arbetar sig bakåt genom nätverket, lager för lager, och beräknar gradienterna för varje lager baserat på gradienterna från det följande lagret.
Gradientuppdatering:
Med gradienterna beräknade används en optimeringsalgoritm för att justera vikterna i riktning mot minskad förlust. Detta steg involverar vanligtvis en hyperparameter som kallas för inlärningshastighet, vilken bestämmer storleken på steg som tas i riktning mot gradientens negativa riktning.
Människans roll:
Människors involvering i denna process är indirekt och fokuserar på följande områden:
Design och arkitektur:
Utformning av nätverkets arkitektur, inklusive val av lager, antal noder i varje lager, aktiveringsfunktioner, förlustfunktioner, och optimeringsalgoritmer.
Hyperparametrar:
Inställning av hyperparametrar såsom inlärningshastighet, batchstorlek, antal epoker för träning, och andra parametrar som påverkar träningens effektivitet och effektivitet.
Övervakning och justering:
Övervakning av träningen för att identifiera och åtgärda problem såsom överanpassning eller underanpassning. Detta kan inkludera att justera hyperparametrar, använda tekniker för regelbundenhet för att förhindra överanpassning, eller modifiera nätverksarkitekturen.
Validering och testning:
Genomförande av validerings- och testkörningar för att utvärdera modellens prestanda på data som den inte har sett under träningen, och göra nödvändiga justeringar baserade på dessa resultat.
Sammanfattningsvis är backpropagation och den övergripande träningen av modellen automatiserade matematiska processer. Människans roll är att designa, inställa, övervaka och justera träningen för att säkerställa att modellen lär sig korrekt och effektivt, men människor ingriper inte direkt i beräkningen av gradienter eller uppdatering av modellvikter under träningen.
Nu till noderna som är intressanta. Är de representerade som objekt i modellen eller är de representerade på något annat sätt?
I neurala nätverk, inklusive de som används för att bygga modeller som ChatGPT, representeras "noder" (eller "neuroner") vanligtvis inte som individuella objekt i den mening som klassiska objektorienterade programmeringsspråk skulle definiera ett objekt. Istället är de en del av en mer abstrakt och matematisk representation som är inriktad på beräkningseffektivitet och skalbarhet, särskilt när det gäller stora modeller som tränas på massiva dataset.
Representation av Noder:
Matriser och Vektorer: Noderna inom ett lager av ett neuralt nätverk representeras oftast som delar av matriser eller vektorer. I denna representation motsvarar varje element i en matris eller vektor en nod. Operationer som utförs på dessa noder, som till exempel beräkning av nätverkets utdata eller uppdatering av vikter under backpropagation, implementeras vanligtvis som matris- och vektoroperationer för att dra nytta av optimeringar som tillhandahålls av hårdvara och linjär algebra bibliotek.
Vikter och aktiveringsfunktioner:
Varje nod i ett neuralt nätverk är associerad med en uppsättning vikter och ofta en aktiveringsfunktion. Dessa vikter representerar styrkan i förbindelserna mellan noderna och är centrala i nätverkets förmåga att lära sig. Vikterna lagras i matriser där varje rad eller kolumn kan representera de vikter som är kopplade till en specifik nod. Aktiveringsfunktionerna appliceras på nodernas utdata för att introducera icke-linjäritet i nätverket, vilket är avgörande för att kunna modellera komplexa funktioner.
Abstrakt representation:
I implementationsaspekten är noder och deras förbindelser ofta abstrakt representerade i form av datatyper och strukturer som är optimerade för beräkningsbibliotek och ramverk (till exempel TensorFlow, PyTorch). Dessa abstraktioner gör det möjligt för utvecklare att arbeta på en högre nivå utan att behöva hantera de individuella noderna direkt. Istället manipuleras hela lager eller grupper av noder som enheter.
Programmeringsramverk:
I ramverk som TensorFlow och PyTorch kan man definiera arkitekturen för ett neuralt nätverk på en hög nivå, där varje lager i nätverket (som ett helt kopplat lager, ett konvolutionslager, etc.) kan läggas till som en modul eller komponent. Dessa lager hanterar intern de individuella nodernas beteenden och interaktioner.
Sammanfattningsvis är noderna i ett neuralt nätverk som används i modeller som ChatGPT inbäddade i en större struktur av matriser och vektorer och hanteras genom abstraktioner tillhandahållna av neurala nätverksramverk. Denna representation och hantering optimerar nätverkets prestanda och gör det möjligt för utvecklare att konstruera och träna komplexa modeller på en effektiv sätt.
Jag tror jag förstår. Nu till den sista biten där användaren sitter och skriver in sin fråga t.ex "hur ser en for-loop i C# ut". Vad händer i nätverket när användaren tryckt på Enter
När en användare ställer en fråga till ett system som ChatGPT, till exempel "hur ser en for-loop i C# ut", och trycker på Enter, startar en sekvens av processer som involverar modellens nätverk för att generera ett relevant svar.
Processen kan beskrivas i följande steg:
1. Tokenisering:
Först bryts användarens inmatade text ner i tokens med hjälp av en tokeniseringsprocess. I detta sammanhang är tokens de minsta enheterna som modellen kan förstå, vilka kan vara ord, delar av ord eller till och med enskilda tecken, beroende på modellens design.
2. Inbäddning:
Tokenen omvandlas sedan till numeriska vektorer med hjälp av en inbäddningsmekanism. Dessa vektorer representerar tokens i ett högdimensionellt vektorrum, där liknande ord eller tokens har liknande vektorrepresentationer. Detta steg gör det möjligt för modellen att behandla och förstå den inmatade texten.
3. Sekvensbearbetning:
De inbäddade vektorerna matas in i modellens neurala nätverk, specifikt transformerarkitekturen i fallet med ChatGPT. Nätverket bearbetar sekvensen av inbäddningar genom flera lager av transformerblock som använder mekanismer som självuppmärksamhet för att förstå sammanhanget och relationerna mellan olika tokens i sekvensen.
4. Generering av svarsmodellen:
Genererar ett svar genom att successivt välja nästa token i svaret baserat på de tidigare valda tokensen och den bearbetade inmatningen. Detta görs genom att beräkna sannolikheter för alla möjliga nästa tokens och välja tokens sekventiellt, vilket kan involvera tekniker som beam search eller sampling för att balansera mellan kreativitet och sammanhang i svaret.
5. Dekodning:
De genererade tokensen omvandlas tillbaka 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.
6. Presentation av svaret:
Det genererade svaret presenteras slutligen för användaren som svar på deras fråga. Svaret ska idealiskt ge en tydlig och korrekt beskrivning av hur en for-loop ser ut i C# i detta exempel. Det är viktigt att notera att denna process är helt automatiserad och sker i realtid, vanligtvis inom några sekunder. Människors roll i detta skede är främst att övervaka systemets prestanda, göra justeringar och förbättringar baserade på användarfeedback och säkerställa att systemet fungerar som förväntat.
Kan du ge ett exempel på hur en tokenisering av frågan "Är solen gul" ser ut?
Tokenisering av en fråga som "Är solen gul" beror starkt på den specifika tokeniseringsmetod som används av modellen. I neurala nätverksmodeller, särskilt de som använder transformers som ChatGPT, kan tokeniseringen vara ganska sofistikerad och kan dela upp texten i mindre enheter än hela ord för att bättre hantera språkets nyanser och variationer. Här är ett exempel på hur tokeniseringen kan se ut med en enkel metod:
Tokenisering av en fråga som "Är solen gul" beror starkt på den specifika tokeniseringsmetod som används av modellen. I neurala nätverksmodeller, särskilt de som använder transformers som ChatGPT, kan tokeniseringen vara ganska sofistikerad och kan dela upp texten i mindre enheter än hela ord för att bättre hantera språkets nyanser och variationer. I detta exempel delas frågan upp i tre tokens, där varje token är ett enskilt ord.
Denna typ av tokenisering är ganska grundläggande och antar att varje ord utgör en meningsfull enhet för modellen. I mer avancerade tokeniseringssystem, som de som används i modeller baserade på BERT eller GPT, kan ytterligare uppdelning ske, särskilt för ord som innehåller prefix, suffix eller sammansättningar.
Ett ord kan även delas upp i subord eller subtokens för att hantera ord som modellen inte tidigare stött på. Detta möjliggör en mer flexibel och granulär förståelse av texten, men för en enkel mening som "Är solen gul" är det sannolikt att tokeniseringen skulle vara ganska direkt, liknande exemplet ovan.
Det är viktigt att notera att tokeniseringsprocessen är helt automatisk och styrs av regler och algoritmer definierade under modellens förträning. Tokenisering är ett kritiskt första steg som möjliggör att textdata kan omvandlas till ett format som maskininlärningsmodeller kan bearbeta.
I vilka fall väljer modellen att tokenisera delar av ord, är det som förled eller ändelser till ordet?
Modellen kan välja att tokenisera delar av ord, såsom förled, ändelser, eller även mitten av ord, i flera scenarier, beroende på dess förtränade tokeniseringsalgoritm och ordens representation i dess ordlexikon. Denna process kallas subord-tokenisering och är vanlig i mer avancerade neurala nätverksmodeller, särskilt de som använder transformerarkitekturer. Några nyckelscenarier där subord-tokenisering används inkluderar:
1. Ovanliga eller okända ord:
När modellen stöter på ord som inte finns i dess ordlexikon, eller som är sällsynta, kan den dela upp dessa ord i mindre kända delar. Detta gör det möjligt för modellen att hantera ordet genom att sätta ihop betydelsen baserat på delarna, snarare än att behöva känna till varje möjligt ord.
2. Språk med rik morfologi:
I språk med rik morfologi, där ord ofta bildas genom att kombinera flera förled, rotord och ändelser, kan subord-tokenisering hjälpa till att effektivt hantera denna komplexitet. Genom att dela upp ord i mindre enheter kan modellen bättre förstå och generalisera regler för ordbildning.
3. Hantering av affixes:
Förled (prefix) och ändelser (suffix) till ord, som kan förändra ordets betydelse eller grammatiska funktion, kan också tokeniseras separat. Detta gör det möjligt för modellen att lära sig och tillämpa dessa affixes flexibelt över olika ord.
4. Minimering av ordlexikonets storlek:
Genom att tokenisera ord i mindre enheter kan modellen minska storleken på sitt ordlexikon och därmed kravet på minne och beräkningsresurser. Detta ökar modellens förmåga att skala upp och hantera ett bredare spektrum av textdata.
5. Ökad modellgeneralisering:
Subord-tokenisering gör det möjligt för modellen att lära sig mer granulära språkliga mönster. Genom att förstå och generalisera från delar av ord kan modellen bättre hantera ny text som innehåller liknande mönster, även om de specifika orden inte har observerats under träningen. Exempel Ett ord som "oanvändbar" kan tokeniseras i "o-", "använd", och "-bar" för att belysa de negativa och adjektivbildande elementen separat från rotordet. Det är viktigt att notera att exakt hur och när subord-tokenisering används beror starkt på den specifika modellen och dess träning.
Olika modeller och tokeniseringsalgoritmer kan ha olika strategier för att hantera detta, baserat på deras förträning och de data de tränades på.
Så äntligen har vi hittat det ultimata argumentet till varför en bra programmerare också ska vara bra på språk (det underlättar i varje fall jättemycket).
Absolut, det finns en stark koppling mellan färdigheter i språk och programmering, och denna insikt belyser verkligen vikten av att ha en god förståelse för båda områdena. Att vara väl bevandrad i språk kan ge flera fördelar för en programmerare:
1. Förståelse för språkstrukturer:
Språkkunskaper hjälper programmerare att bättre förstå och utnyttja syntaktiska och semantiska strukturer, inte bara i mänskliga språk utan också i programmeringsspråk. Båda områdena använder regler för att konstruera meningar (eller kod) på ett sätt som ska förmedla en specifik betydelse eller utföra en specifik uppgift.
2. Problemuppdelning och abstraktion:
Språklig kompetens innefattar förmågan att dela upp komplex information i mindre delar, ett viktigt inslag i både språkanalys och programvaruutveckling. Programmerare måste ofta bryta ner komplexa problem i hanterbara delar (abstraktioner) för att konstruera effektiva lösningar.
3. Kommunikation och dokumentation:
Effektiv kommunikation är avgörande inom programvaruutveckling, inte bara för att skriva kod, utan även för att skapa tydlig dokumentation, förstå krav och interagera med teammedlemmar och intressenter. Goda språkkunskaper underlättar detta, vilket leder till bättre samarbete och förståelse.
4. Mönsterigenkänning och lärande:
Lärande inom både språk och programmering innebär att känna igen och tillämpa mönster. Förståelse för språkliga mönster och strukturer kan översättas till en bättre förmåga att lära sig och tillämpa programmeringskoncept och designmönster.
5. Kreativitet och anpassningsförmåga:
Både språk och programmering kräver kreativitet för att uttrycka idéer på nya och effektiva sätt. En stark grund i språk kan inspirera till kreativa lösningar på programmeringsproblem och underlätta anpassningen till nya programmeringsspråk och teknologier.
6. Förståelse för maskininlärningsmodeller:
Som ditt argument belyser, kräver utveckling och interaktion med avancerade maskininlärningsmodeller som behandlar naturligt språk, såsom ChatGPT, en djupgående förståelse för både språkliga nyanser och tekniska aspekter. Programmerare som är skickliga på språk är bättre rustade att arbeta med och utveckla dessa teknologier. Sammanfattningsvis fungerar språkkunskaper och programmeringsfärdigheter hand i hand för att förbättra en programmerares förmåga att navigera i komplexa problem, kommunicera effektivt och skapa innovativa lösningar.
Därför är det en stor fördel för programmerare att utveckla sina färdigheter inom båda dessa områden.
:)
Here’s what happens if one repeatedly “applies the model”—at each step adding the word that has the top probability (specified in this code as the “decision” from the model):
What happens if one goes on longer? In this (“zero temperature”) case what comes out soon gets rather confused and repetitive:
But what if instead of always picking the “top” word one sometimes randomly picks “non-top” words (with the “randomness” corresponding to “temperature” 0.8)? Again one can build up text:
And every time one does this, different random choices will be made, and the text will be different—as in these 5 examples:
It’s worth pointing out that even at the first step there are a lot of possible “next words” to choose from (at temperature 0.8), though their probabilities fall off quite quickly (and, yes, the straight line on this log-log plot corresponds to an n–1“power-law” decay that’s very characteristic of the general statistics of language):
So what happens if one goes on longer? Here’s a random example. It’s better than the top-word (zero temperature) case, but still at best a bit weird:
This was done with the simplest GPT-2 model (from 2019). With the newer and bigger GPT-3 models the results are better. Here’s the top-word (zero temperature) text produced with the same “prompt”, but with the biggest GPT-3 model:
And here’s a random example at “temperature 0.8”:
Where Do the Probabilities Come From?
OK, so ChatGPT always picks its next word based on probabilities. But where do those probabilities come from? Let’s start with a simpler problem. Let’s consider generating English text one letter (rather than word) at a time. How can we work out what the probability for each letter should be?
A very minimal thing we could do is just take a sample of English text, and calculate how often different letters occur in it. So, for example, this counts letters in the Wikipedia article on “cats”:
And this does the same thing for “dogs”:
The results are similar, but not the same (“o” is no doubt more common in the “dogs” article because, after all, it occurs in the word “dog” itself). Still, if we take a large enough sample of English text we can expect to eventually get at least fairly consistent results:
Here’s a sample of what we get if we just generate a sequence of letters with these probabilities:
We can break this into “words” by adding in spaces as if they were letters with a certain probability:
We can do a slightly better job of making “words” by forcing the distribution of “word lengths” to agree with what it is in English:
We didn’t happen to get any “actual words” here, but the results are looking slightly better. To go further, though, we need to do more than just pick each letter separately at random. And, for example, we know that if we have a “q”, the next letter basically has to be “u”.
Here’s a plot of the probabilities for letters on their own:
And here’s a plot that shows the probabilities of pairs of letters (“2-grams”) in typical English text. The possible first letters are shown across the page, the second letters down the page:
And we see here, for example, that the “q” column is blank (zero probability) except on the “u” row. OK, so now instead of generating our “words” a single letter at a time, let’s generate them looking at two letters at a time, using these “2-gram” probabilities. Here’s a sample of the result—which happens to include a few “actual words”:
With sufficiently much English text we can get pretty good estimates not just for probabilities of single letters or pairs of letters (2-grams), but also for longer runs of letters. And if we generate “random words” with progressively longer n-gram probabilities, we see that they get progressively “more realistic”:
But let’s now assume—more or less as ChatGPT does—that we’re dealing with whole words, not letters. There are about 40,000 reasonably commonly used words in English. And by looking at a large corpus of English text (say a few million books, with altogether a few hundred billion words), we can get an estimate of how common each word is. And using this we can start generating “sentences”, in which each word is independently picked at random, with the same probability that it appears in the corpus. Here’s a sample of what we get:
Not surprisingly, this is nonsense. So how can we do better? Just like with letters, we can start taking into account not just probabilities for single words but probabilities for pairs or longer n-grams of words. Doing this for pairs, here are 5 examples of what we get, in all cases starting from the word “cat”:
It’s getting slightly more “sensible looking”. And we might imagine that if we were able to use sufficiently long n-grams we’d basically “get a ChatGPT”—in the sense that we’d get something that would generate essay-length sequences of words with the “correct overall essay probabilities”. But here’s the problem: there just isn’t even close to enough English text that’s ever been written to be able to deduce those probabilities.
In a crawl of the web there might be a few hundred billion words; in books that have been digitized there might be another hundred billion words. But with 40,000 common words, even the number of possible 2-grams is already 1.6 billion—and the number of possible 3-grams is 60 trillion. So there’s no way we can estimate the probabilities even for all of these from text that’s out there. And by the time we get to “essay fragments” of 20 words, the number of possibilities is larger than the number of particles in the universe, so in a sense they could never all be written down.
So what can we do? The big idea is to make a model that lets us estimate the probabilities with which sequences should occur—even though we’ve never explicitly seen those sequences in the corpus of text we’ve looked at. And at the core of ChatGPT is precisely a so-called “large language model” (LLM) that’s been built to do a good job of estimating those probabilities.
