Nevrale nettverk for nybegynnere - et nevralt nettverk for dummies. Hvordan et nevralt nettverk fungerer: algoritmer, trening, aktivering og tapsfunksjoner Hvordan lage et nevralt nettverk for et spill

Nylig, mer og oftere snakker de om de såkalte nevrale nettverkene, sier de, snart vil de bli brukt aktivt i robotikk, og i maskinteknikk, og i mange andre områder av menneskelig aktivitet, men algoritmene til søkemotorer, samme Google, begynner allerede sakte å bruke dem. arbeid. Hva er disse nevrale nettverkene, hvordan fungerer de, hva er deres applikasjoner og hvordan de kan være nyttige for oss, les om alt dette videre.

Hva er nevrale nettverk

Nevrale nettverk er et av områdene for vitenskapelig forskning innen feltet for å skape kunstig intelligens (AI), som er basert på ønsket om å etterligne det menneskelige nervesystemet. Inkludert hennes (nervesystemet) evne til å rette opp feil og selvlære. Alt dette, selv om det er noe grovt, bør tillate oss å simulere arbeidet til den menneskelige hjernen.

Biologiske nevrale nettverk

Men denne definisjonen i avsnittet ovenfor er rent teknisk, men når vi snakker på biologiens språk, er det nevrale nettverket det menneskelige nervesystemet, det settet med nevroner i hjernen vår, takket være hvilke vi tenker, tar visse avgjørelser, oppfatter verden rundt oss.

Et biologisk nevron er en spesiell celle som består av en kjerne, en kropp og prosesser som dessuten har et nært forhold til tusenvis av andre nevroner. Gjennom denne forbindelsen overføres konstant elektrokjemiske impulser, noe som bringer hele det nevrale nettverket inn i en tilstand av spenning eller omvendt. For eksempel vil en hyggelig og samtidig spennende begivenhet (møte en kjær, vinne en konkurranse, etc.) generere en elektrokjemisk impuls i det nevrale nettverket som er plassert i hodet vårt, som vil føre til eksitasjon. Som et resultat vil det nevrale nettverket i hjernen vår overføre sin eksitasjon til andre organer i kroppen vår og føre til økt hjertefrekvens, hyppigere blinking med øynene, etc.

Her på bildet er en svært forenklet modell av det biologiske nevrale nettverket i hjernen. Vi ser at et nevron består av en cellekropp og en kjerne, cellekroppen har på sin side mange forgrenede fibre kalt dendritter. Lange dendritter kalles aksoner og har en lengde som er mye større enn vist i denne figuren, gjennom aksoner utføres kommunikasjon mellom nevroner, takket være dem fungerer det biologiske nevrale nettverket i hodene våre.

Historie om nevrale nettverk

Hva er historien om utviklingen av nevrale nettverk innen vitenskap og teknologi? Det har sin opprinnelse med ankomsten av de første datamaskinene eller datamaskinene (elektroniske datamaskiner) som de ble kalt på den tiden. Så tilbake på slutten av 1940-tallet utviklet en viss Donald Hebb en nevrale nettverksmekanisme, som fastsatte reglene for undervisning av datamaskiner, disse "protodatamaskinene".

Den videre kronologien av hendelsene var som følger:

• I 1954 finner den første praktiske bruken av nevrale nettverk i driften av datamaskiner sted.
• I 1958 utviklet Frank Rosenblatt en algoritme for mønstergjenkjenning og en matematisk merknad for den.
• På 1960-tallet bleknet interessen for utvikling av nevrale nettverk noe på grunn av datidens svake datakraft.
• Og det ble gjenopplivet igjen allerede på 1980-tallet, det var i denne perioden et system med en tilbakemeldingsmekanisme dukket opp, selvlærende algoritmer ble utviklet.
• I 2000 hadde kraften til datamaskiner vokst så mye at de var i stand til å realisere de villeste drømmene til fortidens forskere. På dette tidspunktet dukket det opp programmer for stemmegjenkjenning, datasyn og mye mer.

Kunstige nevrale nettverk

Kunstige nevrale nettverk blir ofte forstått som datasystemer som har evnen til å lære seg selv, gradvis øke ytelsen. Hovedelementene i den nevrale nettverksstrukturen er:

• Kunstige nevroner, som er elementære sammenkoblede enheter.
• er en forbindelse som brukes til å sende og motta informasjon mellom nevroner.
• Et signal er den faktiske informasjonen som skal overføres.

Anvendelse av nevrale nettverk

Omfanget av kunstige nevrale nettverk utvides hvert år, i dag brukes de på områder som:

• Maskinlæring er en type kunstig intelligens. Den er basert på AI-trening på eksemplet med millioner av oppgaver av samme type. I dag implementeres maskinlæring aktivt av søkemotorene Google, Yandex, Bing, Baidu. Så basert på millioner av søk som vi alle legger inn på Google hver dag, lærer algoritmene deres å vise oss de mest relevante resultatene slik at vi kan finne akkurat det vi leter etter.
• I robotikk brukes nevrale nettverk i utviklingen av en rekke algoritmer for jern-"hjernene" til roboter.
• Datasystemarkitekter bruker nevrale nettverk for å løse problemet med parallell databehandling.
• Ved hjelp av nevrale nettverk kan matematikere løse ulike komplekse matematiske problemer.

Typer nevrale nettverk

Generelt brukes forskjellige typer og typer nevrale nettverk til forskjellige oppgaver, blant annet kan vi skille:

• konvolusjonelle nevrale nettverk,
• tilbakevendende nevrale nettverk,
• Hopfield nevrale nettverk.

Konvolusjonelle nevrale nettverk

Konvolusjonelle nettverk er en av de mest populære typene kunstige nevrale nettverk. Så de beviste sin effektivitet i visuell mønstergjenkjenning (video og bilder), anbefalingssystemer og språkbehandling.

• Konvolusjonelle nevrale nettverk er svært skalerbare og kan brukes til mønstergjenkjenning av enhver stor oppløsning.
• Disse nettverkene bruker volumetriske tredimensjonale nevroner. Innenfor ett lag er nevroner bare forbundet med et lite felt, kalt det reseptive laget.
• Nevronene til nabolagene er koblet sammen gjennom mekanismen for romlig lokalisering. Arbeidet til mange slike lag leveres av spesielle ikke-lineære filtre som reagerer på et økende antall piksler.

Tilbakevendende nevrale nettverk

Tilbakevendende nevrale nettverk er de hvis forbindelser mellom nevroner danner en indikativ syklus. Har følgende egenskaper:

• Hver forbindelse har sin egen vekt, som også er en prioritet.
• Noder er delt inn i to typer, innledende noder og skjulte noder.
• Informasjon i et tilbakevendende nevralt nettverk overføres ikke bare i en rett linje, lag for lag, men også mellom nevronene selv.
• Et viktig kjennetegn ved et tilbakevendende nevralt nettverk er tilstedeværelsen av det såkalte "oppmerksomhetsområde", når maskinen kan gis visse biter av data som krever forbedret behandling.

Tilbakevendende nevrale nettverk brukes til å gjenkjenne og behandle tekstdata (i frekvens er de basert på Google-oversetter, Yandex Palekh-algoritmen og Apple Siri-taleassistenten).

Nevrale nettverk, video

Og til slutt, en interessant video om nevrale nettverk.

Da jeg skrev artikkelen prøvde jeg å gjøre den så interessant, nyttig og av høy kvalitet som mulig. Jeg vil være takknemlig for tilbakemeldinger og konstruktiv kritikk i form av kommentarer til artikkelen. Du kan også skrive ditt ønske/spørsmål/forslag til min mail [e-postbeskyttet] eller på Facebook, med respekt, forfatteren.

Hvis du er en erfaren fotballspiller som leser defensive diagrammer like lett som gateskilt, eller en filmstjerne hvis navn alene kan lage en filmboks, eller en aksjemegler som kan sakene sine bedre enn Warren Buffett, så gratulerer: du vil bli verdsatt så mye, akkurat som en dataforsker eller maskinlæringsingeniør med en doktorgrad fra Stanford, MIT eller Carnegie Mellon University. Hvert selskap i Silicon Valley - og flere og flere selskaper i andre regioner - søker å få slike spesialister som deltar i en slags spill for å fange flagget, bare innen personalpolitikk. Bedrifter innser i økende grad at deres konkurranseevne avhenger av bruk av maskinlæring og, og antallet ledige stillinger for spesialister på disse områdene langt overstiger hva andre supermakter trenger.

Men hva om du kunne høste fordelene ved å bruke AI uten å måtte ansette de sjeldne og dyre talentene? Hva om denne inngangsterskelen kan senkes med smart programvare? Kan dyp læring brukes med en mindre mangfoldig arbeidsstyrke?

En oppstart kalt Bonsai og en hel gruppe lignende selskaper svarer ja på dette spørsmålet. Gjør deg klar til å demokratisere kunstig intelligens. En dag kan denne bevegelsen forene millioner, om ikke milliarder, av mennesker under sitt banner.

På O'Reilly AI Developers Conference i New York holdt Bonsai-sjef Mark Hammond en presentasjon av selskapet sitt. (Han annonserte også en investeringsrunde på 6 millioner dollar – ikke så mye penger gitt at AI VC-investeringen allerede er på 1,5 milliarder dollar i år.) Presentasjonen inkluderte en gjentakelse av en av de mest kjente prestasjonene til eliteutvikleres dyplæring: å kjøre DeepMind-algoritmen av gamle spill for Atari-datamaskiner i sanntid. Spesielt et spill kalt Breakout ("Tennis"), der plattformen treffer en firkantet "ball" som bryter flimrende blokker. (Spillet, utgitt i 1976, var et gjennombrudd for sin tid - han jobbet med det selv)

37 linjer med kode - hele strukturen til det nevrale nettverket, som trenes gjennom det klassiske Atari-spillet. Kilde: Bonsai

DeepMind-varianten ble skapt av verdens beste AI-eksperter som lærte det nevrale nettverket det grunnleggende om Atari-spill, og resultatet av arbeidet deres var verdig vitenskapelige publikasjoner i verdensklasse. Bonsai-versjonen er en forenkling. Det hele starter med et utviklingssystem som lastes opp til skyen. Bare én programmerer, selv en som ikke har studert det grunnleggende om AI i det hele tatt, kan beskrive spillet i generelle termer, og systemet vil selv velge den passende læringsalgoritmen for å bruke det nevrale nettverket. (De stakkars doktorgradsstudentene ved DeepMind måtte skrive disse algoritmene på egen hånd.) På dette stadiet trenger programmereren bare å legge ned de grunnleggende prinsippene for spillet i løpet av et par minutter - for eksempel "fange ballen på plattformen" - og så vil Bonsai selv utvikle det nevrale nettverket og optimere det til det beste resultat. Og det nevrale nettverket ved utgangen vil allerede spille "Tennis" selv.

Versjonen av spillet skrevet av Bonsai er bare 37 linjer med kode. Men denne enkelheten er villedende. Når Hammond forklarer hva som er kjernen i algoritmen, viser han en tegning som viser hvordan systemet hans bygger et nevralt nettverk som kan konkurrere med en av de beste kreasjonene til Google. Programmereren selv trengte ikke engang å fordype seg i forviklingene ved maskinlæring. Se, mamma, jeg klarer meg uten hendene til en doktorgrad!

Dette er hvordan et nevralt nettverk trent av Bonsai-systemet spiller tennis. Kilde: Bonsai

Imponerende triks. "Vanligvis er det vanskelig å imponere meg med en demo," sier George Williams, en stipendiat ved New York Universitys Courant Institute of Mathematics. – Det Mark viste meg var imidlertid ganske ekte og samtidig fantastisk. Han tok alle prestasjoner av maskinintelligens og skapte verktøyene som vil tillate utviklingen av en ny generasjon AI-systemer."

