Da Maschinen intelligentes Verhalten überwiegend durch Menschen lernen, ist das Beibringen ein weiteres grundlegendes Konzept zum Maschinellen Lernen. Realisieren lässt sich das durch explizites und deklaratives Beibringen sowie implizites Lernen.

Das explizite Beibringen ist dadurch charakterisiert, dass Gelerntes mit Worten beschrieben und erklärt werden kann. Ein Beispiel wäre, wenn der Nutzer dem Digitalassistenten folgenden Satz diktiert und erwartet, dass der Digitalassistent sich die Angaben merkt:

Benutzer: Bestelle eine 15-kg-Packung trockenes Hundefutter mit Lammfleisch von der Marke Happy Dog.

Maschine: Soll ich mir deine Angaben merken, damit du es nächstes Mal einfacher hast?

Benutzer: Ja, gerne. Merke es dir unter „Bestelle Hundefutter“.

Es passiert selten, dass ein Benutzer eine Bestellung so perfekt mit den wichtigen Parametern angibt. Dennoch reichen diese Angaben zur Bestellung noch nicht aus. Denn bevor sich der Digitalassistent eine Bestellung merken kann, ist es wichtig, wie er mit unvollständigen Angaben umgeht. Listing 1 zeigt die Implementierung der Sentence Component, die diese Aussage verarbeitet.

@SentenceComponent
public class FutterBestellen
{
  private Anbieter anbieter;
  private Futter futter;
  private DateInterval liefertermin;
  private BankKonto bankKonto;
 
  @Sentence("Bestelle von irgendeinem Anbieter irgendein Futter " +
"für irgendeinen Liefertermin")
  public void codeSegment()
  {
// Die Implementierung dieser Methode ist an dieser Stelle unwichtig!
  }
 
  @NaturalTypeMethod(naturalName = "von irgendeinem Anbieter",
naturalType = "Anbieter")
  public void setAnbieter(String anbieter){ this.anbieter = anbieter; }
 
  @Question ("Welches Futter möchtest du bestellen?")
  @NaturalTypeMethod (naturalName = "irgendein Futter", naturalType = "Futter")
  public void setFutter(Futter futter){ this.futter = futter; }
 
  @Question ("Wann darf es geliefert werden?")
  @NaturalTypeMethod(naturalName = "für irgendeinen Liefertermin",
naturalType = "Datum")
  public void setLiefertermin (DateInterval liefertermin){ this. liefertermin = liefertermin; }
 
  @Question ("Von welchem Konto möchtest du es zahlen?")
  @NaturalTypeMethod(naturalName = null, naturalType = "Bankkonto")
  public void setBankkonto(Bankkonto bankkonto){ this. bankkonto= bankkonto; }
}

Obwohl die Benutzereingabe sehr genau ist, fehlen immer noch einige Parameter, um eine Bestellung durchzuführen. Die Sentence Component aus Listing 1 erwartet einen Anbieter des zu bestellenden Futters sowie eine Marke, einen Liefertermin und ein Konto, von dem die Bestellung bezahlt wird. Dabei sind Anbieter und Marke optional. Falls sie nicht angegeben werden, wird die Sentence Component einfach den günstigsten Anbieter nehmen. Alle anderen Parameter geben durch die Annotation @Question eine W-Frage an, die beim Fehlen der Parameter im Eingabetext durch die Plattform gestellt wird.

@Question ("Welches Futter möchtest du bestellen?")
@NaturalTypeMethod (naturalName = "irgendein Futter", naturalType = "Futter")
public void setFutter(Futter futter){ this.futter = futter; }
 
@Question ("Wann darf es geliefert werden?")
@NaturalTypeMethod(naturalName = "für irgendeinen Liefertermin", naturalType = "Datum")
public void setLiefertermin (DateInterval liefertermin){ this. liefertermin = liefertermin; }
 
@Question ("Von welchem Konto möchtest du es zahlen?")
@NaturalTypeMethod(naturalName = null, naturalType = "Bankkonto")
public void setBankkonto(Bankkonto bankkonto){ 
this. bankkonto= bankkonto; 
}
 

Wir habe im zweiten Teil dieser Artikelserie ausführlich über die natürlichen Datentypen gesprochen und gezeigt, wie durch den Mechanismus der natürlichen Datentypen aus dem Eingabetext die dazu passenden Wortfolgen in technische Datentypen konvertiert werden. Der Datentyp Futter, gekennzeichnet durch naturalType = "Futter", konvertiert die Wortfolge „eine 15-kg-Packung trockenes Hundefutter mit Lammfleisch von der Marke Happy Dog“ in den technischen Datentyp Futter und weist ihm die Inhalte zu:

Futter futter = new Futter();
futter.setTier("Hund");
futter.setInhalte( {"Lammfleisch"} );
futter.setArt("Trocken");
futter.setGewicht(15);
futter.setEinheit("kg");
futter.setAnzahl(1);
futter.setMarke("Happy Dog");

Dem technischen Datentyp Futter wird dann durch die Plattform die Methode setFutter(Futter futter) zugewiesen. Mit dem Attribut naturalName = "irgendein Futter" wird ein Teil des mit der Annotation @Sentence markierten Definitionssatzes als Variable deklariert. Ein Ausnahmefall liegt vor, wenn naturalName auf NULL gesetzt wird. Dann erwartet die Plattform, dass die Angabe des natürlichen Datentyps durch eine andere Sentence Component erfolgt. Dieser Aspekt ist wichtig, um zwischen dem Eingabetext und einer Sentence Component aus der Menge der in der Plattform vorhandenen Sentence Components eine Übereinstimmung zu finden. Für jeden Eingabetext führt die Plattform eine linguistische Analyse durch. Dadurch separiert sie zuerst die Sätze voneinander und wendet an jedem Eingabesatz einen Matching-Algorithmus an, um dafür eine Übereinstimmung mit den im System vorhandenen Sentence Components zu finden. Als Erstes wird das Prädikat des Eingabesatzes mit jedem Prädikat der Definitionssätze der Sentence Components verglichen. Die Übereinstimmung der Prädikate wird stark gewichtet, da dies als Absicht des Satzes verstanden wird. Danach kommen Subjekt, Objekt und die Anzahl der übereinstimmenden Parameter zum Tragen (Abb. 1).

Abb. 1: Linguistische Analyse eines Eingabesatzes

Die Plattform zählt also die Methode setBankkonto() mit der Annotation @NaturalTypeMethod(naturalName = null, naturalType = "Bankkonto") nicht zu den Parametern der Sentence Component mit dem Definitionssatz @Sentence ("Bestelle von irgendeinem Anbieter irgendein Futter von irgendeiner Marke für irgendeinen Liefertermin"). In diesem Beispiel stimmen das Prädikat Bestelle und die Parameter Futter und Marke mit den Inhalten des Eingabetexts überein. Der Parameter Anbieter hat keine Annotation @Question, und damit kann die Plattform den Benutzer zur Ergänzung des Parameters nicht befragen. Der Parameter Liefertermin wurde durch eine W-Frage beantwortet. Damit ist eine akzeptable Übereinstimmung des Eingabesatzes mit der Sentence Component erreicht.

Um die Bestellung durchführen zu können, müssen die Kontodaten durch die W-Frage „Von welchem Konto möchtest du bezahlen?“ geklärt werden. Die Antwort wird durch den Faktensammler mit der Annotation @ Sentence("Zahle den Betrag von irgendeinem Kreditinstitut mit irgendeiner IBAN und irgendeinem Passwort") realisiert (Listing 2).

@SentenceComponent
public class BankAccount
{
  private Iban iban;
  private Kreditinstitut kreditinstitut;
  private Passwort passwort;
 
  @Sentence("Zahle den Betrag von irgendeinem Kreditinstitut mit irgendeiner IBAN und irgendeinem Passwort")
  public BankData codeSegment()
  {
BankData  bankData = new BankData(kreditinstitut, iban, passwort);
KnowlageBase.insert("welches.bankkonto", bankData ) )
 
return new bankData;
  }
 
  @NaturalTypeMethod (naturalName = "von irgendeinem Kreditinstitut",
naturalType = " Kreditinstitut ")
  public void setInstitute (Kreditinstitut kreditinstitut){
    this. kreditinstitut = kreditinstitut;
  }
 
  @NaturalTypeMethod (naturalName = "mit irgendeiner IBAN", naturalType = "IBAN")
  public void setIban(Iban iban){
    this.iban = iban;
  }
 
  @NaturalTypeMethod (naturalName = "mit irgendeinem Passwort", naturalType = "Passwort")
  public void setPasswort(Passwort passwort){
    this.passwort = passwort;
  }
}

