Crowd Sensing und Social Data Mining mit Mobilen Agenten

Labor und Datenanalyse

PD Stefan Bosse
Universitรคt Bremen - Fachbereich Mathematik und Informatik
SS2020
2020-06-17

Agenten

Motivation

  • Crowdsensing ist verteilte Datenverarbeitung
  • Verteilte Datenverarbeitung bedeutet verteilte Kommunikation zwischen Prozessen

  • Traditionelle verteilte Netzwerke wie das Internet der Dinge (IoT) mรผssen mit einer Vielzahl von Kommunikationsprotokollen und Netzwerkstrukturen umgehen kรถnnen Stark heterogene Systeme

  • Datenreprรคsentation ist eine weitere Hรผrde in solchen verteilten Systemen

  • Hรคufig HTTP basierte Klienten-Server Kommunikation (zentrale Serverinstanz)

fighttp1

Motivation

figiotproto1


Abb. 1. GroรŸe Diversitรคt an IoT Protokollen und Datenreprรคsentation fรผr die Kommunikation → nicht einheitlich [4]

Agenten

Agenten besitzen eine Vielzahl von Fรคhigkeiten, die sie von klassischen Programmen unterscheiden - obwohl Agenten auch Programme sein kรถnnen!

Merkmale

  • Fรคhigkeit zu eigenstรคndiger Aktivitรคt (Nicht Nutzeraktiviert)

  • Autonomes, “selbstbestimmtes” Verhalten (Nicht durch zentrale Instanz gesteuert)

  • Fรคhigkeit zum selbststรคndigen Schlussfolgern (Umgang mit unsicheren Wissen)

  • Flexibles und rationales Verhalten (Adaptivitรคt an verรคnderliche Weltbedingungen)

  • Fรคhigkeit zu Kommunikation und Interaktion (Synchronisation)

  • Kooperatives oder konkurrierendes Verhalten (Lรถsung von Wettbewerbskonflikten)

  • Fรคhigkeit zur ziel- und aufgabenorientierten Koordination (Kooperation)

Agenten

  • Man unterscheidet zwischen realen und virtuellen Welten;
  • Agenten kรถnnen natรผrliche (reale) Welten abbilden oder in realen Welten agieren

fighumagent[Galan,2009]


Abb. 2. Beziehung realer natรผrlicher Welt mit Lebewesen zu virtueller Welt mit Agenten

Agenten und Weltumgebung

Agentenmodell

  • Ein Agent in seiner Umgebung nimmt sensorische Eingaben aus der Umgebung auf und produziert Ausgabe-Aktionen, die ihn und die Umgebung beeinflussen.

  • Die Interaktion ist gewรถhnlich fortlaufend und nicht-terminierend!

Einfachstes Agentenmodell

figagentenv0[J]

Beispiel

Umgebung: Raum in Gebรคude
Sensor: Temperatur T
Aktor:  Heizung
 
Verhalten:
(1) Temperatur zu niedrig  Heizung an
(2) Temperatur angenehem   Heizung aus

Agenten und Weltumgebung

Reaktive und Zustandsbasierte Agenten

  • Reaktive und zustandsbasierte Agenten fรผhren einen Zyklus durch:
    • Perzeption Verabeitung Zustandsรคnderung Entscheidung Aktion

figreactag1

ATG Modell

Zustandsbasierter Agent

  • Besteht aus: (1) Kรถrpervariablen (2) Kontrollzustand und Verhalten

Aktivitรคt und Zustand

  • Das Verhalten eines aktivitรคtsbasierten Agenten ist durch einen Agentenzustand gekennzeichnet, der durch Aktivitรคten verรคndert wird.

  • Aktivitรคten verarbeiten Wahrnehmungen, planen Aktionen und fรผhren Aktionen aus, die den Steuerungs- und Datenzustand des Agenten รคndern.

  • Aktivitรคten und รœbergรคnge zwischen Aktivitรคten werden durch einen Aktivitรคtsรผbergangsgraphen (Activity Transition Graph, ATG) dargestellt.

  • Die รœbergรคnge starten Aktivitรคten in der Regel abhรคngig von der Auswertung von Agentendaten (Kรถrpervariablen), die den Datenzustand des Agenten reprรคsentieren.

ATG Modell

figatg


Abb. 3. Links) Agentenverhalten, das von einem Aktivitรคtsรผbergangsgraphen vorgegeben ist, und die Interaktion mit der Umgebung, die durch Aktionen erfolgt, die in Aktivitรคten ausgefรผhrt werden (Rechts) Agentenmerkmale

ATG Modell

  • Ein Aktivitรคtsรผbergangsgraph, der mit Agentenklassen assoziiert ist, besteht aus einer Menge von Aktivitรคten 𝔸 = {A1, A2, ..} und einer Menge von รœbergรคngen 𝕋 = {T1 (C1), T2 (C2), ..}, die die Kanten des gerichteten Graphen darstellen.

  • Die Ausfรผhrung einer Aktivitรคt, die selbst aus einer Folge von Aktionen und Berechnungen besteht, ist mit dem Erreichen eines Unterzieles oder das Erfรผllen einer Voraussetzung verknรผpft, um ein bestimmtes Ziel zu erreichen, z. B. Sensordatenverarbeitung und Verteilung von Informationen.

  • Normalerweise werden Agenten verwendet, um komplexe Aufgaben zu zerlegen basierend auf der Zerlegung durch MAS.

  • Agenten kรถnnen ihr Verhalten basierend auf Lern- und Umgebungsรคnderungen oder durch Ausfรผhren einer bestimmten Unteraufgabe mit nur einer Untermenge des ursprรผnglichen Agentenverhaltens รคndern Dynamische ATG.

ATG Modell

  • Das ATG-Verhaltensmodell ist eng mit der Interaktion von Agenten mit deren Umgebung verbunden, hier hauptsรคchlich durch
    • Den Austausch von Daten unter Verwendung einer Tupelraum-Datenbank;
    • Durch Migration; und durch
    • Die Weitergabe von Nachrichten zwischen Agenten mittels Signalen.
    • Replikation und Instantiierung von Agenten