Det er ennå ikke klart om Bonsai vil forbli lederen av denne bevegelsen. Men Williams har rett. Det neste trinnet i den uunngåelige fremveksten av stadig smartere datamaskiner vil være utviklingen av maskinlæringsverktøy for (relative) dummies.

Bonsai ble født på stranden. Hammond, en tidligere programvareingeniør og evangelist, har tenkt på mulighetene for kunstig intelligens i noen tid. Etter å ha forlatt Microsoft i 2004, flyttet han til nevrovitenskap ved Yale, og i 2010 hadde han en kort periode hos Numenta, en AI-oppstart eid av Jeff Hawkins (medgründer av Palm, PDA-produsenten). Hammond åpnet deretter et annet selskap i et helt annet felt, som han deretter solgte.

Så, i 2012, kom Hammond til Sør-California for å besøke venner. Den lille sønnen hans var sliten og alle gikk tilbake til bilen. Mens kona til Hammond pratet med venner og sønnen sovnet i armene hans, kjørte han et tankeeksperiment. I hjertet av dette eksperimentet var et populært meme fra AI-verdenen - konseptet "mesteralgoritme". Professor Pedro Dominguez fra University of Washington skrev i en bok med samme navn at denne ennå ikke opprettede algoritmen kan være et universalmiddel for alle problemene i industrien. I teorien, når denne algoritmen fortsatt er oppfunnet, vil det med hjelpen være mulig å metodisk introdusere AI-systemer hvor som helst.

Hammond konkluderte med at vi må lage et system som lar selv den mest vanlige utviklere bruke AI-verktøy. Men Hammond så en feil i denne ideen. «Anta at vi fant denne mesteralgoritmen,» sa han til seg selv mens hans 18 måneder gamle sønn døset i armene hans, «hvem ville implementert den i utallige mulige scenarier?» For øyeblikket er det bare ekte maskinlæringseksperter som kan bruke slike verktøy. Mulighetene for å bruke AI vil være for mange for et begrenset antall av disse menneskene. Så han kom til den konklusjonen at han trengte å lage et system som ville senke adgangsbarrieren og la selv den mest middelmådige utvikleren bruke disse verktøyene. Et slikt system vil ikke trenge høyt spesialiserte ingeniører for å trene nevrale nettverk. Programmerere vil kunne trene dem selv for å få ønsket resultat.

Mens Hammond funderte over ideene sine, trakk han analogier til programmeringshistorien. I utgangspunktet måtte dataoperatører møysommelig skrive koden som fikk utstyret til å fungere. Så tok programmererne i bruk et sett med standardinstruksjoner som ble kalt assemblerspråk og satte fart på prosessen – men du måtte fortsatt ha et veldig høyt treningsnivå for å få det riktig. Gjennombruddet kom da ingeniører laget en kompilator - et program som konverterte kode på mer praktiske, såkalte "høynivå"-språk (fra den aller første BASIC og LISP til nåværende Python og C), til assemblerspråkkode . Først etter det ble opprettelsen av kraftige applikasjoner tilgjengelig selv for relativt lavt nivå fagfolk. Hammond mener at nå, takket være Googles TensorFlow, har AI-systemer nådd nivået av assemblerspråk, det vil si at det allerede blir lettere for ingeniører å lage nevrale nettverk, men det er fortsatt tilgjengelig for de som virkelig forstår hvordan de fungerer. . Hammond ønsket å lage en kompilatoranalog for å forenkle ting enda mer.

Han presenterte ideen til Kean Brown, en tidligere Microsoft-kollega som nylig solgte spilloppstarten sin til et kinesisk internettselskap. Han likte ideen, fordi han på den tiden bare prøvde å gjøre maskinlæring ved å bruke verktøyene som var tilgjengelige på den tiden. "Generelt er jeg ikke en dum person," sier Brown. "Jeg kom til Kina og lærte språket deres, jobbet som programmerer i Microsoft, men selv for meg var det for mye." Han gikk med på å være med å grunnlegge Bonsai. (Navnet ble valgt fordi denne japanske kunsten har en perfekt balanse mellom det naturlige og det kunstige. En annen fordel kom da Internett-domeneeierne lot det nye selskapet registrere siden deres på bons.ai.)

Bonsai er ikke det eneste selskapet som jobber for å møte mangelen på dyktige AI-fagfolk. Noen av de større selskapene innså behovet for å trene opp sin egen arbeidsstyrke og trene vanlige programmerere til å bli nevrale nettverksmestere: Google opprettet en hel rekke interne programmer, og Apple begynte å ta hensyn til ferdighetene og personlige egenskapene til programmerere som ville hjelpe dem raskt mestre de nødvendige ferdighetene. Som nevnt ovenfor har Google også gitt ut TensorFlow-programmet til publikum, takket være det er det lettere for ingeniørene å lage nevrale nettverk. Andre AI-verktøysett er allerede tilgjengelige, og det vil uten tvil komme flere slike verktøy.

"Vi åpner for nye muligheter for de som ikke er forskere eller programmerere" Samtidig jobber også andre startups med å demokratisere AI. Bottlenose adresserer mangelen på forskere, men for en annen målgruppe: Hvis Bonsai produserer produktet sitt primært for programvareutviklere, planlegger Bottlenose å gjøre livet enklere for forretningsanalytikere. Motivene er imidlertid de samme. "Vi åpner for nye muligheter for de som ikke er forskere eller programmerere," sier administrerende direktør Nova Spivak. Noen startups kommer til å nå enda flere brukere: Clarifais presentasjon på O'Reilly-konferansen ble kalt "How to make sure that every person on the planet can teach and use AI."

Så selv om Bonsai ser ut til å ha kommet til rett tid på rett sted, er AI-industrien så blomstrende akkurat nå at Hammonds oppstart kan ha vanskelig for å trekke oppmerksomhet til seg selv. Adam Cheyer, en AI-spesialist som var med på å skape og nå er sjefingeniør, har allerede sett Bonsai-produktet og ble veldig imponert. Men han bemerker at selv om Bonsai gjør AI tilgjengelig selv for nybegynnere, må folk fortsatt anstrenge seg for å finne ut programmeringsspråket og den generelle systemdesignen. «Når et stort selskap som Google lanserer et nytt produkt, skynder folk seg å prøve det. Men hvis en startup lager det samme produktet, er det mye vanskeligere å tiltrekke folk til det. Vil de være sterke nok til å engasjere nok brukere til å gjøre verktøyet deres populært? Om Bonsai vil lykkes eller ikke er vanskelig å si akkurat nå.»

Selskapet har bygget et system med flere komponenter, inkludert Brain, et skybasert system for å bygge nevrale nettverk, et skriptspråk kalt Inkling, og Mastermind, et "integrert utviklingsmiljø" som gir programmerere alle verktøyene de trenger på ett sted . ("En app for å bygge apper," forklarer Brown). Bonsai-systemet er tilgjengelig for betatesting.

Mark Hammond ved Bonsai-hovedkvarteret i sentrum av Berkeley. Foto: Backchannel

Som Hammond forklarer, skiller det å bygge et nevralt nettverk med Bonsai seg på flere viktige måter fra hvordan proffene gjør det. I dag må du bestemme deg for hvilke verktøy som er best for å løse et problem, og denne løsningen krever kunnskap og erfaring. Ifølge Hammond gjør Bonsai det for deg. Alt du trenger å gjøre er å legge ut det grunnleggende om hva du vil lære systemet.

Så mens erfarne AI-systemingeniører "trener" nettverket ved å sammenligne resultatet med ønsket resultat (for eksempel vise nettverksbilder av hunder og belønne det med utdata av passende egenskaper), lar Bonsai deg "lære" systemet ved å ganske enkelt bryte ned hele prosessen i grunnleggende prinsipper. . For å fortsette med hundeeksemplet kan du nevne ting som fire ben, en snute og en tunge som henger ut av munnen. Du gir bare den nødvendige basen, og Bonsai sin skybaserte "smarte motor", som inkluderer "hjernen", bringer saken til slutten.

Denne tilnærmingen har en indirekte positiv effekt: forskere som har trent opp et tradisjonelt nevralt nettverk har ofte ingen anelse om nøyaktig hvordan magien gjøres, fordi slike nettverk i utgangspunktet rekonfigurerer seg selv, og organiserer alt på en måte som bare de kan forstå. Når det gjelder Bonsai, kan du forstå prinsippene for nettverkstenkning i henhold til reglene som brukeren har fastsatt. "Programvare bør ikke være en svart boks," sier Hammond. Hvis du for eksempel lager et program for et ubemannet kjøretøy og det ikke stoppet i rett øyeblikk, bør du kunne fordype deg i og forstå hvorfor systemet tok en slik beslutning. På omtrent samme måte forklarer Amazon hvorfor denne eller den boken dukket opp i anbefalingene dine.

Et stort spørsmål om Bonsai-tilnærmingen er om alle disse abstrakte tingene vil redusere ytelse og effektivitet. Dette er vanligvis hva som skjer når du bruker kompilatorer: programmer som er skrevet med dem, fungerer ikke like raskt og effektivt som de som er skrevet på assemblerspråk og overføres direkte til maskinvaren. I tillegg, å si at et system som selv velger et verktøy for bruk gjør det bedre enn de professorene som ser ut til å ikke lenger trenger å bygge nevrale nettverk, det ville være en klar overdrivelse.

"Jeg tror du alltid må inngå kompromisser," sier Laila Tretikov, en AI-spesialist som tidligere fungerte som leder av Wikimedia Foundation og ga Bonsai råd. – Resultatene blir ikke helt de samme som om man involverer en gruppe forskere. Men jeg er ikke sikker på hva som er viktigst: kvaliteten eller evnen til å gjøre det selv." Vivs Adam Cheyer antyder også at Bonsai-kode kanskje ikke fungerer like effektivt som programvare som er optimalisert for en spesifikk oppgave. "Men det er fortsatt jævla bra kode, og det holder deg fra å gå inn i unødvendige detaljer," legger han til. Cheyer sier også at selskapet hans, der slike verdifulle AI-spesialister jobber, sannsynligvis ikke vil bruke Bonsai - bortsett fra å prototype noen av ideene før de implementerer den på den gamle velprøvde måten.

Bonsai hjelper bevegelsen med å bringe kunstig intelligens til utrente Hammond forsikrer på sin side at tapet i kvalitet ved bruk av Bonsai slett ikke er stort. "Produktiviteten øker over tid," sier han, "du må bare tro det." En dag vil det være mulig ikke bare å tro det, men også å sjekke det.

Bonsai har store planer for de neste månedene. Snart vil selskapet kunngjøre et samarbeid med komponentprodusenten Nvidia, og Bonsai-kunder vil kunne få bedre resultater når de bruker utstyr av dette merket. Selskapet vil også publisere informasjon om avtalen med Siemens TTB-senteret, som har testet Bonsai-systemet innen automatisering og produksjonskontroll de siste månedene.

Bonsai prøver å løse problemer som selv de mektigste selskapene ikke kunne løse. "Vi jobber med mange spill," legger Hammond til, og forklarer at spillene løser nøkkelproblemer som Bonsai planlegger å løse. «Noen spill egner seg ikke engang til DeepMind. Selv om de har lært algoritmen deres å spille mange spill i tillegg til tennis, er systemet deres ennå ikke i stand til å spille Pac-Man.

Men enda viktigere, hvordan Bonsai hjelper bevegelsen med å bringe AI til utrente. Over tid vil verktøy på høyt nivå bli kraftigere og til slutt bli allestedsnærværende. Kommer vi til et punkt hvor alle kan trene og bruke kunstig intelligens? La oss si det slik: det er satset mye penger på nettopp dette scenariet.

