import numpy as np
from itertools import product  # To generate all binary combinations
 
# Initialisierung der Schwellenwerte
lower_threshold = 0.8
upper_threshold = 1.2
 
# Lernrate
learning_rate = 0.1
 
# Trainingsdaten (Inputs für das XOR-Problem und andere)
inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
 
# Alle möglichen Zieltabellen (16 Kombinationen)
all_possible_targets = list(product([0, 1], repeat=4))
 
# Trainingsloop für jede mögliche Zieltabelle
for table_index, targets in enumerate(all_possible_targets, start=1):
    print(f"\n=== Wahrheitstabelle {table_index}: Targets = {targets} ===")
 
    # Trainingsloop mit max. 1000 Iterationen
    max_iterations = 1000
    epoch = 0
    network_trained = False
    start_weights = None
    final_weights = None
    bias = 0.0  # Initial bias value is set to 0.0
    bias_increment = 0.1  # Increment to change bias
    max_bias = 1.3  # Maximum bias
    min_bias = -1.3  # Minimum bias
 
    # Erste Trainingsrunde ohne Bias-Erhöhung
    while epoch < max_iterations:
        epoch += 1
        all_correct = True  # Flag, um zu überprüfen, ob alle Ausgaben korrekt sind
        current_weights = np.random.rand(2)  # Zufällige Startgewichte
 
        if epoch == 1:  # Die erste Iteration nach Initialisierung
            start_weights = current_weights  # Speichere die Startgewichte
 
        for input_vector, target in zip(inputs, targets):
            # Berechnung der gewichteten Summe inkl. Bias
            weighted_sum = np.dot(input_vector, current_weights) + bias
 
            # Aktivierungsfunktion (einfache Schwellenwertfunktion)
            output = 1 if lower_threshold < weighted_sum < upper_threshold else 0
 
            # Fehlerberechnung
            error = target - output
 
            # Wenn ein Fehler vorliegt, dann weise die Gewichte an
            if error != 0:
                all_correct = False
                current_weights += learning_rate * error * np.array(input_vector)
 
        # Überprüfe, ob alle Ausgaben korrekt sind
        if all_correct:
            network_trained = True
            final_weights = current_weights  # Speichere die finalen Gewichte
            break  # Stoppe, wenn alle Ausgaben korrekt sind
 
    # Wenn das Netzwerk nach 1000 Iterationen nicht gelernt hat, füge den Bias hinzu
    if not network_trained:
        print(f"Das Netzwerk hat Wahrheitstabelle {table_index} nach {epoch} Iterationen nicht korrekt gelernt.")
        print("Erhöhe den Bias und versuche es erneut.")
 
        # Bias erhöhen in Schritten bis 1.3 und dann bis -1.3
        if bias < max_bias:
            bias += bias_increment  # Erhöhe den Bias
        elif bias >= max_bias and bias > min_bias:
            bias -= 0.1  # Wenn der Bias 1.3 erreicht hat, beginne ihn zu verringern
 
        # Neue Trainingsrunde mit angepasstem Bias starten
        epoch = 0  # Setze die Anzahl der Epochen zurück
        start_weights = np.random.rand(2)  # Zufällige Startgewichte für die erneute Trainingsrunde
        network_trained = False  # Netzwerk muss erneut trainiert werden
 
        while epoch < max_iterations:
            epoch += 1
            all_correct = True
            current_weights = np.random.rand(2)  # Zufällige Startgewichte
 
            for input_vector, target in zip(inputs, targets):
                # Berechnung der gewichteten Summe inkl. Bias
                weighted_sum = np.dot(input_vector, current_weights) + bias
 
                # Aktivierungsfunktion (einfache Schwellenwertfunktion)
                output = 1 if lower_threshold < weighted_sum < upper_threshold else 0
 
                # Fehlerberechnung
                error = target - output
 
                # Wenn ein Fehler vorliegt, dann weise die Gewichte an
                if error != 0:
                    all_correct = False
                    current_weights += learning_rate * error * np.array(input_vector)
 
            # Überprüfe, ob alle Ausgaben korrekt sind
            if all_correct:
                network_trained = True
                final_weights = current_weights  # Speichere die finalen Gewichte
                break  # Stoppe, wenn alle Ausgaben korrekt sind
 
        # Ausgabe der Ergebnisse nach der zweiten Trainingsrunde mit erhöhtem Bias
        print(f"Versuch mit Bias ({bias}):")
        print(f"Total Iterationen: {epoch}")
        print(f"Startgewichte: {start_weights}")
        print(f"Endgewichte: {final_weights}")
        print(f"Endgültiger Bias: {bias}")
 
    # Prüfen, ob das Netzwerk die Tabelle erfolgreich gelernt hat
    if network_trained:
        print(f"\nDas Netzwerk hat Wahrheitstabelle {table_index} erfolgreich gelernt!")
        print(f"Startgewichte: {start_weights}")
        print(f"Endgewichte: {final_weights}")
        print(f"Endgültiger Bias: {bias}")
    else:
        print(f"\nDas Netzwerk hat Wahrheitstabelle {table_index} nach Anpassung des Bias immer noch nicht korrekt gelernt.")
 

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