DATG Modell

  • Ein ATG beschreibt das vollstรคndige Agentenverhalten.

  • Jedes Unterdiagramm und jeder Teil des ATG kann einem Unterklasseverhalten eines Agenten zugeordnet werden.

  • Daher fรผhrt das Modifizieren der Menge von Aktivitรคten 𝔸 und รœbergรคngen 𝕋 des ursprรผnglichen ATG zu mehreren Unter- und Oberverhaltensweisen, die Algorithmen implementieren, um verschiedene unterschiedliche Ziele zu erfรผllen.

  • Die Rekonfiguration der Aktivitรคten fรผhrt zu einer Menge von Aktivitรคtsmengen 𝔸* = {𝔸i 𝔸, 𝔸j 𝔸, 𝔸k 𝔸, ..}, die von der ursprรผnglichen Menge 𝔸 abgeleitet sind, und die Modifikation oder Rekonfiguration von รœbergรคngen 𝕋* = {𝕋1 𝕋, 𝕋2 𝕋, ..} ermรถglicht die dynamische ATG-Zusammensetzung (Komposition) und Agentenunterklassifizierung zur Laufzeit,

DATG Modell

figdatg


Abb. 4. Dynamischer ATG: Transformation und Komposition

Beispiel eines Agenten

ATG eines einfachen Umfrageagenten mit Unterklassen (master, requester, worker)

#surveyagatg01

Agentenklassen

Eine Agentenklasse beschreibt ein bestimmtes Verhalten eines Agenten mittels eines ATG und einer Menge von Kรถrpervariablen.

  • Von einer Klasse kรถnnen zur Laufzeit Agenten instantiiert (erzeugt) werden.
Verhalten

Eine bestimmte Agentenklasse ACi bezieht sich auf das zuvor eingefรผhrte ATG Modell, dass das Laufzeitverhalten und die von Agenten ausgefรผhrten Aktion definiert.

Wahrnehmung

Ein Agent interagiert mit seiner Umgebung, indem er eine Datenรผbertragung unter Verwendung eines einheitlichen Tupelraums mit einer koordinierten datenbankรคhnlichen Schnittstelle durchfรผhrt.

Daten aus der Umgebung beeinflussen das folgende Verhalten und die Aktion eines Agenten. Daten, die an die Umgebung (z.B. die Datenbank) weitergegeben werden, beeinflussen das Verhalten anderer Agenten.

Agentenklassen

Speicher
Zustandsbasierte Agenten fรผhren Berechnungen durch, indem sie Daten รคndern. Da Agenten als autonome Datenverarbeitungseinheiten betrachtet werden kรถnnen, werden sie hauptsรคchlich private Daten modifizieren, und ein Berechnungsergebnis, dass diese Daten verwendet, in die Umgebung รผbertragen.
Daher enthรคlt jeder Agent und jede Agentenklasse eine Menge von Kรถrpervariablen 𝕍 = {v1:typ1, v2: typ2, ..}, die durch Aktionen in Aktivitรคten modifiziert und in Aktivitรคten und รœbergangsausdrรผcken gelesen werden.

Agentenklassen

Parameter
Agenten kรถnnen zur Laufzeit von einer bestimmten Agentenklasse instantiiert werden, die Agenten mit gleichen anfรคnglichen Steuerungs- und Datenzustรคnden erstellt.
Um einzelne Agenten zu unterscheiden (Individuen zu erzeugen), wird eine externe sichtbare Parametermenge = {p1: typ1, p2: typ2, ..} hinzugefรผgt, die die Erstellung verschiedener Agenten bezรผglich des Datenzustands ermรถglicht. Innerhalb einer Agentenklasse werden Parameter wie Variablen behandelt.

Agentenklassen

Eine Agentenklasse ACi ist daher zunรคchst definiert durch das folgende Mengentupel:

\[\begin{gathered}
  AC_i = \left\langle {\mathbb{A}_i,\mathbb{T}_i,\mathbb{V}_i,\mathbb{P}_i} \right\rangle  \hfill \\
  \mathbb{A} = \{ {a_1},{a_2},..,{a_n}\}  \hfill \\
  \mathbb{T} = \{ {t_{ij}} = {t_{ij}}({a_i},{a_j},cond)|{a_i}\xrightarrow{{cond}}{a_j};i,j \in \{ 1,2,..,n\} \} \hfill \\
  {a_i} = \{ {i_1},{i_2},..|{i_u} \in ST\}  \hfill \\
  \mathbb{V} = \{ {v_1},{v_2},..,{v_m}\}  \hfill \\
  \mathbb{P} = \{ {p_1},{p_2},..,{p_i}\}  \hfill \\ 
\end{gathered}
\]

Agentenklassen

Multiagentensysteme

Definition 1.
Es gibt ein Multiagentensystem (MAS), das aus einer Reihe einzelner Agenten besteht (ag1, ag2, ..). Es gibt verschiedene Verhaltensweisen fรผr Agenten, die als Klassen AC = {AC1, AC2, ..} bezeichnet werden. Ein Agent gehรถrt zu einer dieser Klassen.

Jede Agentenklasse wird dann durch das erweiterte Tupel AC = <𝔸, 𝕋, 𝔽, 𝕊, , 𝕍, > angegeben.

  • 𝔸 ist der Satz von Aktivitรคten (Graphenknoten), 𝕋 ist der Satz von รœbergรคngen, die Aktivitรคten (Beziehungen, Graphenkanten) verbinden,
  • 𝔽 ist der Satz von Rechenfunktionen,
  • 𝕊 ist der Satz von Signalen, ist der Satz von Signalhandlern,
  • 𝕍 ist die Menge der Kรถrpervariablen und die Menge der Parameter, die von der Agentenklasse verwendet werden.

Agentenklassen

Definition 2.
In einer spezifischen Situation ist ein Agent agi an einen Netzwerkknoten Nm,n,o,.. (z.B. Mikrochip, Computer, virtueller Simulationsknoten) an einem eindeutigen rรคumlichen Ort (m, n, o, ..) gebunden und wird dort verarbeitet.

Es gibt eine Menge verschiedener Knoten N = {N1, N2, ..}, die z.B. in einem maschenartigen Netzwerk mit einer Nachbarverbindung (z.B. vier in einem zweidimensionalen Gitter) angeordnet sind. Die Knotenverbindung kann dynamisch sein und sich im Laufe der Zeit รคndern. Die Knotennachbarn sind unterscheidbar.

Jeder Knoten ist in der Lage, eine Anzahl von Agenten ni(ACi) zu verarbeiten, die zu einer Agentenverhaltensklasse ACi gehรถren, und mindestens eine Teilmenge von AC' AC zu unterstรผtzen.

Ein Agent (oder zumindest sein Zustand) kann zu einem Nachbarknoten migrieren wo er weiter ausgefรผhrt wird.