Et kunstig nevralt nettverk er en samling nevroner som samhandler med hverandre. De er i stand til å motta, behandle og lage data. Det er like vanskelig å forestille seg som arbeidet til den menneskelige hjerne. Det nevrale nettverket i hjernen vår fungerer slik at du nå kan lese dette: nevronene våre gjenkjenner bokstavene og setter ord på dem.

Et kunstig nevrale nettverk er som en hjerne. Det ble opprinnelig programmert for å forenkle noen komplekse beregningsprosesser. I dag har nevrale nettverk mye flere muligheter. Noen av dem er på smarttelefonen din. En annen del har allerede registrert i databasen at du åpnet denne artikkelen. Hvordan alt dette skjer og hvorfor, les videre.

Hvordan det hele startet

Folk ønsket virkelig å forstå hvor en persons sinn kommer fra og hvordan hjernen fungerer. I midten av forrige århundre forsto den kanadiske nevropsykologen Donald Hebb dette. Hebb studerte samspillet mellom nevroner med hverandre, undersøkte prinsippet der de kombineres i grupper (vitenskapelig - ensembler) og foreslo den første algoritmen i vitenskapen for å trene nevrale nettverk.

Noen år senere modellerte en gruppe amerikanske forskere et kunstig nevralt nettverk som kunne skille kvadratiske former fra andre former.

Hvordan fungerer et nevralt nettverk?

Forskerne fant ut at et nevralt nettverk er en samling av lag av nevroner, som hver er ansvarlig for å gjenkjenne et spesifikt kriterium: form, farge, størrelse, tekstur, lyd, volum osv. År etter år, som et resultat av millioner av eksperimenter og tonnevis av beregninger, ble det enkleste nettverket lagt til nye og nye lag med nevroner. De bytter på å jobbe. For eksempel bestemmer den første om en firkant er eller ikke er en firkant, den andre forstår om firkanten er rød eller ikke, den tredje beregner størrelsen på firkanten, og så videre. Ikke firkanter, ikke røde og upassende størrelser faller inn i nye grupper av nevroner og blir undersøkt av dem.

Hva er nevrale nettverk og hva kan de gjøre?

Forskere har utviklet nevrale nettverk slik at de har lært å skille mellom komplekse bilder, videoer, tekster og tale. Det finnes mange typer nevrale nettverk i dag. De er klassifisert avhengig av arkitekturen - sett med dataparametere og vekten av disse parameterne, en viss prioritet. Nedenfor er noen av dem.

Konvolusjonelle nevrale nettverk

Nevroner er delt inn i grupper, hver gruppe beregner karakteristikken gitt til den. I 1993 viste den franske forskeren Jan LeCun verden LeNet 1, det første konvolusjonelle nevrale nettverket som raskt og nøyaktig kunne gjenkjenne tall skrevet på papir for hånd. Se for deg selv:

I dag brukes konvolusjonelle nevrale nettverk hovedsakelig til multimedieformål: de jobber med grafikk, lyd og video.

Tilbakevendende nevrale nettverk

Nevroner husker konsekvent informasjon og bygger videre handlinger basert på disse dataene. I 1997 modifiserte tyske forskere de enkleste tilbakevendende nettverkene til nettverk med et langt korttidsminne. Basert på dem ble det deretter utviklet nettverk med kontrollerte tilbakevendende nevroner.

I dag, ved hjelp av slike nettverk, skrives og oversettes tekster, programmeres roboter som fører meningsfulle dialoger med en person, koder for sider og programmer lages.

Bruken av denne typen nevrale nettverk er muligheten til å analysere og generere data, kompilere databaser og til og med lage spådommer.

I 2015 ga SwiftKey ut verdens første tastatur drevet av et tilbakevendende nevralt nettverk med kontrollerte nevroner. Deretter ga systemet hint i prosessen med å skrive basert på de siste ordene som ble skrevet inn. I fjor trente utviklerne det nevrale nettverket til å lære konteksten til den maskinskrevne teksten, og hintene ble meningsfulle og nyttige:

Kombinerte nevrale nettverk (konvolusjonelt + tilbakevendende)

Slike nevrale nettverk er i stand til å forstå hva som er på bildet og beskrive det. Og omvendt: tegn bilder i henhold til beskrivelsen. Det klareste eksemplet ble demonstrert av Kyle Macdonald, som tok et nevralt nettverk en tur rundt i Amsterdam. Nettverket bestemte umiddelbart hva som var foran det. Og nesten alltid nøyaktig:

Nevrale nettverk er hele tiden selvlærende. Gjennom denne prosessen:

1. Skype har introdusert muligheten for simultanoversettelse for 10 språk. Blant dem, for et øyeblikk, er det russisk og japansk - en av de vanskeligste i verden. Selvfølgelig trenger kvaliteten på oversettelsen alvorlig forbedring, men selve det faktum at du selv nå kan kommunisere med kolleger fra Japan på russisk og være sikker på at du blir forstått er inspirerende.

2. Yandex opprettet to søkealgoritmer basert på nevrale nettverk: Palekh og Korolev. Den første hjalp til med å finne de mest relevante nettstedene for lavfrekvente søk. "Palekh" studerte titlene på sidene og sammenlignet deres betydning med betydningen av forespørsler. På grunnlag av Palekh dukket Korolev opp. Denne algoritmen evaluerer ikke bare tittelen, men også hele tekstinnholdet på siden. Søket blir mer nøyaktig, og nettstedeiere begynner å nærme seg innholdet på sidene mer intelligent.

3. Kolleger av SEO-spesialister fra Yandex har opprettet et musikalsk nevralt nettverk: det komponerer poesi og skriver musikk. Nevrogruppen heter symbolsk Neurona, og de har allerede sitt første album:

4. Google Inbox bruker nevrale nettverk for å svare på en melding. Utviklingen av teknologi er i full gang, og i dag studerer nettverket allerede korrespondanse og genererer mulige svar. Du kan ikke kaste bort tid på å skrive og ikke være redd for å glemme en viktig avtale.

5. YouTube bruker nevrale nettverk for å rangere videoer, og i henhold til to prinsipper samtidig: det ene nevrale nettverket studerer videoer og publikumsreaksjoner på dem, det andre forsker på brukere og deres preferanser. Det er derfor YouTube-anbefalinger alltid er på temaet.

6. Facebook jobber aktivt med DeepText AI – et kommunikasjonsprogram som forstår sjargong og renser chatter fra uanstendig ordforråd.

7. Applikasjoner som Prisma og Fabby, bygget på nevrale nettverk, lager bilder og videoer:

Colorize gjenoppretter farge til svart-hvitt-bilder (overrask bestemor!).

MakeUp Plus velger den perfekte leppestiften for jenter fra en rekke ekte merker: Bobbi Brown, Clinique, Lancome og YSL er allerede i gang.

8. Apple og Microsoft oppgraderer stadig sine nevrale Siri og Contana. Foreløpig følger de bare våre ordre, men i nær fremtid vil de begynne å ta initiativet: å gi anbefalinger og forutse våre ønsker.

Og hva annet venter oss i fremtiden?

Selvlærende nevrale nettverk kan erstatte mennesker: de vil begynne med tekstforfattere og korrekturlesere. Allerede nå lager roboter tekster med mening og uten feil. Og de gjør det mye raskere enn folk. De vil fortsette med ansatte i kundesentre, teknisk støtte, moderatorer og administratorer av publikum i sosiale nettverk. Nevrale nettverk vet allerede hvordan de skal lære manuset og spille det med stemmen din. Hva med andre områder?

Landbrukssektoren

Det nevrale nettverket skal implementeres i spesialutstyr. Combines vil autopilote, skanne planter og studere jorda, og overføre data til det nevrale nettverket. Hun vil bestemme - å vanne, gjødsle eller sprøyte fra skadedyr. I stedet for et par dusin arbeidere vil det maksimalt være behov for to spesialister: en tilsynsførende og en teknisk.

Medisinen

Microsoft jobber nå aktivt med å lage en kur mot kreft. Forskere er engasjert i bioprogrammering - de prøver å digitalisere prosessen med fremveksten og utviklingen av svulster. Når alt ordner seg, vil programmerere kunne finne en måte å blokkere en slik prosess på, analogt vil en medisin bli laget.

Markedsføring

Markedsføring er svært personlig tilpasset. Allerede kan nevrale nettverk på sekunder bestemme hvilken bruker, hvilket innhold og til hvilken pris som skal vises. I fremtiden vil markedsførerens deltakelse i prosessen reduseres til et minimum: nevrale nettverk vil forutsi forespørsler basert på data om brukeratferd, skanne markedet og gi de best egnede tilbudene innen en person tenker på å kjøpe.

E-handel

E-handel vil bli implementert overalt. Du trenger ikke lenger å gå til nettbutikken ved å bruke lenken: du kan kjøpe alt der du ser det med ett klikk. Du leser for eksempel denne artikkelen noen år senere. Du liker virkelig leppestiften på skjermen fra MakeUp Plus-appen (se over). Du klikker på den og går rett til handlekurven. Eller se en video om de nyeste Hololens (mixed reality-brillene) og legg inn en bestilling rett fra YouTube.

På nesten alle felt vil spesialister med kunnskap eller i det minste forståelse for strukturen til nevrale nettverk, maskinlæring og kunstig intelligens-systemer bli verdsatt. Vi vil eksistere side om side med roboter. Og jo mer vi vet om dem, jo ​​roligere vil vi leve.

P.S. Zinaida Falls er et Yandex nevrale nettverk som skriver poesi. Vurder arbeidet som maskinen skrev, etter å ha lært om Mayakovsky (stavemåte og tegnsetting bevart):

« Dette»

dette
bare
noe
i fremtiden
og kraft
den personen
er det alt eller ikke
det er blod rundt omkring
avtale
bli fet
herlighet kl
land
med en sprekk i nebbet

Imponerende, ikke sant?

Mange av begrepene i nevrale nettverk er relatert til biologi, så la oss starte fra begynnelsen:

Hjernen er en kompleks ting, men den kan også deles inn i flere hoveddeler og operasjoner:

Årsaken kan være innvendig(for eksempel et bilde eller en idé):

La oss nå se på det grunnleggende og forenklede deler hjerne:

Hjernen er som et kabelnettverk.

Nevron- hovedberegningsenheten i hjernen, den mottar og behandler de kjemiske signalene fra andre nevroner, og, avhengig av en rekke faktorer, gjør den enten ingenting eller genererer en elektrisk impuls, eller Action Potential, som deretter sender signaler til nabonevroner gjennom synapser i slekt nevroner:

Drømmer, minner, selvregulerende bevegelser, reflekser, og faktisk alt du tenker eller gjør - alt skjer takket være denne prosessen: millioner eller til og med milliarder av nevroner jobber på forskjellige nivåer og skaper forbindelser som skaper forskjellige parallelle delsystemer og representerer et biologisk nevrale nettverket. nett.

Selvfølgelig er disse alle forenklinger og generaliseringer, men takket være dem kan vi beskrive en enkel
nevrale nettverket:

Og beskriv det formalisert ved hjelp av en graf:

Litt forklaring kreves her. Sirkler er nevroner, og linjer er forbindelser mellom dem,
og for ikke å komplisere på dette stadiet, sammenkoblinger representerer en direkte flyt av informasjon fra venstre til høyre. Det første nevronet er for øyeblikket aktivt og er uthevet i grått. Vi har også tildelt den et tall (1 hvis det fungerer, 0 hvis det ikke gjør det). Tall mellom nevroner viser vekt forbindelser.

