Version ohne GUI

.gitignore

@@ -0,0 +1,34 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*
+
+# Dokumentationen im Unterordner Quellcode
+Quellcode/doc/
+
+# Daten
+*.csv
+
+
+
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Oliver Heidbüchel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Quellcode/Aktivierungsfunktion.java

@@ -0,0 +1,24 @@
+/**
+ * Die Aktivierungsfunktion für ein neuronales Netz.
+ * 
+ * @author Dr. Oliver Heidbüchel
+ * @version 2023-11-05
+ */
+public abstract class Aktivierungsfunktion
+{
+    /**
+     * Die Aktivierungsfunktion
+     *
+     * @param x eine Zahl
+     * @return der Funktionswert der Aktivierungsfunktion an der Stelle x
+     */
+    public abstract double phi(double x);
+
+    /**
+     * Die Ableitung der Aktivierungsfunktion
+     *
+     * @param x eine Zahl
+     * @return die Ableitung der Aktivierungsfunktion an der Stelle x
+     */
+    public abstract double phiStrich(double x);
+}

Quellcode/MNIST.java

@@ -0,0 +1,129 @@
+import java.io.*;
+
+/**
+ * Erkennung von handgeschriebenen Ziffern mit den MNIST-Daten
+ * 
+ * @author Dr. Oliver Heidbüchel
+ * @version 2023-04-26
+ */
+public class MNIST
+{
+    private Netz n;
+    private double[][] eingabe;
+    private double[][] ausgabe;
+    double lernrate = 0.001;
+    int paketGroesse = 1000;
+    int wiederholungen = 100;
+
+    /**
+     * Konstruktor für die Erkennung von handgeschriebenen Ziffern mit den MNIST-Daten
+     * 
+     * @param af Aktivierungfunktion
+     */
+    public MNIST(Aktivierungsfunktion af)
+    {
+        n = new Netz(784, new int[]{20,20,10}, af);
+
+        // lese Trainingsdaten
+        int anzahl = 60000;
+        eingabe = new double[anzahl][784];
+        ausgabe = new double[anzahl][10];
+
+        int counter = 0;
+        try {
+            FileReader filereader = new FileReader("mnist_train.csv");
+            BufferedReader reader = new BufferedReader(filereader);
+            String line = reader.readLine();
+            while (line != null && counter < anzahl){
+                String[] eintraege = line.split(",");
+                int z = Integer.parseInt(eintraege[0]);
+                ausgabe[counter][z] = 1;
+                for (int i = 1; i < 785; i++){
+                    eingabe[counter][i - 1] = Double.parseDouble(eintraege[i]);
+                }
+                counter++;
+                line = reader.readLine();
+            }
+            reader.close();
+        } catch (Exception ex){
+            System.err.println("Fehler beim Einlesen der Trainingsdaten!");
+        }
+    }
+
+    /**
+     * Trainiere das neuronale Netz mit den MNIST-Trainingsdaten
+     * 
+     * @param lernrate die Lernrate
+     * @param paketGroesse die Paketgröße
+     * @param wiederholungen die Anzahl der Wiederholungen
+     * @return der Fehler
+     */
+    public double trainiere(double lernrate, int paketGroesse, int wiederholungen){
+        this.lernrate = lernrate;
+        this.paketGroesse = paketGroesse;
+        this.wiederholungen = wiederholungen;
+        return trainiere();
+    }
+
+    /**
+     * Trainiere das neuronale Netz mit den MNIST-Trainingsdaten und Standardparametern
+     * 
+     * @return der Fehler
+     */
+    public double trainiere(){
+        long beginn = System.nanoTime();
+        double fehler = n.trainiere(eingabe, ausgabe, lernrate, paketGroesse, wiederholungen);
+        long dauer = System.nanoTime() - beginn;
+        dauer /= 1000000000;
+        System.out.println("Training: " + dauer + " Sekunden, d.h. " + (dauer / 60 / 60) % 60 + " Stunden " + (dauer / 60) % 60 + " Minuten " + dauer % 60 + " Sekunden");
+        return fehler;
+    }
+
+    /**
+     * Teste das Netz mit den MNIST-Trainingsdaten<br>
+     * Die Ausgabe erfolgt über die Konsole.
+     */
+    public void teste(){
+        int korrekt = 0;
+        int[] abweichungen = new int[10];
+
+        try {
+            FileReader filereader = new FileReader("mnist_test.csv");
+            BufferedReader reader = new BufferedReader(filereader);
+            String line = reader.readLine();
+            while (line != null){
+                String[] eintraege = line.split(",");
+                int zahl = Integer.parseInt(eintraege[0]);
+                double daten[] = new double[784];
+                for (int i = 1; i < 785; i++){
+                    daten[i - 1] = Double.parseDouble(eintraege[i]);
+                }
+                double ausgabe[] = n.berechne(daten);
+
+                double maxWert = ausgabe[0];
+                int maxStelle = 0;
+                for (int i = 1; i < 10; i++){
+                    if (ausgabe[i] > maxWert){
+                        maxWert = ausgabe[i];
+                        maxStelle = i;
+                    }
+                }
+                int berechnet = maxStelle;
+                System.out.println(zahl + " - " + berechnet);
+                if (zahl == berechnet) korrekt++; else abweichungen[zahl]++;
+                line = reader.readLine();
+            }
+            reader.close();
+        } catch (Exception ex){
+            System.err.println("Fehler beim Einlesen der Trainingsdaten!");
+        }
+
+        System.out.println("Korrekt: " + korrekt);
+        System.out.println("Anzahl der Fehler bei ...");
+        for (int i = 0; i < 10; i++){
+            System.out.println("   ... " + i + ": " + abweichungen[i]);
+        }
+        System.out.println("insgesamt: " + (10000 - korrekt));
+    }
+
+}