Tupelrรคume

  • Tupel-Rรคume stellen ein assoziiertes Shared-Memory-Modell dar, wobei die gemeinsam genutzten Daten als Objekte mit einer Reihe von Operationen betrachtet werden, die den Zugriff der Datenobjekte unterstรผtzen

  • Tupel sind in Rรคumen organisiert, die als abstrakte Berechnungsumgebungen betrachtet werden kรถnnen.

  • Ein Tupelraum verbindet verschiedene Programme, die verteilt werden kรถnnen, wenn der Tupel-Space oder zumindest sein operativer Zugriff verteilt ist.

    • Oder: Mobile Agenten als Tupel Verteiler!
  • Das Tupelraum Organisations- und Zugangsmodell bietet generative Kommunikation, d.h. Datenobjekte kรถnnen in einem Raum durch Prozesse mit einer Lebensdauer รผber das Ende des Erzeugungsprozesses hinaus gespeichert werden.

  • Ein bekanntes Tupelraum-Organisations- und Koordinationsparadigma ist Linda [GEL85].

Tupelrรคume

figts[3]


Abb. 5. Ein Schnappschuss eines Tupelraumes mit Tupeln und Tupeloperationen

Tupelrรคume

  • Kommunikation von Agenten รผber Tupelrรคume ist eine Koordinationssprache.

figtsgen


Abb. 6. Direkter Nachrichtenaustausch (a), z.B. durch Signale, im Vergleich zu generativer Kommunikation (b) und virtuelle verteilte Rรคume (c) durch mobile Prozesse (Agenten)

Tupelrรคume - Datenmodell

  • Die Daten sind mit Tupeln organisiert.

  • Ein Tupel ist eine lose gekoppelte Verbindung einer beliebigen Anzahl von Werten beliebiger Art /Typ/

  • Ein Tupel ist ein Wert und sobald es in einem Tupelraum gespeichert ist, ist es persistent.

  • Tupeltypen รคhneln den Datenstrukturtypen, sie sind jedoch dynamisch und kรถnnen zur Laufzeit ohne statische Beschrรคnkungen erstellt werden.

  • Auf die Elemente von Tupeln kann nicht direkt zugegriffen werden, was รผblicherweise Mustererkennung und musterbasierte Dekomposition erfordert, im Gegensatz zu Datenstrukturtypen, die einen benannten Zugriff auf Feldelemente bieten, obwohl die Behandlung von Tupeln als Arrays oder Listen diese Beschrรคnkung lรถsen kann.

  • Ein Tupel mit n Feldern heiรŸt n-stellig und wird in der Notation <v1, v2, ..> angegeben.

Tupelrรคume - Operationale Semantik

  • Es gibt eine Reihe von Operationen, die von Prozessen angewendet werden kรถnnen, bestehend aus
    • einer Reihe reiner Datenzugriffsoperationen, die Tupel als passive Datenobjekte behandeln,
    • und Operationen, die Tupel als eine Art von aktiven Rechenobjekten behandeln (genauer gesagt, zu berechnende Daten).
    • RPC-Semantik (Remote Procedure Call).
out
function (t:tuple)
Die Ausfรผhrung der Ausgabeoperation fรผgt das Tupel t in den Tupelraum ein. Mehrere Kopien desselben Tupelwerts kรถnnen eingefรผgt werden, indem die Ausgabeoperation iterativ angewendet wird. Die gleichen Tupel kรถnnen nach dem Einfรผgen in den Tupelraum nicht unterschieden werden.

Tupelrรคume - Operationale Semantik

inp

function (p:pattern, callback: function (tuple|tuple[]|null),all?:boolean)

Die Ausfรผhrung der Eingabeoperation entfernt ein Tupel t aus dem Tupelraum, der der Mustervorlage p entspricht. Wenn kein passendes Tupel gefunden wird fรผhrt das zu einer Blockierung des aufrufenden Prozesses bis ein passendes Tupel eingestellt wird.

rd

function (p:pattern, cb:function (tuple|tuple[]|null),all?:boolean)

Die Ausfรผhrung der Leseoperation gibt eine Kopie eines Tupels t zurรผck, dass der Vorlage p entspricht, entfernt sie jedoch nicht. Wenn kein passendes Tupel gefunden wird fรผhrt das zu einer Blockierung des aufrufenden Prozesses bis ein passendes Tupel eingestellt wird.

Tupelrรคume - Operationale Semantik

Beispiele

out(["Sensor",1,100]); 
out(["Sensor",2,121]);
inp(["Sensor",1,_], function (t) { if (t) v=t[2]; }); 
inp(["Sensor",_,_], function (t) { if (t) n=t[1],v=t[2] });`
rd(["Sensor",_,_], function (t) { if (t) n=t[1],v=t[2] });`

Tupelrรคume - Operationale Semantik

try_inp, try_rd

function (0,p:pattern,callback?:function,all?:boolean) tuple|tuple[]|null

Nichtblockierende Version von inp/rd. Wird kein passendes Tupel gefunden wird die Operation ergebnislos terminiert.

try_inp, try_rd

function (tmo:number,p:pattern,callback:function,all?:boolean) tuple|tuple[]|null

Teilblockierende Version von try_inp/try_rd, Wird innerhalb einer Zeit von tmo kein passendes Tupel gefunden wird die Operation ergebnislos abgebrochen.

  • Die Verwendung von zeitlich unbegrenzt blockierenden Operationen kann unter Betrachtung der Lebendigkeit von Agenten nachteilig sein. Daher sollte immer eine zeitliche Begrenzung und anschlieรŸende Abfrage des Operationsstatus erfolgen (abgebrochen?)

Tupelrรคume - Operationale Semantik

test

function (pattern) boolean

Nicht blockierender Test eines Tupels.

ts (testandset)

function (pattern,function (tuple) tuple)

Nicht blockierender Test eines Tupels und atomare Verรคnderung eines Tupels, dass der Vorlage p entspricht. Das zweite Argument ist eine Abbildungsfunktion. Das Ergebnistupel ersetzt das ursprรผngliche.

rm

function (p:pattern,all?:boolean)

Entfernung eines oder aller passenden Tupel.

Tupelrรคume - Operationale Semantik

Markierungen

  • Tupel sind persistent und kรถnnen fรผr immer in einem Tupelraum verbleiben!
  • Daher ist die Verwendung von Markierungen hรคufig sinnvoll.
  • Eine Markierung ist ein Tupel mit einer Lebenszeit τ
  • Nach Ablauf der Lebenszeit wird das Tupel - sofern es nicht entfernt wurde - durch einen Garbagecollector entfernt.