Grafene ovenfor viser tiden til nettverket, for en mer nøyaktig visning må du dele den inn i tidsintervaller:

For å lage ditt eget nevrale nettverk, må du forstå hvordan vekter påvirker nevroner og hvordan nevroner lærer. Som et eksempel, la oss ta en kanin (prøvekanin) og sette den i forholdene til et klassisk eksperiment.

Når en trygg luftstrøm rettes mot dem, blinker kaniner, som mennesker:

Denne atferdsmodellen kan tegnes med grafer:

Som i forrige diagram viser disse grafene kun øyeblikket når kaninen føler et pust, og vi dermed kode puff som en boolsk verdi. I tillegg beregner vi om det andre nevronet avfyrer basert på verdien av vekten. Hvis det er lik 1, fyrer det sensoriske nevronet, vi blinker; hvis vekten er mindre enn 1, blinker vi ikke: det andre nevronet grense- 1.

La oss introdusere et element til - et trygt lydsignal:

Vi kan modellere kanininteresse slik:

Hovedforskjellen er at nå er vekten null, så vi fikk ikke en blinkende kanin, vel, ikke ennå, i hvert fall. Nå skal vi lære kaninen å blinke på kommando, blande
irriterende stoffer (pip og pust):

Det er viktig at disse hendelsene skjer på ulike tidspunkt æra, i grafer vil det se slik ut:

Lyden i seg selv gjør ingenting, men luftstrømmen får likevel kaninen til å blinke, og dette viser vi gjennom vektene ganger stimuli (i rødt).

utdanning kompleks oppførsel kan forenkles som en gradvis endring i vekt mellom tilkoblede nevroner over tid.

For å trene en kanin, gjenta trinnene:

For de tre første forsøkene vil diagrammene se slik ut:

Vær oppmerksom på at vekten for lydstimulusen øker etter hver repetisjon (uthevet i rødt), denne verdien er nå vilkårlig - vi valgte 0,30, men tallet kan være hva som helst, til og med negativt. Etter den tredje repetisjonen vil du ikke merke en endring i oppførselen til kaninen, men etter den fjerde repetisjonen vil noe fantastisk skje - oppførselen vil endre seg.

Vi fjernet eksponeringen for luft, men kaninen blinker fortsatt når den hører pipetonen! Vår siste skjema kan forklare denne oppførselen:

Vi trente kaninen til å reagere på lyd ved å blinke.

I et reelt eksperiment av denne typen kan det kreves mer enn 60 repetisjoner for å oppnå et resultat.

Nå skal vi forlate den biologiske verdenen til hjernen og kaninene og prøve å tilpasse alt det
lært å lage et kunstig nevralt nettverk. Først, la oss prøve å gjøre en enkel oppgave.

La oss si at vi har en maskin med fire knapper som serverer mat når den rette trykkes.
knapper (vel, eller energi hvis du er en robot). Oppgaven er å finne ut hvilken knapp som gir en belønning:

Vi kan skildre (skjematisk) hva en knapp gjør når den trykkes slik:

Det er bedre å løse et slikt problem som helhet, så la oss se på alle mulige resultater, inkludert det riktige:

Klikk på den tredje knappen for å få middagen din.

For å reprodusere et nevralt nettverk i kode, må vi først lage en modell eller graf som nettverket kan kartlegges til. Her er en passende graf for oppgaven, i tillegg viser den godt sitt biologiske motstykke:

Dette nevrale nettverket mottar ganske enkelt input - i dette tilfellet vil det være oppfatningen av hvilken knapp som ble trykket. Deretter erstatter nettverket inndatainformasjonen med vekter og trekker en konklusjon basert på tillegget av laget. Det høres litt forvirrende ut, men la oss se hvordan knappen er representert i modellen vår:

Merk at alle vekter er 0, så det nevrale nettverket, som en baby, er helt tomt, men fullstendig sammenkoblet.

Dermed matcher vi en ekstern hendelse med inngangslaget til det nevrale nettverket og beregner verdien ved utgangen. Det kan eller ikke faller sammen med virkeligheten, men vi vil ignorere dette foreløpig og begynne å beskrive oppgaven på en måte som er forståelig for datamaskinen. La oss starte med å legge inn vektene (vi bruker JavaScript):

Var-innganger = ; var vekter = ; // For enkelhets skyld kan disse vektorene kalles
Det neste trinnet er å lage en funksjon som samler inn inngangsverdier og vekter og beregner utgangsverdien:

Function evaluateNeuralNetwork(inputVector, weightVector)( var result = 0; inputVector.forEach(function(inputValue, weightIndex) ( layerValue = inputValue*weightVector; result += layerValue; )); return (result.toFixed(2)); ) / / Kan virke komplisert, men alt det gjør er å matche vekt/inndata-parene og legge til resultatet
Som forventet, hvis vi kjører denne koden, vil vi få samme resultat som i vår modell eller graf...

EvaluateNeuralNetwork(innganger, vekter); // 0,00
Live eksempel: Neural Net 001.

Det neste trinnet i å forbedre vårt nevrale nettverk vil være en måte å sjekke sin egen utgang eller resulterende verdier på samme måte som den virkelige situasjonen,
la oss først kode denne virkeligheten inn i en variabel:

For å oppdage inkonsekvenser (og hvor mange), legger vi til en feilfunksjon:

Error = Reality - Neural Net Output
Med den kan vi evaluere ytelsen til vårt nevrale nettverk:

Men enda viktigere – hva med situasjoner der virkeligheten gir et positivt resultat?

Nå vet vi at vår nevrale nettverksmodell ikke fungerer (og vi vet hvordan), flott! Og dette er flott for nå kan vi bruke feilfunksjonen til å kontrollere treningen vår. Men alt gir mening hvis vi omdefinerer feilfunksjonen som følger:

feil= Ønsket utgang- Neural nettoutgang
En subtil, men viktig divergens, som stille indikerer at vi vil
bruke tidligere resultater for å sammenligne med fremtidige handlinger
(og for læring, som vi skal se senere). Dette finnes også i det virkelige liv, komplett
repeterende mønstre, slik at det kan bli en evolusjonær strategi (vel, i
fleste tilfeller).

var input = ; var vekter = ; vardesiredResult = 1;
Og en ny funksjon:

Funksjon evaluateNeuralNetError(desired,actual) (retur (ønsket - faktisk); ) // Etter å ha evaluert både nettverket og feilen ville vi få: // "Neural Net output: 0.00 Error: 1"
Live eksempel: Neural Net 002.

La oss oppsummere. Vi startet med en oppgave, laget en enkel modell av den i form av et biologisk nevralt nettverk, og fikk en måte å måle ytelsen i forhold til virkeligheten eller ønsket resultat. Nå må vi finne en måte å rette på inkonsekvensen på – en prosess som for både datamaskiner og mennesker kan betraktes som læring.

Hvordan trene et nevralt nettverk?

Grunnlaget for å trene både biologiske og kunstige nevrale nettverk er repetisjon
Og læringsalgoritmer, så vi vil jobbe med dem separat. La oss begynne med
læringsalgoritmer.

I naturen forstås læringsalgoritmer som endringer i fysisk eller kjemisk
egenskaper til nevroner etter eksperimentene:

Den dramatiske illustrasjonen av hvordan to nevroner endrer seg over tid i koden og vår «læringsalgoritme»-modell betyr at vi bare vil endre ting over tid for å gjøre livene våre enklere. Så la oss legge til en variabel for å indikere hvor mye enklere livet er:

Var learningRate = 0,20; // Jo større verdi, jo raskere vil læringsprosessen være :)
Og hva vil det endre?

Dette vil endre vektene (akkurat som en kanin!), spesielt vekten på utgangen vi ønsker å få:

Hvordan kode en slik algoritme er ditt valg, for enkelhets skyld legger jeg til læringsfaktoren til vekten, her er den i form av en funksjon:

Funksjon learn(inputVector, weightVector) ( weightVector.forEach(function(weight, index, weights) ( if (inputVector > 0) (weights = weight + learningRate; ) )); )
Når den brukes, vil denne treningsfunksjonen ganske enkelt legge til læringshastigheten vår til vektvektoren aktivt nevron, før og etter treningssirkelen (eller repetisjonen), vil resultatene være som følger:

// Original vektvektor: // Neural Netto utgang: 0,00 Feil: 1 læring(inngang, vekter); // Ny vektvektor: // Neural Nettoutput: 0,20 Feil: 0,8 // Hvis det ikke er åpenbart, er utgangen til det nevrale nettverket nær 1 (kyllingutgang) - som er det vi ønsket, så vi kan konkludere med at vi beveger seg i riktig retning
Live eksempel: Neural Net 003.

Ok, nå som vi beveger oss i riktig retning, vil den siste brikken i puslespillet implementeres repetisjoner.

Det er ikke så vanskelig, i naturen gjør vi bare det samme om og om igjen, men i kode spesifiserer vi bare antall repetisjoner:

Var forsøk = 6;
Og introduksjonen av funksjonen for antall repetisjoner i vårt treningsnevrale nettverk vil se slik ut:

Funksjonstog(forsøk) ( for (i = 0; i< trials; i++) { neuralNetResult = evaluateNeuralNetwork(input, weights); learn(input, weights); } }
Og her er vår endelige rapport:

Neural Netto utgang: 0,00 Feil: 1,00 Vektvektor: Neural Nettoeffekt: 0,20 Feil: 0,80 Vektvektor: Neural Nettoeffekt: 0,40 Feil: 0,60 Vektvektor: Neural Nettoeffekt: 0,60 Feil: 0,40 Vektvektor: Neural Nettoeffekt: 0. : 0,20 Vektvektor: Neural Nettoeffekt: 1,00 Feil: 0,00 Vektvektor: // Kyllingmiddag !
Live eksempel: Neural Net 004.

Nå har vi en vektvektor som bare vil gi ett resultat (kylling til middag) hvis inputvektoren stemmer overens med virkeligheten (trykk på den tredje knappen).

Så hva er det kule vi nettopp har gjort?

I dette spesielle tilfellet kan vårt nevrale nettverk (etter trening) gjenkjenne innspillet og si hva som vil føre til ønsket resultat (vi må fortsatt programmere spesifikke situasjoner):

I tillegg er det en skalerbar modell, et leketøy og et verktøy for vår læring med deg. Vi var i stand til å lære noe nytt om maskinlæring, nevrale nettverk og kunstig intelligens.

Forsiktig til brukere:

• Mekanismen for lagring av de lærte vektene er ikke gitt, så dette nevrale nettverket vil glemme alt det vet. Når du oppdaterer eller kjører koden på nytt, trenger du minst seks vellykkede repetisjoner for at nettverket skal trene fullt ut, hvis du tror at en person eller en maskin vil trykke på knappene i tilfeldig rekkefølge ... Dette vil ta litt tid.
• Biologiske nettverk for å lære viktige ting har en læringsrate på 1, så kun én vellykket repetisjon vil være nødvendig.
• Det er en læringsalgoritme som ligner veldig på biologiske nevroner, den har et fengende navn: widroff-hoff regel, eller widroff-hoff trening.
• Nevronale terskler (1 i vårt eksempel) og overtilpasningseffekter (med et stort antall repetisjoner vil resultatet være større enn 1) er ikke tatt i betraktning, men de er svært viktige i naturen og er ansvarlige for store og komplekse blokker av atferdsreaksjoner . Det samme er negative vekter.

Notater og litteraturliste for videre lesning

Jeg prøvde å unngå matematikken og de strenge begrepene, men i tilfelle du lurer, bygde vi en perceptron, som er definert som en overvåket læringsalgoritme (overvåket læring) av doble klassifiserere - tunge ting.

