Mijn kennismaking met neurale netwerken vond plaats toen het uitkwam Prisma-app. Het verwerkt elke foto met behulp van neurale netwerken en reproduceert deze helemaal opnieuw met de geselecteerde stijl. Omdat ik hierin geïnteresseerd raakte, haastte ik me om artikelen en ‘tutorials’ te zoeken, voornamelijk over Habré. En tot mijn grote verbazing vond ik geen enkel artikel dat duidelijk en stap voor stap het algoritme voor de werking van neurale netwerken beschreef. Informatie was verspreid en ontbrak belangrijkste punten. Bovendien haasten de meeste auteurs zich om code in de ene of andere programmeertaal weer te geven zonder hun toevlucht te nemen tot gedetailleerde uitleg.

P Mijn eerste en belangrijkste ontdekking was de playlist van de Amerikaanse programmeur Jeff Heaton, waarin hij gedetailleerd en duidelijk de werkingsprincipes van neurale netwerken en hun classificatie uitlegt. Nadat ik deze afspeellijst had bekeken, besloot ik mijn eigen neurale netwerk te creëren, te beginnen met de zeer eenvoudig voorbeeld. Dat weet je waarschijnlijk wel als je net begint met lesgeven nieuwe taal, is je eerste programma Hello World. Het is een soort traditie. in de wereld machinaal leren heeft ook zijn eigen Hello world en dit is een neuraal netwerk probleem oplossen exclusief of (XOR). De XOR-tabel ziet er als volgt uit:

Dienovereenkomstig neemt het neurale netwerk twee getallen als invoer en moet het een ander getal uitvoeren: het antwoord. Nu over de neurale netwerken zelf.

Wat is een neuraal netwerk?

Een neuraal netwerk is een reeks neuronen die met elkaar zijn verbonden door synapsen. De structuur van een neuraal netwerk kwam rechtstreeks vanuit de biologie naar de programmeerwereld. Dankzij deze structuur krijgt de machine het vermogen om te analyseren en zelfs te onthouden diverse informatie. Neurale netwerken zijn ook in staat om niet alleen binnenkomende informatie te analyseren, maar deze ook uit hun geheugen te reproduceren. Voor degenen die geïnteresseerd zijn, bekijk zeker 2 video's van TED Talks:Video 1 , Video 2 ). Met andere woorden: een neuraal netwerk is een machinale interpretatie van het menselijk brein, dat miljoenen neuronen bevat die informatie doorgeven in de vorm van elektrische impulsen.

Wat zijn er neurale netwerken?

Voor nu zullen we voorbeelden uit de praktijk bekijken basistype Neurale netwerken zijn een feed-forward-netwerk (hierna de DPR genoemd). Ook in volgende artikelen zal ik introduceren meer concepten en je vertellen over terugkerende neurale netwerken. SPR is, zoals de naam al aangeeft, een netwerk met een opeenvolgende verbinding van neurale lagen; informatie stroomt altijd in slechts één richting.

Waar zijn neurale netwerken voor?

Neurale netwerken worden gebruikt om complexe problemen op te lossen waarvoor analytische berekeningen nodig zijn, vergelijkbaar met wat het menselijk brein doet. De meest voorkomende toepassingen van neurale netwerken zijn:

Classificatie - verdeling van gegevens per parameters. U krijgt bijvoorbeeld een aantal mensen als input en u moet beslissen aan wie u eer wilt geven en aan wie niet. Dit werk kan worden gedaan door een neuraal netwerk, dat informatie analyseert zoals leeftijd, solvabiliteit, kredietgeschiedenis, enz.

Voorspelling - het vermogen om de volgende stap te voorspellen. Bijvoorbeeld de stijging of daling van aandelen op basis van de situatie op de aandelenmarkt.

Herkenning - Momenteel het meest wijdverspreide gebruik van neurale netwerken. Gebruikt in Google wanneer u naar een foto zoekt of in telefooncamera's wanneer het de positie van uw gezicht detecteert en markeert, en nog veel meer.

Laten we, om te begrijpen hoe neurale netwerken werken, eens kijken naar de componenten en hun parameters.

Wat is een neuron?

Een neuron is een rekeneenheid die informatie ontvangt en daarop produceert eenvoudige berekeningen en geeft het door. Ze zijn onderverdeeld in drie hoofdtypen: invoer (blauw), verborgen (rood) en uitvoer (groen). Er is ook een verplaatsingsneuron en een contextneuron, waarover we het in het volgende artikel zullen hebben. In het geval dat een neuraal netwerk uit een groot aantal neuronen bestaat, wordt de term laag geïntroduceerd. Dienovereenkomstig is er een invoerlaag die informatie ontvangt, n verborgen lagen (meestal niet meer dan 3) die deze verwerken, en een uitvoerlaag die het resultaat uitvoert. Elk neuron heeft 2 hoofdparameters: invoergegevens en uitvoergegevens. In het geval van een inputneuron: input=output. In de rest bevat het invoerveld de totale informatie van alle neuronen uit de vorige laag, waarna deze wordt genormaliseerd met behulp van de activeringsfunctie (laten we het ons nu maar voorstellen als f(x)) en in het uitvoerveld terechtkomt.

Belangrijk om te onthouden dat neuronen werken met getallen in het bereik of [-1,1]. Maar hoe, zo vraagt ​​u zich af, verwerkt u dan getallen die buiten dit bereik vallen? Op in dit stadium, het eenvoudigste antwoord is om 1 te delen door dat getal. Dit proces wordt normalisatie genoemd en wordt vaak gebruikt in neurale netwerken. Hierover later meer.

Wat is een synaps?

Een synaps is een verbinding tussen twee neuronen. Synapsen hebben 1 parameter: gewicht. Dankzij dit verandert de ingevoerde informatie wanneer deze van het ene neuron naar het andere wordt overgedragen. Laten we zeggen dat er drie neuronen zijn die informatie doorgeven aan de volgende. Dan hebben we 3 gewichten die overeenkomen met elk van deze neuronen. Voor het neuron waarvan het gewicht groter is, zal die informatie dominant zijn in het volgende neuron (bijvoorbeeld bij het mengen van kleuren). In feite is de reeks gewichten van een neuraal netwerk of de gewichtsmatrix een soort brein van het hele systeem. Dankzij deze gewichten wordt de invoerinformatie verwerkt en omgezet in een resultaat.