Quellcode/Netz.java

@@ -0,0 +1,104 @@
+/**
+ * Ein neuronales Netz
+ * 
+ * @author Dr. Oliver Heidbüchel
+ * @version 2023-10-21
+ */
+public class Netz
+{
+    private Schicht[] schichten;
+
+    /**
+     * Ein neuronales Netz mit mehreren Schichten.
+     * 
+     * @param eingaenge Anzahl der Eingänge für die erste Schicht
+     * @param neuronenProSchicht die Anzahl der Knoten für die einzelnen Schichten
+     * @param af die Aktivierungsfunktion
+     */
+    public Netz(int eingaenge, int[] neuronenProSchicht, Aktivierungsfunktion af)
+    {
+        schichten = new Schicht[neuronenProSchicht.length];
+        schichten[0] = new Schicht(eingaenge, neuronenProSchicht[0], af);
+        for (int i = 1; i < schichten.length; i++){
+            schichten[i] = new Schicht(neuronenProSchicht[i - 1], neuronenProSchicht[i], af);
+        }
+    }
+
+    /**
+     * Berechnet die Ausgaben für die gegebenen Eingaben.
+     * Die Länge des Arrays eingaben muss so groß sein wie die Anzahl der Eingänge der ersten Schicht.
+     * 
+     * @param eingaben die Eingaben
+     * @param Ausgaben der letzten Schicht
+     */
+    public double[] berechne(double[] eingaben){
+        double[] ausgaben = eingaben;
+        for (int i = 0; i < schichten.length; i++){
+            ausgaben = schichten[i].berechne(ausgaben);
+        }
+        return ausgaben;
+    }
+
+    /** 
+     * Trainiert das Netz mit gegebenen Trainigsdaten.
+     * 
+     * @param eingabe Eingabedaten
+     * (eingabe[i].length muss gleich der Anzahl der Neuronen in der ersten Schicht sein, eingabe.length muss gleich ausgabe.length sein)
+     * @param ausgabe Ausgabedaten
+     * (ausgabe[i].length muss gleich der Anzahl der Neuronen in der Ausgabeschicht sein, eingabe.length muss gleich ausgabe.length sein)
+     * @param lernrate die Lernrate
+     * @param paketGroesse die Anzahl der Datensätze, die trainiert wird, bevor die Änderungen geschrieben werden
+     * Wenn paketGroesse die Anzahl der Eingabedaten nicht teilt, so werden "überzählige" Datensätze weggelassen.
+     * @param wiederholungen die Anzahl der Durchläufe der Trainingsdaten
+     * @return der durchschnittliche Fehler für alle Datensätze nach dem letzten Training
+     */
+    public double trainiere(double[][] eingabe, double[][] ausgabe, double lernrate, int paketGroesse, int wiederholungen){
+        int pakete = eingabe.length / paketGroesse;
+        for (int h = 0; h < wiederholungen; h++){
+            for (int i = 0; i < pakete; i++){
+                for (int j = paketGroesse * i; j < paketGroesse * (i+1); j++){
+                    double[] berechnet = berechne(eingabe[j]);
+                    schichten[schichten.length - 1].berechneAenderungen(lernrate, ausgabe[j]);
+                    for (int k = schichten.length - 2; k >= 0; k--){
+                        schichten[k].berechneAenderungen(lernrate, schichten[k + 1]);
+                    }
+                }
+                aendereGewichtungen();
+            }
+        }
+
+        double f = 0;
+        for (int i = 0; i < eingabe.length; i++){
+            f += fehler(ausgabe[0], berechne(eingabe[0]));
+        }
+        return f /= eingabe.length;
+    }
+
+    /**
+     * Die Gewichtungen werden geändert und die Deltas auf 0 gesetzt.
+     */
+    public void aendereGewichtungen(){
+        for (int i = 0; i < schichten.length; i++){
+            schichten[i].aendereGewichtungen();
+        }
+    }
+
+    /**
+     * Berechnet den Fehler.
+     * 
+     * @param t die tatsächlichen Werte
+     * @param o die berechneten Werte
+     * @return der Fehler
+     */
+    public double fehler(double[] t, double[] o){
+        double summe = 0;
+        for (int i = 0; i < t.length; i++){
+            double faktor = t[i] - o[i];
+            summe += faktor * faktor;
+        }
+        return summe / 2;
+    }
+}
+
+
+