Hjernens biologiske struktur er ikke et lett tema, dels på grunn av unøyaktigheter, dels på grunn av kompleksiteten. Bedre å starte med nevrovitenskap (Purves) og kognitiv nevrovitenskap (Gazzaniga). Jeg modifiserte og tilpasset kanineksemplet fra Gateway to Memory (Gluck), som også er en flott guide til grafenes verden.

En annen fantastisk ressurs, An Introduction to Neural Networks (Gurney), er flott for alle dine AI-behov.

Og nå i Python! Takk til Ilya Andshmidt for å ha levert Python-versjonen:

Inndata = vekter = ønsket_resultat = 1 læringsrate = 0,2 forsøk = 6 def evaluate_neural_network(input_array, weight_array): resultat = 0 for i i området(len(input_array)): layer_value = input_array[i] * weight_array[i] resultat += layer_value print("evaluate_neural_network: " + str(result)) print("vekter: " + str(vekter)) returner resultat def evaluate_error(ønsket, faktisk): feil = ønsket - faktisk utskrift("evaluate_error: " + str(error) ) returner feil 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) ): for i in range(trial): neural_net_result = evaluate_neural_network(inputs, weights) learn(inputs, weights) train(trials)
Og nå på GO! Takk til Kieran Maher for denne versjonen.

Pakke hovedimport ("fmt" "math") func main() ( fmt.Println("Opprette inndata og vekter ...") inputs:= float64(0.00, 0.00, 1.00, 0.00) weights:= float64(0.00, 0,00; for i:= 1;i< 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("\nError: ") fmt.Print(math.Round(errorResult*100) / 100) fmt.Print("\n\n") } } func learn(inputVector float64, weightVector float64, learningRate float64) float64 { for index, inputValue:= range inputVector { if inputValue >0,00 ( weightVector = weightVector + learningRate ) ) return weightVector ) func evaluate(inputVector float64, weightVector float64) float64 (resultat:= 0,00 for indeks, inputValue:= range inputVector ( layerValue:= inputValue * weightVector resultat =) return layerVector resultat =) ) func evaluateError(ønsket float64, faktisk float64) float64 ( return ønsket - faktisk )

Du kan hjelpe og overføre noen midler til utviklingen av nettstedet

 

Det morsomme med høyteknologi er at den er tusenvis av år gammel! For eksempel ble kalkulus oppfunnet uavhengig av Newton og Leibniz for over 300 år siden. Det som en gang ble ansett som magi er nå godt forstått. Og selvfølgelig vet vi alle at geometri ble oppfunnet av Euklid for et par tusen år siden. Trikset er at det ofte tar år før noe blir «populært». Nevrale nettverk er et utmerket eksempel. Vi har alle hørt om nevrale nettverk og hva de lover, men av en eller annen grunn ser vi ikke de vanlige programmene basert på dem. Grunnen til dette er at den sanne naturen til nevrale nettverk er ekstremt kompleks matematikk, og det er nødvendig å forstå og bevise komplekse teoremer som dekker det, og kanskje er kunnskap om sannsynlighetsteori og kombinatorisk analyse nødvendig, for ikke å snakke om fysiologi og nevrologi.

Incitamentet til å lage hvilken som helst teknologi for en person eller mennesker er opprettelsen av et Killer Program med dets hjelp. Vi vet alle nå hvordan DOOM fungerer, dvs. ved å bruke BSP-trær. John Carmack oppfant dem imidlertid ikke på den tiden, han leste om dem i en artikkel skrevet i 1960. Denne artikkelen beskrev teorien om BSP-teknologi. John tok neste steg ved å forstå hvordan BSP-trær kunne brukes og DOOM ble født. Jeg mistenker at nevrale nettverk vil oppleve en lignende renessanse de neste årene. Datamaskiner er raske nok til å etterligne dem, VLSI-designere lager dem rett i silisium, og det er hundrevis av publiserte bøker om emnet. Og siden nevrale nettverk er den mest matematiske enheten vi vet om, er de ikke knyttet til noen fysisk representasjon, og vi kan lage dem med programvare eller lage ekte silisiummodeller. Hovedsaken er at essensen av et nevralt nettverk er en abstrakt modell.

På mange måter har grensene for digital databehandling allerede blitt realisert. Vi skal selvfølgelig forbedre dem og gjøre dem enda raskere, mindre og billigere, men digitale datamaskiner vil alltid kunne oppfatte kun digital informasjon, siden de er basert på en binær beregningsmodell. Nevrale nettverk er imidlertid basert på forskjellige beregningsmodeller. De er basert på en distribuert, sannsynlighetsmodell på høyt nivå som ikke kreves for å finne en løsning på et problem på samme måte som et dataprogram gjør; den modellerer et nettverk av celler som kan finne, identifisere eller korrelere mulige måter å løse et problem på på en mer "biologisk" måte, løse problemet i små biter og legge sammen resultatene. Denne artikkelen er en oversikt over teknologien til nevrale nettverk, hvor de vil bli demontert så detaljert som mulig på flere sider.

biologiske analoger

Nevrale nettverk ble inspirert av våre egne hjerner. Bokstavelig talt - noens hjerne i noens hode sa en gang: "Jeg er interessert i hvordan jeg jobber?", Og fortsatte deretter med å lage en enkel modell av seg selv. Rart, ikke sant? Standard nevrale nodemodell, basert på en forenklet modell av det menneskelige nevronet, ble oppfunnet for over femti år siden. Ta en titt på figur 1.0. Som du kan se, er det tre hoveddeler av en nevron, disse er:

• Dentritt(er) (Dendrite) .................... Ansvarlig for innsamling av innkommende signaler
• Soma (Soma) ................................ Ansvarlig for hovedbehandling og summering av signaler
• Axon (Axon) ................................... Ansvarlig for signalisering til andre dendritter.

Den gjennomsnittlige menneskelige hjernen inneholder omtrent 100 milliarder eller 10 til 11. potens av nevroner, og hver av dem har opptil 10 000 forbindelser gjennom dendritter. Signaler overføres ved hjelp av elektrokjemiske prosesser basert på natrium, kalium og ioner. Signaler overføres ved å bygge opp potensialforskjellen forårsaket av disse ionene, men kjemien er irrelevant her, og signalene kan tenkes på som enkle elektriske impulser som går fra akson til dendritt. Festingen av en dendritt til et fremmed akson kalles en synapse, og dette er hovedpunktene for overføring av impulser.

Så hvordan fungerer en nevron? Det er ikke noe enkelt svar på dette spørsmålet, men følgende forklaring vil være tilstrekkelig for våre formål. Dendrittene samler inn signaler mottatt fra andre nevroner, deretter utfører somas summeringen og beregningen av signaler og data, og til slutt, basert på resultatet av behandlingen, kan de "fortelle" aksonene om å sende signalet videre. Overføringen avhenger videre av en rekke faktorer, men vi kan modellere denne atferden som en overføringsfunksjon som tar input, behandler den og forbereder utdata dersom egenskapene til overføringsfunksjonen er oppfylt. I tillegg, i ekte nevroner, er utgangen av data ikke-lineær, det vil si at signalene ikke er digitale, men analoge. Faktisk mottar og sender nevroner kontinuerlig signaler, og deres virkelige modell avhenger av frekvens og må analyseres i S-domenet (frekvensdomenet). Den virkelige overføringsfunksjonen til et enkelt biologisk nevron er faktisk modellert av oss.

Nå har vi en ide om hva nevroner er og hva vi faktisk prøver å modellere. La oss gå bort et øyeblikk og snakke om hvordan vi kan bruke nevrale nettverk i videospill.

Spill

Nevrale nettverk ser ut til å være svaret på alle våre behov. Hvis vi kunne overføre karakterer og ord til små spillhjerner, forestill deg hvor kult det ville vært. Den nevrale nettverksmodellen gir oss den grove strukturen til nevroner, men gir oss ikke et høyt nivå av intelligens og deduksjonsfunksjonalitet, i hvert fall i klassisk forstand av ordet. Det krever litt omtanke å komme opp med måter å bruke nevrale nettverksteknologi i spill AI, men når du først gjør det, kan du bruke den sammen med deterministiske algoritmer, fuzzy logic og genetiske algoritmer for å skape en veldig robust og avansert AI-tankegang for spillene dine. Uten tvil vil resultatet bli bedre enn noe du kan oppnå med hundrevis av if-else-blokker eller skriptskript. Nevrale nettverk kan brukes til ting som:

Skanning og gjenkjennelse av miljøet Et nevralt nettverk kan motta informasjon i form av syn eller hørsel. Denne informasjonen kan deretter brukes til å danne et svar eller svar, eller til å trene nettverket. Disse svarene kan vises i sanntid og oppdateres for å forbedre svarene.

Hukommelse- et nevralt nettverk kan brukes som en form for minne for spillkarakterer. Nevrale nettverk kan lære av erfaring og legge til et sett med responser og reaksjoner.

atferdskontroll- utgangen fra det nevrale nettverket kan brukes til å kontrollere handlingene til spillkarakteren. Inndata kan være forskjellige variabler for spillmotoren. Da vil nettverket kunne kontrollere oppførselen til spillkarakteren.

Responskartlegging- nevrale nettverk fungerer veldig bra med "assosiasjoner", som i hovedsak er bindingen av et rom til et annet. En assosiasjon kommer i to varianter: en auto-assosiasjon, som knytter en input til seg selv, og en hetero-assosiasjon, som kobler en input til noe annet. Responsbinding bruker nevrale nettverk som en back-end eller utgang for å skape et nytt lag med indirekte kontroll over oppførselen til et objekt. Typisk vil vi kunne ha en rekke kontrollvariabler, men vi har kun klare svar på en rekke spesifikke kombinasjoner som vi kan trene nettverket på. Men ved å bruke et nevralt nettverk som utgang kan vi få andre svar som er omtrent i samme område som våre veldefinerte.

Eksemplene som er gitt kan virke litt vage, men de er det. Faktum er at nevrale nettverk er et verktøy som vi kan bruke som vi vil. Nøkkelen her er at bruken av dem gjør oppgaven med å lage AI enklere og vil gjøre oppførselen til spillerkarakterene mer fornuftig.

Nevrale nettverk 101

I denne delen vil vi gjennomgå hovedbegrepene og begrepene som brukes når vi diskuterer nevrale nettverk. Det er ikke så enkelt, for nevrale nettverk er egentlig et produkt av flere forskjellige disipliner, og hver av dem har sitt eget spesifikke vokabular. Akk, vokabularet knyttet til nevrale nettverk er skjæringspunktet mellom ordbøkene til alle disse disiplinene, så vi kan rett og slett ikke vurdere alt. Neural nettverksteori er også full av maskinvare som er overflødig, noe som betyr at mange mennesker finner opp hjulet på nytt. Dette påvirket etableringen av en rekke nevrale nettverksarkitekturer på en gang, som hver har sitt eget navn. Jeg vil prøve å beskrive generelle termer og situasjoner for ikke å gå fast i navngivning. Vel, i denne artikkelen skal vi se på noen nettverk som er forskjellige nok til å ha forskjellige navn. Mens du leser, ikke bekymre deg for mye hvis du ikke umiddelbart kan forstå alle konseptene og begrepene, bare les dem, så vil vi prøve å dekke dem igjen i sammenheng med artikkelen. La oss begynne...