Belangrijk om te onthouden , dat tijdens de initialisatie van het neurale netwerk de gewichten in willekeurige volgorde worden geplaatst.

Hoe werkt een neuraal netwerk?

IN in dit voorbeeld toont een deel van een neuraal netwerk, waarbij de letters I invoerneuronen aanduiden, de letter H een verborgen neuron aanduidt en de letter w gewichten aanduidt. De formule laat zien dat de invoerinformatie de som is van alle invoergegevens vermenigvuldigd met hun overeenkomstige gewichten. Dan geven we 1 en 0 als invoer. Stel dat w1=0,4 en w2 = 0,7. De invoergegevens van neuron H1 zijn als volgt: 1*0,4+0*0,7=0,4. Nu we de invoer hebben, kunnen we de uitvoer verkrijgen door de invoer in de activeringsfunctie te pluggen (daarover later meer). Nu we de output hebben, geven we deze door. En dus herhalen we dit voor alle lagen totdat we het uitgangsneuron bereiken. Nu we voor het eerst een dergelijk netwerk hebben gelanceerd, zullen we zien dat het antwoord verre van correct is, omdat het netwerk niet is getraind. Om de resultaten te verbeteren gaan wij haar trainen. Maar voordat we leren hoe we dit moeten doen, introduceren we eerst een paar termen en eigenschappen van een neuraal netwerk.

Activeringsfunctie

Een activeringsfunctie is een manier om invoergegevens te normaliseren (we hebben hier eerder over gesproken). Dat wil zeggen, als je bij de ingang bent groot aantal Door het door de activeringsfunctie te halen, krijgt u een output in het bereik dat u nodig heeft. Er zijn nogal wat activeringsfuncties, dus we zullen de meest elementaire overwegen: lineair, sigmoïde (logistiek) en hyperbolische tangens. Hun belangrijkste verschillen zijn het bereik van waarden.

Lineaire functie

Deze functie wordt bijna nooit gebruikt, behalve wanneer u een neuraal netwerk moet testen of een waarde moet doorgeven zonder conversie.

Sigmoïd

Dit is de meest voorkomende activeringsfunctie en het bereik van waarden is . Dit is waar de meeste voorbeelden op internet worden getoond, en wordt ook wel de logistieke functie genoemd. Dienovereenkomstig, als er in uw geval negatieve waarden zijn (aandelen kunnen bijvoorbeeld niet alleen stijgen, maar ook dalen), dan heeft u een functie nodig die ook negatieve waarden vastlegt.

Hyperbolische raaklijn

Het heeft alleen zin om de hyperbolische tangens te gebruiken als uw waarden zowel negatief als positief kunnen zijn, aangezien het bereik van de functie [-1,1] is. Het is niet raadzaam om deze functie alleen bij positieve waarden te gebruiken, omdat dit de resultaten van uw neurale netwerk aanzienlijk zal verslechteren.

Trainingsset

Een trainingsset is een reeks gegevens waarop een neuraal netwerk werkt. In ons geval van eliminatie of (xor) hebben we slechts 4 verschillende uitkomsten, dat wil zeggen dat we 4 trainingssets hebben: 0xor0=0, 0xor1=1, 1xor0=1,1xor1=0.

Iteratie

Dit is een soort teller die toeneemt elke keer dat het neurale netwerk één trainingsset doorloopt. Met andere woorden: dit is het totale aantal trainingssets dat door het neurale netwerk is voltooid.

tijdperk

Wanneer het neurale netwerk wordt geïnitialiseerd, wordt deze waarde ingesteld op 0 en heeft deze een handmatig ingesteld plafond. Hoe groter het tijdperk, hoe beter het netwerk is getraind en dus ook het resultaat ervan. Het tijdperk neemt toe elke keer dat we de hele set trainingssets doorlopen, in ons geval vier sets of vier iteraties.

Belangrijk verwar iteratie niet met tijdperk en begrijp de volgorde van hun toename. Eerste nzodra de iteratie toeneemt, en dan het tijdperk, en niet andersom. Met andere woorden: je kunt een neuraal netwerk niet eerst op slechts één set trainen, dan op een andere, enzovoort. Je moet elke set één keer per tijdperk trainen. Zo voorkom je fouten in de berekeningen.

Fout

Fout is een percentage dat het verschil weergeeft tussen de verwachte en ontvangen antwoorden. De fout wordt elk tijdperk gevormd en moet afnemen. Als dit niet gebeurt, doe je iets verkeerd. De fout kan op verschillende manieren worden berekend, maar we zullen slechts drie hoofdmethoden beschouwen: Mean Squared Error (hierna MSE), Root MSE en Arctan. Er is hier geen beperking op het gebruik, zoals bij de activeringsfunctie, en u bent vrij om elke methode te kiezen die u brengt beste resultaat. Houd er alleen rekening mee dat elke methode fouten anders telt. Bij Arctan zal de fout bijna altijd groter zijn, omdat het werkt volgens het principe: hoe groter het verschil, hoe groter het verschil meer fout. De root-MSE heeft de kleinste fout, dus het is het gebruikelijkst om een ​​MSE te gebruiken die het evenwicht in de foutberekening handhaaft.

Root-MSE

Arctan

Het principe van rekenfouten is in alle gevallen hetzelfde. Voor elke set tellen we de fout door het resultaat af te trekken van het ideale antwoord. Vervolgens kwadrateren we het of berekenen we de kwadratische raaklijn uit dit verschil, waarna we het resulterende getal delen door het aantal sets.

Taak

Om uzelf te testen, berekent u nu de output van een bepaald neuraal netwerk met behulp van sigmoid en de fout ervan met behulp van MSE.

Gegevens:

I1=1, I2=0, w1=0,45, w2=0,78 ,w3=-0,12 ,w4=0,13 ,w5=1,5 ,w6=-2,3.

Oplossing

H1-ingang = 1*0,45+0*-0,12=0,45

H1uitvoer = sigmoïde(0,45)=0,61

