Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Mache den Chatbot funktionsfähig, dass er eine Antwort gibt und überarbeite den gesamten…

  1. User

    Mache den Chatbot funktionsfähig, dass er eine Antwort gibt und überarbeite den gesamten Code: package com.mycompany.simplechatbot;

    import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors;

    /**

    • Ein einfacher Chatbot mit Wortvektoren, einem neuronalen Netz und einem einfachen Attention-Mechanismus. */ public class SimpleChatbot {

      /**

      • Repräsentiert ein Wort und seinen zugehörigen Vektor. */ static class WordVector { private String word; private double[] vector;

        public WordVector(String word, double[] vector) { this.word = word; this.vector = vector; }

        public String getWord() { return word; }

        public double[] getVector() { return vector; } }

      // Eine Liste deutscher Stopwörter (angepasst) static final Set stopwords = new HashSet<>(Arrays.asList( "a", "an", "the" ));

      /**

      • Lädt und verwaltet Wortvektoren aus einer Datei. */ static class WordVectorModel { private Map<String, WordVector> wordVectors; private Map<String, Integer> wordToIndex; private Map<Integer, String> indexToWord; private int vectorSize = -1;

        public WordVectorModel(String filePath) throws IOException { wordVectors = new HashMap<>(); wordToIndex = new HashMap<>(); indexToWord = new HashMap<>(); loadWordVectors(filePath); }

        private void loadWordVectors(String filePath) throws IOException { String line; int index = 0; try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) { while ((line = reader.readLine()) != null) { String[] parts = line.split(" "); if (parts.length < 2) continue; // Sicherstellen, dass mindestens Wort und eine Dimension vorhanden sind String word = parts[0]; double[] vector = new double[parts.length - 1]; for (int i = 0; i < parts.length - 1; i++) { try { vector[i] = Double.parseDouble(parts[i + 1]); } catch (NumberFormatException e) { System.out.println("Fehler beim Parsen der Zahl für Wort: " + word + ". Überspringe dieses Wort."); vector = null; break; } } if(vector == null) continue;

                 if (!stopwords.contains(word)) {
                     // Überprüfung der Vektorlänge
                     if(vectorSize == -1) {
                         vectorSize = vector.length;
                     } else if(vector.length != vectorSize) {
                         System.out.println("Vektorgröße inkonsistent für Wort: " + word + ". Erwartet: " + vectorSize + ", Gefunden: " + vector.length);
                         continue; // Überspringe Vektoren mit inkonsistenter Größe
                     }
        
                     wordVectors.put(word.toLowerCase(), new WordVector(word, vector));
                     wordToIndex.put(word.toLowerCase(), index);
                     indexToWord.put(index, word.toLowerCase());
                     index++;
                 }
             }
        
             System.out.println("Vektoren erfolgreich aus der Datei geladen: " + filePath);
             System.out.println("Anzahl Wörter im Model: " + wordVectors.size());
             System.out.println("Dimension der Vektoren: " + vectorSize);
        
             // Optional: Ausgabe einiger Vektoren zur Überprüfung
             int count = 0;
             for (Map.Entry<String, WordVector> entry : wordVectors.entrySet()) {
                 String word = entry.getKey();
                 double[] vector = entry.getValue().getVector();
        
                 System.out.print("Word: " + word + ", Vector: [");
                 for (int i = 0; i < Math.min(vector.length, 5); i++) { // Begrenze die Ausgabe für Lesbarkeit
                     System.out.print(vector[i]);
                     if (i < vector.length - 1 && i < 4) { // Anpassung der Bedingung zur Begrenzung auf 5 Elemente
                         System.out.print(", ");
                     }
                 }
                 System.out.println("...]");
                 count++;
                 if (count >= 1) break; // Entferne dies, um mehr Vektoren zu sehen
             }
        
         } catch (IOException e) {
             System.out.println("Fehler beim Laden der Vektoren.");
             e.printStackTrace();
             throw e; // Weiterwerfen der Ausnahme nach der Protokollierung
         }
        

        }

        public WordVector getWordVector(String word) { return wordVectors.get(word.toLowerCase()); }

        public int getVectorSize() { return vectorSize; }

        public Collection getAllWordVectors() { return wordVectors.values(); }

        public Map<String, Integer> getWordToIndexMap() { return wordToIndex; }

        public Map<Integer, String> getIndexToWordMap() { return indexToWord; }

        public int getVocabSize() { return wordVectors.size(); } }

      /**

      • Stellt Hilfsfunktionen für Vektoroperationen bereit. */ static class VectorUtils {

        public static double[] add(double[] a, double[] b) { double[] result = new double[a.length]; for(int i=0; i<a.length; i++) { result[i] = a[i] + b[i]; } return result; }

        public static double[] subtract(double[] a, double[] b) { double[] result = new double[a.length]; for(int i=0; i<a.length; i++) { result[i] = a[i] - b[i]; } return result; }

        public static double[] multiply(double scalar, double[] a) { double[] result = new double[a.length]; for(int i=0; i<a.length; i++) { result[i] = scalar * a[i]; } return result; }

        public static double dotProduct(double[] a, double[] b) { double sum = 0.0; for(int i=0; i<a.length; i++) { sum += a[i] * b[i]; } return sum; }

        public static double norm(double[] a) { return Math.sqrt(dotProduct(a, a)); }

        public static double cosineSimilarity(double[] a, double[] b) { double dot = dotProduct(a, b); double normA = norm(a); double normB = norm(b); if(normA == 0 || normB == 0) return 0.0; return dot / (normA * normB); }

        public static double[] average(List<double[]> vectors) { if(vectors == null || vectors.isEmpty()) return null; int size = vectors.get(0).length; double[] avg = new double[size]; for(double[] vec : vectors) { for(int i=0; i<size; i++) { avg[i] += vec[i]; } } for(int i=0; i<size; i++) { avg[i] /= vectors.size(); } return avg; }

        public static double[] normalize(double[] a) { double n = norm(a); if(n == 0) return a; return multiply(1.0 / n, a); } }

      /**

      • Ein einfaches neuronales Netzwerk mit einer versteckten Schicht. */ static class NeuralNetwork {

        private int inputSize; private int hiddenSize; private int outputSize;

        private double[][] weightsInputHidden; private double[][] weightsHiddenOutput;

        private double learningRate = 0.001; // Reduzierte Lernrate für stabiles Training

        private Random rand = new Random();

        public NeuralNetwork(int inputSize, int hiddenSize, int outputSize) { this.inputSize = inputSize; this.hiddenSize = hiddenSize; this.outputSize = outputSize;

         weightsInputHidden = new double[inputSize][hiddenSize];
         weightsHiddenOutput = new double[hiddenSize][outputSize];
        
         initializeWeights(weightsInputHidden);
         initializeWeights(weightsHiddenOutput);
        

        }

        public int getHiddenSize() { return hiddenSize; }

        private void initializeWeights(double[][] weights) { for(int i=0; i<weights.length; i++) { for(int j=0; j<weights[i].length; j++) { weights[i][j] = rand.nextGaussian() * 0.01; } } }

        /**

        • Führt einen Forward-Pass durch das Netzwerk durch und gibt die aktivierten Output-Werte zurück.

        • @param input Der Eingabevektor.

        • @param temperature Die Temperatur zur Steuerung der Softmax-Verteilung.

        • @return Der aktivierte Ausgabevektor nach Softmax. */ public double[] forward(double[] input, double temperature) { // Berechne Hidden Layer Aktivierungen double[] hiddenOutput = new double[hiddenSize]; for (int j = 0; j < hiddenSize; j++) { double sum = 0.0; for (int i = 0; i < inputSize; i++) { sum += input[i] * weightsInputHidden[i][j]; } hiddenOutput[j] = relu(sum); }

          // Berechne Output Layer (Logits) double[] logits = new double[outputSize]; for (int k = 0; k < outputSize; k++) { for (int j = 0; j < hiddenSize; j++) { logits[k] += hiddenOutput[j] * weightsHiddenOutput[j][k]; } }

          // Wende Softmax mit Temperatur an double[] probabilities = softmax(logits, temperature);

          return probabilities; }

        /**

        • Aktivierungsfunktion ReLU.
        • @param x Eingabewert.
        • @return Aktivierungswert. */ private double relu(double x) { return Math.max(0, x); }

        /**

        • Trainiert das Netzwerk mit der Kreuzentropie-Verlustfunktion und Backpropagation.

        • @param input Der Eingabevektor.

        • @param target Der Zielindex des Zielwortes. */ public void train(double[] input, int target) { // Forward pass mit fester Temperatur von 1.0 double[] hidden = new double[hiddenSize]; for(int j=0; j<hiddenSize; j++) { double sum = 0.0; for(int i=0; i<inputSize; i++) { sum += input[i] * weightsInputHidden[i][j]; } hidden[j] = relu(sum); }

          // Berechne Output Layer (Logits) double[] logits = new double[outputSize]; for(int k=0; k<outputSize; k++) { for(int j=0; j<hiddenSize; j++) { logits[k] += hidden[j] * weightsHiddenOutput[j][k]; } }

          // Softmax-Ausgabe mit fester Temperatur 1.0 double[] probabilities = softmax(logits, 0.00000001);

          // Ziel-Probabilities (One-Hot) double[] targetProbabilities = new double[outputSize]; targetProbabilities[target] = 1.0;

          // Kreuzentropie-Verlust und Gradienten berechnen double[] outputErrors = new double[outputSize]; for(int k=0; k<outputSize; k++) { outputErrors[k] = probabilities[k] - targetProbabilities[k]; }

          // Backpropagate errors to hidden layer double[] hiddenErrors = new double[hiddenSize]; for(int j=0; j<hiddenSize; j++) { double error = 0.0; for(int k=0; k<outputSize; k++) { error += outputErrors[k] * weightsHiddenOutput[j][k]; } // ReLU-Derivative hiddenErrors[j] = hidden[j] > 0 ? error : 0.0; }

          // Update weightsHiddenOutput for(int j=0; j<hiddenSize; j++) { for(int k=0; k<outputSize; k++) { weightsHiddenOutput[j][k] -= learningRate * outputErrors[k] * hidden[j]; } }

          // Update weightsInputHidden for(int i=0; i<inputSize; i++) { for(int j=0; j<hiddenSize; j++) { weightsInputHidden[i][j] -= learningRate * hiddenErrors[j] * input[i]; } } }

        /**

        • Wendet die Softmax-Funktion auf ein Array von Logits an, unter Berücksichtigung der Temperatur.

        • @param logits Die Eingabewerte (Logits).

        • @param temperature Die Temperatur zur Steuerung der Entropie.

        • @return Die normalisierten Wahrscheinlichkeiten. */ private double[] softmax(double[] logits, double temperature) { double max = Double.NEGATIVE_INFINITY; for (double logit : logits) { if (logit > max) max = logit; }

          double sum = 0.0; double[] expScores = new double[logits.length]; for (int i = 0; i < logits.length; i++) { expScores[i] = Math.exp((logits[i] - max) / temperature); sum += expScores[i]; }

          double[] softmax = new double[logits.length]; for (int i = 0; i < logits.length; i++) { softmax[i] = expScores[i] / sum; } return softmax; }

        /**

        • Wählt einen Index basierend auf den Wahrscheinlichkeiten mittels stochastic sampling aus.
        • @param probabilities Das Array der Wahrscheinlichkeiten.
        • @param rand Ein Random-Objekt.
        • @return Der ausgewählte Index. */ private int sampleFromDistribution(double[] probabilities, Random rand) { double p = rand.nextDouble(); double cumulative = 0.0; for (int i = 0; i < probabilities.length; i++) { cumulative += probabilities[i]; if (p < cumulative) { return i; } } return probabilities.length - 1; // Rückfall, falls numerische Instabilität }

      // Methode für Vorhersagen mit Temperatur public double[] predict(double[] input, double temperature) { // Berechne Hidden Layer Aktivierungen double[] hiddenOutput = new double[hiddenSize]; for (int j = 0; j < hiddenSize; j++) { double sum = 0.0; for (int i = 0; i < inputSize; i++) { sum += input[i] * weightsInputHidden[i][j]; } hiddenOutput[j] = relu(sum); }

      // Berechne Output Layer (Logits) double[] logits = new double[outputSize]; for (int k = 0; k < outputSize; k++) { for (int j = 0; j < hiddenSize; j++) { logits[k] += hiddenOutput[j] * weightsHiddenOutput[j][k]; } }

      // Wende Softmax mit Temperatur an return softmax(logits, temperature); }

      }

      /**

      • Lädt die Trainingsdaten und speichert Eingabe-Antwort-Paare. */ public static class TrainingData { private List<String[]> inputPairs; private List<String[]> outputPairs; private Map<String, Integer> wordFrequencies;

        public TrainingData(String trainingFilePath) throws IOException { inputPairs = new ArrayList<>(); outputPairs = new ArrayList<>(); wordFrequencies = new HashMap<>(); loadTrainingData(trainingFilePath); }

        public Map<String, Integer> getWordFrequencies() { return wordFrequencies; }

        private void loadTrainingData(String filePath) throws IOException { Pattern pattern = Pattern.compile("\b[a-zA-ZäöüÄÖÜß0-9']+\b");

         try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
             String line;
             while ((line = reader.readLine()) != null) {
                 String[] parts = line.split("\t");
                 if (parts.length != 2) continue;
        
                 String[] inputWords = extractFilteredWords(parts[0], pattern);
                 String[] outputWords = extractFilteredWords(parts[1], pattern);
        
                 if (inputWords.length > 0 && outputWords.length > 0) { // Optionale Überprüfung
                     inputPairs.add(inputWords);
                     outputPairs.add(outputWords);
                     
                     // Frequenzzählung der Zielwörter
                     for(String word : outputWords) {
                         wordFrequencies.put(word, wordFrequencies.getOrDefault(word, 0) + 1);
                     }
                 }
             }
         }
        
         System.out.println("Geladene Trainingsbeispiele: " + inputPairs.size());
        
         System.out.println("Input: ");
         inputPairs.forEach(input -> System.out.println(String.join(" ", input)));
        
         System.out.println("Output: ");
         outputPairs.forEach(output -> System.out.println(String.join(" ", output)));
        

        }

        /**

        • Extrahiert Wörter aus einem Text, wendet das Regex-Muster an, konvertiert sie zu Kleinbuchstaben

        • und filtert dabei Stopwörter heraus.

        • @param text Der Eingabetext.

        • @param pattern Das Regex-Muster zum Extrahieren der Wörter.

        • @return Ein Array von gefilterten Wörtern. */ private String[] extractFilteredWords(String text, Pattern pattern) { Matcher matcher = pattern.matcher(text.toLowerCase()); List words = new ArrayList<>();

          while (matcher.find()) { String word = matcher.group(); if (!stopwords.contains(word)) { words.add(word); } }

          return words.toArray(new String[0]); }

        public List<String[]> getInputPairs() { return inputPairs; }

        public List<String[]> getOutputPairs() { return outputPairs; } }

      /**

      • Integriert alle Komponenten und ermöglicht das Training und die Interaktion. */ static class Chatbot { private WordVectorModel model; private NeuralNetwork neuralNet; private Scanner scanner; private Map<String, Double> samplingProbabilities;

        // Trainingsdaten private TrainingData trainingData; private final int EPOCHS = 2000000; // Reduzierte Epochen für Debugging

        // Für Einfachheit definieren wir eine feste Antwortlänge private final int MAX_RESPONSE_LENGTH = 5;

        public Chatbot(String vectorFilePath, String trainingFilePath) throws IOException { model = new WordVectorModel(vectorFilePath); int inputSize = model.getVectorSize(); int outputSize = model.getVocabSize(); // Setze outputSize auf die Vokabulargröße // Einfaches neuronales Netz: Eingabe -> Hidden (133) -> Ausgabe (Vokabulargröße) neuralNet = new NeuralNetwork(inputSize, 134, outputSize); scanner = new Scanner(System.in); trainingData = new TrainingData(trainingFilePath); computeSamplingProbabilities(); }

         /*
         * Berechnet die Sampling-Gewichte für jedes Wort, sodass jedes Wort
         * im Output gleich oft vorkommt.
         */
         public void computeSamplingProbabilities() {
             Map<String, Integer> frequencies = trainingData.getWordFrequencies();
               samplingProbabilities = new HashMap<>();
        
             // Summe der inversen Frequenzen für Normalisierung
             double inverseSum = 0.0;
        
             // Berechne die Inversen der Frequenzen und addiere sie zur Normalisierung
             for (Map.Entry<String, Integer> entry : frequencies.entrySet()) {
                 int frequency = entry.getValue();
                 double inverseFreq = 1.0 / frequency;
                 samplingProbabilities.put(entry.getKey(), inverseFreq);
                 inverseSum += inverseFreq;
             }
        
             // Normalisiere die Gewichte, sodass ihre Summe 1 ergibt (damit es Wahrscheinlichkeiten sind)
             for (Map.Entry<String, Double> entry : samplingProbabilities.entrySet()) {
                 samplingProbabilities.put(entry.getKey(), entry.getValue() / inverseSum);
             }
         }
        

        private void trainNetwork() { List<String[]> inputs = trainingData.getInputPairs(); List<String[]> outputs = trainingData.getOutputPairs(); double temperature = 1.0;

         Map<String, Integer> wordToIndex = model.getWordToIndexMap();
         Random random = new Random();
        
         for(int epoch = 0; epoch < EPOCHS; epoch++) {
             double totalLoss = 0.0;
             for(int i = 0; i < inputs.size(); i++) {
                 String[] inputWords = inputs.get(i);
                 String[] outputWords = outputs.get(i);
        
                 // Verarbeitung der Eingabe
                 List<WordVector> inputVectorsList = new ArrayList<>();
                 for(String word : inputWords) {
                     WordVector wv = model.getWordVector(word);
                     if(wv != null) inputVectorsList.add(wv);
                 }
        
                 if(inputVectorsList.isEmpty()) continue;
        
                 double[] contextVector = VectorUtils.average(
                     inputVectorsList.stream().map(WordVector::getVector).collect(Collectors.toList())
                 );
        
                 // Iteration über jedes Wort in der Ausgabe
                 for(int k = 0; k < outputWords.length && k < MAX_RESPONSE_LENGTH; k++) {
                     String targetWord = outputWords[k];
                     Integer targetIndex = wordToIndex.get(targetWord);
                     if(targetIndex == null) continue;
        
                     // Bestimme, ob das Wort trainiert werden soll basierend auf Sampling-Wahrscheinlichkeit
                     double prob = samplingProbabilities.getOrDefault(targetWord, 1.0);
                     if(random.nextDouble() > prob) {
                         // Wort wird übersprungen
                         // Update Kontextvektor mit dem Vektor des Zielwortes
                         WordVector targetWordVector = model.getWordVector(targetWord);
                         if(targetWordVector == null) continue;
                         contextVector = VectorUtils.add(contextVector, targetWordVector.getVector());
                         contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
        
                         continue;
                     }
        
                     // Trainiere das neuronale Netzwerk mit contextVector und targetIndex
                     neuralNet.train(contextVector, targetIndex);
        
                     // Forward-Pass zur Verlustberechnung
                     double[] outputProbabilities = neuralNet.forward(contextVector, temperature);
                     double loss = -Math.log(outputProbabilities[targetIndex] + 1e-9); // Kreuzentropie-Verlust
                     totalLoss += loss;
        
                     // Update Kontextvektor mit dem Vektor des Zielwortes
                     WordVector targetWordVector = model.getWordVector(targetWord);
                     if(targetWordVector == null) continue;
                     contextVector = VectorUtils.add(contextVector, targetWordVector.getVector());
                     contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
                 }
             }
        
             // Ausgabe des Verlusts alle 100 Epochen
             if(epoch % 1000 == 0) { // Anpassung der Frequenz für Verlustaussage
                 double averageLoss = totalLoss / (inputs.size() * MAX_RESPONSE_LENGTH);
                 System.out.println("Epoch " + epoch + " - Durchschnittlicher Verlust: " + averageLoss);
             }
        
             // Optional: Break if loss is sufficiently low
             // if(totalLoss / (inputs.size() * MAX_RESPONSE_LENGTH) < desiredThreshold) break;
         }
        

        }

        /**

        • Startet das Training und die Benutzerinteraktion. */ public void start() { System.out.println("Starte Training..."); trainNetwork(); System.out.println("Training abgeschlossen.");

          System.out.println("Willkommen beim erweiterten Chatbot mit einfachem Attention! Tippe 'exit' zum Beenden.");

          while (true) { System.out.print("Du: "); String input = scanner.nextLine().trim().toLowerCase();

           if ("exit".equalsIgnoreCase(input)) {
               System.out.println("Chatbot beendet. Auf Wiedersehen!");
               break;
           }
          
           String response = generateResponse(input);
           System.out.println("Bot: " + response);
          

          }

          scanner.close(); }

        /**

        • Generiert eine Antwort basierend auf der Benutzereingabe.
        • @param input Die Benutzereingabe.
        • @return Die generierte Antwort. */ private String generateResponse(String input) { String[] words = input.split("\s+"); List vectors = new ArrayList<>(); double generationTemperature = 0.000001; // Lokaler Temperaturparameter für die Generierung

      for(String word : words) { WordVector wv = model.getWordVector(word); if(wv != null) { vectors.add(wv); } }

      if(vectors.isEmpty()) { return "Entschuldigung, ich verstehe dich nicht."; }

      // Sammle die Vektoren double[][] inputVectors = vectors.stream().map(WordVector::getVector).toArray(double[][]::new);

      // Initialer Kontextvektor (z.B. Durchschnitt der Eingabevektoren) double[] contextVector = VectorUtils.average(Arrays.asList(inputVectors)); contextVector = VectorUtils.normalize(contextVector); // Normalisierung zur Stabilität Random rand = new Random(); // Initialisiere Random-Objekt hier

      StringBuilder responseBuilder = new StringBuilder(); Map<Integer, String> indexToWord = model.getIndexToWordMap();

      for(int i=0; i<MAX_RESPONSE_LENGTH; i++) { // Berechne Aufmerksamkeitsscores basierend auf der Kosinusähnlichkeit double[] attentionWeights = computeAttentionWeights(inputVectors, contextVector);

       // Berechne gewichtete Summe der Eingabevektoren
       double[] weightedInput = new double[contextVector.length];
       for(int j=0; j<inputVectors.length; j++) {
           double[] weightedWord = VectorUtils.multiply(attentionWeights[j], inputVectors[j]);
           weightedInput = VectorUtils.add(weightedInput, weightedWord);
       }
      
       // Vorhersage mit Temperatur
       double[] outputProbabilities = neuralNet.predict(weightedInput, generationTemperature);
      
       // Wählen Sie ein Wort basierend auf den Wahrscheinlichkeiten
       int predictedIndex = neuralNet.sampleFromDistribution(outputProbabilities, rand);
       String nextWord = indexToWord.get(predictedIndex);
       if (nextWord == null) {
           break;
       }
      
       responseBuilder.append(nextWord).append(" ");
      
       // Update Kontextvektor durch Akkumulation
       WordVector nextWordVector = model.getWordVector(nextWord);
       if(nextWordVector != null) {
           contextVector = VectorUtils.add(contextVector, nextWordVector.getVector());
           contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
       }
      

      }

      return responseBuilder.toString().trim(); }

       /**
        * Berechnet die Aufmerksamkeitsgewichte basierend auf der Kosinusähnlichkeit zwischen
        * dem Kontextvektor und jedem Eingabewortvektor.
        *
        * @param inputVectors  Die Eingabewortvektoren.
        * @param contextVector Der Kontextvektor.
        * @return Die normalisierten Aufmerksamkeitsscores.
        */
       private double[] computeAttentionWeights(double[][] inputVectors, double[] contextVector) {
           int n = inputVectors.length;
           double[] scores = new double[n];
      
           for(int i=0; i<n; i++) {
               scores[i] = VectorUtils.cosineSimilarity(inputVectors[i], contextVector);
           }
      
           // Softmax-Funktion zur Normalisierung der Scores
           double[] softmaxScores = softmax(scores);
           return softmaxScores;
       }
      
       /**
        * Wendet die Softmax-Funktion auf ein Array von Scores an.
        *
        * @param scores Die Eingabescores.
        * @return Die normalisierten Softmax-Scores.
        */
       private double[] softmax(double[] scores) {
           double max = Double.NEGATIVE_INFINITY;
           for(double s : scores) {
               if(s > max) max = s;
           }
      
           double sum = 0.0;
           double[] expScores = new double[scores.length];
           for(int i=0; i<scores.length; i++) {
               expScores[i] = Math.exp(scores[i] - max);
               sum += expScores[i];
           }
      
           double[] softmax = new double[scores.length];
           for(int i=0; i<scores.length; i++) {
               softmax[i] = expScores[i] / sum;
           }
           return softmax;
       }
      

      }

      public static void main(String[] args) {

       String trainingFilePath = "/home/benito/Schreibtisch/train.txt";
       String vectorFilePath = "/home/benito/Schreibtisch/skynetModel.txt";
      
       try {
           Chatbot chatbot = new Chatbot(vectorFilePath, trainingFilePath);
           chatbot.start();
       } catch(IOException e) {
           System.err.println("Fehler beim Laden der Dateien: " + e.getMessage());
       }
      

      } }

  2. Assistant

    Um den Chatbot funktionsfähig zu machen und sicherzustellen, dass er Antworten generiert, wurden mehrere Anpassungen am ursprünglichen Code vorgenommen. Die wichtigsten Änderungen umfassen:

    1. Anpassung der Hyperparameter:

      • Epochenanzahl reduziert: Die ursprüngliche Anzahl von 2.000.000 Epochen ist extrem hoch und kann zu sehr langen Trainingszeiten führen. Diese wurde auf 10.000 Epochen verringert, was für Debugging-Zwecke ausreichend ist.
      • Lernrate erhöht: Eine zu niedrige Lernrate kann das Training verlangsamen und die Konvergenz behindern. Die Lernrate wurde von 0.001 auf 0.01 erhöht.
      • Temperatureinstellungen angepasst: Die Temperaturen für die Softmax-Funktion im Trainings- und Generierungsprozess wurden von extrem niedrigen Werten (1e-8 bzw. 1e-6) auf 1.0 gesetzt, um eine angemessene Wahrscheinlichkeitsverteilung zu gewährleisten.
    2. Erweiterung der Stopwörter:

      • Die Liste der Stopwörter wurde erweitert, um gängige deutsche Stopwörter einzuschließen, die während der Vorverarbeitung entfernt werden sollten.
    3. Sichtbarkeit und Methodensicherheit:

      • Die Methode sampleFromDistribution in der NeuralNetwork-Klasse wurde auf public gesetzt, um sie im Chatbot verwenden zu können.
    4. Optimierung und Fehlerbehebung:

      • Einige kleinere logische Fehler und Inkonsistenzen im Code wurden behoben, um sicherzustellen, dass der Chatbot korrekt trainiert und antwortet.
      • Zusätzliche Debugging-Ausgaben wurden hinzugefügt, um den Trainingsfortschritt besser verfolgen zu können.

    Nach diesen Anpassungen sollte der Chatbot in der Lage sein, auf Benutzereingaben zu reagieren und sinnvollere Antworten zu generieren.

    Hier ist der überarbeitete Code:

    package com.mycompany.simplechatbot;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.*;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import java.util.stream.Collectors;
    
    /**
     * Ein einfacher Chatbot mit Wortvektoren, einem neuronalen Netz und einem einfachen Attention-Mechanismus.
     */
    public class SimpleChatbot {
    
        /**
         * Repräsentiert ein Wort und seinen zugehörigen Vektor.
         */
        static class WordVector {
            private String word;
            private double[] vector;
    
            public WordVector(String word, double[] vector) {
                this.word = word;
                this.vector = vector;
            }
    
            public String getWord() {
                return word;
            }
    
            public double[] getVector() {
                return vector;
            }
        }
    
        // Eine erweiterte Liste deutscher Stopwörter
        static final Set<String> stopwords = new HashSet<>(Arrays.asList(
            "aber", "alle", "also", "als", "am", "an", "auch", "auf", "aus", "bei",
            "bin", "bis", "bist", "da", "damit", "dann", "der", "den", "des", "dem",
            "die", "das", "daß", "derselbe", "derselben", "denselben", "desselben",
            "demselben", "dieselbe", "dieselben", "dasselbe", "dazu", "dein", "deine",
            "deinem", "deinen", "deiner", "deines", "denn", "derer", "dessen", "dich",
            "dir", "du", "dies", "diese", "diesem", "diesen", "dieser", "dieses", "doch",
            "dort", "durch", "ein", "eine", "einem", "einen", "einer", "eines", "eigentlich",
            "einige", "einiger", "einigem", "einigen", "einigerer", "einiges", "er",
            "ihn", "ihm", "es", "etwas", "euer", "eure", "eurem", "euren", "eurer",
            "eures", "für", "gegen", "gewesen", "hab", "habe", "haben", "hat", "hatte",
            "hatten", "hier", "hin", "hinter", "ich", "mich", "mir", "ihr", "ihre",
            "ihrem", "ihren", "ihrer", "ihrerseits", "in", "ist", "ja", "jede", "jedem",
            "jeden", "jeder", "jedes", "jener", "jenem", "jenen", "jener", "jenes", "jetzt",
            "kann", "kannst", "können", "könnt", "machen", "macht", "machte", "mag",
            "mich", "mir", "mit", "muß", "mußt", "musst", "müssen", "müsst", "nach",
            "nachdem", "nein", "nicht", "nichts", "noch", "nur", "ob", "oder", "ohne",
            "sehr", "sein", "seine", "seinem", "seinen", "seiner", "seines", "selbst",
            "sich", "sie", "ihnen", "sind", "so", "solche", "solchem", "solchen",
            "solcher", "solches", "soll", "sollen", "sollst", "sollt", "sondern",
            "sonst", "über", "um", "und", "uns", "unse", "unsem", "unsen", "unser",
            "unsere", "unserem", "unseren", "unserer", "unseres", "unter", "viel",
            "vom", "von", "vor", "während", "war", "waren", "warst", "was", "weg",
            "weil", "weiter", "welche", "welchem", "welchen", "welcher", "welches",
            "wenn", "wer", "werde", "werden", "wie", "wieder", "will", "wir", "wird",
            "wirst", "wo", "wollen", "wollt", "wollte", "wollten", "würde", "würden",
            "zu", "zum", "zur", "zwar", "zwischen"
        ));
    
        /**
         * Lädt und verwaltet Wortvektoren aus einer Datei.
         */
        static class WordVectorModel {
            private Map<String, WordVector> wordVectors;
            private Map<String, Integer> wordToIndex;
            private Map<Integer, String> indexToWord;
            private int vectorSize = -1;
    
            public WordVectorModel(String filePath) throws IOException {
                wordVectors = new HashMap<>();
                wordToIndex = new HashMap<>();
                indexToWord = new HashMap<>();
                loadWordVectors(filePath);
            }
    
            private void loadWordVectors(String filePath) throws IOException {
                String line;
                int index = 0;
                try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
                    while ((line = reader.readLine()) != null) {
                        String[] parts = line.split(" ");
                        if (parts.length < 2) continue; // Sicherstellen, dass mindestens Wort und eine Dimension vorhanden sind
                        String word = parts[0];
                        double[] vector = new double[parts.length - 1];
                        boolean parseError = false;
                        for (int i = 0; i < parts.length - 1; i++) {
                            try {
                                vector[i] = Double.parseDouble(parts[i + 1]);
                            } catch (NumberFormatException e) {
                                System.out.println("Fehler beim Parsen der Zahl für Wort: " + word + ". Überspringe dieses Wort.");
                                parseError = true;
                                break;
                            }
                        }
                        if(parseError) continue;
    
                            // Überprüfung der Vektorlänge
                        if(vectorSize == -1) {
                            vectorSize = vector.length;
                        } else if(vector.length != vectorSize) {
                            System.out.println("Vektorgröße inkonsistent für Wort: " + word + ". Erwartet: " + vectorSize + ", Gefunden: " + vector.length);
                            continue; // Überspringe Vektoren mit inkonsistenter Größe
                        }
    
                        if (!stopwords.contains(word.toLowerCase())) {
                            wordVectors.put(word.toLowerCase(), new WordVector(word.toLowerCase(), vector));
                            wordToIndex.put(word.toLowerCase(), index);
                            indexToWord.put(index, word.toLowerCase());
                            index++;
                        }
                    }
    
                    System.out.println("Vektoren erfolgreich aus der Datei geladen: " + filePath);
                    System.out.println("Anzahl Wörter im Model: " + wordVectors.size());
                    System.out.println("Dimension der Vektoren: " + vectorSize);
    
                    // Optional: Ausgabe einiger Vektoren zur Überprüfung
                    int count = 0;
                    for (Map.Entry<String, WordVector> entry : wordVectors.entrySet()) {
                        String word = entry.getKey();
                        double[] vector = entry.getValue().getVector();
    
                        System.out.print("Word: " + word + ", Vector: [");
                        for (int i = 0; i < Math.min(vector.length, 5); i++) { // Begrenze die Ausgabe für Lesbarkeit
                            System.out.print(vector[i]);
                            if (i < vector.length - 1 && i < 4) { // Anpassung der Bedingung zur Begrenzung auf 5 Elemente
                                System.out.print(", ");
                            }
                        }
                        System.out.println("...]");
                        count++;
                        if (count >= 5) break; // Erhöht die Anzahl der angezeigten Vektoren
                    }
    
                } catch (IOException e) {
                    System.out.println("Fehler beim Laden der Vektoren.");
                    e.printStackTrace();
                    throw e; // Weiterwerfen der Ausnahme nach der Protokollierung
                }
            }
    
            public WordVector getWordVector(String word) {
                return wordVectors.get(word.toLowerCase());
            }
    
            public int getVectorSize() {
                return vectorSize;
            }
    
            public Collection<WordVector> getAllWordVectors() {
                return wordVectors.values();
            }
    
            public Map<String, Integer> getWordToIndexMap() {
                return wordToIndex;
            }
    
            public Map<Integer, String> getIndexToWordMap() {
                return indexToWord;
            }
    
            public int getVocabSize() {
                return wordVectors.size();
            }
        }
    
        /**
         * Stellt Hilfsfunktionen für Vektoroperationen bereit.
         */
        static class VectorUtils {
    
            public static double[] add(double[] a, double[] b) {
                double[] result = new double[a.length];
                for(int i=0; i<a.length; i++) {
                    result[i] = a[i] + b[i];
                }
                return result;
            }
    
            public static double[] subtract(double[] a, double[] b) {
                double[] result = new double[a.length];
                for(int i=0; i<a.length; i++) {
                    result[i] = a[i] - b[i];
                }
                return result;
            }
    
            public static double[] multiply(double scalar, double[] a) {
                double[] result = new double[a.length];
                for(int i=0; i<a.length; i++) {
                    result[i] = scalar * a[i];
                }
                return result;
            }
    
            public static double dotProduct(double[] a, double[] b) {
                double sum = 0.0;
                for(int i=0; i<a.length; i++) {
                    sum += a[i] * b[i];
                }
                return sum;
            }
    
            public static double norm(double[] a) {
                return Math.sqrt(dotProduct(a, a));
            }
    
            public static double cosineSimilarity(double[] a, double[] b) {
                double dot = dotProduct(a, b);
                double normA = norm(a);
                double normB = norm(b);
                if(normA == 0 || normB == 0) return 0.0;
                return dot / (normA * normB);
            }
    
            public static double[] average(List<double[]> vectors) {
                if(vectors == null || vectors.isEmpty()) return null;
                int size = vectors.get(0).length;
                double[] avg = new double[size];
                for(double[] vec : vectors) {
                    for(int i=0; i<size; i++) {
                        avg[i] += vec[i];
                    }
                }
                for(int i=0; i<size; i++) {
                    avg[i] /= vectors.size();
                }
                return avg;
            }
    
            public static double[] normalize(double[] a) {
                double n = norm(a);
                if(n == 0) return a;
                return multiply(1.0 / n, a);
            }
        }
    
        /**
         * Ein einfaches neuronales Netzwerk mit einer versteckten Schicht.
         */
        static class NeuralNetwork {
    
            private int inputSize;
            private int hiddenSize;
            private int outputSize;
    
            private double[][] weightsInputHidden;
            private double[][] weightsHiddenOutput;
    
            private double learningRate = 0.01; // Erhöhte Lernrate für effizienteres Training
    
            private Random rand = new Random();
    
            public NeuralNetwork(int inputSize, int hiddenSize, int outputSize) {
                this.inputSize = inputSize;
                this.hiddenSize = hiddenSize;
                this.outputSize = outputSize;
    
                weightsInputHidden = new double[inputSize][hiddenSize];
                weightsHiddenOutput = new double[hiddenSize][outputSize];
    
                initializeWeights(weightsInputHidden);
                initializeWeights(weightsHiddenOutput);
            }
    
            public int getHiddenSize() {
                return hiddenSize;
            }
    
            private void initializeWeights(double[][] weights) {
                for(int i=0; i<weights.length; i++) {
                    for(int j=0; j<weights[i].length; j++) {
                        weights[i][j] = rand.nextGaussian() * 0.01;
                    }
                }
            }
    
            /**
             * Führt einen Forward-Pass durch das Netzwerk durch und gibt die aktivierten Output-Werte zurück.
             *
             * @param input      Der Eingabevektor.
             * @param temperature Die Temperatur zur Steuerung der Softmax-Verteilung.
             * @return Der aktivierte Ausgabevektor nach Softmax.
             */
            public double[] forward(double[] input, double temperature) {
                // Berechne Hidden Layer Aktivierungen
                double[] hiddenOutput = new double[hiddenSize];
                for (int j = 0; j < hiddenSize; j++) {
                    double sum = 0.0;
                    for (int i = 0; i < inputSize; i++) {
                        sum += input[i] * weightsInputHidden[i][j];
                    }
                    hiddenOutput[j] = relu(sum);
                }
    
                // Berechne Output Layer (Logits)
                double[] logits = new double[outputSize];
                for (int k = 0; k < outputSize; k++) {
                    for (int j = 0; j < hiddenSize; j++) {
                        logits[k] += hiddenOutput[j] * weightsHiddenOutput[j][k];
                    }
                }
    
                // Wende Softmax mit Temperatur an
                double[] probabilities = softmax(logits, temperature);
    
                return probabilities;
            }
    
            /**
             * Aktivierungsfunktion ReLU.
             *
             * @param x Eingabewert.
             * @return Aktivierungswert.
             */
            private double relu(double x) {
                return Math.max(0, x);
            }
    
            /**
             * Trainiert das Netzwerk mit der Kreuzentropie-Verlustfunktion und Backpropagation.
             *
             * @param input  Der Eingabevektor.
             * @param target Der Zielindex des Zielwortes.
             */
            public void train(double[] input, int target) {
                // Forward pass mit Temperature auf 1.0
                double[] hidden = new double[hiddenSize];
                for(int j=0; j<hiddenSize; j++) {
                    double sum = 0.0;
                    for(int i=0; i<inputSize; i++) {
                        sum += input[i] * weightsInputHidden[i][j];
                    }
                    hidden[j] = relu(sum);
                }
    
                // Berechne Output Layer (Logits)
                double[] logits = new double[outputSize];
                for(int k=0; k<outputSize; k++) {
                    for(int j=0; j<hiddenSize; j++) {
                        logits[k] += hidden[j] * weightsHiddenOutput[j][k];
                    }
                }
    
                // Softmax-Ausgabe mit Temperatur 1.0
                double[] probabilities = softmax(logits, 1.0);
    
                // Ziel-Probabilities (One-Hot)
                double[] targetProbabilities = new double[outputSize];
                targetProbabilities[target] = 1.0;
    
                // Kreuzentropie-Verlust und Gradienten berechnen
                double[] outputErrors = new double[outputSize];
                for(int k=0; k<outputSize; k++) {
                    outputErrors[k] = probabilities[k] - targetProbabilities[k];
                }
    
                // Backpropagate errors to hidden layer
                double[] hiddenErrors = new double[hiddenSize];
                for(int j=0; j<hiddenSize; j++) {
                    double error = 0.0;
                    for(int k=0; k<outputSize; k++) {
                        error += outputErrors[k] * weightsHiddenOutput[j][k];
                    }
                    // ReLU-Derivative
                    hiddenErrors[j] = hidden[j] > 0 ? error : 0.0;
                }
    
                // Update weightsHiddenOutput
                for(int j=0; j<hiddenSize; j++) {
                    for(int k=0; k<outputSize; k++) {
                        weightsHiddenOutput[j][k] -= learningRate * outputErrors[k] * hidden[j];
                    }
                }
    
                // Update weightsInputHidden
                for(int i=0; i<inputSize; i++) {
                    for(int j=0; j<hiddenSize; j++) {
                        weightsInputHidden[i][j] -= learningRate * hiddenErrors[j] * input[i];
                    }
                }
            }
    
            /**
             * Wendet die Softmax-Funktion auf ein Array von Logits an, unter Berücksichtigung der Temperatur.
             *
             * @param logits     Die Eingabewerte (Logits).
             * @param temperature Die Temperatur zur Steuerung der Entropie.
             * @return Die normalisierten Wahrscheinlichkeiten.
             */
            private double[] softmax(double[] logits, double temperature) {
                double max = Double.NEGATIVE_INFINITY;
                for (double logit : logits) {
                    if (logit > max) max = logit;
                }
    
                double sum = 0.0;
                double[] expScores = new double[logits.length];
                for (int i = 0; i < logits.length; i++) {
                    expScores[i] = Math.exp((logits[i] - max) / temperature);
                    sum += expScores[i];
                }
    
                double[] softmax = new double[logits.length];
                for (int i = 0; i < logits.length; i++) {
                    softmax[i] = expScores[i] / sum;
                }
                return softmax;
            } 
            
            /**
             * Wählt einen Index basierend auf den Wahrscheinlichkeiten mittels stochastic sampling aus.
             *
             * @param probabilities Das Array der Wahrscheinlichkeiten.
             * @param rand          Ein Random-Objekt.
             * @return Der ausgewählte Index.
             */
            public int sampleFromDistribution(double[] probabilities, Random rand) {
                double p = rand.nextDouble();
                double cumulative = 0.0;
                for (int i = 0; i < probabilities.length; i++) {
                    cumulative += probabilities[i];
                    if (p < cumulative) {
                        return i;
                    }
                }
                return probabilities.length - 1; // Rückfall, falls numerische Instabilität
            }   
        
        // Methode für Vorhersagen mit Temperatur
        public double[] predict(double[] input, double temperature) {
            // Berechne Hidden Layer Aktivierungen
            double[] hiddenOutput = new double[hiddenSize];
            for (int j = 0; j < hiddenSize; j++) {
                double sum = 0.0;
                for (int i = 0; i < inputSize; i++) {
                    sum += input[i] * weightsInputHidden[i][j];
                }
                hiddenOutput[j] = relu(sum);
            }
    
            // Berechne Output Layer (Logits)
            double[] logits = new double[outputSize];
            for (int k = 0; k < outputSize; k++) {
                for (int j = 0; j < hiddenSize; j++) {
                    logits[k] += hiddenOutput[j] * weightsHiddenOutput[j][k];
                }
            }
    
            // Wende Softmax mit Temperatur an
            return softmax(logits, temperature);
        }
            
        }  
    
        /**
         * Lädt die Trainingsdaten und speichert Eingabe-Antwort-Paare.
         */
        public static class TrainingData {
            private List<String[]> inputPairs;
            private List<String[]> outputPairs;
            private Map<String, Integer> wordFrequencies;
    
            public TrainingData(String trainingFilePath) throws IOException {
                inputPairs = new ArrayList<>();
                outputPairs = new ArrayList<>();
                wordFrequencies = new HashMap<>();
                loadTrainingData(trainingFilePath);
            }
    
            public Map<String, Integer> getWordFrequencies() {
                return wordFrequencies;
            }
            
            private void loadTrainingData(String filePath) throws IOException {
                Pattern pattern = Pattern.compile("\\b[a-zA-ZäöüÄÖÜß0-9']+\\b");
    
                try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        String[] parts = line.split("\t");
                        if (parts.length != 2) continue;
    
                        String[] inputWords = extractFilteredWords(parts[0], pattern);
                        String[] outputWords = extractFilteredWords(parts[1], pattern);
    
                        if (inputWords.length > 0 && outputWords.length > 0) { // Optionale Überprüfung
                            inputPairs.add(inputWords);
                            outputPairs.add(outputWords);
                            
                            // Frequenzzählung der Zielwörter
                            for(String word : outputWords) {
                                wordFrequencies.put(word, wordFrequencies.getOrDefault(word, 0) + 1);
                            }
                        }
                    }
                }
    
                System.out.println("Geladene Trainingsbeispiele: " + inputPairs.size());
    
                System.out.println("Beispiel Input:");
                inputPairs.stream().limit(5).forEach(input -> System.out.println(String.join(" ", input)));
    
                System.out.println("Beispiel Output:");
                outputPairs.stream().limit(5).forEach(output -> System.out.println(String.join(" ", output)));
            }
    
            /**
             * Extrahiert Wörter aus einem Text, wendet das Regex-Muster an, konvertiert sie zu Kleinbuchstaben
             * und filtert dabei Stopwörter heraus.
             *
             * @param text    Der Eingabetext.
             * @param pattern Das Regex-Muster zum Extrahieren der Wörter.
             * @return Ein Array von gefilterten Wörtern.
             */
            private String[] extractFilteredWords(String text, Pattern pattern) {
                Matcher matcher = pattern.matcher(text.toLowerCase());
                List<String> words = new ArrayList<>();
    
                while (matcher.find()) {
                    String word = matcher.group();
                    if (!stopwords.contains(word)) {
                        words.add(word);
                    }
                }
    
                return words.toArray(new String[0]);
            }
    
            public List<String[]> getInputPairs() {
                return inputPairs;
            }
    
            public List<String[]> getOutputPairs() {
                return outputPairs;
            }
        }
    
        /**
         * Integriert alle Komponenten und ermöglicht das Training und die Interaktion.
         */
        static class Chatbot {
            private WordVectorModel model;
            private NeuralNetwork neuralNet;
            private Scanner scanner;
            private Map<String, Double> samplingProbabilities;
    
            // Trainingsdaten
            private TrainingData trainingData;
            private final int EPOCHS = 10000; // Reduzierte Epochen für Debugging
    
            // Für Einfachheit definieren wir eine feste Antwortlänge
            private final int MAX_RESPONSE_LENGTH = 10; // Erhöhte Antwortlänge für mehr Ausdrucksfähigkeit
    
            public Chatbot(String vectorFilePath, String trainingFilePath) throws IOException {
                model = new WordVectorModel(vectorFilePath);
                int inputSize = model.getVectorSize();
                int outputSize = model.getVocabSize(); // Setze outputSize auf die Vokabulargröße
                // Einfaches neuronales Netz: Eingabe -> Hidden (134) -> Ausgabe (Vokabulargröße)
                neuralNet = new NeuralNetwork(inputSize, 134, outputSize);
                scanner = new Scanner(System.in);
                trainingData = new TrainingData(trainingFilePath);
                computeSamplingProbabilities();
            }
            
                /*
                * Berechnet die Sampling-Gewichte für jedes Wort, sodass seltenere Wörter höhere Gewichtungen haben.
                */
                public void computeSamplingProbabilities() {
                    Map<String, Integer> frequencies = trainingData.getWordFrequencies();
                      samplingProbabilities = new HashMap<>();
    
                    // Summe der inversen Frequenzen für Normalisierung
                    double inverseSum = 0.0;
    
                    // Berechne die Inversen der Frequenzen und addiere sie zur Normalisierung
                    for (Map.Entry<String, Integer> entry : frequencies.entrySet()) {
                        int frequency = entry.getValue();
                        double inverseFreq = 1.0 / frequency;
                        samplingProbabilities.put(entry.getKey(), inverseFreq);
                        inverseSum += inverseFreq;
                    }
    
                    // Normalisiere die Gewichte, sodass ihre Summe 1 ergibt (damit es Wahrscheinlichkeiten sind)
                    for (Map.Entry<String, Double> entry : samplingProbabilities.entrySet()) {
                        samplingProbabilities.put(entry.getKey(), entry.getValue() / inverseSum);
                    }
                }
    
            private void trainNetwork() {
                List<String[]> inputs = trainingData.getInputPairs();
                List<String[]> outputs = trainingData.getOutputPairs();
                double temperature = 1.0; // Angepasste Temperatur
    
                Map<String, Integer> wordToIndex = model.getWordToIndexMap();
                Random random = new Random();
    
                for(int epoch = 0; epoch < EPOCHS; epoch++) {
                    double totalLoss = 0.0;
                    for(int i = 0; i < inputs.size(); i++) {
                        String[] inputWords = inputs.get(i);
                        String[] outputWords = outputs.get(i);
    
                        // Verarbeitung der Eingabe
                        List<WordVector> inputVectorsList = new ArrayList<>();
                        for(String word : inputWords) {
                            WordVector wv = model.getWordVector(word);
                            if(wv != null) inputVectorsList.add(wv);
                        }
    
                        if(inputVectorsList.isEmpty()) continue;
    
                        double[] contextVector = VectorUtils.average(
                            inputVectorsList.stream().map(WordVector::getVector).collect(Collectors.toList())
                        );
    
                        // Iteration über jedes Wort in der Ausgabe
                        for(int k = 0; k < outputWords.length && k < MAX_RESPONSE_LENGTH; k++) {
                            String targetWord = outputWords[k];
                            Integer targetIndex = wordToIndex.get(targetWord);
                            if(targetIndex == null) continue;
    
                            // Bestimme, ob das Wort trainiert werden soll basierend auf Sampling-Wahrscheinlichkeit
                            double prob = samplingProbabilities.getOrDefault(targetWord, 1.0);
                            if(random.nextDouble() > prob) {
                                // Wort wird übersprungen
                                // Update Kontextvektor mit dem Vektor des Zielwortes
                                WordVector targetWordVector = model.getWordVector(targetWord);
                                if(targetWordVector == null) continue;
                                contextVector = VectorUtils.add(contextVector, targetWordVector.getVector());
                                contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
    
                                continue;
                            }
    
                            // Trainiere das neuronale Netzwerk mit contextVector und targetIndex
                            neuralNet.train(contextVector, targetIndex);
    
                            // Forward-Pass zur Verlustberechnung
                            double[] outputProbabilities = neuralNet.forward(contextVector, temperature);
                            double loss = -Math.log(outputProbabilities[targetIndex] + 1e-9); // Kreuzentropie-Verlust
                            totalLoss += loss;
    
                            // Update Kontextvektor mit dem Vektor des Zielwortes
                            WordVector targetWordVector = model.getWordVector(targetWord);
                            if(targetWordVector == null) continue;
                            contextVector = VectorUtils.add(contextVector, targetWordVector.getVector());
                            contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
                        }
                    }
    
                    // Ausgabe des Verlusts alle 1000 Epochen
                    if(epoch % 1000 == 0) { // Anpassung der Frequenz für Verlustaussage
                        double averageLoss = totalLoss / (inputs.size() * MAX_RESPONSE_LENGTH);
                        System.out.println("Epoch " + epoch + " - Durchschnittlicher Verlust: " + averageLoss);
                    }
    
                    // Optional: Break if loss is sufficiently low
                    // if(totalLoss / (inputs.size() * MAX_RESPONSE_LENGTH) < desiredThreshold) break;
                }
            }
    
            /**
             * Startet das Training und die Benutzerinteraktion.
             */
            public void start() {
                System.out.println("Starte Training...");
                trainNetwork();
                System.out.println("Training abgeschlossen.");
    
                System.out.println("Willkommen beim erweiterten Chatbot mit einfachem Attention! Tippe 'exit' zum Beenden.");
    
                while (true) {
                    System.out.print("Du: ");
                    String input = scanner.nextLine().trim().toLowerCase();
    
                    if ("exit".equalsIgnoreCase(input)) {
                        System.out.println("Chatbot beendet. Auf Wiedersehen!");
                        break;
                    }
    
                    String response = generateResponse(input);
                    System.out.println("Bot: " + response);
                }
    
                scanner.close();
            }
    
            /**
             * Generiert eine Antwort basierend auf der Benutzereingabe.
             *
             * @param input Die Benutzereingabe.
             * @return Die generierte Antwort.
             */
            private String generateResponse(String input) {
                String[] words = input.split("\\s+");
                List<WordVector> vectors = new ArrayList<>();
                double generationTemperature = 1.0; // Angepasster Temperaturparameter für die Generierung
    
                for(String word : words) {
                    WordVector wv = model.getWordVector(word);
                    if(wv != null) {
                        vectors.add(wv);
                    }
                }
    
                if(vectors.isEmpty()) {
                    return "Entschuldigung, ich verstehe dich nicht.";
                }
    
                // Sammle die Vektoren
                double[][] inputVectors = vectors.stream().map(WordVector::getVector).toArray(double[][]::new);
    
                // Initialer Kontextvektor (z.B. Durchschnitt der Eingabevektoren)
                double[] contextVector = VectorUtils.average(Arrays.asList(inputVectors));
                contextVector = VectorUtils.normalize(contextVector); // Normalisierung zur Stabilität
                Random rand = new Random(); // Initialisiere Random-Objekt hier
    
                StringBuilder responseBuilder = new StringBuilder();
                Map<Integer, String> indexToWord = model.getIndexToWordMap();
    
                for(int i=0; i<MAX_RESPONSE_LENGTH; i++) {
                    // Berechne Aufmerksamkeitsscores basierend auf der Kosinusähnlichkeit
                    double[] attentionWeights = computeAttentionWeights(inputVectors, contextVector);
    
                    // Berechne gewichtete Summe der Eingabevektoren
                    double[] weightedInput = new double[contextVector.length];
                    for(int j=0; j<inputVectors.length; j++) {
                        double[] weightedWord = VectorUtils.multiply(attentionWeights[j], inputVectors[j]);
                        weightedInput = VectorUtils.add(weightedInput, weightedWord);
                    }
    
                    // Vorhersage mit Temperatur
                    double[] outputProbabilities = neuralNet.predict(weightedInput, generationTemperature);
    
                    // Wählen Sie ein Wort basierend auf den Wahrscheinlichkeiten
                    int predictedIndex = neuralNet.sampleFromDistribution(outputProbabilities, rand);
                    String nextWord = indexToWord.get(predictedIndex);
                    if (nextWord == null) {
                        break;
                    }
    
                    // Vermeidung von wiederholten Wörtern
                    if(responseBuilder.toString().toLowerCase().contains(nextWord)) {
                        break;
                    }
    
                    responseBuilder.append(nextWord).append(" ");
    
                    // Update Kontextvektor durch Akkumulation
                    WordVector nextWordVector = model.getWordVector(nextWord);
                    if(nextWordVector != null) {
                        contextVector = VectorUtils.add(contextVector, nextWordVector.getVector());
                        contextVector = VectorUtils.normalize(contextVector); // Optional: Normalisierung
                    }
                }
    
                return responseBuilder.toString().trim();
            }
    
            /**
             * Berechnet die Aufmerksamkeitsgewichte basierend auf der Kosinusähnlichkeit zwischen
             * dem Kontextvektor und jedem Eingabewortvektor.
             *
             * @param inputVectors  Die Eingabewortvektoren.
             * @param contextVector Der Kontextvektor.
             * @return Die normalisierten Aufmerksamkeitsscores.
             */
            private double[] computeAttentionWeights(double[][] inputVectors, double[] contextVector) {
                int n = inputVectors.length;
                double[] scores = new double[n];
    
                for(int i=0; i<n; i++) {
                    scores[i] = VectorUtils.cosineSimilarity(inputVectors[i], contextVector);
                }
    
                // Softmax-Funktion zur Normalisierung der Scores
                double[] softmaxScores = softmax(scores);
                return softmaxScores;
            }
    
            /**
             * Wendet die Softmax-Funktion auf ein Array von Scores an.
             *
             * @param scores Die Eingabescores.
             * @return Die normalisierten Softmax-Scores.
             */
            private double[] softmax(double[] scores) {
                double max = Double.NEGATIVE_INFINITY;
                for(double s : scores) {
                    if(s > max) max = s;
                }
    
                double sum = 0.0;
                double[] expScores = new double[scores.length];
                for(int i=0; i<scores.length; i++) {
                    expScores[i] = Math.exp(scores[i] - max);
                    sum += expScores[i];
                }
    
                double[] softmax = new double[scores.length];
                for(int i=0; i<scores.length; i++) {
                    softmax[i] = expScores[i] / sum;
                }
                return softmax;
            }
        }
    
        public static void main(String[] args) {
    
            String trainingFilePath = "/home/benito/Schreibtisch/train.txt";
            String vectorFilePath = "/home/benito/Schreibtisch/skynetModel.txt";
    
            try {
                Chatbot chatbot = new Chatbot(vectorFilePath, trainingFilePath);
                chatbot.start();
            } catch(IOException e) {
                System.err.println("Fehler beim Laden der Dateien: " + e.getMessage());
            }
        }
    }
    

    Zusätzliche Hinweise:

    1. Datenqualität und Größe:

      • Wortvektoren: Stellen Sie sicher, dass die Datei skynetModel.txt korrekt formatiert ist und eine ausreichende Anzahl von Wortvektoren enthält. Eine typische Wortvektor-Datei enthält pro Zeile ein Wort gefolgt von seinen Vektor-Komponenten, getrennt durch Leerzeichen.
      • Trainingsdaten: Die Datei train.txt sollte Paarungen von Eingaben und erwarteten Ausgaben enthalten, getrennt durch ein Tabulatorzeichen (\t). Zum Beispiel:
        Hallo	Wie geht es dir?
        Mir geht es gut	Danke der Nachfrage!
        
    2. Ressourcenverwaltung:

      • Das aktuelle Setup lädt und trainiert das Modell jedes Mal, wenn das Programm gestartet wird. Für eine effizientere Nutzung könnten Sie überlegen, das trainierte Modell zu speichern und beim nächsten Start zu laden, anstatt jedes Mal neu zu trainieren.
    3. Performance-Optimierungen:

      • Für größere Datensätze und Modelle könnten weitere Optimierungen notwendig sein, wie z.B. die Implementierung von Mini-Batch-Training oder die Nutzung effizienterer Datenstrukturen.
    4. Erweiterung der Funktionen:

      • Der aktuelle Chatbot ist recht einfach und generiert Antworten basierend auf dem trainierten neuronalen Netz. Weitere Funktionen wie Kontextspeicherung, komplexere Attention-Mechanismen oder die Integration vortrainierter Modelle könnten hinzugefügt werden, um die Qualität der Antworten zu verbessern.
    5. Fehlerbehandlung:

      • Zusätzliche Fehlerbehandlungen könnten implementiert werden, um unerwartete Situationen besser zu handhaben, z.B. wenn ein Wort nicht im Vokabular vorhanden ist.

    Mit diesen Anpassungen sollte der Chatbot nun in der Lage sein, auf Benutzereingaben zu reagieren und sinnvolle Antworten zu generieren. Testen Sie den Chatbot mit einfachen Eingaben und passen Sie bei Bedarf die Hyperparameter und die Trainingsdaten weiter an, um die Leistung zu verbessern.