Nå som vi har sett den "biologiske" versjonen av nevronet, la oss se på det grunnleggende om det kunstige nevronet for å legge grunnlaget for resonnementet vårt. Ris. 2.0 er en grafisk standard for en "nevronode" eller kunstig nevron. Som du kan se, har den flere innganger merket X1 - Xn og B. Disse inngangene har en vekt W1-Wn knyttet til seg, og en b festet til dem. I tillegg er det en oppsummeringsforbindelse Y og en utgang y. Utgangen y i nevroden er basert på overføringsfunksjonen, eller "aktivering", som er en funksjon av inngangen til nevroden i nettverket. Innkommende data kommer fra X-er og fra B-er som er koblet til nabonoder. Tanken er at B er «fortid», «minne». Den grunnleggende operasjonen til en neuronode er dette: input fra X multipliseres med tilhørende vekt og summeres. Utgangen fra summeringen er inngangen for å aktivere Ya. Aktiveringen mates deretter inn i aktiveringsfunksjonen fa(x) og den endelige utgangen er y. Ligningen for det hele er:

ur. 1.0

n
Ya \u003d B * b + e Xi * wi
i = 1 OG

y = fa(Ya)

De ulike formene for fa(x) vil bli diskutert om et øyeblikk.

Før vi fortsetter, bør vi snakke om den innledende Xi, vektene Wi og deres respektive områder. I de fleste tilfeller inneholder inngangene positive og negative tall i settet (- ¥, + innganger = I). Imidlertid bruker mange nevrale nettverk enkle verdier med to verdier (som sant/falsk). Grunnen til å bruke et så enkelt skjema er at alle komplekse data til slutt konverteres til en ren binær representasjon. I tillegg må vi i mange tilfeller løse dataproblemer som stemmegjenkjenning, som er helt riktig for representasjoner med to verdier. Den er imidlertid ikke hugget i stein. I begge tilfeller er verdiene som brukes i det divalente systemet primært 0 og 1 i det binære systemet, eller -1 og 1 i det bipolare systemet. Begge systemene er like bortsett fra at den bipolare representasjonen er matematisk mer praktisk enn den binære. Vekter Wi ved hver inngang er vanligvis mellom (-Ґ , +Ґ), og kalles "spennende" eller "hemmende" for henholdsvis positive og negative verdier. Ekstra inngang B, som alltid kalles med 1,0 og multipliseres med b, hvor b er vekten.

Fortsetter analysen vår, etter å ha funnet aktiveringen Ya for nevroden, brukes den på aktiveringsfunksjonen og resultatet kan beregnes. Det finnes en rekke aktiveringsfunksjoner med forskjellig bruk. Fa(x) hovedaktiveringsfunksjoner:

Ligningene for hver er ganske enkle, men hver passer til sin egen modell eller har sitt eget sett med parametere.

Trinn-for-trinn (trinn) funksjon brukes i en rekke nevrale nettverk og modeller for å oppnå en gitt kritikalitet av inngangssignalet. Hensikten med q-faktoren er å modellere det kritiske nivået til inngangssignalet som nevronet må reagere på.

Lineær (lineær) aktiveringsfunksjon brukes når vi ønsker at utgangen fra nevroden skal følge inngangsaktiveringen så tett som mulig. En lignende funksjon kan brukes til å lage lineære systemer som bevegelse med konstant hastighet. Til slutt er den eksponentielle funksjonen nøkkelen til avanserte nevrale nettverk, den eneste måten å lage nevrale nettverk som kan gi ikke-lineære responser og modellere ikke-lineære prosesser. Den eksponentielle aktiveringsfunksjonen er en gaffel i utviklingen av nevrale nettverk, fordi ved å bruke trinn- og lineære funksjoner kan vi aldri lage et nevralt nettverk som gir en ikke-lineær respons. Vi er imidlertid ikke pålagt å bruke denne spesielle funksjonen. Hyperbolske, logaritmiske og transcendentale funksjoner kan også brukes avhengig av de ønskede nettverksegenskapene. Endelig kan vi bruke alle slike funksjoner hvis vi vil.

Som du kan gjette, vil ikke en nevron gjøre mye, så du må lage en gruppe nevroner og et lag med nevroder, som vist i fig. 3.0. Figuren illustrerer et lite enkeltlags nevralt nettverk. Det nevrale nettverket i fig. 3.0 inneholder en rekke inngangs- og utgangsnoder. Etter konvensjon er dette et enkeltlags nevralt nettverk, fordi inndatalaget ignoreres med mindre det er det eneste laget i nettverket. I dette tilfellet er inngangslaget også utgangslaget, så nettverket er enkeltlags. Ris. 4.0 viser et to-lags nevralt nettverk. Merk at inputlaget fortsatt ikke er tatt i betraktning og det indre laget kalles "skjult". Utgangslaget kalles utgangen til responslaget. Teoretisk sett er det ingen grense for antall lag i et nevralt nettverk, men det kan være svært vanskelig å beskrive sammenhengene mellom de ulike lagene og akseptable treningsmetoder. Den beste måten å lage et flerlags nevralt nettverk på er å gjøre hvert nettverk til ett eller to lag, og deretter koble dem som komponenter eller funksjonelle blokker.

Ok, la oss nå snakke om "midlertidig" eller temaet tid. Vi vet alle at hjernen vår er ganske treg sammenlignet med en digital datamaskin. Faktisk produserer hjernen vår én syklus på millisekundskala, mens tiden for en digital datamaskin måles i nanosekunder og nesten allerede i subnanosekunder. Dette betyr at signalveien fra nevron til nevron tar litt tid. Dette er også modellert i kunstige nevroner i den forstand at vi gjør beregningene lag for lag og sender ut resultatene sekvensielt. Dette bidrar til å modellere tidsforsinkelsen som er tilstede i biologiske systemer som hjernen vår.

Vi er nesten ferdige med den foreløpige diskusjonen, la oss snakke om noen konsepter på høyt nivå og avslutte med et par terminer til. Spørsmålet du bør stille deg er "hva er poenget med nevrale nettverk?" Dette er et godt spørsmål, og det er vanskelig å svare definitivt på det. Utvidet spørsmål - "Hva vil du prøve for å få nevrale nettverk til å gjøre?" I utgangspunktet viser de en teknikk som bidrar til å reflektere et rom i forhold til et annet. I hovedsak er nevroner en type hukommelse. Og som med ethvert minne, kan vi bruke noen passende termer for å beskrive dem. nevroner har både STM (korttidshukommelse) og LTM (langtidshukommelse). STM er evnen til et nevralt nettverk til å huske noe det nettopp har lært, og LTM er evnen til et nevralt nettverk til å huske noe det lærte for en tid siden i lys av informasjonen det nettopp mottok. Dette bringer oss til konseptet plastisitet eller, med andre ord, til konseptet om hvordan det nevrale nettverket vil oppføre seg med informasjon eller ved læring. Kan et nevralt nettverk lære mer informasjon og fortsette å "huske" tidligere lært informasjon riktig? I så fall blir nevrale nettverk ustabile, ettersom de til slutt vil inneholde så mye informasjon at dataene uendelig vil krysse og overlappe hverandre. Dette bringer oss til et annet krav - stabilitet. Poenget er at vi ønsker at det nevrale nettverket skal ha god LTM, god STM, være fleksibelt og stabilt. Selvfølgelig er noen nevrale nettverk ikke analoge med minne, de er hovedsakelig rettet mot funksjonell kartlegging, og disse konseptene gjelder ikke for dem, men du får den grunnleggende ideen. Nå som vi vet om de ovennevnte konseptene relatert til hukommelse, la oss fullføre gjennomgangen om noen matematiske faktorer som vil hjelpe til med å evaluere og forstå disse egenskapene.

En av hovedapplikasjonene til nevrale nettverk er å lage en minnemekanisme som kan behandle ufullstendige eller uklare inndata og returnere et resultat. Resultatet kan være selve innspillet (assosiasjon) eller en helt annen respons enn innspillet (heteroassosiasjon). Det er også mulig å overlegge det N-dimensjonale rommet på den M-dimensjonale og ikke-lineære datainnlastingen. Dette betyr at det nevrale nettverket er en slags hyperspatial minneenhet, siden det kan koble et inngangs-N-element til et utgangs-M-element, der M kan være lik N eller ikke.

Det nevrale nettverk i hovedsak gjør er å dele det N-dimensjonale rommet i regioner som unikt kartlegger innganger til utganger eller klassifiserer innganger i forskjellige klasser. Deretter, når verdiene (vektorene) til det innkommende datasettet (la oss kalle det S) øker, følger det logisk at det vil være vanskeligere for nevrale nettverk å skille informasjon. Og siden de nevrale nettverkene er fylt med informasjon, vil inngangsverdiene som må "huskes" overlappe, siden inngangsrommet ikke kan inneholde alle separerte data i et uendelig antall dimensjoner. Denne overlappingen betyr at noen oppføringer ikke er så sterke som de kunne vært. Selv om det ikke er et problem i en rekke tilfeller, er det en bekymring når man modellerer minnenevrale nettverk; la oss, for å illustrere konseptet, anta at vi prøver å koble et N-sett med inngangsvektorer til et sett med utganger. Utgangssettet er ikke et like stort problem for riktig funksjon som utgangssettet S er.

Hvis inngangssettet S strengt tatt er binært, så vurderer vi sekvenser av formen 1101010 ... 10110. La oss si at inngangsdataene våre bare har 3 biter hver, så hele inngangsrommet består av vektorer:

v0 = (0,0,0), v1 = (0,0,1), v2 = (0,1,0), v3 = (0,1,1), v4 = (1,0,0), v5 = (1,0,1), v6 = (1,1,0),

For mer presisjon er grunnlaget for dette settet med vektorer:

v = (1,0,0) * b2 + (0,1,0) * b1 + (0,0,1) * b0, hvor bi kan ta på seg verdiene 0 eller 1.

For eksempel, hvis vi antar at B2=1, B1=0 og B0=1, får vi følgende vektor:

v = (1.0.0) * 1 + (0.1.0) * 0 + (0.0.1) * 1 = (1.0.0) + (0.0.0) + (0 ,0,1) = (1,0 ,1) som er V-ene til vår mulige inngangsmatrise

En basis er en spesiell summert vektor som beskriver en rekke vektorer i rommet. Så V beskriver alle vektorer i rommet vårt. Generelt, uten å gå inn i lange forklaringer, jo mer ortogonale vektorene i inngangsmatrisen er, jo bedre vil de forplante seg i det nevrale nettverket, og jo bedre kan de kalles. Ortogonalitet refererer til uavhengigheten til vektorer, med andre ord, hvis to vektorer er ortogonale, så er punktproduktet deres null, deres projeksjon på hverandre er null, og de kan ikke beskrives i forhold til hverandre. Det er mange ortogonale vektorer i matrisen v, men de kommer i små grupper, for eksempel er V0 ortogonal på alle vektorer, så vi kan alltid inkludere den. Men hvis vi inkluderer V1 i matrisen S, vil bare vektorene V2 og V4 opprettholde ortogonalitet med den:

v0 = (0,0,0), v1 = (0,0,1), v2= (0,1,0), v4 = (1,0,0)

Hvorfor? Fordi Vi - Vj for alle i,j fra 0...3 er lik null. Med andre ord, prikkproduktet til alle vektorpar er 0, så de må alle være ortogonale. Så denne matrisen er veldig god som en inngangsmatrise for nevrale nettverk. Imidlertid, matrisen:

v6 = (1,1,0), v7 = (1,1,1)

potensielt dårlig, fordi innganger v6-v7 er ikke-null, i et binært system er det 1. Det neste spørsmålet er kan vi måle denne ortogonaliteten? Svaret er ja. I det binære systemet av vektorer er det et mål som kalles Hamming-avstanden. Den brukes til å måle den N-dimensjonale avstanden mellom binære vektorer. Dette er ganske enkelt antall biter som er forskjellige mellom de to vektorene. For eksempel vektorer:

v0 = (0,0,0), v1 = (0,0,1)

ha en Hamming-avstand på 1 seg imellom, og

v2 = (0,1,0), v4 = (1,0,0)