H2-ingang = 1*0,78+0*0,13=0,78

H2-uitvoer = sigmoïde(0,78)=0,69

O1-ingang = 0,61*1,5+0,69*-2,3=-0,672

O1uitvoer = sigmoïde(-0,672)=0,33

O1ideaal = 1 (0xof1=1)

Fout = ((1-0,33)^2)/1=0,45

Resultaat - 0,33, fout - 45%.

Hartelijk dank voor uw aandacht! Ik hoop dat dit artikel je heeft kunnen helpen bij het bestuderen van neurale netwerken. In het volgende artikel zal ik het hebben over bias-neuronen en hoe je een neuraal netwerk kunt trainen met behulp van deze methode terugpropagatie en gradiëntafdaling.

Gebruikte bronnen:

Wat gaan we doen? We zullen proberen een eenvoudig en heel klein neuraal netwerk te creëren, dat we laten we het uitleggen En wij zullen het leren iets onderscheiden. Tegelijkertijd zullen we niet ingaan op de geschiedenis en de wiskundige jungle (dergelijke informatie is heel gemakkelijk te vinden) - in plaats daarvan zullen we proberen de taak uit te leggen (het is geen feit dat het zal slagen) aan u en aan onszelf met tekeningen en code.
Veel van de termen in neurale netwerken hebben betrekking op de biologie, dus laten we bij het begin beginnen:

De hersenen zijn een complex geheel, maar kunnen worden onderverdeeld in verschillende hoofdonderdelen en operaties:

De veroorzaker kan zijn intern(bijvoorbeeld een afbeelding of een idee):

Laten we nu eens kijken naar de basis en vereenvoudigd onderdelen brein:

De hersenen lijken over het algemeen op een kabelnetwerk.

Neuron- de basiseenheid van de berekening in de hersenen. Deze ontvangt en verwerkt chemische signalen van andere neuronen en doet, afhankelijk van een aantal factoren, niets of genereert een elektrische impuls, of actiepotentiaal, dat vervolgens signalen via synapsen naar aangrenzende neuronen stuurt. degenen verwant neuronen:

Dromen, herinneringen, zelfregulerende bewegingen, reflexen en eigenlijk alles wat je denkt of doet – alles gebeurt dankzij dit proces: miljoenen of zelfs miljarden neuronen werken aan verschillende niveaus en verbindingen creëren die verschillende parallelle subsystemen creëren en een biologisch neuraal vertegenwoordigen netto.

Dit zijn natuurlijk allemaal vereenvoudigingen en generalisaties, maar dankzij hen kunnen we een eenvoudige beschrijving beschrijven
neuraal netwerk:

En beschrijf het formeel met behulp van een grafiek:

Enige verduidelijking is hier vereist. De cirkels zijn de neuronen en de lijnen zijn de verbindingen ertussen, en om het op dit punt simpel te houden: relaties vertegenwoordigen de directe beweging van informatie van links naar rechts. Het eerste neuron in op dit moment actief en grijs gemarkeerd. We hebben er ook een nummer aan gegeven (1 als het werkt, 0 als het niet werkt). De getallen tussen de neuronen laten zien gewicht communicatie.

De bovenstaande grafieken tonen het tijdstip van het netwerk; voor een nauwkeurigere weergave moet u het in tijdsperioden verdelen:

Om je eigen neurale netwerk te creëren, moet je begrijpen hoe gewichten neuronen beïnvloeden en hoe neuronen leren. Laten we als voorbeeld een konijn (testkonijn) nemen en het onder de omstandigheden van een klassiek experiment plaatsen.

Wanneer een veilige luchtstroom op hen wordt gericht, knipperen konijnen, net als mensen:

Dit gedragsmodel kan in grafieken worden weergegeven:

Net als in het vorige diagram laten deze grafieken alleen het moment zien waarop het konijn de adem voelt, en wij dus coderen whiff als een Booleaanse waarde. Daarnaast berekenen we op basis van de gewichtswaarde of het tweede neuron vuurt. Als het gelijk is aan 1, vuurt het sensorische neuron, we knipperen; als het gewicht kleiner is dan 1, knipperen we niet: het tweede neuron beperken— 1.

Laten we nog een element introduceren: veilig piep:

We kunnen de interesse van het konijn als volgt modelleren:

Het belangrijkste verschil is dat het gewicht nu gelijk is aan nul, dus we hebben geen knipperend konijn gekregen, nou ja, nog niet, tenminste. Laten we het konijn nu leren op commando te knipperen door te mixen
stimuli (piep en blaas):

Het is belangrijk dat deze gebeurtenissen op verschillende tijdstippen plaatsvinden tijdperk, in grafieken ziet het er als volgt uit:

Het geluid zelf doet niets, maar de luchtstroom zorgt er nog steeds voor dat het konijn knippert, en we laten dit zien door de gewichten vermenigvuldigd met de stimuli (in rood). Onderwijs Complex gedrag kan simplistisch worden uitgedrukt als een geleidelijke gewichtsverandering tussen verbonden neuronen in de loop van de tijd.

Om een ​​konijn te trainen herhalen we de stappen:

Voor de eerste drie pogingen zien de schema's er als volgt uit:

Houd er rekening mee dat het gewicht voor de geluidsstimulus na elke herhaling toeneemt (rood gemarkeerd). Deze waarde is momenteel willekeurig - we kozen voor 0,30, maar het getal kan van alles zijn, zelfs negatief. Na de derde herhaling merk je geen verandering in het gedrag van het konijn, maar na de vierde herhaling zal er iets verbazingwekkends gebeuren: het gedrag zal veranderen.

We hebben de blootstelling aan de lucht verwijderd, maar het konijn knippert nog steeds als het de piep hoort! Ons laatste diagram kan dit gedrag verklaren:

We hebben het konijn getraind om op geluid te reageren door te knipperen.

Bij een echt experiment van deze soort kan het meer dan 60 herhalingen duren voordat het resultaat wordt bereikt.

Nu zullen we de biologische wereld van de hersenen en konijnen verlaten en proberen alles aan te passen
geleerd een kunstmatig neuraal netwerk te creëren. Laten we eerst proberen een eenvoudige taak uit te voeren.

