kramann.info
© Guido Kramann

Login: Passwort:










Robuste Systemintegration
1 Grundlagen
..1.1 Newton
....1.1.1 LinearSchwinger
....1.1.2 Daempfung
....1.1.4 ODE
....1.1.5 Saaluebung
..1.2 NewtonEuler
....1.2.1 Traegheitsmomente
....1.2.2 Modellgleichungen
....1.2.3 Einfachpendel
..1.3 Scilab
....1.3.1 Erste_Schritte
....1.3.2 Skripte
....1.3.3 Funktionen
..1.4 Laplace
....1.4.1 Eigenwerte
....1.4.2 PT1
..1.5 Regleroptimierung
....1.5.1 Guetefunktion
....1.5.2 Heuristiken
....1.5.3 Scilab
..1.6 Einstellregeln
....1.6.1 Totzeit
....1.6.2 Methode1
....1.6.3 Methode2
....1.6.4 Scilab
..1.7 Zustandsregler
..1.8 Polvorgabe
..1.8 Polvorgabe_alt
..1.9 Beobachter
....1.9.1 Haengependel
..1.10 Daempfungsgrad
..1.11 Processing
....1.11.1 Installation
....1.11.2 Erste_Schritte
....1.11.3 Mechatronik
....1.11.4 Bibliotheken
....1.11.5 Uebung
....1.11.6 Snippets
......1.11.6.1 Dateioperationen
......1.11.6.2 Bilder
......1.11.6.3 GUI
......1.11.6.4 Text
......1.11.6.5 PDF
......1.11.6.8 Maus
......1.11.6.10 Zeit
......1.11.6.13 Animation
......1.11.6.15 Simulation
....1.11.7 Referenzen
..1.12 Breakout
2 Beispiel
3 Beispielloesung
4 Praxis
5 javasci
6 Fehlertoleranz1
7 Reglerentwurf
..7.1 Sprungantwort
..7.2 Messdaten
..7.3 Systemidentifikation
..7.4 Polvorgabe
..7.5 Beobachter
..7.6 Robuster_Entwurf
..7.7 SIL
8 Systementwicklung
9 Arduino
..9.1 Lauflicht
..9.2 Taster
..9.3 Sensor
..9.12 Motor_PWM1
..9.13 Motor_PWM2_seriell
..9.14 Motor_PWM3_analogWrite
..9.15 Scheduler
..9.20 AV
..9.21 Mikrofon
..9.22 Universal
....9.22.1 Laborplatine
....9.22.2 LED_Leiste
....9.22.3 Motortreiber
....9.22.4 Sensoreingaenge
....9.22.5 Taster
....9.22.6 Tests
....9.22.7 Mikrofon
....9.22.8 Lautsprecher
....9.22.9 Fahrgestell
..9.23 Zauberkiste
..9.24 OOP
....9.24.1 Uebungen
..9.25 AVneu
....9.25.1 Tests
..9.26 DA_Wandler
..9.27 CompBoard
....9.27.1 Tastenmatrix
....9.27.2 ASCIIDisplay
..9.28 CTC
..9.29 Tonerzeugung
10 EvoFuzzy
..10.1 Fuzzy
....10.1.1 Fuzzylogik
....10.1.2 FuzzyRegler
....10.1.3 Uebung9
....10.1.5 Softwareentwicklung
......10.1.5.1 AgileSoftwareentwicklung
......10.1.5.2 FuzzyRegler
......10.1.5.3 Uebung
....10.1.6 Umsetzung
......10.1.6.1 FuzzyRegler
......10.1.6.2 Simulation
......10.1.6.3 Optimierung
......10.1.6.4 Uebung
....10.1.7 Haengependel
......10.1.7.1 Haengependel
......10.1.7.2 Simulation
......10.1.7.3 FuzzyRegler
......10.1.7.4 Optimierer
......10.1.7.5 Genetisch
....10.1.8 Information
....10.1.9 Energie
..10.2 Optimierung
....10.2.1 Gradientenverfahren
....10.2.2 Heuristiken
....10.2.3 ModifizierteG
....10.2.4 optim
..10.3 Genalgorithmus
..10.4 NeuronaleNetze
....10.4.1 Neuron
....10.4.2 Backpropagation
....10.4.3 Umsetzung
....10.4.4 Winkelerkennung
..10.5 RiccatiRegler
11 Agentensysteme
12 Simulation
20 Massnahmen
21 Kalmanfilter
..21.1 Vorarbeit
..21.2 Minimalversion
..21.3 Beispiel
30 Dreirad
31 Gleiter
..31.1 Fehlertoleranz