ha en slagavstand på 2.

Vi kan bruke Hamming-avstanden som et mål på ortogonalitet i binære vektorsystemer. Og det kan hjelpe oss å finne ut om våre input-datasett har skjæringspunkter. Å bestemme ortogonalitet med vanlige inngangsvektorer er vanskeligere, men prinsippet er det samme. Det er nok konsepter og terminologi, la oss hoppe videre og se på faktiske nevrale nettverk som gjør noe, og kanskje ved slutten av denne artikkelen kan du bruke dem til å forbedre AI i spillet ditt. Vi vil se på nevrale nettverk som brukes til å utføre logiske funksjoner, klassifisere innganger og assosiere dem med utganger.

Ren logikk

De første kunstige nevrale nettverkene ble opprettet i 1943. McCulloch og Pitts. De besto av en rekke neuronoder og ble hovedsakelig brukt til å beregne enkle logiske funksjoner som AND, OR, XOR og deres kombinasjoner. Ris. 5.0. representerer hovednevronodene til McCulloch og Pitts med to innganger. Hvis du er en elektroingeniør, vil du umiddelbart se deres nære likhet med transistorer. I alle fall har McCulloch-Pitts nevronoder ingen forbindelser, og den enkle aktiveringsfunksjonen Fmp(x) er:

fmp (x) = 1, hvis xq
0, hvis x< q

MP (McCulloch-Pitts) nevronoden fungerer ved å summere produktet av Xi-inngangene og Wi-vektene og tar Ya som resultat for Fmp(x)-funksjonen. McCulloch-Pitts' tidlige forskning fokuserte på å bygge komplekse logiske kretsløp med nevrodemodeller. I tillegg er en av reglene for nevronodemodellering at signaloverføring fra nevron til nevron tar ett tidstrinn. Dette bidrar til å være nærmere modellen av naturlige nevroner. La oss ta en titt på noen eksempler på MP nevrale nettverk som implementerer grunnleggende logikkfunksjonalitet. Boolsk funksjon OG har følgende sannhetstabell:

Vi kan modellere dette med to input MP nevrale nettverk med vektene w1=1, w2=2 og q=2. Dette nevrale nettverket er vist i fig. 6,0a. Som du kan se, fungerer alle inngangskombinasjoner riktig. For eksempel, hvis vi prøver å sette inngangene X1=0, Y1=1, vil aktiveringen være:

X1*w1 + X2*w2 = (1)*(1) + (0)*(1) = 1,0

Hvis vi bruker 1.0 for Fmp(x)-aktiveringsfunksjonen, blir resultatet 0, som er det riktige svaret. Som et annet eksempel, hvis vi prøver å sette inngangene X1=1, X2=1, vil aktiveringen være:

X1*w1 + X2*w2 = (1)*(1) + (1)*(1) = 2,0

Hvis vi legger inn 2.0 i Fmp(x) aktiveringsfunksjonen, er resultatet 1.0, som er riktig. I andre tilfeller vil det fungere på samme måte. ELLER-funksjonen er lik, men sensitiviteten til q endres til 1,0 i stedet for 2,0 som den var i OG. Du kan prøve å kjøre dataene selv gjennom sannhetstabeller for å se resultatene.

XOR-nettverket er litt annerledes siden det faktisk har 2 lag siden resultatene av forbehandlingen blir videre behandlet i utgangsneuronen. Dette er et godt eksempel på hvorfor et nevralt nettverk trenger mer enn ett lag for å løse visse problemer. XOR er et generelt nevralt nettverksproblem som ofte brukes til å teste ytelsen til et nettverk. I alle fall er XOR lineært uatskillelig i et eget lag, det må brytes ned i mindre stadier, hvis resultater oppsummeres. Sannhetstabellen for XOR ser slik ut:

XOR er bare sant når inngangene er forskjellige, noe som er et problem fordi begge inngangene refererer til samme utgang. XOR er lineært uatskillelig, som vist i fig. 7.0. Som du kan se, er det ingen måte å skille det riktige svaret direkte. Saken er at vi kan skille det riktige svaret med to linjer, og det er akkurat det det andre laget gjør. Det første laget forhåndsbehandler dataene eller løser deler av problemet, og det gjenværende laget fullfører beregningen. Med henvisning til fig. 6.0 ser vi at vektene er Wq=1, W2=-1, W3=1, W4=-1, W5=1, W6=1. Nettverket fungerer som følger: laget beregnes hvis X1 og X2 er motsatte, resultatene i tilfellene (0,1) eller (1,0) er mat for lag to, som summerer dem og sender dem videre hvis det er sant. I hovedsak har vi laget en boolsk funksjon:

z = ((X1 OG IKKE X2) ELLER (IKKE X1 OG X2))

Hvis du vil eksperimentere med grunnleggende McCulloch-Pitts nevronoder, er følgende liste en komplett to-inngang nevronodstimulator.

// MCULLOCCH PITTS-SIMULATOR
// INKLUDERER
/////////////////////////////////////////////////////

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere

// HOVED
/////////////////////////////////////////////////////

void main(void )
{
flyte terskel, // dette er theta-begrepet som brukes for å terskel summen
w1, w2, // disse holder vektene
x1, x2, // innganger til nevroden
y_in, // summert inngangsaktivering
y_out; // endelig utgang av nevrode

printf ( "nMcCulloch-Pitts Single Neurode Simulator.n") ;
printf("nVennligst skriv inn terskel?");
scanf("%f" ,& terskel) ;

printf ( "nAngi verdi for vekt w1?") ;
scanf("%f",&w1) ;

printf ( "nAngi verdi for vekt w2?") ;
scanf("%f",&w2) ;

printf("nnBegynnelsessimulering:" ) ;

// gå inn i hovedhendelsesløkken

mens (1)
{
printf ( "nnSimulation Parms: terskel=%f, W=(%f,%f) n", terskel, w1, w2);

// be om innspill fra bruker
printf("nAngi inndata for X1?");
scanf("%f",& x1) ;

printf("nAngi inndata for X2?");
scanf("%f",& x2) ;

// beregningsaktivering
y_in = x1* w1 + x2* w2;

// skriv inn resultat til aktiveringsfunksjon (enkelt binært trinn)
if (y_in >= terskel)
y_out = (flytende) 1.0;
ellers
y_out = (flytende) 0,0;

// skriv ut resultatet
printf("nNeurode-utdata er %fn" , y_out) ;

// Prøv igjen
printf ( "Ønsker du å fortsette Y eller N?") ;
char ans[8];
scanf("%s" , ans) ;

if (toupper(ans[ 0 ] ) != "Y" )
gå i stykker ;
) // slutt mens

printf("nnSimulation Complete.n");
) // end main

Dette avslutter vår diskusjon om de grunnleggende byggesteinene til et MP-nevrale nettverk, la oss gå videre til mer komplekse nevrale nettverk som de som brukes til å klassifisere inngangsvektorer.

Klassifisering og gjenkjenning av "bilder"

Endelig er vi klare til å se på ekte nevrale nettverk som har funnet noen nytte! For å gå videre til en påfølgende diskusjon av Hebb og Hopfield nevrale nettverk, vil vi analysere den generelle strukturen til nevrale nettverk, som vil illustrere en rekke begreper som lineær separerbarhet, bipolare representasjoner og analogier mellom nevrale nettverk og minner. La oss først ta en titt på fig. 8.0 som representerer den grunnleggende nevrale nettverksmodellen vi skal bruke. Som du kan se, er dette et en-node nettverk med tre innganger, inkludert offset B, og en utgang. Vi ønsker å se hvordan vi kan bruke dette nettverket til å implementere den logiske OG operasjonen som vi så enkelt implementerte i McCulloch-Pitts nevronoder.

La oss starte med å bruke bipolare representasjoner, så alle 0-er erstattes med -1-er. Sannhetstabellen for logikk OG ved bruk av bipolare innganger og utganger er vist nedenfor:

Og her er fc(x)-aktiveringsfunksjonen som vi skal bruke:

fc (x) = 1, hvis x i q
- 1, hvis x< q

Merk at funksjonen er et skritt mot bipolar utgang. Før jeg fortsetter, la meg plante frø i hjernen din: blanding og sansing ender opp med å gjøre det samme, de gir oss en annen grad av frihet i nevronene våre som lar dem skape responser som ikke kan oppnås uten det. Du vil se det snart.

En enkelt nevrode i fig. 8.0 prøver å gjøre en klassifisering for oss. Det kommer til å fortelle oss om våre innspill er av denne klassen eller ikke. For eksempel om det er et bilde av et tre eller ikke. Eller, i vårt tilfelle (enkel logisk OG), er det +1 eller -1 klasse? Dette er grunnlaget for de fleste nevrale nettverk, og det er derfor jeg snakket om lineær separerbarhet. Vi må komme frem til en lineær separasjon av rommet som vil korrelere våre innganger og utganger slik at det er en solid separasjon av rommet som skiller dem. Så vi må komme opp med de riktige vekt- og skjevhetsverdiene som vil gjøre det for oss. Men hvordan gjør vi det? Er det bare prøving og feiling, eller er det noen metodikk? Svaret er at det finnes en rekke metoder for å trene et nevralt nettverk. Disse metodene fungerer på forskjellige matematiske eksempler og kan bevises, men for øyeblikket tar vi bare verdier som fungerer uten å vurdere prosessen med å skaffe dem. Disse øvelsene vil lede oss til å lære algoritmer og mer komplekse nettverk enn de som vises her.

Ok, vi prøver å finne vektene Wi og bias B som vil gi riktig resultat for ulike innganger med en aktiveringsfunksjon Fc(x). La oss skrive summeringsaktiveringen av nevronoden vår og se om vi kan skape noen relasjoner mellom vekt og input som kan hjelpe oss. Gitt innganger X1 og X2 med vekter W1 og W2 sammen med B=1 og skjevhet b, får vi følgende formel:

X1*w1 + X2*w2 + B*b=q

Siden B alltid er 1.0, forenkler formelen til:

X1*w1 + X2*w2 + b=q

X2 = -X1*w1/w2 + (q -b)/w2 (løser i form av X2)

Hva det er? Det er en strek! Og hvis venstre side er større enn eller lik q, det vil si (X1*W1+X2*W2+b), så vil nevroden svare 1, ellers vil den gi resultatet -1. De. linjen er grensen for løsningen. Ris. 9.0 illustrerer dette. På diagrammet kan du se at helningen til linjen er -w1/w2 og X2-avskjæringen er (q-b)/w2. Nå er det klart hvorfor vi kan bli kvitt q? Det er en del av en konstant, og vi kan alltid skalere b for å oppnå ethvert tap, så vi vil anta at Q=0, og som et resultat får vi ligningen:

X2 \u003d -X1 * w1 / w2 - b / w

Vi ønsker å finne vektene W1 og W2 og bias b slik at de skiller våre utganger eller klassifiserer dem i spesielle partisjoner uten overlapping. Dette er nøkkelen til lineær separerbarhet. Ris. 9.0 viser antall beslutningsgrenser som vil være nok, slik at du kan ta hvilken som helst av dem. La oss ta de enkleste:

W1=W2=1

Med disse verdiene blir beslutningsgrensen:

X2 = -X1*w1/w2 - b/w2 -> X2 = -1*X1 + 1

Helningen er -1 og skjærer X2 = 1. Hvis vi plugger inngangsvektorene for logisk OG inn i denne ligningen og bruker Fc(x) aktivering, får vi riktig utgang. For eksempel, hvis X2+X1-1 > 0, vil responsen til nevroden være -1. La oss prøve med våre OG-innspill og se hva som skjer:

