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.
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.
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;
}
}