Hallo en welkom bij het eerste deel van deze implementatie, deel één, het oog bouwen.
En zoals je kunt zien, heb ik al een dimensie toegevoegd aan de structuur van deze implementatie met de drie
secties die er een vormen die duidelijk laten zien hoe we dit oog gaan bouwen.
Eerst gaan we de hersenen maken die niets anders zijn dan het neurale netwerk.
Dan gaan we het lichaam maken, dat zal bepalen hoe de acties zullen worden gespeeld.
En als we eenmaal de hersenen en het lichaam hebben, zullen we ze samenvoegen om de A te maken. L. , die in het laatste deel
van dit eerste deel zal staan.
U kunt nu dus al een goed beeld hebben van de opbouw van deze implementatie.
Eerst maken we de hersenen, dan maken we het lichaam, en dan assembleren we de twee om de lucht te maken.
En dan gaan we zo beginnen met het eerste deel dat gaat over het maken van de hersenen.
En dit gaat ons voor tutorials brengen.
Je kunt je voorstellen dat het maken van een brein niet hetzelfde is als het maken van een cake.
Dit vereist dus meer dan één tutorial.
En natuurlijk, zoals gewoonlijk, gaan we dat brein vertegenwoordigen met een klas omdat we verschillende functies nodig
hebben.
En om een structuur te hebben van verschillende functies die in een soort instructies zullen worden georganiseerd.
Natuurlijk hebben we een klas nodig.
En dat is perfect, want als we die klasse eenmaal goed hebben gemaakt, kunnen we zoveel hersens creëren als we
willen door slechts enkele objecten van deze klasse te maken.
Dus nogmaals, klassen in Python en in het algemeen en objectgeoriënteerde programmeertalen zijn erg praktisch omdat je je model
maakt van iets dat je wilt bouwen en dan kun je zoveel objecten maken als je wilt
en ze zullen alle functies hebben die u in de klas definieert.
En voor onze hersenen zullen de kenmerken dat natuurlijk zijn.
Allereerst de architectuur van het neurale netwerk, waarvan ik veronderstel dat het op CNN zal zijn
en natuurlijk de verschillende functies, zoals bijvoorbeeld het doorgeven van de signalen van de inputneuronen
naar de outputneuronen.
Dus dat wordt natuurlijk de vierde functie die we gaan maken.
Dus laten we dit doen.
Laten we beginnen met het maken van de hersenen.
Dit gaat best spannend worden.
Het is een van mijn favoriete onderdelen en daarom gaan we er meteen op in.
Dus we beginnen natuurlijk met het introduceren van een klas, en we gaan deze klas noemen.
Ik aarzelde om het hersenen te noemen, maar laten we directer zijn en het CNN noemen, want eigenlijk
is het brein een CNN-netwerk, een convolutioneel neuraal netwerk.
Dus dat is wat je hersenen kunt noemen als je wilt.
Maar nu weten we tenminste wat we aan het bouwen zijn.
En CNN, wat betreft het netwerk van de zelfrijdende auto, gaat erven van de Annand-module.
Dus onthoud, de motormodule is wat we hier hebben geïmporteerd, en we willen alle tools van deze motormodule
kunnen gebruiken.
En daarom willen we deze techniek gebruiken in objectgeoriënteerd programmeren, wat overerving is, en waarmee
we, je weet wel, alle tools van een bovenliggende klasse kunnen gebruiken.
En deze klas zal in die module zitten.
Daar gaan we.
En nu kunnen we alle gereedschappen en objecten van de engine, die module, gebruiken.
Oke.
Dus nu we onze erfenis hebben, kunnen we naar de klas gaan om onze eerste functie te maken.
En zoals je waarschijnlijk al vermoedt, is de eerste functie de init-functie die alle variabelen van de toekomstige
hersenobjecten in de toekomst zal definiëren.
CNN-objecten die worden gemaakt.
Oké, dus laten we dit def doen, dan twee op deze cursus erin naar de weer en nu moeten we wat variabelen
plaatsen.
Dus eerst en vooral zou ik mezelf zijn.
Dat is natuurlijk om naar het object te verwijzen.
Nu denk ik dat je je hier redelijk comfortabel bij voelt.
Vervolgens gaan we nog een variabele toevoegen, namelijk het aantal acties in de omgeving.
Dus we gaan het aantal acties noemen, aantal acties.
En eigenlijk is deze variabele niet verplicht voor de init-functie.
Het is alleen zo dat als je het idee wilt testen dat we op
andere Dhume-omgevingen gaan bouwen, dit heel praktisch zal zijn omdat we dit aantal acties zullen invoeren, variabel vanuit
de doom-omgeving, rappers met twee discrete.
En als we dat doen, zullen we, je weet wel, de naam van de omgeving invoeren, V0 doen.
En dus als je wilt, weet je, hiermee experimenteren in andere DUME-omgevingen en andere games spelen, nou,
dan heb je niets te doen omdat dit aantal acties direct het aantal acties in de
omgeving krijgt die je' mee zal spelen.
OK, dus dat is het voor de twee argumenten van deze init-functie.
Dus nu kunnen we naar binnen gaan en ons herinneren wat we moeten doen.
Het eerste dat we moeten doen, is de overerving activeren met de superfunctie.
Dus dat is precies hetzelfde als voor de zelfrijdende auto.
We nemen de superfunctie, dan beginnen we met het invoeren van de klasse die het neurale netwerk
zal definiëren en dat is CNN.
Dan moeten we zelf invoeren om naar het object te verwijzen.
Maar onthoud, dat is niet alles wat we hier bij DOT moeten toevoegen en dan de init-functie.
Met wat haakjes, en door dat te doen, activeren we de overerving en nu kunnen we alle tools van
die module gebruiken.
Oke.
Dus nu denk ik dat het tijd is om de architectuur van het neurale netwerk te bouwen.
En dus, zoals je je herinnert, gaan we een CNN convolutief neuraal netwerk bouwen, simpelweg omdat de
AI deze keer ogen zal hebben en de ogen van de AI de convolutionele lagen van dit convolutionele neurale
netwerk.
En dan na de A. L. visualiseert de beelden met de convolutionele lagen, het
zal de signalen doorgeven aan een klassiek kunstmatig neuraal netwerk.
Dus dat is degene die we eerder hadden met volledig verbonden lagen.
En dat is waar het zal proberen de kernwaarden te voorspellen voor elke mogelijke actie die we kunnen spelen.
Dus je hebt de architectuur in gedachten.
Eerst zullen we enkele convolutionele lagen hebben en dan enkele volledig verbonden lagen, en dit
zal het brein zijn van onze A. L. Dus waar we gaan doen om een stap terug te
kunnen doen waar we goed in zijn, laten we deze architectuur maken met de variabelen die we willen creëren.
Dus eigenlijk, over deze architectuur gesproken, we gaan een CNN bouwen met drie convolutionele lagen.
En dan na die ene verborgen laag, dat betekent dat we drie convolutionele verbindingen en twee
volledige verbindingen nodig hebben.
En over verbindingen gesproken, dat is precies wat we gaan definiëren.
Dat zijn de variabelen van onze CNN-klasse.
En daarom ga ik nu vijf variabelen definiëren, drie voor de convolutionele verbindingen en twee
voor de volledige verbindingen.
Dus laten we dit doen.
We beginnen met de convolutieverbindingen.
Dus ik ga ze zelf die convolutie noemen.
Ik ga dat kopiëren en.
Neem ze hieronder en daar gaan we, zelfcontradictie twee en zelfconvolutie drie die convolutieverbindingen zijn met deze eerste
convolutie, één hier zal enige convolutie toepassen op de invoerafbeeldingen om de eerste convolutionele laag
te krijgen.
Dan zal de tweede conclusie tot hier de eerste convolutionele laag als invoer nemen.
En door opnieuw wat convolutie toe te passen, zal het een tweede convolutionele laag creëren.
En in deze convolutionele daar zullen we een aantal nieuwe afbeeldingen krijgen, die elk een specifiek kenmerk detecteren.
Dus we zullen deze nieuwe afbeeldingen daar in een convolutie krijgen.
Vervolgens passen we deze convolutie hier toe om deze nieuwe afbeeldingen van deze eerste convolutionele laag te verbinden met
enkele nieuwe afbeeldingen van een tweede convolutionele laag.
En deze nieuwe afbeeldingen zullen opnieuw enkele kenmerken detecteren in de afbeeldingen van de eerste convolutionele laag.
Dus het is alleen om de functiedetectie te versterken en dan naar de afbeeldingen van de tweede convolutie.
Daar passen we de derde convolutie hier toe om voor elk van hen wat meer afbeeldingen te krijgen die nog meer
functies in de invoerafbeeldingen detecteren.
Dus hoe meer we dit doen, hoe meer we enkele windingen toepassen op de verschillende lagen van afbeeldingen.
Welnu, hoe meer we in staat zijn om sommige functies te detecteren.
En dat is hoe het oog door de kenmerken te detecteren, zal begrijpen waar de monsters zijn, waar het moet
schieten om ze te doden en waar het naartoe moet.
Het zal ook de muren detecteren, de obstakels, nou ja, letterlijk waar het heen moet, en dat is
te danken aan wat al deze convolutionele lagen detecteren in de originele invoerbeelden.
Oke.
Dus dat is voor het convolutiegedeelte van de CNN.
Maar onthoud dan dat we na de convolutionele lagen alle pixels moeten afvlakken die zijn verkregen door de verschillende
reeksen convoluties die zijn toegepast.
En door alle arrays van pixels af te vlakken, krijgen we deze enorme vector die de invoer wordt van een
klassiek kunstmatig neuraal netwerk.
En daar krijgen we onze volledig verbonden spelers en dus onze volledige verbindingen.
Wat we nu moeten doen, is twee nieuwe variabelen creëren, want we krijgen één Hillaire in dit klassieke
kunstmatige neurale netwerk dat hierna komt.
En daarom hebben we één volledige verbinding nodig van deze enorme afgeplatte vector naar deze hier en
daar, en een tweede volledige verbinding tussen deze hier en daar en de outputlaag die bestaat uit de
outputneuronen die de kernwaarden zijn.
Dus laten we deze twee eerste verbindingen maken en dan zullen we al deze verbindingen definiëren.
Dus wat betreft de zelfrijdende auto, we gaan ze zelf die ene noemen en dan zelf die F. C. naar.
Oke.
Dus nu hebben we al onze variabelen.
En dus moeten we ze nu natuurlijk definiëren met de klassen van de motormodule.
Dus dat betekent dat we in feite de architectuur van het neurale netwerk zullen creëren en dat zullen we
tot die tijd in de volgende tutorial doen.
En ik.