som du kan se, løser nevrale nettverk med passende vekt og skjevhet problemet perfekt. I tillegg er det en hel familie av vekter som vil gjøre dette like bra (skutte beslutningsgrensene i en retning vinkelrett på seg selv). Det er imidlertid et viktig poeng. Uten offset eller sensitivitet vil kun direkte pasninger være mulig, som intercept X2 skal være 0. Dette er veldig viktig og er hovedårsaken til å bruke sensitivitet eller offset, så dette eksemplet var viktig fordi det tydelig viser dette faktum. Så, mer til poenget - hvordan finne de riktige vektverdiene? Ja, vi har nå geometriske analogier, og dette er begynnelsen på å finne en algoritme.

Hebb trening

Vi er nå klare til å se den første læringsalgoritmen og dens anvendelse i et nevralt nettverk. En av de enkleste læringsalgoritmene ble oppfunnet av Donald Hebb og er basert på å bruke inngangsvektorer for å endre vekten slik at vekten skaper best mulig lineær separasjon av innganger og utganger. Akk, algoritmen fungerer helt fint. For ortogonale innganger fungerer dette bra, men for ikke-ortogonale innganger faller algoritmen fra hverandre. Selv om algoritmen ikke resulterer i riktige vekter for alle innganger, er den kjernen i de fleste læringsalgoritmer, så vi starter med den.

Før du ser algoritmen, husk at den bare er for én nevrode, et enkeltlags nevralt nettverk. Du kan selvfølgelig legge mange nevroder i et lag, men de vil alle fungere parallelt og kan trenes parallelt. I stedet for å bruke en enkeltvektsvektor, bruker multinevronoder en vektmatrise. Uansett, algoritmen er enkel, den ser omtrent slik ut:

• Inngangen er i bipolar form I=(-1,1,0,... -1,1) og inneholder k elementer.
• Det er N inngangsvektorer, og vi vil referere til deres sett som et J-element, f.eks. Ij.
• Utgangene vil bli kalt Yj, og det er K utganger, hver for en inngang Ij.
• Vektene W1-Wk er inneholdt i en vektor W=(w1, w2,...wk)

Trinn 1. Initialiser alle vektene våre til 0 og la dem være inneholdt i en vektor W av N oppføringer. Initialiser også offset b til 0.

Trinn 2. Fra j=1 til n, gjør:

b = b + yj (hvor y er ønsket resultat

w = w + Ij * yj (Husk at dette er en vektoroperasjon)

En algoritme er ikke noe mer enn en slags "akkumulator". Forskyvning av beslutningsgrenser er basert på endringer i input og output. Det eneste problemet er at i noen tilfeller vil grensen ikke bevege seg raskt nok (eller i det hele tatt) og "læring" vil ikke finne sted.

Så hvordan bruker vi Hebbs læring? Svaret på dette spørsmålet er det samme som det forrige nevrale nettverket, bortsett fra at vi nå har en algoritmisk metode for å trene nettverket, og dette nettverket kalles Hebbian Net. Som et eksempel, la oss ta vår gyldige boolske funksjon og se om algoritmen kan finne de riktige vekt- og skjevhetsverdiene for den. Summen nedenfor tilsvarer å kjøre algoritmen:

w = + + + = [(-1, -1)*(-1)] + [(-1, 1)*(-1)] + [(1, -1)*(-1)] + [ (1, 1)*(1)] = (2,2)

b = y1 + y2 + y3 + y4 = (-1) + (-1) + (-1) + (1) = -2

Dermed W1=2, W2=2 og b=2. Dette er ganske enkelt skalerte versjoner av W1=1, W2=2, B=-1 verdiene vi fikk i forrige seksjon. Med denne enkle algoritmen kan vi trene et nevralt nettverk (fra en enkelt nevrode) til å svare på en rekke inndata eller klassifisere dem som sanne/falske, eller 1/-1. Og nå, hvis vi hadde en rekke slike nevronoder, kunne vi opprettet et nettverk som ikke bare definerer innganger som ja/nei, men som også forbinder innganger med visse mønstre. Dette er et av grunnlaget for den neste strukturen av nevrale nettverk, Hopfield-nettverk.

Hopfield-algoritmer

John Hopfield er en fysiker som liker å leke med nevrale nettverk (noe som er bra for oss). Han kom opp med en enkel (i det minste forholdsvis) men effektiv nevrale nettverksmodell kalt Hopfield Network. Den brukes til å assosiere, hvis du skriver inn en vektor x, så får du x som utgang (håper jeg). Hopfield-nettverket er vist i figur 10.0. Dette er et enkeltlagsnettverk med et visst antall nevronoder lik antall innganger Xi. Nettverket er fullt tilkoblet, noe som betyr at hver nevrode er koblet til annenhver nevrode, og inngangene er også utgangene. Dette kan virke rart for deg, fordi vises Tilbakemelding. Tilbakemelding er en av nøkkelfunksjonene til Hopfield-nettverket, og det er et av de grunnleggende grunnlagene for å få det riktige resultatet.

Hopfield-nettverket er et iterativt autoassosiativt minne. Det kan ta fra én til flere sykluser for å få riktig resultat. La meg presisere: et Hopfield-nettverk mottar input og gir det deretter tilbake, og den resulterende utgangen kan være den ønskede inngangen eller ikke. Denne tilbakemeldingssløyfen kan gå gjennom flere ganger før inngangsvektoren returneres. Dermed den funksjonelle sekvensen til Hopfield-nettverket: Bestem først vekten av inngangene våre som vi ønsker å assosiere, gi deretter inngangsvektoren og se hva aktiveringsfunksjonen gir. Hvis resultatet er det samme som vår opprinnelige inngang, fungerte alt, hvis ikke, tar vi den resulterende vektoren og mater den til nettverket. La oss nå se vektmatrisen og læringsalgoritmen som brukes i Hopfield-nettverk.

Læringsalgoritmen for Hopfield-nettverket er basert på Hebbs regel og summerer ganske enkelt resultatet. Men siden Hopfield-nettverk har flere inngangsneuroner, er vekten ikke lenger en rekke vekter, men en rekke matriser som er kompakt inneholdt i en enkelt matrise. Dermed er vektmatrisen W for Hopfield-nettverket opprettet basert på denne ligningen:

• Inngangsvektorene er i bipolar form I = (-1,1,... -1,1) og inneholder k elementer.
• Det er N inngangsvektorer, og vi vil referere til deres sett som et j-element av I, dvs. Ij.
• Utgangene vil bli kalt Yj, og det er k utganger, hver for sin egen inngang Ij.
• Vektmatrisen W er kvadratisk og har dimensjon kxk siden vi har k innganger.

k
W (kxk) = e Iit x Ii
i = 1

Merk: hvert ytre produkt vil ha dimensjonene K x K siden vi multipliserer en kolonnevektor og en radvektor.

Og Wii = 0 for alle i

Aktiveringsfunksjonen fh(x) vises nedenfor:

fh (x) = 1, hvis x i 0
0, hvis x< 0

fh (x) er en trinnfunksjon med et binært resultat. Dette betyr at hver inngang må være binær, men har vi allerede sagt at inngangene er bipolare? Vel, ja, det er det, og det er det ikke. Når vektmatrisen er generert, konverterer vi alle inngangsvektorer til bipolar format, men i normale operasjoner bruker vi den binære versjonen av input og output, som Hopfield-nettverket er også binært. Denne konverteringen er valgfri, men gjør nettverksdiskusjonen litt enklere. Uansett, la oss se på et eksempel. La oss si at vi ønsker å lage 4 Hopfield-nettverksnoder og vi vil at de skal kalle disse vektorene:

I1=(0,0,1,0), I2=(1,0,0,0), I3=(0,1,0,1) Merk: de er ortogonale

Konvertering til bipolare verdier får vi:

I1* = (-1, -1,1, -1) , I2* = (1, -1, -1, -1), I3* = (-1,1, -1,1)

Nå må vi beregne W1,W2,W3 der Wi er produktet av hver inngangs transposisjon med seg selv.

W1= [ I1* t x I1* ] = (— 1 , - 1 , 1 , - 1 ) t x (— 1 , — 1 , 1 , — 1 ) =
1 1 — 1 1
1 1 — 1 1
— 1 — 1 1 — 1
1 1 — 1 1 W2 = [I2*t x I2*] = (1, — 1, — 1, — 1) t x (1, — 1, — 1, — 1) =
1 — 1 — 1 — 1
— 1 1 1 1
— 1 1 1 1
— 1 1 1 1

W3 = [I3*t x I3*] = (-1, 1, -1, 1) t x (-1, 1, - 1, 1) =
1 — 1 1 — 1
— 1 1 — 1 1
1 — 1 1 — 1
— 1 1 — 1 1

Nullstilling av hoveddiagonalen gir oss den endelige vektmatrisen:

W=
0 — 1 — 1 — 1
— 1 0 — 1 3
— 1 — 1 0 — 1
— 1 3 — 1 0

Wow, nå skal vi danse. La oss legge inn våre originale vektorer og se på resultatene. For å gjøre dette, multipliser bare inngangene med matrisen og behandle hver utgang med Fh(x)-funksjonen. Her er resultatene:

, — 1 ) og fh((0 , — 1 , — 1 , — 1 ) ) = (1 , 0 , 0 , 0 )

I3 x B = (— 2 , 3 , - 2 , 3 ) og fh((— 2 , 3 , — 2 , 3 ) ) = (0 , 1 , 0 , 1 )

Innspillene ble perfekt "husket", som seg hør og bør, pga de er ortogonale. Som et siste eksempel, la oss anta at innspillet vårt (hørsel, syn osv.) er litt "støyende" og inneholder én feil. La oss ta I3=(0,1,0,1) og legge til litt støy, dvs. I3 støy = (0,1,1,1). La oss nå se hva som skjer hvis vi introduserer denne "støyende" vektoren i Hopfield-nettverket:

I3 støy x W = (-3, 2, -2, 2) og Fh ((-3,2, -2, 2)) = (0,1,0,1)

Overraskende nok "huskes" den opprinnelige vektoren. Det er veldig hyggelig. På denne måten har vi muligheten til å lage et "minne" som er fylt med bitemønstre som ser ut som trær (eik, gråtepil, gran osv.), og hvis vi går inn i et annet tre, for eksempel en selje, som var ikke i nettverket, vil nettverket vårt (forhåpentligvis) gi ut informasjon om hvordan det "tror" pilen ser ut. Dette er en av styrkene til assosiative minner: vi trenger ikke trene nettverket for alle mulige innspill, vi trenger bare så mye for at nettverket skal ha "assosiasjoner". De "nære" inngangene blir da vanligvis lagret som den opprinnelig lærte inngangen. Det er grunnlaget for bilde- og stemmegjenkjenning. Ikke spør meg hvor jeg har fått tak i "tre"-analogien. I alle fall, på slutten av artikkelen vår, inkluderte jeg en autoassosiativ Hopfield-nettverksimulator som lar deg lage nettverk med opptil 16 nevronoder.

Hjernedød...

Det er alt vi skal se på i dag. Jeg håpet å komme til preceptronnettverkene, men jammen. Jeg håper du forstår i det minste litt hva nevrale nettverk er og hvordan du kan lage arbeidsprogrammer for å modellere dem. Vi har dekket de grunnleggende begrepene og begrepene, noen av de matematiske grunnlagene og noen av de vanligste nettverksmodellene. Imidlertid er det mange flere ting å lære om nevrale nettverk. Disse er perseptroner, fuzzy assosiativt minne eller FAM-er, toveis assosiativt minne eller BAM-er, Kohonen-kart, nettverks-tilbakepropageringsalgoritme, adaptiv resonansnettverksteori og mye mer. Det er det, nevrale nettverket mitt kaller meg til å leke!