KI Elemente

Viele Teile ergeben ein Ganzes! Die Kunst unwichtige Details zu vermeiden!

Neuron mit Zielvorgaben

Ein Beispiel:

Es handelt sich um eine triviale Aufgabe, die zeigen soll, wie ein einfachstes "digitales Neuron" eine Aufgabe lösen kann.

Es handelt sich um eine Bank, in der es gewisse Bedingungen gibt, um den Tresor zu öffnen. Niemand darf das alleine, sondern der Filialleiter muss immer einen Mitarbeiter, von zweien die zur Auswahl stehen, zur Seite haben.

Nennen wir die Mitarbeiter der Einfachheit halber A und B und stellen eine Tabelle auf:

Eingabevektor = 1 ---> Anwesenheit von A oder B; 0 ---> Abwesenheit von A oder B


Wenn beim Wochentag eine 1 steht, ist die Bedingung, dass A oder B anwesend sein müssen, erfüllt. Das BIAS Neuron wurde im Menüpunkt "Einfaches Neuron" behandelt.

Nun gibt es einen gewünschten Output, der mit dem berechneten Output verglichen wird und in eine Fehleranalyse einfließt.

Python - Skript: Bank.py

Es gibt keine Lernphase. Die Gewichte wurden willkürlich gewählt, um die logische ODER Verknüpfung zu erfüllen.

# Stuhlpfarrer Ehrenfried - 2021
# Demo Bank - Anwesenheit - Tresor

import numpy as np

class Bank:
def __init__(self, txt):
print(txt)

# Heaviside - Funktion
def heaviside(self, summe):
# Input: Summe
# Output: 1, falls summe >= 0, sonst 0
if summe >= 0:
return 1
else:
return 0

# Neuron - Berechnung
def perceptron_eval(self, X, y):
# Input: X, Inputvektor | y, der gewünschte Output
# Output: Der Gesamtfehler, d.h. Summe aus dem Betrag der Differenz von errechnetem und gewünschtem Output
# Der Gesamtfehler
gesamtfehler = 0;
# Die Gewichte so wählen, dass das OR - Problem gelöst werden kann
w = np.array([-1, 1, 1])
# Index i und Element x Ermittlung vom Array X
for i, x in enumerate(X):
# x = Zeile für Zeile verwenden
# inneres Produkt zwischen x und w
summe = np.dot(w, x)
ergebnis = self.heaviside(summe)
# Fehler
fehler = np.abs(ergebnis - y[i])
# Gesamtfehler
gesamtfehler += fehler
# Ausgabe
print(
"A = {}, B = {}, gewünschtes Ergebnis = {}, errechnetes Ergebnis = {}, Fehler = {}".format(
x[1], x[2], y[i], ergebnis, fehler))
# Gesamtfehler pro Epoche über ganzen Trainingsdatensatz
return gesamtfehler


# Main -----------------------------------------------
# 3D Input = Bias-Neuron, Mitarbeiter A und B
# 4 Inputvektoren
X = np.array([
[1,0,0],
[1,0,1],
[1,1,0],
[1,1,1]])
# Die 4 gewünschten Ergebniswerte
y = np.array([0,1,1,1])

bank = Bank("Bank - Anwesenheit - Tresor")
# bank.perceptron_eval(X, y)

# Auswertung des Inputs
gesamtfehler = bank.perceptron_eval(X, y)
print("Gesamtfehler = %1d" % (gesamtfehler))

Ausgabe:
Bank - Anwesenheit - Tresor
A = 0, B = 0, gewünschtes Ergebnis = 0, errechnetes Ergebnis = 0, Fehler = 0
A = 0, B = 1, gewünschtes Ergebnis = 1, errechnetes Ergebnis = 1, Fehler = 0
A = 1, B = 0, gewünschtes Ergebnis = 1, errechnetes Ergebnis = 1, Fehler = 0
A = 1, B = 1, gewünschtes Ergebnis = 1, errechnetes Ergebnis = 1, Fehler = 0
Gesamtfehler = 0

KI

Copyright © 2021. All Rights Reserved. Ehrenfried Stuhlpfarrer