Waar F i – functie berekend op de i-de batch, i wordt willekeurig geselecteerd;

De leerstap is een hyperparameter; als de waarden te groot zijn, zal het leeralgoritme uiteenlopen;

Stochastische gradiëntafdaling met traagheid

Bij de stochastische gradiëntafdalingsmethode is het niet ongebruikelijk dat de gradiënt bij elke iteratie in grote mate verandert. Dit komt doordat de functionaliteit wordt berekend op basis van verschillende gegevens, die aanzienlijk kunnen verschillen. Deze verandering kan worden afgevlakt door gebruik te maken van gradiënten die in eerdere iteraties zijn berekend en geschaald met de traagheidshyperparameter μ:

	(14)
	(15)

Zoals je misschien wel vermoedt, heeft de traagheidshyperparameter μ deze naam gekregen vanwege het feit dat, net als de zogenaamde Newtoniaanse traagheidskracht, d.w.z. tegenkracht, “weerstaat” veranderingen in de gradiënt en verzacht veranderingen in wegingscoëfficiënten tijdens de training. Dit leeralgoritme wordt stochastische gradiëntafdaling met momentum of SGDM (stochastische gradiëntafdaling met momentum) genoemd.

Adaptieve gradiëntmethode

De adaptieve gradiëntmethode (Adagrad - van het Engelse ‘adaptive gradiëntalgoritme’) is gebaseerd op het idee van schaling. Het herschaalt de leersnelheid voor elke afstembare parameter afzonderlijk, waarbij rekening wordt gehouden met de geschiedenis van alle eerdere gradiënten voor die parameter. Om dit te doen, wordt elk gradiëntelement gedeeld door de vierkantswortel van de som van de kwadraten van de voorgaande corresponderende gradiëntelementen. Deze aanpak vermindert effectief de leersnelheid voor die gewichten die een grote gradiëntwaarde hebben, en vermindert ook de leersnelheid voor alle parameters in de loop van de tijd, aangezien de som van de kwadraten gestaag toeneemt voor alle parameters bij elke iteratie. Bij het instellen van een initiële schaalparameter g = 0, heeft de formule voor het herberekenen van de wegingscoëfficiënten de vorm (deling wordt element voor element uitgevoerd).

De stochastische gradiënt wordt geschat met de formule:

dat wil zeggen, het is de som van alle willekeurige vectoren met gewichten die gelijk zijn aan de stappen van de functie die in gegeven willekeurige richtingen worden geminimaliseerd.

Als we eenheidsvectoren als parameters nemen, dan geeft deze schatting, zoals gemakkelijk te zien is uit (3.3.22), de exacte waarde van de gradiënt.

Beide beschreven gradiëntschattingen kunnen effectief worden gebruikt voor alle waarden, inclusief en die ze aanzienlijk onderscheiden van de deterministische schattingsmethode (3.3.22), waarvoor strikt dezelfde omstandigheid bevestigt dat deterministische methoden worden gegeneraliseerd naar willekeurige methoden (zie het einde van paragraaf 3.3.1). Laten we nog een voorbeeld geven van een dergelijke generalisatie.

Gradient search (3.3.21) is een speciaal geval van ten minste twee willekeurige zoekalgoritmen. Eerste algoritme:

waar is nog steeds een willekeurige dimensionale eenheidsvector. Dit is een bekend willekeurig gradiëntzoekalgoritme. Het tweede algoritme heeft de vorm (3.3.23), maar de gradiëntschatting wordt berekend met behulp van de formule

Wanneer, zoals gemakkelijk te zien is, beide algoritmen degenereren tot een gradiëntzoekalgoritme (3.3.21).

Willekeurig zoeken is dus een natuurlijke uitbreiding, voortzetting en generalisatie van bekende reguliere zoekmethoden.

Een ander kenmerk van willekeurig zoeken, dat ruime mogelijkheden biedt voor effectief gebruik ervan, is het gebruik van de willekeurige stapoperator als een stochastisch model van complexe reguliere operatoren voor het vinden van zoekrichtingen in de ruimte van geoptimaliseerde parameters.

Het willekeurige zoekalgoritme met lineaire tactieken (3.3.12) is dus een stochastisch model van het algoritme met de steilste afdaling:

waarin een willekeurige vector de schatting van de gradiënt modelleert. Het is merkwaardig dat een dergelijke ‘schatting’ niet eens ruw kan worden genoemd, aangezien de stochastische eigenschappen ervan niet lijken op de eigenschappen van de geschatte gradiënt. Zoals hierboven weergegeven, is het willekeurige zoekalgoritme echter niet alleen efficiënt, maar in sommige gevallen ook efficiënter dan het algoritme met de steilste afdaling. Hier

de willekeurige stapoperator vervangt de omslachtige operator voor het schatten van de gradiënt, bijvoorbeeld volgens formule (3.3.22).

Het volgende kenmerk van willekeurig zoeken dat het gunstig onderscheidt van reguliere methoden is de globaliteit ervan, die zich vooral manifesteert in lokale willekeurige zoekalgoritmen die niet bedoeld zijn om een ​​globaal extremum te vinden. Het willekeurige afdalingsalgoritme kan dus een globaal extremum vinden, maar het reguliere steilste afdalingsalgoritme staat deze mogelijkheid in principe niet toe, omdat het is ontworpen om een ​​lokaal extremum te vinden.