10.4.1 Einzelnes Neuron

  • Das am häufigsten eingesetzte Modell für eine Neuron ist das s.g. Perzeptron.
  • Hier kann es eine beliebige Anzahl von Eingängen xk geben, die mit den Gewichten wk multipliziert werden.
  • Die Summe der gewichteten Eingänge liefert das Argument für eine sigmoide Funktion, deren Ergebnis z.B. der Ausgang des i-ten Neurons oi ist.
Durch Veränderungen der Gewichte wk und d "lernt" ein Neuronales Netz.
Schema eines Perzeptrons

Bild 10.4.1-1: Schema eines Perzeptrons

  • Als sigmoide Funktion werden teilweise abschnittsweise Geraden verwendet.
  • Häufig kommt die folgende Funktion zum Einsatz:
Beispiel einer sigmoiden Funktion

Bild 10.4.1-2: Beispiel einer sigmoiden Funktion

  • o ist dabei der Ausgang.
  • u ist die Summe der gewichteten Eingänge des Neurons.
  • Je größer der positive Parameter d ist, desto mehr nähert sich die Funktion einer Rechteckfunktion.

Umsetzung der Antivalenzschaltung durch geschickte Wahl der Gewichte

  • Im folgenden soll gleich eine Umsetzung einer logischen Antivalenzschaltung mit Hilfe der folgenden Neuronalen Struktur umgesetzt werden:
Neuronales Netz, mit dessen Hilfe eine logische Antivalenzverknüpfung realisiert werden soll.

Bild 10.4.1-3: Neuronales Netz, mit dessen Hilfe eine logische Antivalenzverknüpfung realisiert werden soll.

  • Idee zur Verteilung der Gewichte...
  • Vom Eingang zur ersten Schicht:
  • w0 = 1
  • w1 = -1
  • w2 = -1
  • w3 = 1
  • Vom Eingang zur zweiten Schicht:
  • w4 = 1
  • w5 = 1
  • Bei Neuronalen Netzen wird häufig zur "Belernung" der Backpropagation-Algorithmus eingesetzt.
  • Bei diesem Algorithmus wird der Fehler am Ausgang nach bestimmten Regeln anteilig Schicht für Schicht negativ auf die Gewichte verteilt.
  • Zunächst verwenden wir aber was wir haben:
  • Einen Genetischen Algorithmus.
Übung
  • Das folgende Java-Programm repräsentiert obiges Neuronale Netz und enthält auch gleich eine Fehlerfunktion.
  • Testen Sie die Güte obiger Gewichtsparameterverteilung in Bezug auf eine Realisierung des Antivalenzgatters.
  • Optimieren Sie das Neuronale Netz automatisiert.
  • Ziehen Sie eine weitere Schicht mit zwei Neuronen ein und optimieren Sie neu.
public class Neuro1
{
    public static double[] ww = new double[6];
    public static double[] dd = new double[3];
    public static double sigmoid(double u, double d)
    {
        return 1.0 / ( 1.0 + Math.exp(-d*u) );
    }
    public static double netz(double in0, double in1,double[] w, double[] d)
    {
        double n10 = sigmoid(in0*w[0]+in1*w[3],d[0]);
        double n11 = sigmoid(in1*w[2]+in0*w[1],d[1]);
        double n20 = sigmoid(n10*w[4]+n11*w[5],d[2]);
        return n20;
    }
    public static double berechneFehler(double[] w, double[] d)
    {
        double ausgang;      
        double fehler = 0.0;
        ausgang = netz(0.0,0.0,w,d);
        //System.out.println("in: 0 0 sollout: 0, istwert:"+ausgang);
        fehler += (ausgang-0.0)*(ausgang-0.0);
        ausgang = netz(1.0,0.0,w,d);
        //System.out.println("in: 1 0 sollout: 1, istwert:"+ausgang);
        fehler += (ausgang-1.0)*(ausgang-1.0);
        ausgang = netz(0.0,1.0,w,d);
        //System.out.println("in: 0 1 sollout: 1, istwert:"+ausgang);
        fehler += (ausgang-1.0)*(ausgang-1.0);
        ausgang = netz(1.0,1.0,w,d);
        //System.out.println("in: 1 1 sollout: 0, istwert:"+ausgang);
        fehler += (ausgang-0.0)*(ausgang-0.0);
        return fehler;
    }
    public static double berechneFehler(double[] param)
    {
        for(int i=0;i<6;i++)
            ww[i] = 100.0*param[i]-50.0;
        for(int i=0;i<3;i++)
            dd[i] = 100.0*param[i+6]-50.0;
        return berechneFehler(ww,dd);
    }
    public static void main(String[] args)
    {
        double[] w = new double[]
        {1.0,-1.0,-1.0,1.0,1.0,1.0};
        double[] d = new double[]
        {1.0, 1.0, 1.0};
        System.out.println("Fehler = "+berechneFehler(w,d));
    }
}

Code 10.4.1-1: Java-Implementierung eines Neuronalen Netzes.