Wir haben im letzten Artikel Faktensammler, Themenersteller und Fakteninterpreten vorgestellt und gezeigt, wie Cogniology mit Schlussfolgerungen umgeht. Die Faktensammler sind Sentence Components, die die Antwort einer W-Frage in einem Objekt sammeln und sie in die Wissensbasis schreiben. Eine wichtige Eigenschaft der Faktensammler ist – neben der Speicherung der Fakten in der Wissensbasis –, dass sie das Faktenobjekt als Rückgabewert zurückgeben. Diese Rückgabe der Werte spielt bei der Programmierung in natürlicher Sprache eine große Rolle. Auf dieses Thema werden wir im nächsten Artikel ausführlich eingehen. Die Sentence Component Liefertermin konvertiert den Text „Montagvormittags und mittwochs ab 14 Uhr 30“ in eine Liste von Datumsintervallen. Somit wird die Konversation zwischen dem Digitalassistenten und dem Benutzer wie folgt ablaufen:

Benutzer: Bestelle eine 15-kg-Packung trockenes Hundefutter mit Lammfleisch von der Marke Happy Dog.

Maschine: Wann darf es geliefert werden?

Benutzer: Ich kann die Lieferung nur Montagvormittags und mittwochs ab 14 Uhr 30 entgegennehmen.

Maschine: Von welchem Konto möchtest du es zahlen?

Benutzer: Zahle den Betrag für Hundefutter aus meinem Sparkassenkonto mit IBAN DE12 3456789 00 112223344 und Passwort 1234.

Nachdem alle Parameter für die Bestellung vollständig angegeben worden sind, sucht die Plattform in der Wissensbasis, um herauszufinden, ob diese Sentence Component schon vorher von diesem Benutzer angegeben wurde. Sie schaut also, ob der Benutzer schon einmal Hundefutter bestellt hat. Ist das der Fall, geht sie davon aus, dass der Benutzer kein Interesse daran hat, den Vorgang durch den Digitalassistenten speichern zu lassen. Ist es nicht der Fall, wird er aufgrund der Anzahl der Parameter und der beteiligten Sentence Components diesen Vorgang als komplex einstufen und den Nutzer zwecks Automatisierung dieses Vorgangs ansprechen:

Maschine: Soll ich mir deine Angaben merken, damit du es nächstes Mal einfacher hast?

Benutzer: Ja, gerne. Merke es dir unter „Bestelle Hundefutter“.

Maschine: Also, mit „Bestelle Hundefutter“ meinst du: Bestelle eine 15-kg-Packung trockenes Hundefutter mit Lammfleisch von der Marke Happy Dog. Ich kann die Lieferung nur Montagvormittags und mittwochs ab 14 Uhr 30 entgegennehmen. Zahle den Betrag für Hundefutter aus meinem Sparkassenkonto mit IBAN DE12 3456789 00 112223344 und Passwort 1234.

Nachdem der Benutzer dies bestätigt hat, programmiert der Digitalassistent eine neue Sentence Component mit dem Definitionssatz @Sentence("Bestelle Hundefutter") und fügt sie zu den privaten Sentence Components des aktuellen Benutzers hinzu (Listing 3).

@SentenceComponent
public class AutomaticCreated_Besstelle_Hundefutter_001
{
  @Sentence("Bestelle Hundefutter")
  public void codeSegment()
  {
Anbieter anbieter = null;
 
Futter futter = new Futter();
futter.setTier("Hund");
futter.setInhaltList( {"Lammfleisch"} );
futter.setArt("Trocken");
futter.setGewicht(15);
futter.setEinheit("kg");
futter.setAnzahl(1);
futter.setMarke("Happy Dog");
 
List<DateInterval> moeglicheLiefertermine = null;
DateType dateType = new DateType();
Boolean matched  = null;
matched = dateType.matches("Montagvormittags und mittwochs ab 14 Uhr 30");
if(matched)
{
moeglicheLiefertermine = dateType.getDateIntervalList();
}
Liefertermin liefertermin = new Liefertermin();
liefertermin.setMoeglicheLiefertermine ( moeglicheLiefertermine );
moeglicheLiefertermine = liefertermin.codeSegment();
 
BankAccount bankAccount = new BankAccount();
bankAccount.setKreditinstitut("Sparkasse");
bankAccount.setInstitute("DE12 3456789 00 112223344");
bankAccount.setPassword("1234");
BankData bankData = bankAccount.codeSegment();
 
FutterBestellen futterBestellen = new FutterBestellen();
futterBestellen.setAnbieter( anbieter );
futterBestellen.setMoeglicheLiefertermine ( moeglicheLiefertermine );
futterBestellen.setBankDaten( bankData );
futterBestellen.codeSegment();
  }
}

