Vorstellung meiner erfundenen KI-Methoden

Ascanius

Neues Mitglied
Das Deep Learning gefällt mir nicht besonders gut, weil es so starr ist. Deswegen experimentiere ich mit KI' und gebe ihr dabei auch unkonventionelle Module, um sie ggf. fluider zu machen. Meine KI stützt sich auf der Annahme, dass das menschliche Denken nur aus Assoziation besteht. Meine KI soll das assoziieren simulieren und orientiert sich auch sonst am Gehirn.

Bei meiner Methode werden als erstes die Daten aufbereitet. Ein Eingabegerät könnte z.B. eine Kamera sein, die ein Bild aufnimmt. Das Bild muss in viele sinnvolle Einheiten unterteilt werden, die alle in Arrays eingetragen werden z.B. die Koordinaten von RGB-Punkten mit demselben Wert. Die Koordinaten von allen Werten, wo sie am dichtesten auf dem Bild sind (z.B. bei einem grünen und blauen Ball im weißen Raum), wieder in einen Array oder die Höhe und Breite von Bereichen, wo die Werte am dichtesten sind. Bei einem Satz können z.B. Wörter oder die Lage von Wörtern in einem Array eingetragen werden.

Bei jedem Durchlauf speichert das Programm alle neuen Arrays in der Datenbank. Bei jedem neuen Durchlauf vergleichen sich die Arrays vom Input mit seinen entsprechenden Arrays aus allen Durchläufen aus der Datenbank. Der Durchlauf, der am wenigsten unterschiedlich zum Input ist, wird ausgewählt. Außerdem ist jedem Durchlauf ein Output zugeordnet. Das Belohnungssystem sagt, dass für den neuen Durchlauf in der Datenbank dieser Output übernommen wird, wenn es das gewünschte Ergebnis gab. Manchmal wird ein Output per Zufall zugeordnet.

Dadurch kann man auch besser andere Funktionen vom Gehirn simulieren z.B. das Vergessen oder den Hypothalamus. Elemente aus der Datenbank, die z.B. lange her waren oder sich ähneln können gelöscht werden. Jedem Element in der Datenbank kann ein Array mit bestimmten Zahlen zugeordnet werden, die bestimmen, wie groß die Intensität vom Unterschied zwischen Arrays aus dem Element und Input ist.

Das zeige ich als Beispiel an meinem einfachen Programm, das in Java geschrieben ist, bei dem man den Algorithmus erkennen kann. Dort wird simuliert, wie sich ein Tier auf einer einfachen Oberfläche bewegt und soll zuerst zur Beute gehen und danach zum Feuer. Das wiederholt sich. Unten habe ich die wichtigste Klasse "Tier" angefügt und ist in Java geschrieben.

Screenshot 2022-07-05 204200.png