Laten we zeggen dat we een machine hebben met vier knoppen die voedsel afgeeft als de juiste knop wordt ingedrukt
knoppen (nou ja, of energie als je een robot bent). De taak is om erachter te komen welke knop een beloning oplevert:

We kunnen (schematisch) weergeven wat een knop doet wanneer erop wordt geklikt, als volgt:

Het is het beste om dit probleem volledig op te lossen, dus laten we eens kijken naar alle mogelijke resultaten, inclusief de juiste:

Klik op de 3e knop om uw diner te krijgen.

Om een ​​neuraal netwerk in code te reproduceren, moeten we eerst een model of grafiek maken waarmee het netwerk kan worden vergeleken. Hier is één grafiek die geschikt is voor de taak; bovendien geeft deze goed zijn biologische analoog weer:

Dit neurale netwerk ontvangt eenvoudigweg binnenkomende informatie - in dit geval zou het de perceptie zijn van welke knop werd ingedrukt. Vervolgens vervangt het netwerk de invoerinformatie door gewichten en maakt een gevolgtrekking op basis van de toevoeging van een laag. Het klinkt een beetje verwarrend, maar laten we eens kijken hoe de knop in ons model wordt weergegeven:

Merk op dat alle gewichten 0 zijn, dus het neurale netwerk is als een baby, helemaal leeg, maar volledig met elkaar verbonden.

We vergelijken dus een externe gebeurtenis met de invoerlaag van het neurale netwerk en berekenen de waarde aan de uitvoer ervan. Het kan wel of niet samenvallen met de werkelijkheid, maar we zullen dit voorlopig negeren en het probleem beginnen te beschrijven computer begrijpelijk manier. Laten we beginnen met het invoeren van de gewichten (we gebruiken JavaScript):

Var-invoer = ; var-gewichten = ; // Voor het gemak kunnen deze vectoren worden aangeroepen

De volgende stap is het maken van een functie die de invoerwaarden en gewichten neemt en de uitvoerwaarde berekent:

Functie evaluerenNeuralNetwork(inputVector,weightVector)( var result = 0; inputVector.forEach(function(inputValue,weightIndex) ( layerValue = inputValue*weightVector; result += layerValue; )); return (result.toFixed(2)); ) / / Het lijkt misschien complex, maar het enige dat het doet is het matchen van gewicht/invoerparen en het toevoegen van het resultaat

Zoals verwacht krijgen we, als we deze code uitvoeren, hetzelfde resultaat als in ons model of onze grafiek...

EvaluateNeuralNetwork (invoer, gewichten); // 0,00

Live voorbeeld: Neural Net 001. De volgende stap in het verbeteren van ons neurale netwerk zal een manier zijn om de eigen outputs te controleren resulterende waarden vergelijkbaar met een echte situatie, laten we eerst deze specifieke realiteit in een variabele coderen:

Om inconsistenties (en hoeveel er zijn) te detecteren, voegen we een foutfunctie toe:

Fout = Realiteit - Neurale netto-output

Hiermee kunnen we de prestaties van ons neurale netwerk evalueren:

Maar wat nog belangrijker is: hoe zit het met situaties waarin de realiteit een positief resultaat oplevert?

Nu weten we dat ons neurale netwerkmodel kapot is (en we weten hoeveel), geweldig! Het mooie is dat we nu de foutfunctie kunnen gebruiken om ons leerproces te controleren. Maar dit alles zal logisch zijn als we de foutfunctie als volgt opnieuw definiëren:

Fout = Gewenste uitvoer- Neurale netto-output

Een ongrijpbare, maar zo belangrijke discrepantie, die stilzwijgend laat zien dat we dat wel zullen doen
gebruik eerdere resultaten om te vergelijken met toekomstige acties
(en om te leren, zoals we later zullen zien). Dit bestaat ook in echte leven, vol
zich herhalende patronen, zodat het een evolutionaire strategie kan worden (nou ja, in
de meeste gevallen).

Var-invoer = ; var-gewichten = ; var gewenst resultaat = 1;

En een nieuwe functie:

Functie evaluerenNeuralNetError(gewenst,actueel) ( return (gewenst - actueel);) // Na evaluatie van zowel het netwerk als de fout krijgen we: // "Neural Net output: 0.00 Error: 1"

Live voorbeeld: Neural Net 002. Laten we het samenvatten. We begonnen met een taak en die hebben we uitgevoerd eenvoudig model in de vorm van een biologisch neuraal netwerk en een manier hebben om de prestaties ervan te meten in vergelijking met de werkelijkheid of het gewenste resultaat. Nu moeten we een manier vinden om de discrepantie te corrigeren, een proces dat zowel voor computers als voor mensen als leren kan worden beschouwd.

Hoe train je een neuraal netwerk?

De basis van training voor zowel biologische als kunstmatige neurale netwerken is herhaling.
En algoritmen leren, dus we zullen afzonderlijk met hen samenwerken. Laten we beginnen met
trainingsalgoritmen.

In de natuur verwijzen leeralgoritmen naar veranderingen in fysisch of chemisch opzicht
kenmerken van neuronen na experimenten:

De dramatische illustratie van hoe twee neuronen in de loop van de tijd veranderen in de code en ons 'leeralgoritme'-model betekent dat we in de loop van de tijd eenvoudigweg dingen zullen veranderen om ons leven gemakkelijker te maken. Laten we dus een variabele toevoegen om aan te geven hoe gemakkelijk het leven is:

Var leersnelheid = 0,20; // Hoe groter de waarde, hoe sneller het leerproces zal zijn :)

En wat zal dit veranderen?

Hierdoor veranderen de gewichten (net als bij het konijn!), vooral het uitvoergewicht dat we willen produceren:

Hoe je een dergelijk algoritme codeert is jouw keuze, voor de eenvoud voeg ik de leerfactor toe aan het gewicht, hier is het in de vorm van een functie:

Functie leren(inputVector, gewichtVector) ( gewichtVector.forEach(functie(gewicht, index, gewichten) ( if (inputVector > 0) ( gewichten = gewicht + leersnelheid; ) )); )