Der Codegenerator der Plattform erstellt eine neue Klasse mit einem automatisch generierten Namen. Die Namen spielen dabei keine Rolle. Der Codegenerator der Plattform startet mit der ersten Sentence Component und bearbeitet sie in der Reihenfolge, wie sie vom Benutzer eingegeben wurden. Zu jedem Parameter der Sentence Component generiert er ein entsprechendes Objekt. Die Generierung der Parameter erfolgt von links nach rechts, wie sie im Definitionssatz der Sentence Component angegeben sind.

Die erste Sentence Component in der Hundefutterkonversation bezieht sich auf @Sentence("Bestelle von irgendeinem Anbieter irgendein Futter für irgendeinen Liefertermin"). Die Parameter sind: irgendein Anbieter, irgendein Futter und für irgendeinen Liefertermin. Für den ersten Parameter gab es keine Angabe im Eingabetext, daher wird die Variable mit NULL initiiert: Anbieter anbieter = null;. Der zweite Parameter ist der technische Datentyp des natürlichen Datentyps „eine 15-kg-Packung trockenes Hundefutter mit Lammfleisch von der Marke Happy Dog“:

Futter futter = new Futter();
futter.setTier("Hund");
futter.setInhaltList( {"Lammfleisch"} );
futter.setArt("Trocken");
futter.setGewicht(15);
futter.setEinheit("kg");
futter.setAnzahl(1);
futter.setMarke("Happy Dog");

Der dritte Parameter ist der Liefertermin, der durch die Sentence Component mit der Definition @Sentence("Ich nehme die Lieferung zu jeder Zeit an") bearbeitet wird (Listing 4).

@SentenceComponent
public class Terminvereinbarung
{
  private List<DateInterval> moeglicheLiefertermine;
 
  @DynamicValue
@Sentence("Ich nehme die Lieferung zu jeder Zeit an")
  public List<DateInterval> codeSegment()
  {
return moeglicheLiefertermine.
  }
 
  @NaturalTypeMethod (naturalName = "zu jeder Zeit", naturalType = "Datum")
  public void setMoeglicheLiefertermine (List<DateInterval> moeglicheLiefertermine){
    this. moeglicheLiefertermine = moeglicheLiefertermine;
  }
}

Da die Methode codeSegment() mit @DynamicValue annotiert ist, muss der natürliche Datentyp, also „Montagvormittags und mittwochs ab 14 Uhr 30“, immer neu berechnet werden. So ist es auch richtig, da Montagvormittags abhängig vom Durchführungszeitpunkt dieser Methode jeweils ein anderes Datum ergeben kann.

List<DateInterval> moeglicheLiefertermine = null;
DateType dateType = new DateType();
Boolean matched  = null;
matched = dateType.matches("Montagvormittags und mittwochs ab 14 Uhr 30");
if(matched)
{
moeglicheLiefertermine = dateType.getDateIntervalList();
}
Liefertermin liefertermin = new Liefertermin();
liefertermin.setMoeglicheLiefertermine ( moeglicheLiefertermine );
moeglicheLiefertermine = liefertermin.codeSegment();

Da die Plattform die Implementierung der Methode codeSegment nicht kennt, ruft sie diese immer wieder auf.

Die letzte Angabe ist die Bankverbindung, die zwar kein Parameter ist, jedoch in der Codegenerierung genau wie alle anderen Parameter behandelt wird:

BankAccount bankAccount = new BankAccount ();
bankAccount.setInstitute("Sparkasse");
bankAccount.setInstitute("DE12 3456789 00 112223344");
bankAccount.setPassword("1234");
BankData bankData = bankAccount.codeSegment();

Jetzt ist es soweit. Die Bestellung kann durchgeführt werden.

FutterBestellen futterBestellen = new FutterBestellen();
futterBestellen.setAnbieter( anbieter );
futterBestellen.setMoeglicheLiefertermine ( moeglicheLiefertermine );
futterBestellen.setBankDaten( bankData );
futterBestellen.codeSegment();

