fork download
copy 
  1. import numpy as np
  2.  
  3. # Initialisierung der Schwellenwerte
  4. lower_threshold = 0.8
  5. upper_threshold = 1.2
  6.  
  7. # Lernrate
  8. learning_rate = 0.1
  9.  
  10. # Trainingsdaten (XOR-Problem)
  11. inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
  12. targets = [0, 1, 1, 0]
  13.  
  14. # Trainingsloop mit max. 1000 Iterationen
  15. max_iterations = 1000
  16. epoch = 0
  17. network_trained = False
  18. start_weights = None
  19. final_weights = None
  20. start_bias = None
  21. final_bias = None
  22. all_epoch_outputs = []  # Store outputs of all epochs for debugging and transparency
  23.  
  24. # Initialize weights and bias
  25. current_weights = np.random.rand(2)  # Initial random weights
  26. bias = np.random.rand()  # Random initial bias
  27.  
  28. while epoch < max_iterations:
  29.     epoch += 1
  30.     all_correct = True  # Flag, um zu überprüfen, ob alle Ausgaben korrekt sind
  31.  
  32.     if epoch == 1:  # Die erste Iteration nach Initialisierung
  33.         start_weights = current_weights  # Speichere die Startgewichte
  34.         start_bias = bias  # Speichere den Start-Bias
  35.  
  36.     epoch_outputs = []  # To store outputs of this epoch
  37.  
  38.     for input_vector, target in zip(inputs, targets):
  39.         # Berechnung der gewichteten Summe mit Bias
  40.         weighted_sum = np.dot(input_vector, current_weights) + bias
  41.  
  42.         # Aktivierungsfunktion (einfache Schwellenwertfunktion)
  43.         output = 1 if lower_threshold < weighted_sum < upper_threshold else 0
  44.  
  45.         # Fehlerberechnung
  46.         error = target - output
  47.  
  48.         # Wenn ein Fehler vorliegt, dann weise die Gewichte und den Bias an
  49.         if error != 0:
  50.             all_correct = False
  51.             current_weights += learning_rate * error * np.array(input_vector)  # Update weights
  52.             bias += learning_rate * error  # Update bias
  53.  
  54.         epoch_outputs.append((input_vector, output, target))  # Save each iteration's output
  55.  
  56.     all_epoch_outputs.append(epoch_outputs)
  57.  
  58.     # Überprüfe, ob alle Ausgaben korrekt sind
  59.     if all_correct:
  60.         network_trained = True
  61.         final_weights = current_weights  # Speichere die finalen Gewichte
  62.         final_bias = bias  # Speichere den finalen Bias
  63.         break  # Stoppe, wenn alle Ausgaben korrekt sind
  64.  
  65.     # Wenn XOR nach 100 Iterationen nicht gelernt wurde, setze neue zufällige Startgewichte und Bias
  66.     if epoch % 100 == 0:  # 100 statt 20
  67.         print(f"Nicht funktionierende Startgewichte: {start_weights} und Bias: {start_bias}")
  68.         current_weights = np.random.rand(2)  # Setze neue Startgewichte
  69.         bias = np.random.rand()  # Setze neuen Bias
  70.  
  71. if network_trained:
  72.     print(f"Das Netzwerk hat XOR korrekt nach {epoch} Iterationen gelernt.")
  73.     print(f"Die Working Startgewichte waren: {start_weights} und Bias: {start_bias}")
  74.     print(f"Die finalen Gewichte sind: {final_weights} und der finale Bias ist: {final_bias}")
  75. else:
  76.     print(f"Das Netzwerk hat XOR nach {epoch} Iterationen nicht korrekt gelernt.")
  77.  
  78. # Testen des Netzwerks nach den Lern-Iterationen
  79. print("\nFinal Test Output:")
  80. for input_vector, target in zip(inputs, targets):
  81.     weighted_sum = np.dot(input_vector, final_weights) + final_bias
  82.     output = 1 if lower_threshold < weighted_sum < upper_threshold else 0
  83.     print(f"Input: {input_vector}, Target: {target}, Output: {output}")
  84.  
  85. # Optionally, print out the outputs of each epoch for transparency
  86. print("\nEpoch Outputs:")
  87. for epoch_index, epoch_outputs in enumerate(all_epoch_outputs):
  88.     print(f"Epoch {epoch_index + 1}:")
  89.     for input_vector, output, target in epoch_outputs:
  90.         print(f"  Input: {input_vector}, Output: {output}, Target: {target}")
  91.  
Success #stdin #stdout 0.16s 28992KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Das Netzwerk hat XOR korrekt nach 2 Iterationen gelernt.
Die Working Startgewichte waren: [0.63278539 0.85555508] und Bias: 0.002213910350791992
Die finalen Gewichte sind: [0.63278539 0.85555508] und der finale Bias ist: 0.202213910350792

Final Test Output:
Input: [0, 0], Target: 0, Output: 0
Input: [0, 1], Target: 1, Output: 1
Input: [1, 0], Target: 1, Output: 1
Input: [1, 1], Target: 0, Output: 0

Epoch Outputs:
Epoch 1:
  Input: [0, 0], Output: 0, Target: 0
  Input: [0, 1], Output: 0, Target: 1
  Input: [1, 0], Output: 0, Target: 1
  Input: [1, 1], Output: 0, Target: 0
Epoch 2:
  Input: [0, 0], Output: 0, Target: 0
  Input: [0, 1], Output: 1, Target: 1
  Input: [1, 0], Output: 1, Target: 1
  Input: [1, 1], Output: 0, Target: 0
https://ideone.com/ETT4lk
language:
Python 3 (python  3.9.5)
created:
2 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!