Die Klasse "Tier":
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Tier {
    
    
    private int xTier, yTier, xZiel, yZiel, xFeuer, yFeuer, Tag;

    private double Entfernung, EntfernungFeuer;
    private int Nördlich, Östlich, Südlich, Westlich,
    NördlichFeuer, ÖstlichFeuer, SüdlichFeuer, WestlichFeuer;
    
    private int DurchlaufGewichtung, Durchlaufzahl = -1,
    DurchlaufAbzug, Anzahl2 = 0;
    
    boolean Hunger = false;
    
    
    public boolean isHunger() {
        return Hunger;
    }

    public void setHunger(boolean hunger) {
        Hunger = hunger;
    }



    private double EntfernungAlt = 1000000, EntfernungFeuerAlt = 1000000;
    
    private int Modus = 0;
    
    private List<ArrayList<Integer>> Werte = new ArrayList<>();   
    private List<ArrayList<Integer>> WerteTh = new ArrayList<>();
    
    private ArrayList<Integer> WertTh = new ArrayList<>();

    private int Output;
    
    private Random random2 = new Random();
    private Random random = new Random();
    
    
    
    
    public Tier() {

        
    }
        
    public void Rechnen(int xTier, int yTier, int xZiel, int yZiel, int xFeuer, int yFeuer,
            int Tag) {
    
        //Konstruktor
        xTier = xTier;
        yTier = yTier;
        xZiel = xZiel;
        yZiel = yZiel;
        xFeuer = xFeuer;
        yFeuer = yFeuer;
        Tag = Tag;
        


        
        //Belohnungssystem-------------------------------------------------
        
        //Inputarray erstellen
        
        Durchlaufzahl++;
        
        ArrayList<Integer> Input = new ArrayList<>();
        
        Input.add(5); //Bereich für den Output
        
        Entfernung = Math.sqrt(Math.pow(xTier-xZiel, 2)+Math.pow(yTier-yZiel, 2));
        EntfernungFeuer = Math.sqrt(Math.pow(xTier-xFeuer, 2)+Math.pow(yTier-yFeuer, 2));
        
        Input.add((int) Math.round(Entfernung));
        Input.add((int) Math.round(EntfernungFeuer));
        
        
        if(Tag == 0) {
            
        //Belohnungssystem
        
        //Beute Geruch
        if(Entfernung > EntfernungAlt && Werte.size() > 0) {
            Werte.remove(Werte.size()-1);
            WerteTh.remove(WerteTh.size()-1);
            DurchlaufAbzug++;
        }else {DurchlaufGewichtung++;}
        
        EntfernungAlt = Entfernung;
        
        //Wärme
        
        }    else    {
            
            if(EntfernungFeuer > EntfernungFeuerAlt && Werte.size() > 0) {
                Werte.remove(Werte.size()-1);
                WerteTh.remove(WerteTh.size()-1);
                DurchlaufAbzug++;
            } else {DurchlaufGewichtung++;}
            
        EntfernungAlt = EntfernungFeuer;
            
            
        }
        
        
        //Hunger
        /*
        if(Hunger == true) {
            Anzahl2++;
        if(Math.sqrt(Math.pow(xTier-xZiel, 2)+Math.pow(yTier-yZiel, 2)) < 20) {
              Hunger = false;
          }}
        */       

        
        int Unterschiede = 0;
        int Favorit = 0;
        int FavoritPunkte = 1000000;
        
        
        //Werte anpassen
        int Ergebnis = xTier-xZiel;
        if(Ergebnis >= 0) {
        Östlich = 200;
        Westlich = 0;
        }else{
        Östlich = 0;
        Westlich = 200;}
        
        Input.add(Östlich);
        Input.add(Westlich);
        
        Ergebnis = yTier-yZiel;
        if(Ergebnis >= 0) {
        Nördlich = 200;
        Südlich = 0;
        }else{
        Nördlich = 0;
        Südlich = 200;}
        
        Input.add(Nördlich);
        Input.add(Südlich);
        
        Ergebnis = xTier-xFeuer;
        if(Ergebnis >= 0) {
        ÖstlichFeuer = 200;
        WestlichFeuer = 0;
        }else{
        ÖstlichFeuer = 0;
        WestlichFeuer = 200;}
        
        Input.add(ÖstlichFeuer);
        Input.add(WestlichFeuer);
        
        Ergebnis = yTier-yFeuer;
        if(Ergebnis >= 0) {
        NördlichFeuer = 200;
        SüdlichFeuer = 0;
        }else{
        NördlichFeuer = 0;
        SüdlichFeuer = 200;}
        
        Input.add(NördlichFeuer);
        Input.add(SüdlichFeuer);
        

        Input.add(Tag*100);
        
        
        
        
        //AI----------------------------------------------------------------
        
        
        
        for(int i = 0; i <= Werte.size()-1; i++) {
            
            //ArrayList<Integer> Lösung = new ArrayList<>();
            //int Lsg = 0;
            
            for(int j = 1; j <= Werte.get(i).size()-1; j++) {
                    
                if(Werte.get(i).get(j) > Input.get(j)) {
                    

                    Unterschiede += ((Werte.get(i).get(j) - Input.get(j))*WerteTh.get(i).get(j-1))/100;
                    //Lösung.add(Werte.get(i).get(j) - Input.get(j));
                    //if(j == 11) {Lsg = ((Werte.get(i).get(j) - Input.get(j))*WerteTh.get(i).get(j-1))/100;}
                    
                    
                } else {
                    
                    Unterschiede += ((Input.get(j) - Werte.get(i).get(j))*WerteTh.get(i).get(j-1))/100;
                    //Lösung.add(Input.get(j) - Werte.get(i).get(j));
                    //if(j == 11) {Lsg = ((Input.get(j) - Werte.get(i).get(j))*WerteTh.get(i).get(j-1))/100;}
                    
                }       
                
                
                
            }
            
            
            //System.out.println(Werte.get(i) + " " + Input + Lösung + " " + Lsg);
            
            if(Unterschiede < FavoritPunkte) {
                FavoritPunkte = Unterschiede;
                Favorit = i;
            }
            

            Unterschiede = 0;
            
        }
        
        

        
        //Besten Output herausfinden----------------------------------------------
        if(Werte.size() > 0) {
        Output = Werte.get(Favorit).get(0);}
        
        
        
        int value = random.nextInt(3);
        
        if(value == 2) {
        
        if(Tag == 0) {
            
            value = random.nextInt(2);
            
            if(value == 1) {
            if(Östlich == 200) {
                Output = 2;
            }else {Output = 0;}
            
            }else{
            
            if(Nördlich == 200) {
                Output = 3;
            }
            else{Output = 1;}}
            
        }else{
            
            value = random.nextInt(2);
            
            if(value == 1) {
            if(ÖstlichFeuer == 200) {
                Output = 2;
            }else {Output = 0;}
            
            }else{
            
            if(NördlichFeuer == 200) {
                Output = 3;
            }
            else{Output = 1;}}
            
        }}
        
        /*Kreativer Output
          
          int value = random.nextInt(5);
          if(value == 4) {
              value = random.nextInt(4);
              Output = value;   
          }
          
          */
          
          Input.set(0, Output);
          
      
          
          //Hypothalamus erstellen
          int Durchläufe = 50;
          
          
          
          if(Durchlaufzahl == Durchläufe) {
              //System.out.print("Status: ");
              if(DurchlaufGewichtung <= 25  && WerteTh.size() > Durchläufe) {
                  //System.out.println("gelöscht");
                  for(int i = 0; i < (Durchläufe - DurchlaufAbzug); i++) {
                      WerteTh.remove(WerteTh.size()-1);
                      Werte.remove(Werte.size()-1);  } }
                  
          Durchlaufzahl = 0;
          DurchlaufGewichtung = 0;
          DurchlaufAbzug = 0;   
          
          
          
          Modus = random.nextInt(2);
          }
          

          
          if (Durchlaufzahl == 0 && Werte.size() < Durchläufe) {
              Modus = 0;
          }
          
          
          
          
          if(Durchlaufzahl == 0 && Modus == 0) {
                  WertTh.clear();
              

                  int WertTag = valueTh();
                  int WertNacht = valueTh();
                  WertTh.add(0);   
                  WertTh.add(0);
                  for(int i = 0; i < 4; i++) {
                      WertTh.add(valueTh());
                  }
                  for(int i = 0; i < 4; i++) {
                      WertTh.add(valueTh());
                  }
                  WertTh.add(10000);
                  
                      }
          
          if(Modus == 0) {
              WerteTh.add(WertTh);
              }else{
                  try {
                      WerteTh.add(WerteTh.get(Favorit));       
              } catch(Exception e) {
                        WerteTh.add(WertTh);
              }
                  
                  }
              
        
          
          
          
          
          
          
      
          
        //Neuen Array eintragen 
          Werte.add(Input);
          

          
          
        //Vergessen simulieren----------------------------------------------------
          
          if(Werte.size() > 100) {
                
              
          //Durchschnitt Berechnen
          ArrayList<Integer> Durchschnitt = new ArrayList<>();
          for(int i = 0; i <= Input.size()-1; i++) {
              Durchschnitt.add(0);
              }
          
          
          for(int i = 0; i <= Werte.size()-1; i++) {
              for(int j = 1; j <= WertTh.size()-1; j++) {
                  Durchschnitt.set(j-1, Durchschnitt.get(j-1) + (Werte.get(i).get(j)*WerteTh.get(i).get(j-1)/100));
              }
          }
          
          for(int i = 0; i <= Durchschnitt.size()-1; i++) {
          Durchschnitt.set(i, Durchschnitt.get(i) / Werte.size());
          }
        
          
          //Abweichungen berechnen
          int UnterschiedAlt = 1000000;
          int Unterschied = 0;
          Favorit = 0;
          
          
      for(int i = 0; i <= Werte.size()-1; i++) {
          
          Unterschied = 0;
              
              for(int j = 1; j <= Werte.get(i).size()-1; j++) {
                  try {
                  if(Durchschnitt.get(j) >= Werte.get(i).get(j)) {
                      Unterschied += (Durchschnitt.get(j-1) - (Werte.get(i).get(j)*WerteTh.get(i).get(j-1)/100));
                  } else {
                      Unterschied += ((Werte.get(i).get(j)*WerteTh.get(i).get(j-1)/100) - Durchschnitt.get(j));
                  }
                  
              }catch(Exception e){System.out.println("Error");}}
              
              if(Unterschied < UnterschiedAlt) {
                  UnterschiedAlt = Unterschied;
                  Favorit = i;
              }
              
      }

      //Löschen
      Werte.remove(Favorit);
      WerteTh.remove(Favorit);
            
      
    
      
        
      
          }
          
          }

    
    
    
    
    public int valueTh() {
        int valueTh = random2.nextInt(2)*100;
        return valueTh;
    }
    
    
    
    public int OutputAusgeben() {
        return Output;
        
    }
    

    
}
 
Für den Anwendungsfall wäre Deep Learning allein auch nicht unbedingt das Richtige, also ist es schon vernünftig, sich nach Alternativen umzuschauen.

Wäre interessant zu sehen, wie es sich gegenüber anderen naturanalogen Optimierungsverfahren schlägt. ZB Bergsteigeralgorithmus (mit und ohne Simulated Annealing) und Partikelschwarmoptimierung.

Hab grad leider nur wenig Zeit, sonst würde ich es mir genauer ansehen. Jedenfalls interessant. Achja, vorsicht mit Umlauten in Variablennamen.
 
Zurück
Oben Unten