Diese erzeugte Sentence Component besteht aus sequenziellen Aufrufen einiger einfacher Methoden, also ohne bedingte Anweisungen, ohne Schleifen, ohne Abfrage der Wissensbasis und ohne komplizierte mathematische Berechnungen. Es ist jedoch ein gutes Beispiel für das Lernen durch Selbstprogrammierung. Wir werden in den nächsten Teilen dieser Artikelserie zeigen, wie wir dem Digitalassistent komplexe Aufgaben beibringen können.

Implizites Lernen: auf Einflüsse reagieren

Das implizite Lernen umfasst Fertigkeiten, die automatisch, ohne Nachdenken eingesetzt werden. Dazu gehören vor allem motorische Abläufe wie Gehen, Fahrradfahren oder Greifen. Das implizit Gelernte wird im Kontext einer bestimmten Prozedur, eines bestimmten Verhaltens abgerufen. Implizites Lernen versetzt eine Maschine in die Lage, durch Geräte wie Sensoren, Kameras oder Radar die Umwelt wahrzunehmen und angepasst auf die Bedürfnisse des jeweiligen Nutzers zu reagieren. Wenn es z. B. kalt wird, soll die Heizung eingeschaltet und die Jalousie heruntergelassen werden.

Benutzer: Es ist kalt.

Maschine: Was soll ich machen, wenn es kalt ist?

Benutzer: Schalte die Heizung an und lasse die Jalousie herunter.

Bisher hat unser Digitalassistent mit seinen Benutzern mittels Mikrofon und Lautsprecher kommuniziert. Dabei setzt er die beiden bekannten Technologien Voice to Text und Text to Voice ein, um die akustischen Signale aus dem Mikrofon in Text und in umgekehrter Richtung einen Text in akustische Signale zu konvertieren, die vom Lautsprecher ausgegeben werden. Diese Art der Konvertierung von Signalen in Text lässt sich auf jedes Gerät übertragen. So kann ein Sensor die Innentemperatur messen und das Ergebnis durch ein Funksignal an eine Software weiterleiten, die aus diesem Funksignal einen Satz erzeugt und ihn an die Plattform sendet. Die Plattform behandelt diesen Satz, als sei er von einem Menschen gesprochen worden, und führt die entsprechende Sentence Component aus (Abb. 2).

Abb. 2: Wenn es kalt wird, soll die Heizung eingeschaltet werden

In Cogniology wird Software, die technische Signale in Text und umgekehrt die Texte in Signale konvertiert, als Device Controller bezeichnet. Durch dieses Konzept kommuniziert die Plattform mit ihrer Umgebung immer durch natürlichsprachliche Texte. Die Plattform stellt mehrere Schnittstellen wie REST, Web Service oder Binary zur Verfügung, um sich vom Device Controller zu entkoppeln. Somit können Device Controller in beliebige Programmiersprachen implementiert sein.

Ein konkretes Beispiel für einen Device Controller wäre ein Temperaturregulationssystem (Listing 5). Wenn die Innentemperatur auf 17 Grad fällt, sendet der Device Controller den Satz „Es ist kalt“ an die Plattform. Die Plattform sucht in der Menge der vorhanden Sentence Components nach einer mit dem Definitionssatz „Es ist kalt“ und führt deren Codesegment aus. Die Sentence Component „Es ist kalt“ kann, wie die Sentence Component „Bestelle Hundefutter“, vom Benutzer programmiert worden sein. Dadurch kann der Benutzer die Raumtemperatur individuell automatisieren.

Das Prinzip der Device Controller ist ähnlich wie das von Hardwaretreibern, die verwendet werden, um das Betriebssystem von Herstellern und tatsächlich verwendeter Hardware unabhängig zu machen. Ein gutes Beispiel dafür ist der Druckertreiber. Jeder Druckerhersteller liefert für seinen Drucker einen passenden Treiber, der ein bestimmtes API implementiert. Somit können die Applikationen ihre Inhalte über dieses API ausdrucken, ohne direkt den Drucker zu steuern.

Das API der Device Controller sind die von Herstellern mitgelieferten Sentence Components und eine so genannte DeviceControllerConfiguration, die die nötigen Konfigurationen für den Betrieb der Hardware sowie der Plattform vornimmt. Diese Komponenten werden per Plug and Play an die Plattform angedockt (Listing 5).