Wanneer deze trainingsfunctie wordt gebruikt, wordt eenvoudigweg onze leerfactor aan de gewichtsvector toegevoegd actieve neuron, voor en na een trainingsronde (of herhaling) zijn de resultaten als volgt:

// Oorspronkelijke gewichtsvector: // Neurale netto-uitvoer: 0,00 Fout: 1 leer (invoer, gewichten); // Nieuwe gewichtsvector: // Neurale netto-output: 0,20 Fout: 0,8 // Als het niet duidelijk is, ligt de neurale netto-output bijna 1 (kippenoutput) - wat we wilden, dus we kunnen concluderen dat we in beweging zijn richting in de goede richting

Live voorbeeld: Neural Net 003. Oké, nu we de goede kant op gaan, zal het laatste stukje van deze puzzel de implementatie zijn herhalingen.

Het is niet zo ingewikkeld, van nature doen we hetzelfde keer op keer, maar in code specificeren we gewoon het aantal herhalingen:

Var-proeven = 6;

En de implementatie van de functie voor het aantal herhalingen in ons neurale trainingsnetwerk zal er als volgt uitzien:

Functietrein(proeven) ( voor (i = 0; i< trials; i++) { neuralNetResult = evaluateNeuralNetwork(input, weights); learn(input, weights); } }

Nou, hier is ons eindrapport:

Neurale netto-uitvoer: 0,00 Fout: 1,00 Gewichtsvector: Neurale netto-uitvoer: 0,20 Fout: 0,80 Gewichtsvector: Neurale netto-uitvoer: 0,40 Fout: 0,60 Gewichtsvector: Neurale netto-uitvoer: 0,60 Fout: 0,40 Gewichtsvector: Neurale netto-uitvoer: 0,80 Fout : 0,20 Gewichtsvector: Neuraal Nettoresultaat: 1,00 Fout: 0,00 Gewichtsvector: // Kipdiner!

Live voorbeeld: Neural Net 004. Nu hebben we een gewichtsvector die slechts één uitvoer zal produceren (kip voor het avondeten) als de invoervector overeenkomt met de werkelijkheid (klik op de derde knop). Dus wat is het coolste dat we net hebben gedaan?

In dit specifieke geval kan ons neurale netwerk (na training) de invoergegevens herkennen en zeggen wat tot het gewenste resultaat zal leiden (we zullen nog specifieke situaties moeten programmeren):

Bovendien is het een schaalbaar model, een speeltje en een hulpmiddel voor ons leren. We hebben iets nieuws kunnen leren over machine learning, neurale netwerken en kunstmatige intelligentie. Waarschuwing voor gebruikers:

• Er is geen mechanisme om geleerde gewichten op te slaan, dus dit neurale netwerk zal alles vergeten wat het weet. Wanneer u de code bijwerkt of opnieuw uitvoert, heeft u minimaal zes succesvolle iteraties nodig om het netwerk volledig te laten leren, als u denkt dat een persoon of machine willekeurig op knoppen zal drukken... Dit zal enige tijd duren.
• Biologische netwerken voor leren belangrijke dingen hebben een leersnelheid van 1, dus er is slechts één succesvolle herhaling nodig.
• Er bestaat een leeralgoritme dat sterk lijkt op biologische neuronen, en het heeft een pakkende naam: Widroff-hoff-regel, of Widroff-hoff-training.
• Neurondrempels (1 in ons voorbeeld) en herscholingseffecten (met grote hoeveelheden herhalingen zal het resultaat meer zijn 1) worden niet in aanmerking genomen, maar ze zijn zeer belangrijk van aard en zijn verantwoordelijk voor grote en complexe blokken gedragsmatige reacties. Dat geldt ook voor negatieve gewichten.

Aantekeningen en lijst met referenties voor verder lezen

Ik heb geprobeerd wiskundige en technische termen te vermijden, maar als je geïnteresseerd bent: we hebben een perceptron gebouwd, dat wordt gedefinieerd als een begeleid leeralgoritme (onder toezicht leren) van dubbele classificaties - zwaar spul. De biologische structuur van de hersenen is geen eenvoudig onderwerp, deels vanwege de onnauwkeurigheid en deels vanwege de complexiteit ervan. Het is beter om te beginnen met Neurowetenschappen (Purves) en Cognitieve Neurowetenschappen (Gazzaniga). Ik heb het konijnenvoorbeeld van Gateway to Memory (Gluck) aangepast en aangepast, wat ook een geweldige introductie is tot de wereld van grafieken. An Introduction to Neural Networks (Gurney) is een andere geweldige bron voor al uw AI-behoeften.
En nu op Python! Met dank aan Ilya Andshmidt voor het beschikbaar stellen van de Python-versie:

Invoer = gewichten = gewenst_resultaat = 1 leersnelheid = 0,2 pogingen = 6 def evalueren_neuraal_netwerk(input_array, gewicht_array): resultaat = 0 voor i in bereik(len(input_array)): laag_waarde = invoer_array[i] * gewicht_array[i] resultaat += laag_waarde print("evaluate_neural_network: " + str(result)) print("weights: " + str(weights)) retourneert resultaat def evalueren_error(gewenst, feitelijk): fout = gewenst - feitelijk print("evaluate_error: " + str(fout) ) return error def learn(input_array,weight_array): print("learning...") for i in range(len(input_array)): if input_array[i] > 0:weight_array[i] += learning_rate def train(trials ): voor i binnen bereik (proeven): neural_net_result = evalueren_neural_network (invoer, gewichten) leren (invoer, gewichten) trainen (proeven)

En nu op GO! Met dank aan Kieran Maher voor deze versie.

