Gradiënt afdaling- het meest gebruikte leeralgoritme, het wordt in vrijwel elk model gebruikt. Gradiëntafdaling is in wezen de manier waarop modellen worden getraind. Zonder GS zou machinaal leren niet zijn waar het nu is. De gradiënt-afdalingsmethode wordt, met enige aanpassingen, veel gebruikt voor leren en diep leren, en staat bekend als fouten.
In dit bericht vind je een uitleg van gradiëntafdaling met een beetje wiskunde. Samenvatting:
- De betekenis van de GS is een uitleg van het hele algoritme;
- Verschillende varianten van het algoritme;
- Code-implementatie: code schrijven in Phyton.
Wat is gradiëntafdaling
Gradiëntdaling is een methode om de minimumwaarde van een verliesfunctie te vinden (er zijn veel typen van deze functie). Het minimaliseren van een functie betekent het vinden van het diepste dal in die functie. Houd er rekening mee dat de functie wordt gebruikt om de fout in de voorspellingen van het machine learning-model te beheersen. Het vinden van het minimum betekent het kleinste krijgen mogelijke fout of het verbeteren van de nauwkeurigheid van het model. We vergroten de nauwkeurigheid door de trainingsdataset te herhalen en tegelijkertijd onze modelparameters (gewichten en biases) af te stemmen.
Er is dus een gradiëntdaling nodig om de verliesfunctie te minimaliseren.
De essentie van het algoritme is het proces waarbij de kleinste foutwaarde wordt verkregen. Op dezelfde manier kan het worden gezien als een afdaling in een depressie in een poging goud te vinden op de bodem van het ravijn (laagste foutwaarde).
Het minimum van een functie vinden In de toekomst, om het meeste te vinden lage fout(diepste depressie) in de verliesfunctie (met betrekking tot één gewicht), moet u de modelparameters aanpassen. Hoe stellen we ze op? Dit zal helpen wiskundige analyse. Door analyse weten we dat de helling van de grafiek van een functie de afgeleide is van de functie ten opzichte van de variabele. Deze helling wijst altijd naar de dichtstbijzijnde verdieping!
In de figuur zien we een grafiek van de verliesfunctie (genaamd "Error" met het symbool "J") met één gewicht. Als we nu de helling (noem dit dJ/dw) van de verliesfunctie berekenen met betrekking tot één gewicht, krijgen we de richting waarin we moeten bewegen om lokale minima te bereiken. Laten we ons nu voorstellen dat ons model slechts één gewicht heeft.
Verlies functie
Belangrijk: Terwijl we alle trainingsgegevens doorlopen, blijven we voor elk gewicht dJ/dw-waarden toevoegen. Omdat het verlies afhangt van het trainingsvoorbeeld, blijft dJ/dw ook veranderen. Vervolgens delen we de verzamelde waarden door het aantal trainingsvoorbeelden om het gemiddelde te verkrijgen. Dit gemiddelde (van elk gewicht) gebruiken we vervolgens om elk gewicht aan te passen.
Let ook op: De verliesfunctie is bedoeld om de fout bij elk trainingsvoorbeeld bij te houden, terwijl de afgeleide van de relatieve enkele gewichtsfunctie aangeeft waar het gewicht moet worden verplaatst om het voor dat trainingsvoorbeeld te minimaliseren. U kunt zelfs modellen maken zonder de verliesfunctie te gebruiken. Maar u zult de afgeleide moeten gebruiken voor elk gewicht (dJ/dw).
Nu we hebben bepaald in welke richting we het gewicht moeten duwen, moeten we uitzoeken hoe we dat moeten doen. Hier gebruiken we de leersnelheidscoëfficiënt, deze wordt een hyperparameter genoemd. Een hyperparameter is een waarde die vereist is door uw model en waar we eigenlijk maar een vaag idee van hebben. Meestal kunnen deze waarden met vallen en opstaan worden geleerd. Dit is hier niet het geval: men past op alle hyperparameters. De leersnelheidsfactor kan worden gezien als een "stap in de goede richting", waarbij de richting afkomstig is van dJ/dw.
Dit was een verliesfunctie gebouwd op één gewicht. IN echt model we doen alles hierboven vermeld voor alle gewichten, waarbij we alle trainingsvoorbeelden doornemen. Zelfs in een relatief klein machine learning-model heb je meer dan 1 of 2 gewichten. Dit maakt visualisatie moeilijk omdat de grafiek dimensies zal hebben die de geest zich niet kan voorstellen.
Meer over gradiënten
Naast de verliesfunctie vereist gradiëntdaling ook een gradiënt die dJ/dw is (de afgeleide van de verliesfunctie met betrekking tot één gewicht, uitgevoerd voor alle gewichten). dj/dw hangt af van uw keuze voor de verliesfunctie. De meest voorkomende verliesfunctie is de root mean square error.
De afgeleide van deze functie met betrekking tot elk gewicht (deze formule toont de berekening van de gradiënt voor):
Dit is alle wiskunde in GS. Als we dit bekijken, kunnen we zeggen dat de GS in wezen niet veel wiskunde bevat. De enige wiskunde die het bevat is vermenigvuldigen en delen, waar we op terug zullen komen. Dit betekent dat uw functiekeuze van invloed is op de berekening van de helling van elk gewicht.
Leersnelheidsfactor
Alles wat hierboven is geschreven, staat in het leerboek. Je kunt elk boek over gradiëntafdaling openen, daar zal hetzelfde worden geschreven. Verloopformules voor elke verliesfunctie zijn op internet te vinden, zonder dat je weet hoe je ze zelf kunt afleiden.
Het probleem met de meeste modellen is echter het leerpercentage. Laten we eens kijken naar de bijgewerkte uitdrukking voor elk gewicht (j varieert van 0 tot het aantal gewichten, en Theta-j is j-de gewicht in de vector van gewichten varieert k van 0 tot het aantal verschuivingen, waarbij B-k is k-de compensatie in de verplaatsingsvector). Hier is alfa de leersnelheidscoëfficiënt. Hieruit kunnen we zeggen dat we dJ/dTheta-j (de gradiënt van het gewicht van Theta-j) berekenen, en vervolgens de stapgrootte alpha in die richting. Daarom gaan we de helling af. Om de offset bij te werken, vervangt u Theta-j door B-k.
Als deze stapgrootte-alfa te groot is, overschrijden we het minimum: dat wil zeggen dat we het minimum missen. Als alfa te klein is, gebruiken we te veel iteraties om het minimum te bereiken. Alfa zou dus passend moeten zijn.
Gradiëntdaling gebruiken
Nou, dat is het dan. Dat is alles wat u moet weten over gradiëntafdaling. Laten we alles samenvatten in pseudocode.
Opmerking: de schalen worden hier weergegeven in vectoren. In grotere modellen zullen het waarschijnlijk matrices zijn.
Van i = 0 naar “aantal trainingsvoorbeelden”
1. Bereken de gradiënt van de verliesfunctie voor het i-de trainingsvoorbeeld voor elk gewicht en elke afwijking. Nu heb je een vector die vol is met gradiënten voor elk gewicht en een variabele die de bias-gradiënt bevat.
2. Voeg de gradiënten toe van de gewichten die zijn berekend voor een afzonderlijke accumulatieve vector, die, nadat u elk trainingsvoorbeeld hebt herhaald, de som van de gradiënten van elk gewicht over meerdere iteraties moet bevatten.
3. Voeg, vergelijkbaar met de situatie met de schalen, een bias-gradiënt toe aan de accumulatieve variabele.
Doe nu, NA het doornemen van alle trainingsvoorbeelden, het volgende:
1. Deel de cumulatieve variabelen voor gewicht en bias door het aantal trainingsvoorbeelden. Dit geeft ons de gemiddelde gradiënten voor alle gewichten en de gemiddelde gradiënt voor de bias. We zullen ze bijgewerkte batterijen (RA) noemen.
2. Gebruik vervolgens de onderstaande formule om alle gewichten en bias bij te werken. In plaats van dj / dTheta-j vervang je OA (bijgewerkte accumulator) voor gewichten en OA voor bias. Doe hetzelfde voor de compensatie.
Dit was slechts één iteratie van gradiëntafdaling.
Herhaal dit proces van begin tot eind gedurende een aantal iteraties. Dit betekent dat u voor de eerste iteratie van de GS alle trainingsvoorbeelden doorloopt, de gradiënten berekent en vervolgens de gewichten en biases bijwerkt. Dan doe je dit voor een aantal iteraties van de HS.
Verschillende soorten gradiëntafdaling
Er zijn 3 opties voor gradiëntafdaling:
1. Mini-batch: Hier verwerken we, in plaats van alle trainingsvoorbeelden te herhalen en bij elke iteratie berekeningen uit te voeren op slechts één trainingsvoorbeeld, n trainingsvoorbeelden tegelijk. Deze keuze is goed voor zeer grote datasets.
2.Stochastische gradiëntafdaling: In dit geval gebruiken we, in plaats van elk trainingsvoorbeeld te gebruiken en door te lopen, SLECHTS EENMAAL. Er zijn een paar dingen waar u op moet letten:
- Bij elke iteratie van de GS moet je de trainingsset in willekeurige volgorde afspelen en selecteren willekeurig voorbeeld opleiding.
- Omdat je maar één trainingsvoorbeeld gebruikt, zal je pad naar de lokale minima erg luidruchtig zijn, net als bij een dronken persoon die veel gedronken heeft.
3. GS-serie: Hierover is in de voorgaande paragrafen geschreven. Doorloop elk leervoorbeeld.
Afbeelding waarin 3 treffers worden vergeleken met lokale minima Voorbeeldcode in Python
Van toepassing op de GS-serie: dit is hoe een blok trainingscode in Python eruit zal zien.
Def train(X, y, W, B, alpha, max_iters): """ Voert GD uit op alle trainingsvoorbeelden, X: Trainingsgegevensset, y: Labels voor trainingsgegevens, W: Gewichtsvector, B: Biasvariabele, alpha : De leersnelheid, max_iters: Maximale GD-iteraties. """ dW = 0 # Gewichtengradiëntaccumulator dB = 0 # Biasgradiëntaccumulator m = X.shape # Nee. van voorbeelden training voor i binnen bereik(max_iters): dW = 0 # De accumulatoren resetten dB = 0 voor j binnen bereik(m): # 1. Herhaal alle voorbeelden, # 2. Bereken gradiënten van de gewichten en biases in w_grad en b_grad, # 3. Update dW door w_grad toe te voegen en dB door b_grad toe te voegen, W = W - alpha * (dW / m) # Update de gewichten B = B - alpha * (dB / m) # Update de bias-retour W, B # Retourneer de bijgewerkte gewichten en bias.
Dat is alles. Je zou nu een goed begrip moeten hebben van wat gradiëntafdaling is.
In deze lezing gaan we erover praten verschillende manieren implementatie, over hun voor- en nadelen. Ik wil het graag hebben over de drie belangrijkste soorten gradiëntafdaling: volledig, batchgewijs en stochastisch.
In de meeste voorgaande cursussen hebben we gebruik gemaakt van volledige gradiëntafdaling.
Waarom is dit zo?
Omdat het brengt meer voordeel, als we de waarschijnlijkheid voor de gehele trainingsset willen maximaliseren:
Het nadeel van deze aanpak is dat het berekenen van de gradiënt veel tijd kost, omdat deze afhankelijk is van elk voorbeeld (observatie).
Precies het tegenovergestelde is stochastische gradiëntafdaling. Het hangt van de fout af voor slechts één specifieke waarneming:
De methode is gebaseerd op het feit dat alle waarnemingen onafhankelijk en uniform verdeeld zijn, waardoor op de lange termijn de fout kleiner zal worden, omdat alle waarnemingen uit dezelfde verdeling komen. In dit geval, toen de berekeningen werden verlaagd van N opmerkingen bij 1, is een opmerkelijke verbetering van de methode.
Wat is het nadeel?
Het is een feit dat als bij volledige gradiëntdaling de logaritme van de waarschijnlijkheidsfunctie altijd verbetert bij elke iteratie, de logaritme van de waarschijnlijkheidsfunctie bij stochastische afdaling zelfs kan verslechteren. In feite zal het gedrag van de kostenfunctie chaotisch veranderen bij elke iteratie, maar op de lange termijn zal het nog steeds afnemen.
Een goed compromis tussen deze twee methoden is batchgradiëntdaling. Als we bijvoorbeeld 10.000 waarnemingen hebben, kunnen we deze verdelen in 100 batches van elk 100 observaties en de kostenfunctie berekenen op basis van elke batch bij elke iteratie:
Wat gebeurt er in dit geval met de kostenfunctie?
Het kan ook groter worden, maar zal minder chaotisch zijn dan bij puur stochastische gradiëntdaling.
En ik zou van deze gelegenheid gebruik willen maken om op te merken dat als je gratis materiaal wilt ontvangen met betrekking tot deep en machinaal leren, evenals gegevensverwerking, mijn website lazyprogrammer.me kunt bezoeken. Ik schrijf voortdurend nieuwe inhoud over deze onderwerpen, dus kom regelmatig terug. Er zou een prompt moeten zijn om u te abonneren, zodat u zich kunt abonneren op mijn gratis introductie bij gegevensverwerking. Het heeft veel geweldige bronnen om te verkennen. Python-taal, algoritmen en datastructuren, evenals kortingsbonnen voor cursussen over.
Volledige, batch- en stochastische gradiëntafdaling in code
Laten we nu de verandering in de kostenfunctie vergelijken in drie gevallen van gradiëntdaling: volledig, batch en stochastisch. Omdat in dit voorbeeld veel code uit andere bestanden is gekopieerd, zullen we de programmatekst één voor één doornemen.
Dus aan het begin van het bestand importeren we alle gebruikelijke bibliotheken. Van bestand util.py we importeren de functie get_getransformeerde_data om gegevens te transformeren met behulp van hoofdcomponentenanalyse en functies forward, error_date, cost, gradW, gradb En y2indicator.
importeer numpy als np
importeer panda's als pd
importeer matplotlib.pyplot als plt
van sklearn.utils import shuffle
van datetime importeer datetime
van util import get_transformed_data, forward, error_rate, cost, gradW, gradb, y2indicator
Om het proces te versnellen, in plaats van helemaal neuraal netwerk we gebruiken .
Dus eerst gebruiken we de functie get_getransformeerde_data, waarbij alleen de eerste 300 kolommen worden gebruikt. Vervolgens normaliseren we onze X door het gemiddelde af te trekken en te delen door de standaardafwijking. Vervolgens, sinds de functie get_getransformeerde_data onze gegevens al heeft gemengd, laten we de laatste 1.000 voorbeelden achter als testset en gebruiken we de rest als trainingsset.
zeker voornaamst():
X, Y, _, _ = get_transformed_data()
X = X[:, :300]
# normaliseer eerst X
mu = X.gemiddelde( as=0)
std = X.std( as=0)
X = (X – mu) / std
print “Logistieke regressie uitvoeren...”
Xtrein = X[:-1000,]
Ytrein = Y[:-1000]
Xtest = X[-1000:,]
N, D = Xtrain.vorm
Ytrein_ind = y2indicator(Ytrein)
Ytest_ind = y2indicator(Ytest)
Vervolgens starten we de wegingscoëfficiënten en dummytermen. Houd er rekening mee dat de geactiveerde wegingscoëfficiënten relatief klein – proportioneel – zijn ingesteld vierkantswortel van dimensie. Zelfs voordat ik deze video opnam, heb ik de leercoëfficiënt en de regularisatiestraf ingesteld op respectievelijk 0,0001 en 0,01. We stellen het aantal iteraties op 200 zodat de berekeningen niet te lang duren.
#1.vol
b = np.nul(10)
LL=
lr = 0,0001
reg = 0,01
t0 = datumtijd.nu()
voor ik erin xbereik(200):
p_y = vooruit(Xtrein, W, b)
Vervolgens werken we de waarden en vrije termen bij met behulp van gradiëntafdaling en . Wij gebruiken de functie ook vooruit om de waarde van de kostenfunctie te berekenen bij het doorlopen van de trainingsset. We zullen de foutpercentagewaarde elke tien iteraties weergeven. Bovendien zullen we de tijd weergeven die aan berekeningen is besteed, omdat een van de methoden erg snel is en de andere erg langzaam.
W += lr*(gradW(Ytrain_ind, p_y, Xtrain) – reg*W)
b += lr*(gradb(Ytrain_ind, p_y) – reg*b)
LL.toevoegen(ll)
als ik % 10 == 0:
print “Foutpercentage:”, err
p_y = vooruit(Xtest, W, b)
print “Verstreken tijd voor volledige GD:”, datetime.now() – t0
In het geval van stochastische gradiëntafdaling doen we vrijwel hetzelfde, behalve dat we slechts één keer door de gegevens gaan, omdat we bij stochastische gradiëntafdaling slechts naar één voorbeeld kijken en de gewichten en onderscheppingen bij elke doorgang afzonderlijk bijwerken en vervolgens de gegevens opnieuw rangschikken. . Omdat als je alle voorbeelden doorneemt, het programma erg langzaam zal werken, dus beperken we ons tot slechts 500 voorbeelden.
Vervolgens berekenen we, zoals gewoonlijk, de gradiënt, werken we de gewichten bij met behulp van regularisatie en berekenen we het foutenpercentage, behalve dat we alleen de waarde van de coëfficiënt afdrukken bij elke N/2-passage, omdat de berekeningen anders erg lang zullen duren. Anders is alles hetzelfde.
#2.stochastisch
W = np.willekeurig.randn(D, 10) / 28
b = np.nul(10)
LL_stochastisch =
lr = 0,0001
reg = 0,01
t0 = datumtijd.nu()
voor ik erin xbereik(1): # duurt erg lang omdat we de kosten berekenen voor 41.000 monsters
voor n-in xbereik(min(N, 500)): # snelkoppeling zodat het niet zo lang duurt...
x = tmpX.reshape(1,D)
y = tmpY.reshape(1,10)
p_y = vooruit(x, W, b)
p_y_test = vooruit(Xtest, W, b)
ll = kosten(p_y_test, Ytest_ind)
LL_stochastic.append(ll)
als n % (N/2) == 0:
err = error_rate(p_y_test, Ytest)
print “Kosten bij iteratie %d: %.6f” % (i, ll)
print “Foutpercentage:”, err
p_y = vooruit(Xtest, W, b)
afdrukken “Eind foutenpercentage:”, error_rate(p_y, Ytest)
print “Verstreken tijd voor SGD:”, datetime.now() – t0
Bij batchgradiëntafdaling is bijna alles hetzelfde. Laten we vaststellen dat elk pakket 500 voorbeelden bevat, zodat het totale aantal pakketten gelijk is aan N gedeeld door de pakketgrootte.
#3.batch
W = np.willekeurig.randn(D, 10) / 28
b = np.nul(10)
LL_batch =
lr = 0,0001
reg = 0,01
batch_sz = 500
n_batches = N/batch_sz
t0 = datumtijd.nu()
voor ik erin xbereik(50):
tmpX, tmpY = shuffle(Xtrain, Ytrain_ind)
voor j-in xbereik(n_batches):
x = tmpX
y = tmpY
p_y = vooruit(x, W, b)
W += lr*(gradW(y, p_y, x) – reg*W)
b += lr*(gradb(y, p_y) – reg*b)
p_y_test = vooruit(Xtest, W, b)
ll = kosten(p_y_test, Ytest_ind)
LL_batch.append(ll)
als j % (n_batches/2) == 0:
err = error_rate(p_y_test, Ytest)
print “Kosten bij iteratie %d: %.6f” % (i, ll)
print “Foutpercentage:”, err
p_y = vooruit(Xtest, W, b)
print “Eindfoutpercentage:”, error_rate(p_y, Ytest)
print “Verstreken tijd voor batch GD:”, datetime.now() – t0
En aan het einde tonen we al onze gegevens op het scherm.
x1 = np.linspace(0, 1, len(LL))
plt.plot(x1, LL, etiket=”vol”)
x2 = np.linspace(0, 1, len(LL_stochastisch))
plt.plot(x2, LL_stochastic, etiket=”stochastisch”)
x3 = np.linspace(0, 1, len(LL_batch))
plt.plot(x3, LL_batch, etiket=”batch”)
plt.legend()
plt.show()
als __naam__ == ‘__hoofd__’:
Laten we het programma uitvoeren.
We kunnen zien dat in het geval van stochastische gradiëntdaling de fout nauwelijks is verbeterd. Dit betekent dat er veel meer iteraties nodig zijn om verbetering te bereiken met stochastische gradiëntdaling. Zoals we kunnen zien convergeert de volledige gradiëntdaling sneller dan de batchdaling, maar werkt ook langzamer.
Als we de evolutie van de kostenfunctie op grotere schaal bekijken, kunnen we zien dat deze in het geval van een batchgradiëntdaling niet erg soepel verloopt, in tegenstelling tot een volledige gradiëntdaling waarbij de kostenfunctie soepel verandert, omdat in dit geval de kostenfunctie altijd afnemend. In het geval van stochastische gradiëntdaling verloopt de verandering in de kostenfunctie ook niet soepel:
Berichtweergaven: 588
Stuur uw goede werk naar de kennisbank is eenvoudig. Gebruik onderstaand formulier
Studenten, promovendi en jonge wetenschappers die de kennisbasis gebruiken in hun studie en werk zullen je zeer dankbaar zijn.
geplaatst op http://www.allbest.ru/
Ministerie van Onderwijs en Wetenschappen van de Russische Federatie
Autonome onderwijsinstelling van de federale staat
Hoger onderwijs
"KAZAN (VOLGA) FEDERALE UNIVERSITEIT"
HOGE SCHOOL VOOR INFORMATIETECHNOLOGIE EN INFORMATIESYSTEMEN
CURSUS WERK
Stochastische gradiëntafdaling. Implementatiemogelijkheden
Invoering
Gradiëntdaling is een methode om een lokaal extremum (minimum of maximum) van een functie te vinden door langs een gradiënt te bewegen.
Van alle lokale optimalisatiemethoden is dit het gemakkelijkst te implementeren. Het land kent vrij zwakke convergentievoorwaarden, maar het convergentiepercentage is vrij laag.
Gradient descent is een populair algoritme voor een breed scala aan machine learning-modellen, waaronder ondersteunende vectormachines, logistieke regressie en grafische modellen. Gecombineerd met het backpropagation-algoritme is het een standaardalgoritme voor het trainen van kunstmatige neurale netwerken. Stochastische gradiëntafdaling concurreert met het L-BFGS-algoritme, dat ook veel wordt gebruikt. Er werd gebruik gemaakt van stochastische gradiëntafdaling ten minste, in 1960 om lineaire regressiemodellen te trainen, aanvankelijk onder de naam Adaline.
Het doel van dit cursus werk is het overwegen van de implementatie van verschillende opties voor stochastische gradiëntdaling, de daaropvolgende vergelijking ervan, en het verduidelijken van de voor- en nadelen.
1. Stochastische gradiëntafdaling
Stochastische gradiëntafdaling is een optimalisatiealgoritme en wordt vaak gebruikt om de parameters van een machine learning-model af te stemmen.
Standaard gradiëntafdaling gebruikt een gradiënt om modelparameters te wijzigen. De gradiënt wordt doorgaans berekend als de som van de gradiënten veroorzaakt door elk trainingselement. De parametervector verandert met een gegeven stap in de richting van de antigradiënt. Daarom vereist de standaardgradiëntafdaling één doorgang door de trainingsgegevens voordat parameters kunnen worden gewijzigd.
Bij stochastische gradiëntafdaling wordt de waarde van de gradiënt benaderd door de gradiënt van de kostenfunctie berekend op slechts één trainingselement. De parameters worden vervolgens veranderd in verhouding tot de geschatte gradiënt. De modelparameters worden dus na elk leerobject gewijzigd. Voor grote datasets kan stochastische gradiëntdaling een aanzienlijk snelheidsvoordeel opleveren ten opzichte van standaard gradiëntdaling.
Er bestaat een compromis tussen deze twee soorten gradiëntdaling, ook wel "minibatch" genoemd. In dit geval wordt de gradiënt benaderd door de som voor een klein aantal trainingsmonsters.
1.1 Vereisten
Statistische schattingen en machinaal leren houden rekening met het probleem van het minimaliseren van een functie, die de vorm heeft:
waarbij de parameter die minimaliseert moet worden geschat. Elke term wordt gewoonlijk geassocieerd met de i-de observatie in de dataset (gebruikt voor training).
In de klassieke statistiek doet zich het probleem van het minimaliseren van sommen voor bij de kleinste kwadratenmethode, maar ook bij de maximale waarschijnlijkheidsmethode (voor onafhankelijke waarnemingen). De algemene klasse van schatters die voortkomt uit het minimaliseren van bedragen wordt M-schatter genoemd. In de statistiek wordt echter al lang erkend dat de eis van zelfs lokale minimalisering te restrictief is voor sommige problemen met het schatten van de maximale waarschijnlijkheid. Moderne statistische theoretici houden dus vaak rekening met stationaire punten op de waarschijnlijkheidsfunctie (nullen van de afgeleide, schattingsfunctie en andere schattingsvergelijkingen).
Het probleem van het minimaliseren van bedragen doet zich ook voor bij het minimaliseren van empirische risico's. In dit geval is dit de waarde van de verliesfunctie voor de i-set, en het empirische risico.
Bij het minimaliseren van een functie zal standaard (of "batch") gradiëntdaling de volgende iteraties uitvoeren:
waar is de stapgrootte (ook wel de leersnelheid genoemd in machine learning).
In veel gevallen heeft de summandfunctie een eenvoudig model dat eenvoudige berekeningen van de somfunctie en de som van de gradiënten omvat. In de statistiek maken exponentiële families met één parameter bijvoorbeeld economische berekeningen van functies en gradiënten mogelijk.
In andere gevallen kunnen schattingen van de totale gradiënt echter een dure schatting vereisen van de gradiënten van alle termfuncties. Wanneer de trainingsset enorm is en niet bestaat eenvoudige formules Het schatten van de som van de gradiënten wordt erg duur omdat het schatten van de gradiënt vereist dat alle gradiënten van de functies worden geëvalueerd met een sommatie. Om bij elke iteratie op de rekenkosten te besparen, is de steekproef bij stochastische gradiëntafdaling een subset van de functies van de termen bij elke stap. Dit is zeer effectief bij grootschalige machine learning-problemen.
1.2 Iteratieve methode
Bij stochastische gradiëntafdaling wordt de werkelijke gradiënt benaderd door de gradiënt in dit voorbeeld:
Terwijl het algoritme de trainingsset doorloopt, voert het de bovenstaande updates uit voor elk trainingsvoorbeeld. Er kunnen meerdere passages over de trainingsset worden gemaakt totdat het algoritme convergeert. Gegevens kunnen voor elke doorgang worden geschud om lussen te voorkomen. Typische implementaties kunnen een adaptieve leersnelheid gebruiken, zodat het algoritme convergeert.
In pseudocode kan stochastische gradiëntafdaling als volgt worden weergegeven:
1) Selecteer de initiële parametervector en leersnelheid.
2) Herhaal totdat het minimum ongeveer is bereikt:
2.1) Schud de voorbeelden in de trainingsset willekeurig.
2.2) Voor i = 1,2,...,n, doe:
De convergentie van stochastische gradiëntafdaling werd geanalyseerd met behulp van de theorie van convexe minimalisatie en stochastische benadering. Wanneer het leertempo met een passend tempo afneemt, en onder relatief zwakke aannames, convergeert de stochastische gradiëntdaling naar een globaal minimum wanneer de functie convex of pseudoconvex is, en convergeert anders naar een lokaal minimum.
1.3 Implementatiemogelijkheden
Er zijn veel verbeteringen voorgesteld en gebruikt ten opzichte van de basismethode voor stochastische gradiëntdaling. Met name bij machinaal leren is de noodzaak om de leersnelheid (stapgrootte) in te stellen problematisch gebleken.
Als u deze parameter te groot instelt, kan het algoritme afwijken. Als het andersom is, zal het algoritme langzaam convergeren.
Een conceptueel eenvoudige uitbreiding van de stochastische gradiëntafdaling zorgt ervoor dat de leersnelheid een afnemende functie wordt, afhankelijk van het aantal iteraties m.
Nadat deze bewerking is uitgevoerd, is het duidelijk dat de eerste iteraties grote veranderingen in de parameters veroorzaken, terwijl de latere iteraties alleen maar fijnafstemming bewerkstelligen.
In het kader van dit werk zullen de volgende opties voor het implementeren van stochastische gradiëntdaling worden overwogen:
1. 4 Momentum
Momentum, ook wel de momentummethode genoemd, is afkomstig van de Amerikaanse psycholoog David Ramelhart, maar ook van het werk van Geoffrey Hinton en Ronald J. William's onderzoek naar de backpropagation-methode. Stochastische gradiëntafdaling met momentum onthoudt de updates bij elke iteratie en bepaalt de volgende update als een lineaire combinatie van de gradiënt en de vorige update:
Dat leidt tot:
waarbij de parameter die minimaliseert moet worden geschat en de stapgrootte (ook wel de leersnelheid genoemd in machine learning).
De naam impuls komt van een analogie met impuls in de natuurkunde: een gewichtsvector. Het idee dat de beweging van een materieel punt door de parameterruimte een versnelling met zich meebrengt als gevolg van de kracht, de verliesgradiënt.
In tegenstelling tot de klassieke stochastische gradiëntafdalingsmethode heeft deze de neiging de beweging in één richting te houden, waardoor oscillaties worden voorkomen. Momentum wordt al tientallen jaren met succes gebruikt.
1.5 AdaGrad
AdaGrad is een gemodificeerde stochastische gradiëntafdaling met voorlopige parameter leersnelheid. Voor het eerst gepubliceerd in 2011. Informeel verhoogt het de leersnelheid voor de meer schaarse parameters en verlaagt het de leersnelheid voor de minder schaarse parameters. Deze strategie vergroot vaak de kans op convergentie standaard algoritme stochastische gradiëntdaling op plaatsen waar gegevens schaars zijn en zeldzame parameters informatiever zijn.
Voorbeelden van dergelijke toepassingen zijn onder meer natuurlijke taalverwerking en patroonherkenning.
Het heeft nog steeds een leersnelheidsbasis, maar wordt vermenigvuldigd met de elementen van een vector die de diagonaal is van het tensorproduct van de matrix.
waar is de gradiënt bij iteratie m.
De diagonaal wordt gespecificeerd als:
De vector wordt na elke iteratie bijgewerkt. De updateformule ziet er nu als volgt uit:
of geschreven als een voorlopige parameterupdate,
Elk vergroot de schaalbaarheid van de leersnelheidsfactor die op een enkele parameter wordt toegepast.
Omdat de noemer de Euclidische norm is van de voorgaande afgeleiden, zijn de marginale waarden van de updateparameters beperkt, terwijl de parameters die kleine updates hebben gehad een hoger leerniveau krijgen.
Terwijl er werd gewerkt aan convexe optimalisatieproblemen, werd AdaGrad met succes toegepast op niet-convexe optimalisatieproblemen.
1.6 RMSProp
RMSProp is ook een methode waarbij het leertempo voor elk van de parameters wordt aangepast. Het idee is om de leersnelheid voor een bepaald gewicht te delen door een voortschrijdend gemiddelde van de laatste gradiënten voor dat gewicht. Het eerste voortschrijdend gemiddelde wordt dus berekend als een vierkant:
waar is de exponentiële wegingsparameter, of de parameter "vergeetfactor".
De parameters worden bijgewerkt met behulp van de onderstaande formule:
RMSProp heeft een uitstekende aanpassing van de leersnelheden in verschillende toepassingen laten zien. RMSProp kan worden beschouwd als een generalisatie van Rprop en kan ook werken met een variant van gradiëntdaling als mini-batch, die in tegenstelling is tot reguliere gradiëntdaling.
2. Implementatie van stochastische gradiëntafdaling
Op in dit stadium implementaties van verschillende varianten van stochastische gradiënt zullen in de vorm worden uitgevoerd programmacode in de programmeertaal Python.
2.1 Implementatie van standaard stochastische gradiëntafdaling
Ten eerste heb je een dataset nodig. In dit geval wordt een dataset gemaakt met behulp van de Scikit-Learn-bibliotheek:
gradiënt stochastisch algoritme leren
vanuit sklearn.datasets importeer make_moons
vanuit sklearn.cross_validation importeer train_test_split
X, y = make_moons(n_samples=5000, willekeurige_status=42, ruis=0,1)
X_train, X_test, y_train, y_test = train_test_split(X, y, willekeurige_status=42)
Dit is wat we hebben:
Foto 1 - Grafische weergave gegevensset
Vervolgens wordt het neurale netwerkmodel bepaald. Dit zijn drie lagen van het netwerk (één verborgen laag):
importeer numpy als np
def make_network(n_hidden=100):
model = dict(W1=np.random.randn(n_feature, n_hidden),
W2=np.random.randn(n_verborgen, n_klasse)
Het definieert ook twee bewerkingen: voorwaartse voortplanting en achterwaartse voortplanting. Laten we eerst de eerste optie doen:
retourneer np.exp(x) / np.exp(x).sum()
def vooruit(x, model):
h = x @model["W1"]
prob = softmax(h @ model["W2"])
Het circuit moet een reeks punten maken van de invoer naar de verborgen laag en vervolgens naar de uitvoerlaag. In de verborgen laag kan ook niet-lineariteit worden toegepast, zodat het neurale netwerk een niet-lineaire beslissingsgrens kan voorspellen. Een prominente vertegenwoordiger van een niet-lineaire functie van vandaag is ReLU.
ReLU wordt gedefinieerd als f(x)=max(0,x), maar in plaats van np.max(0, x) te doen, is er een handige implementatietruc: x = 0.
Zodra de uitvoerlaag is bereikt, moet de uitvoer zodanig zijn dat de Bernoulli-kansverdeling nauwkeurig is, dus wordt de uitvoer gedecomprimeerd met behulp van de SoftMax-functie om de gegeven verdeling te verkrijgen.
Nu is de tweede bewerking gedefinieerd. Backpropagatie ziet er als volgt uit:
def achteruit (model, xs, hs, errs):
dW2 = hs.T @ fout
dh = errs @ model["W2"].T
dh = 0
return dict(W1=dW1, W2=dW2)
De basis van het algoritme is gecreëerd. De sgd-functie wordt geïmplementeerd. Het ziet er zo uit:
def sgd(model, X_train, y_train, batch_size):
voor iter binnen bereik(n_iter):
print("Iteratie ()".format(iter))
X_train, y_train = shuffle(X_train, y_train)
voor i binnen bereik(0, X_train.shape, batch_size):
X_trein_mini = X_trein
y_trein_mini = y_trein
model = sgd_step(model, X_train_mini, y_train_mini)
retourmodel
De functie sgd_step wordt geïmplementeerd. Het ziet er zo uit:
def sgd_step(model, X_train, y_train):
grad = get_batch_grad(model, X_train, y_train)
model = model.kopie()
voor laag in gradiënt:
model += leersnelheid * grad
De get_batch_grad-functie wordt geïmplementeerd. Het ziet er zo uit:
def get_batch_grad(model, X_train, y_train):
xs, hs, errs = , ,
voor x, cls_idx in zip(X_train, y_train):
h, y_pred = vooruit(x, model)
y_true = np.nul(n_klasse)
y_waar = 1.
fout = y_true - y_pred
errs.append(err)
terug naar achteren(model, np.array(xs), np.array(hs), np.array(errs))
In deze functie wordt elk gegevenspunt in batch herhaald en vervolgens naar het netwerk verzonden en wordt het resultaat van het echte label dat door de trainingsgegevens is verkregen, vergeleken. De fout wordt bepaald door het verschil tussen de waarschijnlijkheid van het echte label en de waarschijnlijkheid van onze voorspelling.
2.2 Implementatie van Momentum
Momentum werkt volgens het principe van de fysieke bewegingswet, het gaat door lokale optima (kleine heuvels). Door momentum toe te voegen zal het algoritme sneller convergeren, omdat de snelheid toeneemt en de methodestap groter kan zijn dan de constante stap bij een conventionele methode.
Aangezien de programmasjabloon al gereed is, hoeft u alleen de hoofdfunctie van deze methode te implementeren. De momentumfunctie wordt hieronder gegeven:
def momentum(model, X_train, y_train, batch_size):
snelheid = (k: np.zeros_like(v) voor k, v in model.items())
gamma = 0,9
X_mini, y_mini = batches
voor laag in gradiënt:
snelheid = gamma * snelheid + alpha * gradiënt
model += snelheid
Er wordt een nieuwe snelheidsvariabele ingeschakeld die het momentum voor elke parameter accumuleert. De variabele wordt bij elke nieuwe stap in de gradiëntdaling bijgewerkt met de term alpha*grad. Er is ook een lichte afname in de waarde van de snelheidsvariabele, die in de vorige stap werd berekend met behulp van de gammacoëfficiënt.
2.3 Implementatie van AdaGrad
Tot nu toe werd de leersnelheid alfa genegeerd omdat deze constant was. Het probleem doet zich voor dat de leersnelheid alle parameters beïnvloedt en dat het algoritme niet altijd efficiënt werkt bij een constante leersnelheid. AdaGrad kan een oplossing voor dit probleem zijn.
Bij gebruik van AdaGrad vindt het bijwerken van parameters puntsgewijs plaats, dus de leersnelheid is een adaptieve parameter.
De implementatie van deze methode is in uitvoering. Het hele programma is klaar, je hoeft alleen de hoofdfunctie te wijzigen. Het zal adagrad heten. De functie wordt hieronder weergegeven:
def adagrad(model, X_train, y_train, batch_size):
batches = get_batch(X_train, y_train, batch_size)
voor iter binnen bereik(1, n_iter + 1):
idx = np.random.randint(0, len(batches))
X_mini, y_mini = batches
grad = get_batch_grad(model, X_mini, y_mini)
cache[k] += graad[k]**2
retourmodel
Je kunt zien dat het leertempo normaliseert. Het kan nu groter of kleiner zijn, afhankelijk van hoe de nieuwste gradiënten zich gedragen.
2.4 Implementatie van RMSProp
Je kunt zien dat in het cumulatieve deel van Adagrad de waarde cache[k] += grad[k]**2 monotoon toeneemt als gevolg van de som en het kwadraat. Dit kan problematisch zijn, omdat het leertempo monotoon zal afnemen tot een zeer klein leertempo.
Om dit probleem tegen te gaan, ontleedt RMSProp de in het verleden verzamelde gradiëntwaarde, zodat slechts een deel van de laatste gradiënten in aanmerking wordt genomen. In plaats van rekening te houden met de nieuwste gradiënten, gedraagt RMSProp zich nu als een voortschrijdend gemiddelde.
De implementatie van deze methode is in uitvoering. Het hele programma is klaar, je hoeft alleen de hoofdfunctie te wijzigen. Het zal rmsprop heten. De functie wordt hieronder weergegeven:
def rmsprop(model, X_train, y_train, batch_size):
cache = (k: np.zeros_like(v) voor k, v in model.items())
gamma = 0,9
batches = get_batch(X_train, y_train, batch_size)
voor iter binnen bereik(1, n_iter + 1):
idx = np.random.randint(0, len(batches))
X_mini, y_mini = batches
grad = get_batch_grad(model, X_mini, y_mini)
cache[k] = gamma * cache[k] + (1 - gamma) * (grad[k]**2)
model[k] += alpha * grad[k] / (np.sqrt(cache[k]) + eps)
Het belangrijkste verschil zit in het berekenen van de cache[k]-waarde en nu zal de geaccumuleerde gradiëntwaarde niet agressief monotoon toenemen.
3. Testen en vergelijken
In dit hoofdstuk wordt de implementatie getest en de verkregen resultaten geanalyseerd.
3.1 Testen van standaard stochastische gradiëntafdaling
In dit stadium zal de standaard stochastische gradiëntafdaling worden getest. De procedure wordt 100 keer uitgevoerd en vervolgens wordt de gemiddelde nauwkeurigheid berekend.
n_experiment = 100
accs = np.nul(n_experiment)
voor k binnen bereik(n_experiment):
model = make_netwerk()
model = sgd(model, X_train, y_train, minibatch_size)
probe = vooruit(x, model)
y = np.argmax(waarschijnlijk)
Na voltooiing deze code, Ik heb de volgende waarden:
Gemiddelde nauwkeurigheid: 0,8765040000000001
We kunnen dus concluderen dat de gemiddelde uitvoeringsnauwkeurigheid 87% bedraagt.
3.2 Momentum testen
In dit stadium zal de stochastische gradiëntafdaling worden getest op basis van de Momentum-implementatie. De procedure wordt 100 keer uitgevoerd en vervolgens wordt de gemiddelde nauwkeurigheid berekend.
Het testprogramma vindt u hieronder:
n_experiment = 100
accs = np.nul(n_experiment)
voor k binnen bereik(n_experiment):
model = make_netwerk()
model = momentum(model, X_train, y_train, minibatch_size)
y_pred = np.zeros_like(y_test)
voor i, x in opsomming(X_test):
probe = vooruit(x, model)
y = np.argmax(waarschijnlijk)
accs[k] = (y_pred == y_test).sum() / y_test.size
print("Gemiddelde precisie: (), Ontvangen waarde: ()". format(accs.mean(), accs.std()))
Gemiddelde nauwkeurigheid:
1) 0,3152, met alfa = 0,5
2) 0,8554666666666666, met alfa = 1e-2
3) 0,8613333333333334, met alfa = 1e-5
We kunnen dus concluderen dat bij lagere waarden van de leersnelheid de uitvoeringsnauwkeurigheid merkbaar hoger is.
3.3 Testen AdaGrad
In dit stadium zullen we de stochastische gradiëntafdaling testen op basis van de AdaGrad-implementatie. De procedure wordt 100 keer uitgevoerd en vervolgens wordt de gemiddelde nauwkeurigheid berekend.
Het testprogramma vindt u hieronder:
n_experiment = 100
accs = np.nul(n_experiment)
voor k binnen bereik(n_experiment):
model = make_netwerk()
model = adagrad(model, X_train, y_train, minibatch_size)
y_pred = np.zeros_like(y_test)
voor i, x in opsomming(X_test):
probe = vooruit(x, model)
y = np.argmax(waarschijnlijk)
accs[k] = (y_pred == y_test).sum() / y_test.size
print("Gemiddelde precisie: (), Ontvangen waarde: ()". format(accs.mean(), accs.std()))
Door deze code uit te voeren worden de volgende waarden verkregen:
Gemiddelde nauwkeurigheid:
1) 0,8754666666666667, met alfa = 0,5
2) 0,8786666666666667, met alfa = 1e-2
3) 0,504, met alfa = 1e-5
We kunnen dus concluderen dat bij zeer lage waarden van de leersnelheid de nauwkeurigheid van de uitvoering aanzienlijk wordt verminderd.
3.4 RMSProp testen
In dit stadium zal de stochastische gradiëntafdaling worden getest op basis van de RMSProp-implementatie. De procedure wordt 100 keer uitgevoerd en vervolgens wordt de gemiddelde nauwkeurigheid berekend.
Het testprogramma vindt u hieronder:
n_experiment = 100
accs = np.nul(n_experiment)
voor k binnen bereik(n_experiment):
model = make_netwerk()
model = rmsprop(model, X_train, y_train, minibatch_size)
y_pred = np.zeros_like(y_test)
voor i, x in opsomming(X_test):
probe = vooruit(x, model)
y = np.argmax(waarschijnlijk)
accs[k] = (y_pred == y_test).sum() / y_test.size
print("Gemiddelde precisie: (), Ontvangen waarde: ()". format(accs.mean(), accs.std()))
Door deze code uit te voeren worden de volgende waarden verkregen:
Gemiddelde nauwkeurigheid:
1) 0,8506666666666667, met alfa = 0,5
2) 0,8727999999999999, met alfa = 1e-2
3) 0,30693333333333334, met alfa = 1e-5
We kunnen dus concluderen dat bij zeer lage waarden van de leersnelheid de nauwkeurigheid van de uitvoering, vergelijkbaar met AdaGrad, aanzienlijk wordt verminderd.
Conclusie
Van vergelijkende analyse Het is duidelijk dat bij gebruik van een hoog leertempo, methoden met een adaptief leertempo beter presteren dan methoden met constante snelheid opleiding.
Het tegenovergestelde gebeurt echter wanneer een kleine leersnelheidswaarde wordt gebruikt, zoals 1e-5. Voor standaard versie stochastische gradiëntafdaling en de momentummethode, waarden die klein genoeg zijn, zorgen ervoor dat ze goed werken. Aan de andere kant, als de leersnelheid erg klein is en deze is genormaliseerd adaptieve methoden Het leertempo wordt zelfs nog kleiner, wat de snelheid van de convergentie beïnvloedt. Dit maakt de training erg traag en deze methoden presteren slechter dan de standaard stochastische gradiëntdaling met hetzelfde aantal iteraties.
Lijst met gebruikte bronnen
1. Machinelearning - stochastische gradiëntafdaling
2. Kunstmatige intelligentie in het Russisch - Gradiëntafdalingen
3. Wiki-tutorial - Implementaties van algoritmen/Gradient-afdaling
4. Stanford University - Adaptieve subgradiëntmethoden
5. Cambridge University Press - Online algoritmen en stochastische benaderingen
6. Sanjoy Dasgupta en David Mcallester - Over het belang van initialisatie en momentum in diep leren[Elektronische hulpbron].
Geplaatst op Allbest.ru
...Soortgelijke documenten
Noodzakelijke voorwaarden voor een extremum. Ontwikkeling machine-algoritme en multidimensionale optimalisatieprogramma's voor de gradiëntmethode met behulp van de uniforme zoekmethode. Het controleren van de noodzakelijke en voldoende voorwaarden voor een extremum voor het gevonden minimumpunt.
cursuswerk, toegevoegd op 25-09-2013
Software-implementatie computertoepassingen gespecificeerde functies. De procedure voor het vinden van het minimum van een functie. Toepassing van Hooke-Jeeves en gradiënt-afdalingsmethoden om het probleem op te lossen. Studie van een functie in de buurt van een basispunt, bepaling van de coördinaten ervan.
test, toegevoegd op 02/02/2014
Optimalisatie van de probleemoplossing met behulp van het annealing-algoritme. Analyse van optimalisatietheorie als objectieve functie. Gradiënt-afdalingsmethode. Variabelen en beschrijving van het gloei-algoritme. Weergave van het handelsreizigersprobleem via een grafiek. Het probleem reduceren tot variabelen en het oplossen.
cursuswerk, toegevoegd op 21/05/2015
Training van het eenvoudigste en meerlaagse kunstmatige neurale netwerk. Perceptron-trainingsmethode gebaseerd op het principe van gradiëntafdaling langs het foutoppervlak. Implementatie binnen softwareproduct NeuroPro 0,25. Met behulp van het backpropagation-algoritme.
cursuswerk, toegevoegd 05/05/2015
Een probleem oplossen met betrekking tot het maximaliseren van functies van verschillende variabelen. Beschrijving van de dichotomiemethode, de toepassing ervan voor het oplossen van niet-lineaire vergelijkingen. Dit probleem wordt opgelost met behulp van de coördinatenafdalingsmethode. Algoritmen opstellen, programma's opsommen.
cursuswerk, toegevoegd 10/01/2009
Objectidentificatie met behulp van de kleinste kwadratenmethode. Analyse van paar-, gedeeltelijke en meervoudige correlatiecoëfficiënten. Constructie van een lineair model en een model met gedistribueerde parameters. Iteratieve numerieke methode voor het vinden van de wortel (nul) van een bepaalde functie.
cursuswerk, toegevoegd op 20-03-2014
Basis van de gebruikstechnologie software pakket LabVIEW, voordelen van het systeem. Programmering gebaseerd op dataflow-architectuur. Methoden voor het vinden van het extremum. Gebruik de Gauss-Seidel-methode om het maximum van een tweedimensionale functie te vinden.
test, toegevoegd op 18-03-2011
Doel en classificatie van methoden voor zoekmachineoptimalisatie. Efficiëntie zoekmethode. Zero-order zoekmethoden: inputs, voorwaarden, nadelen en toepassingen. Structuur van de gradiëntzoekmethode. Het hoofdidee van de steilste afdalingsmethode.
lezing, toegevoegd 03/04/2009
Verklaring van het probleem en de formalisering ervan. Het vinden van de waarden van het interpolatiepolynoom op de punten x1 en x2. Het minimum van de functie F(x) op het segment vinden. Controle van de convergentievoorwaarden van methoden. Testen softwaremodules. Gedetailleerd diagram van het algoritme.
cursuswerk, toegevoegd op 02/04/2011
Numerieke methoden voor problemen zonder beperkingen. Schema van afdalingsmethoden. Editor-omgeving Visuele basis. ActiveX-objecten gebruiken in formulieren. Stroomschema van het simulatie-algoritme. Optimalisatieproblemen voor deterministische functies met een enkel extremumpunt.
U heeft dus de taak om een bepaalde waarde, zoals de kosten van een huis, te voorspellen op basis van de grootte ervan. Of de tijd die uw systeem nodig heeft om een verzoek te verwerken. Je weet maar nooit.
U heeft besloten lineaire regressie te gebruiken en wilt nu de coëfficiënten vinden waarbij het verschil tussen de prijs die uw model voorspelt en de werkelijke kosten van verkochte woningen minimaal zal zijn. Om dit te doen, kunt u een van deze methoden gebruiken:
- Batchgradiëntafdaling
- Stochastische gradiëntdaling
- Normale vergelijkingen
- Newton's methode (Newton's methode)
Vandaag zullen we het hebben over twee soorten gradiëntafdaling.
Gradiënt afdaling
Wat is gradiëntafdaling eigenlijk?
Stel je een paar voor complexe functie uit één variabele. Het kent enkele hoogtepunten en dieptepunten. Op elk punt van deze functie kunnen we de afgeleide nemen:
De groene lijn laat zien dat de afgeleide op dit punt positief zal zijn, de rode lijn zal negatief zijn.
Selecteer een willekeurig punt op de functie. U wilt "naar beneden gaan" naar het dichtstbijzijnde minimum op dat punt. Als de afgeleide op jouw punt positief is (groene lijn), betekent dit dat het minimum “achter” je ligt, en om daar naar toe te gaan, moet je aftrekken van de coördinaat van jouw punt X de waarde van uw derivaat.
Als op jouw punt de afgeleide negatief is (rode lijn), betekent dit dat het minimum “voor” je ligt, en om daar te komen, moet je opnieuw aftrekken van de coördinaat X de waarde van uw derivaat. De waarde ervan is negatief, en daarom vergroot u de coördinaat door een negatieve waarde af te trekken X.
Om ervoor te zorgen dat de afdaling niet pijnlijk lang of ten onrechte snel is, vermenigvuldigt u de waarde van uw afgeleide op het geselecteerde punt met een bepaalde coëfficiënt.
Maar dit geldt allemaal voor het geval dat de functie afhankelijk is van één coördinaat. In het geval van ons model voor het verkopen van huizen is de waardefunctie afhankelijk van twee variabelen.
Je kunt deze functie beschouwen als een "beker" in de 3D-ruimte:
De afgeleide van functies van verschillende variabelen wordt een gradiënt genoemd. Een gradiënt is een vector met een dimensie van het aantal variabelen, waarbij elk element van de vector een afgeleide is van één variabele.
Onze kostenfunctie is:
De gradiënt wordt aangegeven als en wordt berekend met behulp van de volgende formule:
In elke partiële afgeleide beschouwen we deze als een functie van één variabele. We beschouwen alle andere variabelen als constanten, daarom zullen hun afgeleiden gelijk zijn aan nul:
Daarna werken we elke waarde bij met behulp van de formule:
De parameter wordt de leersnelheid genoemd en bepaalt hoe snel we verder gaan minimale waarde functies. Met elke update van parameters zetten we een kleine stap richting het minimum. Hierna herhalen we de procedure. Tegelijkertijd kijken we hoeveel de waarde van de kostenfunctie is veranderd ten opzichte van de vorige stap. Wanneer deze verandering erg klein wordt (we zetten de tijd stil), kunnen we stoppen en bedenken dat we het minimumpunt hebben bereikt.
Het is alsof je van een heuvel naar een nabijgelegen vallei loopt. Met gradiëntdaling kunt u een lokaal minimum vinden, maar geen globaal minimum. Dit betekent dat als er verschillende punten zijn waarop uw functie minimaal is, de gradiëntafdaling u naar een van deze punten zal brengen: het punt dat het dichtst bij het startpunt ligt, maar niet noodzakelijkerwijs de diepste kloof.
Vóór de allereerste stap bepalen we de parameters willekeurig, en hoe we ze precies bepalen, bepaalt in welk minimum we zullen vallen:
Hier tussen haakjes moet worden opgemerkt dat het bovenstaande betrekking heeft op gradiëntafdaling in algemeen beeld, maar gaat niet specifiek in op gradiëntdaling voor lineaire regressie. De lineaire regressiekostenfunctie is convex en heeft slechts één minimum (denk aan een 3D-beker), dus de gradiëntafdaling zal dit altijd vinden.
Hoe dichter u bij het minimum van de kostenfunctie komt (hoe kleiner het verschil tussen de voorspelde prijs en de werkelijke prijs), hoe beter uw rechte lijn uw historische gegevens beschrijft:
Als er niet veel historische voorbeelden zijn, is alles in orde, maar als er miljoenen zijn, moeten we voor elke kleine stap richting het minimum miljoenen berekeningen uitvoeren, en dit kan lang duren.
Een alternatief hiervoor zou kunnen zijn stochastische gradiënt afdaling is een methode waarbij we één voorbeeld nemen en de waarden alleen op basis daarvan bijwerken. Vervolgens nemen we het volgende voorbeeld en werken we de parameters bij, waarbij we ons daarop concentreren. Enzovoort. Dit leidt ertoe dat we niet altijd vanaf de heuvel "afdalen", soms doen we een stap omhoog of opzij, maar vroeg of laat bereiken we dat minimum en beginnen er omheen te cirkelen. Wanneer de waarden bij ons beginnen te passen (de nauwkeurigheid bereiken die we nodig hebben), stoppen we de afdaling.
In pseudocode ziet de stochastische gradiëntafdaling er als volgt uit:
Totdat de kostenfunctieverandering klein is: (
Voor j:= 1 tot m (
Ten slotte de convergentiekenmerken van het algoritme: batchgradiëntdaling convergeert altijd naar een minimum, op voorwaarde dat een voldoende kleine waarde wordt gebruikt. Stochastische gradiëntdaling convergeert in het algemeen niet naar een minimum, maar er zijn wijzigingen daarin die het mogelijk maken convergentie te bereiken.