@DeviceControllerConfiguration
public class Temperaturregulationssystem
{
  @Callback (sentenceDefinition = "Es ist kalt",
Question = ("Was soll ich machen, wenn es kalt ist?")
  @Callback (sentenceDefinition = "Es ist warm",
Question = ("Was soll ich machen, wenn es warm ist?")
  @ConfigurationMethod
  public void configure()
  {
// Hier kann die nötige Konfiguration durchgeführt werden.
  }
}

Nach dem Andocken der Device-Controller-Konfiguration ruft die Plattform deren mit @Configuration annotierte Methode auf, damit der Device Controller sich selbst konfiguriert. Damit kann der Hersteller die für sein Gerät nötigen Konfigurationen vornehmen. Die in der Annotation @Callback angegebene sentenceDefinition bezieht sich auf einen Satz, der vom Gerät zur Plattform gesendet wird, sobald sich sein Zustand ändert. Die Plattform behandelt diesen Satz, als ob ihn ein Mensch gesprochen hätte, und führt die entsprechende Sentence Component aus.

Wenn der Benutzer den in sentenceDefinition angegebenen Satz zum ersten Mal spricht, wird die Plattform dem Benutzer die in der Annotation Question angegebene Frage stellen. Somit kann der Benutzer beliebige verschiedene Geräte kombinieren und steuern.

Benutzer: Es ist kalt.

Maschine: Was soll ich machen, wenn es kalt ist?

Benutzer: Schalte die Heizung an und lasse die Jalousie herunter.

Die Plattform generiert durch einen Codegenerator für alle Sätze, die der Benutzer nach der W-Frage sagt, eine neue Sentence Component mit dem Definitionssatz @Sentence("Es ist kalt"). Wenn der Benutzer oder der Sensor beim nächsten Mal sagt „Es ist kalt“, wird die Heizung angeschaltet und die Jalousie heruntergelassen (Listing 6). HeizungService und JalousieService sind die Implementierung der beiden Sentence Components @Sentence("Schalte die Heizung an") und @ Sentence("Lasse die Jalousie herunter").

@SentenceComponent
public class AutomaticCreated_Es_Ist_Kalt_002
{
  @Sentence("Es ist kalt")
  public void codeSegment()
  {
HeizungService heizungService = new HeizungService();
heizungService.codeSegment();
 
JalousieService jalousieService = new JalousieService ();
jalousieService.codeSegment();
  }
}

Deklaratives Beibringen: Lernen durch Fragen

In unseren beiden Beispielen zum expliziten Beibringen und impliziten Lernen initiierten die in der Sentence Component angegebenen Fragen das Lernen und Beibringen. In folgendem Beispiel stellt die Plattform die Frage:

Benutzer: Ich habe Hunger.

Maschine: Was soll ich unter „Ich habe Hunger“ verstehen?

Benutzer: Bestelle ein Roast-Beef-Sandwich auf Italian Brot mit Salat außer Zwiebeln, American-Sauce, extra Käse und eine Cola.

Maschine: Okay, wenn du sagst „Ich habe Hunger“, dann meinst du: Bestelle ein Roast-Beef-Sandwich auf Italian Brot mit Salat außer Zwiebeln, American-Sauce, extra Käse und eine Cola. Bezahle den Betrag von Sparkassenkonto mit IBAN DE12 3456789 00 112223344 und Passwort 1234.

In diesem Fall findet die Plattform für den Satz „Ich habe Hunger“ keine entsprechende Sentence Component. Daher stellt sie eine Frage und generiert für die Antwort durch den Codegenerator eine neue Sentence Component mit dem Definitionssatz @Sentence("Ich habe Hunger"). Da die Sentence Component zur Bestellung eines Sandwiches eine Kontoverbindung verlangt und die Plattform auf die W-Frage „Von welchem Konto möchtest du es zahlen?“ in der Wissensbasis eine entsprechende Antwort findet, schlägt sie diese dem Nutzer vor.

Fazit

Wenn wir uns von den aktuellen Konzepten des Maschinellen Lernens wie Deep Learning oder neuronalen Netzen für einen Moment freimachen und uns fragen, wie eine Maschine intelligentes Verhalten lernen soll, ist meine Antwort darauf: Genauso, wie wir unseren Kindern etwas Neues beibringen. Sie lernen nicht nur durch Nachahmung implizite Fertigkeiten von uns, sondern wir vermitteln ihnen neue Inhalte durch Sprache. So können Maschinen von uns am schnellsten lernen und uns bei der täglichen Arbeit unterstützen. Wie einer Maschine beliebig komplexe Aufgaben durch Menschen beigebracht werden, ist das Thema unserer nächsten beiden Artikel.