Ga naar hoofdinhoud

Een laag

Een plaatje is nu een lijst getallen. Eén neuron zegt daar ja of nee over. Een laag is een rij neuronen die allemaal naar dezelfde invoer kijken, elk met zijn eigen gewichten en bias. Samen geven ze een nieuwe lijst: van elk neuron één uitkomst.

Voorspel​

def neuron(invoer, gewichten, bias):
    som = bias
    for i in range(len(invoer)):
        som = som + invoer[i] * gewichten[i]
    if som > 0:
        return 1
    return 0

invoer = [1, 0]
print(neuron(invoer, [1, 1], 0), neuron(invoer, [1, 1], -1))

Twee neuronen kijken naar dezelfde invoer. Wat print dit programma?

Antwoord
1 0

Het eerste neuron is het OF-neuron, het tweede het EN-neuron. Bij [1, 0] zegt OF ja en EN nee.

Zo werkt het​

De gewichten van een laag staan in een lijst van lijsten: alle_gewichten[n] zijn de gewichten van neuron n, en biases[n] is zijn bias. De functie laag loopt langs de neuronen en zet de uitkomst van elk neuron in een lijst. neuron staat in de verborgen code onder de editor.

Die lijst is weer een gewone invoer. In de volgende stap gaat hij een tweede laag in. In Traffic heet zo'n laag, waarin elk neuron naar alle invoer kijkt, een Dense-laag.

Onderzoek​

  1. Draai de code. Welk neuron doet OF, en welk doet EN?
  2. Zet er een derde neuron bij, met gewichten [-1, -1] en bias 1. Wat zegt het bij de vier combinaties?
  3. Haal daarna de bias van het derde neuron weer weg, maar laat zijn gewichten staan. Wat gebeurt er?
Python
Code-omgeving wordt voorbereid…
Wat zie je?
0 0 -> [0, 0]
0 1 -> [1, 0]
1 0 -> [1, 0]
1 1 -> [1, 1]
Antwoorden
  1. Het eerste neuron doet OF, het tweede EN.
  2. Het derde zegt alleen 1 bij 0 0: geen van beide. Bij 0 0 krijg je [0, 0, 1].
  3. Je krijgt dezelfde foutmelding als bij gewichten: er zijn drie lijsten gewichten maar twee biases, en bij het derde neuron is er geen biases[2].

Opdracht: een laag voor plaatjes​

Maak een laag van drie neuronen die naar een plaatje van 3 bij 3 kijken. Het eerste zegt 1 als de bovenste rij helemaal zwart is, het tweede bij de middelste rij, het derde bij de onderste rij. Voor een liggende streep en een helemaal zwart plaatje print hij:

[0, 1, 0]
[1, 1, 1]

Begin klein, en breid de code stap voor stap uit:

  1. Draai de code: er is alleen het neuron voor de bovenste rij, en dat zegt [0].
  2. Zet het neuron voor de middelste rij erbij, in alle_gewichten en biases. Nu zie je [0, 1].
  3. Zet het neuron voor de onderste rij erbij.
  4. Print ook de laag voor zwart.
Python
Code-omgeving wordt voorbereid…
Tip

Waarom is de bias van het eerste neuron -2? Reken de som uit als twee van de drie pixels van de bovenste rij zwart zijn, en als alle drie zwart zijn.

Antwoord

Dit vervangt de laatste drie regels in de editor:

alle_gewichten = [
    [1, 1, 1, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 1, 1, 1],
]
biases = [-2, -2, -2]
print(laag(liggend, alle_gewichten, biases))   # [0, 1, 0]
print(laag(zwart, alle_gewichten, biases))   # [1, 1, 1]

Elk neuron heeft gewicht 1 op de drie pixels van zijn rij en 0 op de rest. Met bias -2 komt de som alleen boven 0 als alle drie zwart zijn.

Door naar twee lagen.