Pakket hoofdimport ("fmt" "math") func main() ( fmt.Println("Invoer en gewichten maken ...") inputs:= float64(0.00, 0.00, 1.00, 0.00) gewichten:= float64(0.00, 0.00, 0.00, 0.00) gewenst:= 1.00 learningRate:= 0.20 pogingen:= 6 train(trials, inputs,weights, gewenst, learningRate) ) func train(trials int, inputs float64, gewichten float64, gewenst float64, learningRate float64) ( voor ik:= 1;< trials; i++ { weights = learn(inputs, weights, learningRate) output:= evaluate(inputs, weights) errorResult:= evaluateError(desired, output) fmt.Print("Output: ") fmt.Print(math.Round(output*100) / 100) fmt.Print(" Error: ") fmt.Print(math.Round(errorResult*100) / 100) fmt.Print(" ") } } func learn(inputVector float64, weightVector float64, learningRate float64) float64 { for index, inputValue:= range inputVector { if inputValue >0.00 (weightVector = weightVector + learningRate ) returnweightVector ) func evaluatie(inputVector float64,weightVector float64) float64 ( resultaat:= 0.00 voor index, inputValue:= bereik inputVector ( layerValue:= inputValue *weightVector resultaat = resultaat + layerValue ) return resultaat ) func evaluatieError(gewenst float64, actueel float64) float64 (retour gewenst - actueel)

Bladwijzers

We vertellen je hoe je in een paar stappen een eenvoudig neuraal netwerk kunt creëren en leren hoe je beroemde ondernemers op foto's kunt herkennen.

Stap 0. Laten we begrijpen hoe neurale netwerken werken

De eenvoudigste manier om de werkingsprincipes van neurale netwerken te begrijpen, is door het voorbeeld van Teachable Machine te gebruiken, een educatief project van Google.

Teachable Machine gebruikt een afbeelding van een laptopcamera als invoergegevens - wat door het neurale netwerk moet worden verwerkt. Als uitvoergegevens – wat het neurale netwerk moet doen na het verwerken van de binnenkomende gegevens – kunt u een gif of geluid gebruiken.

U kunt Teachable Machine bijvoorbeeld leren ‘Hallo’ te zeggen als uw handpalm omhoog is. Met een duim omhoog - "Cool", en met een verrast gezicht met open mond - "Wauw".

Eerst moet je het neurale netwerk trainen. Om dit te doen, steekt u uw handpalm omhoog en drukt u op de knop "Train Green" - de service maakt enkele tientallen foto's om een ​​patroon in de afbeeldingen te vinden. Een set van dergelijke afbeeldingen wordt gewoonlijk een “dataset” genoemd.

Nu hoeft u alleen nog maar de actie te selecteren die moet worden uitgevoerd bij het herkennen van een afbeelding: zeg een zin, toon een GIF of speel een geluid af. Op dezelfde manier trainen we een neuraal netwerk om een ​​verbaasd gezicht en een duim te herkennen.

Zodra het neurale netwerk is getraind, kan het worden gebruikt. Teachable Machine laat de factor ‘vertrouwen’ zien: hoe ‘zeker’ het systeem is dat het een van de vaardigheden wordt aangeleerd.

Een korte video over hoe de Teachable Machine werkt

Stap 1. De computer voorbereiden op het werken met een neuraal netwerk

Nu gaan we ons eigen neurale netwerk creëren, dat bij het verzenden van een afbeelding zal rapporteren wat er op de afbeelding wordt weergegeven. Eerst leren we het neurale netwerk bloemen op de afbeelding te herkennen: kamille, zonnebloem, paardenbloem, tulp of roos.

Om je eigen neurale netwerk te creëren heb je Python nodig – een van de meest minimalistische en gebruikelijke programmeertalen, en TensorFlow – bibliotheek openen Google voor het maken en trainen van neurale netwerken.

Neurale netwerken zijn nu in de mode, en met goede reden. Met hun hulp kun je bijvoorbeeld objecten op afbeeldingen herkennen of, omgekeerd, de nachtmerries van Salvador Dali tekenen. Dankzij handige bibliotheken kunnen de eenvoudigste neurale netwerken met slechts een paar regels code worden gecreëerd; er is niet veel meer voor nodig om de kunstmatige intelligentie van IBM te gebruiken.

Theorie

Biologen weten nog steeds niet precies hoe de hersenen werken, maar wel het werkingsprincipe individuele elementen zenuwstelsel is goed bestudeerd. Het bestaat uit neuronen - gespecialiseerde cellen die elektrochemische signalen met elkaar uitwisselen. Elk neuron heeft veel dendrieten en één axon. Dendrieten kunnen worden vergeleken met de input waardoor gegevens een neuron binnenkomen, terwijl het axon als output dient. De verbindingen tussen dendrieten en axonen worden synapsen genoemd. Ze zenden niet alleen signalen uit, maar kunnen ook hun amplitude en frequentie veranderen.

De transformaties die plaatsvinden op het niveau van individuele neuronen zijn heel eenvoudig, maar zelfs hele kleine neurale netwerken zijn tot veel in staat. De hele diversiteit aan gedrag van de worm Caenorhabditis elegans - beweging, zoeken naar voedsel, verschillende reacties op externe stimuli en nog veel meer - is gecodeerd in slechts driehonderd neuronen. En oké wormen! Zelfs mieren hebben 250.000 neuronen nodig, en wat ze doen gaat de mogelijkheden van machines beslist te boven.

Bijna zestig jaar geleden probeerde de Amerikaanse onderzoeker Frank Rosenblatt te creëren computersysteem, ontworpen naar het beeld en de gelijkenis van de hersenen, maar de mogelijkheden om het te creëren waren uiterst beperkt. Sindsdien is de belangstelling voor neurale netwerken herhaaldelijk opgelaaid, maar keer op keer bleek dat de rekenkracht niet voldoende is voor geavanceerde neurale netwerken. Op dit vlak is er de afgelopen tien jaar veel veranderd.

Elektromechanisch brein met motor

De machine van Rosenblatt heette de Mark I Perceptron. Het was bedoeld voor beeldherkenning, een taak waar computers nog maar matig in zijn. Mark I was uitgerust met een schijn van een netvlies: vierkante matrix van 400 fotocellen, twintig verticaal en twintig horizontaal. Fotocellen werden willekeurig verbonden met elektronische modellen van neuronen, en deze waren op hun beurt verbonden met acht uitgangen. Rosenblatt gebruikte potentiometers als synapsen die elektronische neuronen, fotocellen en uitgangen met elkaar verbond. Bij het trainen van de perceptron draaiden 512 stappenmotoren automatisch de potentiometerknoppen, waardoor de spanning op de neuronen werd aangepast, afhankelijk van de nauwkeurigheid van het uitgangsresultaat.

Dat is hoe een neuraal netwerk in een notendop werkt. Een kunstmatig neuron heeft, net als een echt neuron, verschillende ingangen en één uitgang. Elke input heeft een wegingsfactor. Door deze coëfficiënten te veranderen, kunnen we het neurale netwerk trainen. De afhankelijkheid van het uitgangssignaal van de ingangssignalen wordt bepaald door de zogenaamde activeringsfunctie.

In de perceptron van Rosenblatt voegde de activeringsfunctie het gewicht toe van alle invoer die een logische invoer ontving, en vergeleek het resultaat vervolgens met een drempelwaarde. Het nadeel was dat een kleine verandering in een van de wegingscoëfficiënten bij deze aanpak een onevenredig grote impact op het resultaat kan hebben. Dit maakt leren lastig.

Moderne neurale netwerken gebruiken doorgaans niet-lineaire activeringsfuncties, zoals de sigmoïde. Bovendien hadden oude neurale netwerken te weinig lagen. Tegenwoordig bevinden zich meestal een of meer verborgen lagen neuronen tussen de input en output. Dat is waar al het plezier gebeurt.

Om het gemakkelijker te maken om te begrijpen wat waar we het over hebben, kijk eens naar dit diagram. Het is een feedforward neuraal netwerk met één verborgen laag. Elke cirkel komt overeen met een neuron. Aan de linkerkant bevinden zich de neuronen van de invoerlaag. Aan de rechterkant bevindt zich het neuron van de uitvoerlaag. In het midden bevindt zich een verborgen laag met vier neuronen. De uitgangen van alle neuronen in de invoerlaag zijn verbonden met elk neuron van de eerste verborgen laag. Op hun beurt zijn de ingangen van het neuron van de uitgangslaag verbonden met alle uitgangen van de neuronen van de verborgen laag.

Niet alle neurale netwerken zijn op deze manier ontworpen. Er zijn bijvoorbeeld (zij het minder gebruikelijke) netwerken waarin het signaal van de neuronen niet alleen naar de volgende laag wordt gestuurd, zoals in het directe voortplantingsnetwerk uit ons diagram, maar ook naar omgekeerde richting. Dergelijke netwerken worden terugkerend genoemd. Volledig verbonden lagen zijn ook slechts één optie, en we zullen zelfs een van de alternatieven bespreken.

Oefening

Laten we dus proberen met onze eigen handen een eenvoudig neuraal netwerk op te bouwen en gaandeweg uit te zoeken hoe het werkt. We zullen Python gebruiken met de Numpy-bibliotheek (we zouden zonder Numpy kunnen, maar met Numpy kost lineaire algebra minder moeite). Het betreffende voorbeeld is gebaseerd op code van Andrew Trask.

We hebben functies nodig om de sigmoïde en zijn afgeleide te berekenen:

Voortzetting is alleen beschikbaar voor abonnees

Optie 1. Abonneer u op Hacker om al het materiaal op de site te lezen

Met een abonnement kunt u ALLE betaalde materialen op de site binnen de aangegeven periode lezen.

Wij accepteren betalingen met bankkaarten, elektronisch geld en overschrijvingen vanaf rekeningen van mobiele operators. Kunstmatige intelligentie, neurale netwerken, machinaal leren: wat betekenen al deze momenteel populaire concepten eigenlijk? Voor de meeste niet-ingewijden, wat ik zelf ben, leken ze altijd iets fantastisch, maar in feite ligt hun essentie aan de oppervlakte. Ik heb al lang het idee om te schrijven in eenvoudige taal

Kunstmatige intelligentie, neurale netwerken, machinaal leren: wat betekenen al deze momenteel populaire concepten eigenlijk? Voor de meeste niet-ingewijden, wat ik zelf ben, leken ze altijd iets fantastisch, maar in feite ligt hun essentie aan de oppervlakte. Ik loop al lang met het idee om in eenvoudige taal te schrijven over kunstmatige neurale netwerken. Ontdek het zelf en vertel anderen wat deze technologie is, hoe het werkt, overweeg de geschiedenis en vooruitzichten ervan. In dit artikel probeerde ik niet in het onkruid te duiken, maar eenvoudig en in de volksmond te praten over deze veelbelovende richting in de wereld van de geavanceerde technologie.

Een beetje geschiedenis

Voor het eerst ontstond het concept van kunstmatige neurale netwerken (ANN) in een poging hersenprocessen te simuleren. De creatie van het McCulloch-Pitts neurale netwerkmodel in 1943 kan worden beschouwd als de eerste serieuze doorbraak op dit gebied. Wetenschappers hebben voor het eerst een model van een kunstneuron ontwikkeld. Ze stelden ook het ontwerp voor van een netwerk van deze elementen om logische bewerkingen uit te voeren. Maar het allerbelangrijkste is dat wetenschappers hebben bewezen dat een dergelijk netwerk in staat is om te leren.

Volgende belangrijke stap was de ontwikkeling door Donald Hebb van het eerste algoritme voor het berekenen van een ANN in 1949, dat fundamenteel werd voor de daaropvolgende decennia. In 1958 ontwikkelde Frank Rosenblatt de parceptron, een systeem dat hersenprocessen imiteert. Ooit had de technologie geen analogen en is ze nog steeds van fundamenteel belang in neurale netwerken. In 1986 verbeterden Amerikaanse en Sovjet-wetenschappers vrijwel gelijktijdig, onafhankelijk van elkaar, de fundamentele methode voor het trainen van een meerlaags perceptron aanzienlijk. In 2007 beleefden neurale netwerken een wedergeboorte. De Britse computerwetenschapper Geoffrey Hinton ontwikkelde eerst een deep learning-algoritme voor meerlaagse neurale netwerken, dat nu bijvoorbeeld wordt gebruikt om zelfrijdende auto’s te besturen.

Kort over het belangrijkste

IN in algemene zin woorden, neurale netwerken zijn dat wel wiskundige modellen, werkend aan het principe van netwerken van zenuwcellen in een dierlijk lichaam. ANN's kunnen worden geïmplementeerd in zowel programmeerbare als hardwareoplossingen. Om de zaken begrijpelijker te maken, kan een neuron worden gezien als een cel met veel invoergaten en één uitvoergat. Hoe meerdere binnenkomende signalen worden omgezet in een uitgangssignaal, wordt bepaald door het berekeningsalgoritme. Aan elke neuroningang worden effectieve waarden geleverd, die vervolgens worden verdeeld langs interneuronverbindingen (synopses). Synapsen hebben één parameter: gewicht, waardoor de invoerinformatie verandert bij het verplaatsen van het ene neuron naar het andere. De eenvoudigste manier om het werkingsprincipe van neurale netwerken voor te stellen is door kleuren te mengen. Blauwe, groene en rode neuronen hebben verschillende gewichten. De informatie van het neuron waarvan het gewicht groter is, zal dominant zijn in het volgende neuron.

Het neurale netwerk zelf is een systeem van veel van dergelijke neuronen (processors). Individueel zijn deze processors vrij eenvoudig (veel eenvoudiger dan een persoonlijke computer), maar verbonden zijn groot systeem neuronen zijn in staat zeer complexe taken uit te voeren.

Afhankelijk van het toepassingsgebied kan een neuraal netwerk op verschillende manieren worden geïnterpreteerd. Vanuit het oogpunt van machine learning is een ANN bijvoorbeeld een patroonherkenningsmethode. Vanuit wiskundig oogpunt is dit een probleem met meerdere parameters. Vanuit het oogpunt van cybernetica - een model adaptieve controle robotica. Voor kunstmatige intelligentie is ANN een fundamenteel onderdeel voor het modelleren van natuurlijke intelligentie met behulp van computationele algoritmen.

Het belangrijkste voordeel van neurale netwerken ten opzichte van conventionele computeralgoritmen is hun vermogen om te leren. In de algemene zin van het woord gaat leren over het vinden van de juiste koppelingscoëfficiënten tussen neuronen, het samenvatten van gegevens en het identificeren van complexe afhankelijkheden tussen invoer- en uitvoersignalen. Succesvolle training van een neuraal netwerk betekent in feite dat het systeem in staat zal zijn het juiste resultaat te identificeren op basis van gegevens die niet in de trainingsset voorkomen.

Huidige situatie

En hoe veelbelovend deze technologie ook mag zijn, ANN’s zijn nog lang niet mogelijk menselijk brein en denken. Neurale netwerken worden echter al op veel gebieden van menselijke activiteit gebruikt. Tot nu toe zijn ze niet in staat om zeer intelligente beslissingen te nemen, maar ze kunnen wel een persoon vervangen waar hij voorheen nodig was. Onder de vele toepassingsgebieden van ANN kunnen we vermelden: het creëren van zelflerende productieprocessystemen, onbemand voertuigen, beeldherkenningssystemen, intelligent beveiligingssystemen, robotica, systemen voor kwaliteitsbewaking, spraakinterfaces interacties, analysesystemen en nog veel meer. Dit wijdverbreide gebruik van neurale netwerken is onder meer te danken aan de opkomst van op verschillende manieren het versnellen van de ANN-training.

Tegenwoordig is de markt voor neurale netwerken enorm: miljarden en miljarden dollars. Zoals de praktijk laat zien, verschillen de meeste neurale netwerktechnologieën over de hele wereld weinig van elkaar. Het gebruik van neurale netwerken is echter een zeer dure activiteit, die in de meeste gevallen alleen door financiële middelen kan worden bekostigd grote bedrijven. Voor het ontwikkelen, trainen en testen van neurale netwerken is veel nodig rekenkracht, het is duidelijk dat grote spelers op de IT-markt hier volop over beschikken. Tot de belangrijkste bedrijven die de ontwikkelingen op dit gebied leiden, behoren de Google DeepMind-divisie, de Microsoft Research-divisie, IBM, Facebook en Baidu.

Dit is natuurlijk allemaal goed: neurale netwerken ontwikkelen zich, de markt groeit, maar tot nu toe hoofdtaak nog steeds niet opgelost. De mensheid is er niet in geslaagd een technologie te creëren die zelfs maar de mogelijkheden van het menselijk brein benadert. Laten we eens kijken naar de belangrijkste verschillen tussen het menselijk brein en kunstmatige neurale netwerken.

Waarom zijn neurale netwerken nog steeds ver verwijderd van het menselijk brein?

Het belangrijkste verschil, dat het principe en de efficiëntie van het systeem radicaal verandert, is ander tuig signalen in kunstmatige neurale netwerken en in een biologisch netwerk van neuronen. Feit is dat neuronen in een ANN waarden doorgeven die echte waarden zijn, dat wil zeggen getallen. In het menselijk brein worden impulsen met een vaste amplitude overgedragen, en deze impulsen zijn vrijwel onmiddellijk. Dit leidt tot een aantal voordelen van het menselijke netwerk van neuronen.

Ten eerste zijn de communicatielijnen in de hersenen veel efficiënter en zuiniger dan die in het ANN. Ten tweede zorgt het pulscircuit voor een gemakkelijke implementatie van de technologie: het is voldoende om te gebruiken analoge circuits in plaats van complexe computationele mechanismen. Uiteindelijk zijn gepulseerde netwerken immuun voor audio-interferentie. Reële cijfers zijn onderhevig aan ruis, wat de kans op fouten vergroot.

Kortom

Natuurlijk heeft de ontwikkeling van neurale netwerken de afgelopen tien jaar een ware hausse gekend. Dit komt vooral doordat het ANN-trainingsproces veel sneller en eenvoudiger is geworden. Er worden ook actief zogenaamde ‘voorgetrainde’ neurale netwerken ontwikkeld, die het proces van de introductie van technologie aanzienlijk kunnen versnellen. En als het nog te vroeg is om te zeggen of neurale netwerken op een dag in staat zullen zijn de capaciteiten van het menselijk brein volledig te reproduceren, wordt de waarschijnlijkheid dat ANN’s in het komende decennium mensen in een kwart van de bestaande beroepen zullen kunnen vervangen steeds groter. .

Voor wie meer wil weten

• De Grote Neurale Oorlog: wat Google werkelijk van plan is
• Hoe cognitieve computers onze toekomst kunnen veranderen