\[m = \left\langle {\tau ,\overrightarrow d } \right\rangle {\text{, with }}\overrightarrow d :: = d|d,\overrightarrow d {\text{ and }}d:: = v|\varepsilon |x,{\text{ }}\tau :{\text{timeout}}
\]
mark
function (tmo:number,t:tuple)
Ausgabe eines Tupels t mit einer Lebenszeit τ (im Tupelraum).

Tupelrรคume - Operationale Semantik

alt
function (pattern [], function (tuple|tuple[]|null),all?:boolean)
Gleichzeitige Mehrfachabfrage (mit inp Semantik) von einer Menge von Mustern. Das erste Tupel welches einem der Muster entspricht wird an die Rรผckruffunktion รผbergeben. Es gibt auch eine nicht- oder partiell blockierende Variante try_alt.

Tupelrรคume - Produzenten und Konsumenten

Produzent

this.act = {
 percept : function () {
   out(["SENSORNODE"]);
   mark(1000,["SENSOR","CLOCK",time()])
   mark(1000,["SENSOR","GPS",
              {lati:x,long:y}])
 }
}

Konsument

this.act = {
 process : function () {
  if (test(["SENSORNODE"])
   inp(["SENSOR","CLOCK",_], function (t) {
    if (t) log('It is time '+t[2]);
   })
 }
}

Aufgabe

Betrachte das zeitliche Verhalten im obigen Beispiel (Laufzeiteigenschaften)

  1. Was kรถnnte im Produzenten-Konsumenten System mรถglicherweise falsch laufen?

  2. Wie mรผsste der Agentencode geรคndert werden um Laufzeitfehler zu vermeiden?


Signale

  • Tupleraumkommunikation ist

    • Anonym und
    • Generativ (d.h. die “Nachricht” kann eine lรคngere Lebensdauer als der Absender besitzen)
  • Eignet sich daher fรผr die Kommunikation von lose gekoppelten Ensembles

  • Neben diesen lose gekoppelten Gruppen gibt es durch Replikation von Kindagenten Gruppen mit starker Kopplung und Kenntnis der Identiรคten

    • Elternagent erfรคhrt die Identitรคt eines Kindagenten beim Forking
    • Kindagent kann die Indentitรคt des Elternagenten durch die Operation myParent() erfahren.
  • Signale sind zielgerichtete Nachrichten mit identifizierbaren Absender und Empfรคnger (wobei es bei Multi- und Broadcastnachrichten viele geben kann)

Signale

  • Ein Signal signal(arg) besteht aus einem Signalnamen oder einer Signalnummer mit einem optionalen Argument.

  • Signale mรผssen auf Empfรคngerseite mit einem Signalhandler im this.on Abschnitt des Agentenmodells eingerichtet werden.

send

function (target:id,signal:string|number,arg?:*)

Sendet eine Signalnachricht signal(arg) an den Empfรคngeragenten target.

broadcast

function (ac:string,r:number,signal:string|number,arg?:*)

Sendet eine Signalnachricht signal(arg) an alle Empfรคngeragenten der Klasse ac im Radius r.

this.on[“signal”]

function (arg,from)

Ein Signalhandler fรผr das Signal signal.

Signale

Produzent

this.act = {
  a1 : function () {
    this.child = fork()
  },
  a2 : function () {
    send(this.child,'ALARM',100)
  }
}

Konsument

this.on = {
  ALARM : function (arg,from) {
    log('Got ALARM '+arg+' from '+from)
  }
}

Mobile Agenten

  • Ein Agent in Ausfรผhrung wird durch einen Prozess reprรคsentiert.

  • Der Prozesszustand setzt sich zusammen aus:

    • Kรถrpervariablen (Datenzustand)
    • Nรคchste Aktivitรคt und Mikroschedulingblรถcke (Kontrollzustand)
    • Signale, Nachrichten
    • Pfad im Netzwerk (Plattformen auf denene der Agent bereits ausgefรผhrt wurde)
    • Verhalten (D.h. ATG)!
  • Mobile Agenten bedeuten mobile Prozesse!

  • Bei der Migration muss ein Agentenprozess in einen

    1. Prozessschnappschuss (Container) eigenfroren und serialisiert werden,
    2. Der Schnappschuss in textueller Form (JSON+) von einer Plattform zu einer anderen รผbertragen werden, und
    3. Der Prozessschnappschuss wieder deserialisiert werden, und der Prozess wird weiter ausgefรผhrt.

Mobile Agenten

Mobiler Code

  • Anstelle von mobilen Daten (Kommunikation) wird durch Agenten mobiler Code in Netzwerken transportiert

Mobile Agenten

  • Eine Agentenplattform reprรคsentiert einen physikalischen Knoten in einem Virtuellen Netzwerkgraphen

    • Es gibt virtuelle und physikalische Kommunikationsverbindungen zwischen den Netzwerkknoten
    • Beispiel: Internet Protokoll (IP/UDP/HTTP)
  • Ports von Plattformen verbinden und stellen Links her

  • Ein Agent kann auf einen anderen Knoten (Plattform) migrieren indem er die moveto Operation ausfรผhrt (innerhalb einer Aktivitรคt):

    • Dabei muss der Agent als Argument das Ziel angeben
    • Ziel kann ein Knotenname (DIR.NODE(<nodename>), eine IP Adresse (DIR.IP(<url>)), oder bei gerichteten Verbindungen die Richtung sein (z.B. DIR.NORTH)

Mobile Agenten

  • Alle aktuell mit einer Plattform verbundenen anderen Plattformen (Namen) kรถnnen mit der link Funktion erfragt werden:
{
  var connected=link(DIR.IP('%'));
  if (connected.length) {
    var next = random(connected);
    moveto(DIR.NODE(next));
  }
}

Agentenplattformen

JavaScript Agent Machine

  • Vollstรคndig in JavaScript programmiert

  • Portabel:

    • Web Browser
    • Cordova WebKit App
    • CLI mit nodejs/jxcore/jerryscript
    • Eingebettet in Java Programm
  • Schlank: ca 1M Byte JS Code

  • AgentJS Code kann direkt ausgefรผhrt werden (nur Sandboxing erforderlich)!

  • Eine physische JAM kann eine Vielzahl von virtuellen JAM Knoten ausfรผhren (nur sequenzielles Scheduling)

JAM

AIOS

  • Das AIOS kapselt eine Vielzahl von Modulen und stellt eine API fรผr Agenten zur Verfรผgung:
    • TUPLE: Tupleraum Datenbank
    • SIGNAL: Signalpropagation zwischen Agenten und JAM Knoten
    • CODE: AgentJS Text Code Transformation, Code Morphing, und Sandboxing
    • NODE: Virtueller JAM Knoten
    • WORLD: Bindung von virtuellen JAM Knoten in einem physischen Knoten (Virtualisierung)
    • PROC: Agentenprozesses (Ausfรผhrungscontainer fรผr Agenten)
    • MOBI: Agentenmobilitรคt, COMM: JAM Kommunikation
    • SECU: JAM Capabilities und Sicherheit
    • WATCHDOG: Faires Agentenscheduling durch Laufzeitรผberwachung (Time slicing)
    • ML: Machine Learning Fokus mobile Algorithmen und Modelle
    • SAT: SAT Logic Solver Knowledge Base

JAM

figaios


Abb. 7. Das Agent Input-Outut System als Schnittstelle zwischen Agenten und JAM und einer Hostplattform (bzw. Applikation)

JAM

Agentenrollen

  • In der realen Welt ist die Anwendungssicherheit ein wichtiges Schlรผsselmerkmal einer verteilten Agentenplattform.

  • Die Ausfรผhrung von Agenten und der Zugriff auf Ressourcen mรผssen kontrolliert werden, um Denial-of-Service-Angriffe, Agent-Masquerading, Spionage oder anderen Missbrauch zu verhindern.

  • Daher haben Agenten unterschiedliche Zugriffsebenen (Rollen):

    1. Gast (nicht vertrauenswรผrdig, semi-mobil)
    2. Normal (vielleicht vertrauenswรผrdig, mobil)
    3. Privilegiert (vertrauenswรผrdig, mobil)
    4. System (sehr vertrauenswรผrdig, System relevant, lokal, nicht mobil)
  • Die unterste Ebene (0) ermรถglicht keine Agentenreplikation, Migration oder das Erstellen neuer Agenten.

  • Die JAM-Plattform entscheidet รผber die Sicherheitsstufe fรผr neue empfangene Agenten. Ein Agent kann keine Agenten mit einer hรถheren Sicherheitsstufe als die eigene erstellen.

JAM

  • Die hรถchste Stufe (3) hat einen erweiterten AIOS mit Host-Plattform-Gerรคtezugriffsfรคhigkeiten.

  • Agenten kรถnnen Ressourcen (z.B. CPU-Zeit) aushandeln und ein Level-Raise erreichen, das mit einem Schlรผssel gesichert ist, der die erlaubten Upgrades definiert.

    • Die Systemebene (3) kann nicht ausgehandelt werden.
  • Der Schlรผssel ist knotenspezifisch. Eine Gruppe von Knoten kann sich einen gemeinsamen Schlรผssel teilen (durch einen Server-Port identifiziert der den JAM Knoten identifiziert).

  • Ein Schlรผssel besteht aus einem Server-Port, einem Rechtefeld und einem verschlรผsselten Schutzfeld das das Rechtefeld enthรคlt, das mit einem zufรคlligen Port generiert wird, der nur dem Server (Knoten) bekannt ist.

JAM

Schlรผssel (Capabilities)

  • Ein Schlรผssel kann verwendet werden um:
    • Einen Agenten von einer Plattform A nach B zu migrieren (B verlangt den Schlรผssel um den Agenten auszufรผhren);
    • Eine neue Agentenrolle (Stufe) auszuhandeln;
    • In einer Agententrolle neue Ressourcen auszuhandeln (CPU, MEM, TS, SCHED, ..);
    • Um neue Agenten erzeugen und andere terminieren zu kรถnnen

figcapability


Abb. 8. Aufbau einer Capability: Der Serverport bindet die Capability an einen Service, die Objektnummer ist optional und kann eine Unterklasse des Service oder der zu schรผtzenden Ressource darstellen, das Rechtefeld kodiert die mรถglichen Operationen der Serviceklasse, und das Schutzfeld (enthรคlt Rechtefeld nochmals verschlรผsselt) schรผtzt die Capability gegen Manipulation.

JAM

Schutz von Capabilities

  • Das Rechtefeld ist zentral da es die durch die Capability erlaubten Operationen angibt.

    • CPU Zeit erhรถhen
    • ร„nderung des Privilegienlevels
    • Migration usw.
    • Zugriff auf Sensoren und persรถnliche Nutzerdaten
  • Damit das Rechtefeld nicht manipuliert werden kann ohne dass die Capability ungรผltig wird (und ggf. die Objektnummer) wird ein Schutzfeld erstellt welches die Rechte mit einem privaten Schlรผssel (Port) mittels einer One-way Funktion verschlรผsselt.

    • Nur der Service / Agentenplattform kennt den privaten Schlรผssel

JAM

figcapprot


Abb. 9. Erzeugung einer รถffentlichen restriktiven Capability aus einer privaten nicht eingeschrรคnkten (enthรคlt privaten Schlรผssel C) mittels One-way Verschlรผsselungsfunktion f(C xor R)

JAM

Kommunikation und Netzwerke

  • JAM Plattformen kรถnnen in beliebigen Netzwerken miteinander verbunden werden.

  • Eine Vielzahl von Kommunikationsprotokolle sind verwendbar:

    • RS232
    • UDP
    • TCP
    • HTTP
  • Beliebige Netzwerktoplogien kรถnnen gebildet werden (physisch wie logisch):

    • Stern
    • Gitter (1D/2D/3D)
    • Bus
    • Intranet und Internet (allg. Graphen)
  • AMP: Agent Management Port als gemeinsames Protokoll und Interface in heterogenen Systemen

JAM

  • AMP definiert eine Menge von Nachrichten die dem Transport von
    • Agenten,
    • Signalen und Tupeln,
    • und Handshakes dienen.

figjamcomm


Abb. 10. JAM Konnektivitรคt und eine breites Spektrum an unterstรผtzten JavaScript Host Plattformen

JAM

Netzwerkstrukturen

  • JAM Platfformen kรถnnen รผber eine oder mehrere virtuelle Kanรคle (AMP) miteinander verbunden werden
    • Verwendung von Relaisstationen fรผhrt zu sternartigen Kommunikationssnetzwerken
    • Browser und mobile JAM Knoten kรถnnen nur an im Internet sichtbare JAM Knoten รผber HTTP sich verbinden erfordert Relais Knoten (ohne Nutzerinteraktion, kopflos)

JAM

figaaplaction


Abb. 11. Effekt von verschiedenen AAPL/AgentJS Anweisungen zur Laufzeit auf Agenten und Plattformen

Programmierung

JavaScript :: Daten und Variablen

  • Variablen werden mit dem Schlรผsselwort var definiert Erzeugung eines Datencontainers!

  • Es gibt keine Typdeklaration in JS! Kerntypen:

    Tcore={number, boolean, object, array, string, function}

  • Alle Variablen sind polymorph und kรถnnen alle Werttypen aufnehmen.

  • Bei der Variabledefinition kann ein Ausdruckswert zugewiesen werden

var v = ε,..;  v = ε; 

JavaScript :: Funktionen

  • Funktionen kรถnnen mit einem Namen oder anonym definiert werden

  • Funktionen sind Werte 1. Ordnung Funktionen kรถnnen Variablen oder Funktionsargumenten zugewiesen werden

  • Eine Funktion kann einen Wert mit der return Anweisung zurรผckgeben. Ohne explizite Wertrรผckgabe undefined

  • Es wird nur Call-by-value Aufruf unterstรผtzt - jedoch werden Objekte, Funktionen und Arrays als Referenz รผbergeben; Parameter pi sind an Funktionsblock gebunden

function name (p1,p2,..) { statements ; return ε } name(ε1,ε2,..)

JavaScript :: Funktionen

  • Da in JavaScript Funktionen Werte erster Ordnung sind kรถnnen

    • Funktionen an Funktionen รผbergeben werden und
    • Funktionen neue Funktionen zurรผckgeben (als Ergebnis mit return)
  • Es kรถnnen daher anonyme Funktionen function (..) {..} definiert werden die entweder einer Variablen als Wert oder als Funktionsargument รผbergeben werden.

var x = function (pi) { ε(pi) }
array.forEach(function(elem,index) { ε(pi) }

JavaScript :: Datenstrukturen

In JavaScript sind Objekte universelle Datenstrukturen (sowohl Datenstrukturen als auch Objekte) die mit Hashtabellen implementiert werden. Arrays werden in JavaScript ebenfalls als Hashtabelle implementiert!. D.h. Objekte == Datenstrukturen == Arrays == Hashtabellen.

  • Es gibt kein nutzerdefinierbares Typensystem in JavaScript.

  • Eine Datenstruktur kann jederzeit definiert und verรคndert werden (d.h. Attribute hinzugefรผgt werden)

var dataobject = {
  a:ε,
  b:ε, ..
  f:function () { .. }
}
..
dataobject.c = ε

JavaScript :: Datenstrukturen

  • Dadurch dass Objekte und Arrays mit Hashtabellen implementiert (d.h. Elemente werden durch eine Textzeichenkette referenziert) werden gibt es verschiedene Mรถglichkeiten auf Datenstrukturen und Objektattribute zuzugreifen:
dataobject.attribute
dataobject["attribute"]
array[index]
array["attribute"]

JavaScript :: Objekte

  • Objekte zeichnen sich in der objektorientierten Programmierung durch Methoden aus mit der ein Zugriff auf die privaten Daten (Variablen) eines Objekts mรถglich wird.

  • In JavaScript kann auf Variablen eines Objekts (die Attribute) immer direkt zugegriffen werden.

  • Attribute kรถnnen Funktionen sein - jedoch kรถnnen die Funktionen nicht wie Methoden direkt auf die Daten des Objektes zugreifen.

  • Daher definiert man Methoden รผber Prototypenerweiterung in JavaScript.

  • Die Methoden kรถnnen รผber die this Variable direkt auf das zugehรถrige Objekt zugreifen (also auch auf die Variablen/Attribute)

  • Es gibt eine Konstruktionsfunktion fรผr solche Objekte mit Prototypendefinition der Methoden

  • Objekte werden mit dem new Operator und der Konstruktionsfunktion erzeugt.

JavaScript :: Objekte

function constructor (pi) {
  this.x=ε
  ..
}
constructor.prototype.methodi = function (..) {
  this.x=ε;
  ..
}
...
 
var obj = new constructor(..);

AgentJS

  • AgentJS ist die JavaScript Implementierung von AAPL (Activity-based Agent Prorgramming Language)
    • Die meisten AAPL Operationen und Anweisungen sind in AgentJS verfรผgbar
    • Aber: JavaScript unterstรผtzt nicht das Konzept der Prozessblockierung
    • Daher anderes Scheduling und Ablaufmodell mit Scheduling Blocks

Agentenklasse

  • Agentenklassen werden in JS รผber Konstrukorfunktionen definiert.

  • Eine Agentenklasse definiert:

    • Kรถrpervariablen (nur mobile und werterhaltende)
    • Aktivitรคten (als Funktionsobjekt)
    • รœbergangsbedingungen (als Funktionsobjekt)
    • Optionale Signalhandler (als Funktionsobjekt)
    • Ein next Attribute initialisiert mit der Startaktivitรคt

AgentJS

  • Aber: Das this Objekt als Refernz auf eine Agenteninstanz ist auch in geschachtelten Funktionen gรผltig, d.h., in allen
    • Aktivitรคtsfunktionen,
    • รœbergangsfunktionen,
    • Signalhandlerfunktionen, und in
    • Callback Funktionen erster Ordnung von eingebauten Funktionen (z.B. iter(list,function () { this is agent! }
  • Ein Agentenprozess wird in einem Sandkasten gekapselt ausgefรผhrt. Daher:
    • Ein Agent darf nur auf Kรถrpervariablen zugreifen und keine freien Variablen oder lokale Variablen verwenden (d.h. welche die auรŸerhalb des Konstruktors definiert wurden oder welche die innerhalb des Konstruktorkรถrper definiert wurden):
function ac (p) {
  var x;      // Wrong!!!
  this.y = p; // Correct!!!
  this.act = { ax: function () { var a; // is correct
}

AgentJS

Definition 3. (Konstruktorfunktion: Template einer Agentenklasse)

function ac(p1,p2,..) {
  // Body Variables
  this.x=ε; ..
  this.act = {     // Activities
   a1: function () { .. },
   a2: function () { .. },
   ..
   an: function () { .. }
  }
  this.trans = {   // Transitions
   a1: function () { return cond?ai:aj },
   a2: aj,
   ..
  } 
  this.on = {      // Signal Handler
    error:   function (err) { .. },
    signal1: function (arg) { .. }
  }
  this.next = a1;
}

AgentJS

Agenteninstantiierung und Terminierung

function create(class:string,arguments:{},level?:number)  id:string
function fork(arguments?:{},level?:number)  id:string
function kill(id:string|undefined)
  • Bei der create Operation die einen neuen Agenten der Klasse ac instantiiert werden die Klassenparameter der Instanz mit konkreten Werten mit dem Parameterargument arguments:{p1:v1,p2:v2,..} initialisiert.

  • Bei der fork Operation die eine Kopie des aufrufenden Agenten erzeugt werden Klassenattribute (die this.x Variablen, nicht die Parameter {p}!) mit neuen Werten รผberschrieben, d.h. arguments:{x:v1,y:v2,..}

  • Die kill Operation ohne Argument fรผhrt zur Terminierung des aufrufenden Agenten (== kill(me()))

AgentJS

Beispiele

id = create('explorer',{dir:DIR.NORTH,radius:1});
child = fork({x:10,y:20});
kill(child);
kill(me());

Asynchrone Operationen

  • Da JavaScript Funktionen als Werte erster Ordnung behandelt werden hรคufig sog. Rรผckruffunktione (callback) an Funktionen als Argumente รผbergeben, die von der aufrufenden Funktion dann aufgerufen werden

  • Rein synchrone Operationen (z.B. Tupelraumoperation out oder jegliche Berechnung, auch mit Rรผckruffunktionen wie iter) kรถnnen in einer Sequenz innerhalb einer Agentenaktivitรคt ausgefรผhrt werden

  • Es gibt aber auch asynchrone Operationen ((z.B. Tupelraumoperation rd), die zwar aufgerufen werden, aber erst spรคter (ggfs. nach Durchlauf einer Aktivitรคt) ausgefรผhrt werden.

AgentJS

Prozessblockierung

  • Eine Aktivitรคt wird in einem Durchlauf ausgefรผhrt und kann nicht blockieren, wie dies z.B. bei den Tupeloperationen der Fall sein kรถnnte.
    • Daher darf sich in AgentJS maximal nur ein blockierende Operation (die tatsรคchlich dann die Aktivitรคt blockiert, und nicht den Programmfluss) am Ende einer Aktivitรคt befinden.
    • Bei einer Sequenz von blockierenden Operationen muss in der Aktivitรคt ein Scheduling Block verwendet werden (Mikroaktivitรคten).
    • Jede Mikroaktivitรคt darf eine blockierende Operation enthalten!
  • Es gibt drei verschiedene Blockkonstruktoren:
    • B: Ein sequenzieller Scheduling Block
    • L: Ein iterativer Schleifenblock
    • I: Ein Iteratorblock fรผr Arrays und Objekte (Strukturen)

AgentJS

Definition 4. (Mikroaktivitรคten und Blรถcke)

B([                    L([
   function () { .. },     function init () {..},
   function () { .. },     function cond () {..}, 
   function () { .. },     function next () {..},
  ..                       [ function () { .. },
])                           function () { .. }, ..
                           ]])
I(obj:[]|{},
  function next (elem:*) { },
  [
   function () {..},
   function () {..}, ..
  ],
   function finalize () { .. }
)

AgentJS

Tupeloperationen

function alt (pattern [],callback:function,all?:boolean,tmo?:number)
function collect (to:path,pattern)  number
function copyto (to:path,pattern)  number
function evaluate (pattern,callback:function (tuple))  tuple
function inp (pattern,callback:function(tuple|tuple[]|none),all?:boolean,tmo?:number)
function listen (pattern,callback:function (pattern)  tuple)
function out (tuple)
function mark (tuple,tmo:number)
function rd (pattern,callback:function(tuple|tuple[]|none) ,all?:boolean,tmo?:number)
function rm (pattern,all?:boolean)
function store (to:path,tuple)  number
function test (pattern)  boolean
function ts (pattern,callback:function(tuple)  tuple)
function alt.try inp.try rd.try (tmo:number,..)
  • collect, copyto, und store sind verteilte Tupelraumoperationen und wirken auf entfernten Tupelrรคumen

AgentJS

Beispiele

out(['MARKING1',1]);
out(['SENSORA',100,true]);
inp(['SENSORA',_,_],function (tuple) {
  if (tuple) this.s =tuple[1];
});
rm(['SENSORA',_,_],true);
rd.try(0,['SENSORA',_,_],function (tuple) { .. });
// oder bei Timeout 0 alternativ ohne callback =>
var t = rd.try(0,['SENSORA',_,_]);
ts(['MARKING',_],function (t) { t[1]++ });
alt([
  ['SENSORA',_,_],
  ['SESNORB',_],
  ['EVENT'],
],function (tuple) {
  if (tuple && tuple[0]=='EVENT') {..}
  else ..
});

AgentJS

Signale und Handler

function send (to:aid,sig:string|number,arg?:*)
fucntion broadcast (class:string,range,@sig,@arg?)
function sendto (to:dir,sig:string|number,arg?:*)
function sleep (milli:number)
function timer.add (milli:number,sig:string,arg:*,repeat:boolean)  string
function timer.delete (sig:string)
this.on = { SIGNAL : function (arg,from) { .. } }

Typen und Muster

type aid = string
type range = hops:number|region:{dx:number,dy:number,..}
enum DIR = {NORTH , SOUTH , WEST , EAST , ..
            PATH (path:string) , NODE(id:string),
            IP (ip:string) ,
            CAP {cap:string}
} : dir

AgentJS

  • Signalhandler werden auรŸerhalb von Aktivitรคten in der this.on Sektion ausgefรผhrt. Der Objektattributname ist der Signalname.

Code Muster

this.child=none;
this.act = {
  a1: function () {
    this.child=fork({child:none});
    timer.add(500,'QUERY',true);
  }
  a2: function () {
   // Raising of signal
   if (this.child) send(this.child,'PARENT',me());
  }
}
// Installation of Signal Handler
this.on : {
   PARENT : function (arg) {
     log('Got signal from my parent '+arg);
   }, 
   QUERY: function () { .. }
}

AgentJS

Mobilitรคt von Agenten

enum DIR = {NORTH , SOUTH , WEST , EAST , ..
            PATH (path:string) , NODE{node:string),
            IP (ip:string) ,
            CAP (cap:string)
} : dir
function moveto (to:dir)
function opposite (dir)  dir
function link (dir)  boolean|string|[]
  • Fรผr die IP Richtung existiert eine Typkonstruktionsfunktion DIR.IP(ip:string|number) mit der Angabe einer IP Adresse und einer IP Portnummer im Format "IP:PORT", oder bei Verbindungen von JAM Knoten auf den gleichem Hostrechner nur die IP Portnummer.

  • Die opposite Funktion liefert die entgegengesetzte Richtung, z.B. NORTH SOUTH. Bei IP Ports i.A. nicht definiert oder bei bereits migrierten Agenten die IP Adresse des letzten Knotens.

  • Als Ziel kann auch ein JAM Knotenname angegeben werden (DIR.NODE("name")).

AgentJS

moveto
function moveto (to:dir)
Der Agent wird eingefroren, zu der neuen Plattform gesendet, und dort weiter ausgefรผhrt. Die Rcihtung kann einen geometrischen Bezug haben (z.B. DIR.NORTH), oder eine Plattformreferenz beschreiben (z.B. DIR.NODE(‘hanaqude’)). Eine geometrische Richtung macht nur in Maschennetzwerken it P2P Verbindungen Sinn.
  • Wenn keine Verbindung in die angegebene Richtung existiert wird der Agent terminiert!
link
function link (dir) boolean|string|[]
Liefert Informationen รผber aktuell erreichbare Nachbarknoten. Die link Funktion testet ob ein Port mit einer anderen Seite verbunden ist (nicht zuverlรคssig). Bei Multicast IP Ports (Standard) gibt die Funktion alle derzeitig angebundenen anderen Knotenadressen (Routes) zurรผck (Aufruf mit Argument DIR.IP('*')).

AgentJS

  • Die von der aktuellen Plattform (JAM Knoten) erreichbaren JAM Knotennamen kรถnnen z.B. mit der link(DIR.IP("%")) Operation als Liste ausgegeben werden.

  • Nach einer Migration wird die nรคchste folgende Aktivitรคt (definiert durch die รœbergangsbedingungen) ausgefรผhrt. Daher muss die moveto Anweisung die letzte in einer Aktivitรคt oder eingebettet in einen Scheduling Block sein!

Simulation

  • Neben der “realen” Ausfรผhrung von mobilen Agenten in Computernetzwerken stellt die Simulation von verteilten Netzwerken aus Agentenplattformen und “virtuellen” mobilen Agenten ein wichtiges experimentelles Werkzeug dar um auch komplexe Szenarien raum- und zeitaufgelรถst zu untersuchen.

SEJAM

  • SEJAM ist das Simulation Environment for JAM und baut auf einer “physischen” JAM Plattform auf
    • JAM wird um eine Bedieneroberflรคche und Visualisierung ergรคnzt
    • Eine virtuelle Welt besteht aus einer Vielzahl virtueller (logische) JAM Knoten und eier geometrischen zweidimensionalen Welt
    • Agenten kรถnnen in der virtuelen Welt zwischen virtuellen Knoten migrieren

Simulation

  • Die virtuellen Knoten sind in der geometrischen Welt mobil
  • Die virtuellen Knoten verfรผgen รผber virtuelle Kommunikationsverbindungen (z.B. radial wie Mobilfunk)
  • Die JAM Plattform in SEJAM kann mit realen Netzwerken gekoppelt werden!
  • Mobile Agenten kรถnnen nicht nur zwischen virtuellen Knoten migrieren, sondern auch die auf externe Plattformen in der realen Welt migrieren

Simulation

figsejam2


Abb. 12. SEJAM2 mit zweidimensionaler Plattformwelt (stationรคre und mobile Knoten) und Agenten; Kreise um Knoten symbolisieren Funkkommunikation

Simulation

Augmented Virtuality

  • Die Fusion von virtuellen Simulationswelten mit realen Netzwerken ermรถglicht die Kopplung von virtuellen Welten mit realen Welten und Interaktion mit Menschen!

  • Chat bots kรถnnen sowohl in virtuellen als auch realen (menschbezogenen) Welten agieren!

  • Das ermรถglicht das Studium komplexer sozio-technischer Systeme

Human-in-the-loop simulation for Augmented Virtuality besteht daher aus:

  • Virtueller Simulationswelt und Framework SEJAM2 mit JAM platform unf virtuellen JAM Netzwerken die mit dem Internet verbudnen sind

  • Mobilen Gertรคten mit JAM Plattform verbunden mit dem Internet oder via Baken (Bluetooth z.B.)

  • Stationรคre Gerรคte (Sensoren, IoT, und Baken) die รผber das Internet mit der virtuellen Welt verbunden sind

Simulation

figsimualtion1


Abb. 13. Augmented Virtuality: Human-in-the-loop Simulation mit mobilen Agenten

Demonstrator

Smart City: Self-Organizing Light Control

Goal

Simulation and investigation of Crowd Interaction with Smart Cities

  • Self-organized control of ambient light conditions (e.g., in streets or buildings) using Crowd Sensing

Virtual World

  • World consists of streets and buildings

    • Beacons placed in buildings and beside streets
    • Smart Light Devices illuminating streets and buildings
  • Agents (can) represent:

    • Technical devices Light Control
    • Network Infrastructure and Communication
    • Computational units and Smart Controllers
    • Chat Bots performing Crowd Sensing
    • Robots
    • Artificial Humans (Artificial Crowd)

Smart City: Self-Organizing Light Control

Real World

  • Mobile Devices using a WEB App with Chat Bot dialog

    • Users interact with remote agents via a chat dialog;
    • Remote agents investigate user location and an assessment of satisfaction of ambient light situation.
  • Additionally, the device sensor data is collected (light, position, ..) if available

Self-organizing Light Control

  • Beacons sent out mobile explorer agents performing question-answer dialogs on mobile devices (random walk)

  • Based on collected crowd data:

    • The light conditions in buildings and streets should be adapted (darker or brighter);
    • Addressing 1. Crowd demands 2. Energy Saving.

Smart City: Self-Organizing Light Control

  • If action is required, mobile notification agents are sent out to neighbouring nodes to change light intensity based on:
    • Directed diffusion
    • Random walk
    • Divide-and-Conquer

Smart City: Self-Organizing Light Control

figsmartcitycrowd


Abb. 14. Simulation world connected to the Internet performing Crowd Sensing → Real world is mapped on Virtual World!

Crowd Sensing App

Real World Virtual World

Conclusions

  1. Fusion of real and virtual worlds can contribute to investigate complex socio-technical systems with ensemble sizes beyond Millions of entities (users, devices, machines)

  2. Using agent-based modelling and simulation with mobile agents create an unified model and representation for:

    • Artificial humans
    • Chat Bots
    • Devices and Machines
    • Distributed Computation
  3. Augmented Virtuality means the integration and tight coupling of ABM simulation with Crowd Sensing and technical devices interaction

  4. Issues:

    • Time scales in real and virtual worlds
    • Spatial scales and spaces in real and virtual worlds
    • Mapping of real on virtual worlds