Bijgevolg is het mondiale karakter van willekeurige zoekalgoritmen een soort ‘premie’ voor het gebruik van willekeur en zoiets als een ‘gratis toepassing’ van het algoritme. Deze omstandigheid is vooral belangrijk bij het optimaliseren van objecten met een onbekende structuur, wanneer er geen volledig vertrouwen is in de één-extremale aard van het probleem en de aanwezigheid van verschillende extrema mogelijk is (hoewel niet verwacht). Het gebruik van mondiale zoekmethoden zou in dit geval een onredelijke verspilling zijn. Lokale willekeurige zoekmethoden zijn hier het meest geschikt, omdat ze effectief een lokaal probleem oplossen en in principe een mondiaal probleem kunnen oplossen, als dat zich voordoet. Dit biedt willekeurige zoekopdrachten een soort psychologische betrouwbaarheid die door gebruikers zeer wordt gewaardeerd.

De algoritmische eenvoud van willekeurig zoeken maakt het vooral aantrekkelijk voor consumenten. De ervaring leert dat de bekende willekeurige zoekalgoritmen slechts een ‘canvas’ zijn waarop de gebruiker, in elk specifiek geval, ‘patronen’ van nieuwe algoritmen ‘borduurt’ die niet alleen zijn smaak en neigingen weerspiegelen (die niet kunnen worden genegeerd), maar ook de specifieke kenmerken van het object dat wordt geoptimaliseerd. Dit laatste schept een gunstige basis voor de implementatie van het bekende principe dat het algoritme ‘voor het object’ moet worden ontworpen. Ten slotte bepaalt de algoritmische eenvoud van willekeurig zoeken de eenvoud van de hardware-implementatie ervan. Dit maakt het niet alleen mogelijk om eenvoudige, compacte en betrouwbare optimizers te bouwen met een onbeperkt aantal geoptimaliseerde parameters, maar maakt het ook vrij eenvoudig om hun optimale synthese op een computer te organiseren.

Uw goede werk indienen bij 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. Stochastische gradiëntafdaling wordt al sinds 1960 gebruikt om lineaire regressiemodellen te trainen, aanvankelijk onder de naam Adaline.

Het doel van dit cursuswerk is het overwegen van de implementatie van verschillende opties voor stochastische gradiëntafdaling, 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ëntdaling 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 groot is en er geen eenvoudige formules bestaan, wordt het schatten van de som van de gradiënten erg duur, omdat het schatten van de gradiënt vereist dat alle gradiënten van de functies door middel van summand worden geschat. 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:

Wat 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 momentum 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 een vooraf ingestelde 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 verbetert vaak de waarschijnlijkheid van convergentie in vergelijking met het standaard stochastische gradiëntdalingsalgoritme op plaatsen waar de gegevens schaars zijn en de schaarse 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ëntafdaling, zoals mini-batch, die in tegenstelling is tot reguliere gradiëntafdaling.

2. Implementatie van stochastische gradiëntafdaling

In dit stadium zullen verschillende varianten van stochastische gradiënt worden geïmplementeerd in de vorm van 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 leeralgoritme

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:

Figuur 1 - Grafische weergave van de dataset

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 gespecificeerde 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 naarmate 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 vinden parameterupdates 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_network()

model = sgd(model, X_train, y_train, minibatch_size)

probe = vooruit(x, model)

y = np.argmax(waarschijnlijk)

Na het uitvoeren van deze code kreeg ik 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_network()

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_network()

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_network()

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

Uit de vergelijkende analyse blijkt duidelijk dat methoden met een adaptief leertempo bij gebruik van een hoog leertempo beter presteren dan methoden met een constant leertempo.

Het tegenovergestelde gebeurt echter wanneer een kleine leersnelheidswaarde wordt gebruikt, zoals 1e-5. Voor de standaardvariant van stochastische gradiëntafdaling en de momentummethode zorgen de waarden die klein genoeg zijn ervoor dat ze goed werken. Aan de andere kant, als de leersnelheid erg klein is, en deze wordt genormaliseerd in adaptieve leersnelheidsmethoden, dan wordt deze zelfs nog kleiner, wat de convergentiesnelheid 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ëntdaling

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 bij diepgaand leren [Elektronische hulpbron].

Geplaatst op Allbest.ru

...

Soortgelijke documenten

Noodzakelijke voorwaarden voor een extremum. Ontwikkeling van een machine-algoritme en multidimensionaal optimalisatieprogramma 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 van een applicatie voor het berekenen van 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 de 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 in het NeuroPro 0.25 softwareproduct. 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


De basis van de technologie voor het gebruik van het LabVIEW softwarepakket, de 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 van de 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 van softwaremodules. Gedetailleerd diagram van het algoritme.

cursuswerk, toegevoegd op 02/04/2011


Numerieke methoden voor problemen zonder beperkingen. Schema van afdalingsmethoden. Visual Basic Editor-omgeving. ActiveX-objecten gebruiken in formulieren. Stroomdiagram van het simulatie-algoritme. Optimalisatieproblemen voor deterministische functies met een enkel extremumpunt.