Künstliche Intelligenz

1. KI Sprachen und Tools
Autor: Erhard Dinhobl

2. KI Sprachen und Tools
Erhard Dinhobl Seite 2 von 16
Index
KI Sprachen und Tools .................................................................................... 1
Kurzfassung ............................................................................................... 3
Einleitung .................................................................................................. 3
Die Geschichte der Programmiersprachen und deren Umgebungen..................... 3
Sprachen Entwicklung wissensbasierter Systeme .......................................... 5
Prolog .................................................................................................... 5
Lisp ....................................................................................................... 8
Software und Projekte ................................................................................. 9
YVE ....................................................................................................... 9
orisabase................................................................................................ 9
Brainware............................................................................................. 10
CAS Computer Aided Security ............................................................... 10
Prolog-Interpreter SWI-Prolog ................................................................. 10
UfaSoft Lisp .......................................................................................... 11
Projekt: Regelbasierte Generierung musikalischer Strukturen in der KI-Sprache
Prolog .................................................................................................. 13
PureData eine grafische Programmiersprache zur Erzeugung von Klang ...... 14
Verwandte Arbeiten................................................................................... 14
Zusammenfassung .................................................................................... 15
Literatur .................................................................................................. 15

3. KI Sprachen und Tools
Erhard Dinhobl Seite 3 von 16
Kurzfassung
Der eine oder andere wird vielleicht schon einmal mit Programmiersprachen der
Künstlichen Intelligenz etwas ausprobiert oder gearbeitet haben. Und derjenige wird
wissen, dass es sich hierbei nicht unbedingt um die herkömmliche prozedurale
Programmierung handelt. Vor allem die deklerative Programmierung bietet Aspekte,
die durch das Implementieren des ersten kleinen Programms gleich zu mehr Ideen
führt. Man beschreibt hier Verständnisdomänen mit Hilfe von Regeln, welche dann
von Interpreter ausgewertet werden. Daten werden hier direkt im Sourcecode
geschrieben und werden auch dementsprechend gehandhabt. Somit ist es möglich
Sourcecode während der Laufzeit zu erzeugen. Die Maschine kann also gewonnenes
Wissen erlernen und somit sich selbst erweitern. Diesen Aspekt nutzt man bei der
Programmierung von Expertensystemen (auch Intelligente Systeme, XPS) welche
maschinell lernen sollen.
Einleitung
Diese Arbeit soll einen Überblick über Programmiersprachen und im speziellen dann
noch über Sprachen der KI geben. Wichtig war mir dabei die praktische Benützung
dieser Sprachen und ich wollte das jonglieren mit Formeln und Rechnungen
vermeiden. Es soll somit auch eine kleine Basis und Einführung in die KI-
Programmierung mit Prolog und Lisp geben, um sich mit der Materie ein wenig
vertraut zu machen und somit ein paar anfängliche neurale Verbindungen in seinem
Gehirn zu schaffen.
Zu Anfang werde ich etwas über die Programmiersprachen im Allgemeinen erzählen
und die Fakten nennen, die man in Geschichtsbüchern über Computer normalerweise
nicht hört.
Im zweiten Kapitel möchte ich ein paar Grundlagen über die Entwicklung von
Expertensystemen erklären und die KI-Programmiersprachen Prolog und Lisp mit
praktischen Beispielen vorstellen.
Zuletzt werde ich die Funktionen von ein paar Intelligenten Systeme am Markt kurz
erklären. Da ich ein musikbegeisterter Mensch bin, möchte ich der Arbeit auch eine
ganz persönliche Note geben und Projekte, die Musik und KI verbinden, präsentieren.
Die Geschichte der Programmiersprachen und deren
Umgebungen
Erste Ideen der Programmierung von Rechnern kamen von Charles Babbage, welcher
1823 die Difference Machine und 11 Jahre später die Analytical Engine entwickelte.
Diese Maschinen wurden nie fertig gestellt. Babbage kannte noch keine
Programmiersprachen sondern dachte in simplen Maschineninstruktionen.
Die erste auf Basis des Binärsystems funktionierende Rechenmaschine war 1941 der
Z3 von Konrad Zuse. Danach entwickelte er die erste Programmiersprache der Welt
für Computer, genannt Plankalkül.
1948 veröffentlichte Claude Shannon seine Theorie über Kommunikation. Diese sollte
Ingenieuren zeigen wie man Daten zwischen Computern optimal übertragen kann.
Darin definiert Shannon auch das Bit als Grundeinheit von Daten und der
Datenverarbeitung.
1952 beendete John Backus die Entwicklung eine der ersten wirklich eingesetzten
Programmiersprachen genannt Speedcoding für den IBM 701 Rechner.
Mitte der 50er begann man definitiv in die Computerentwicklung zu investieren. So
entsprang aus der Zusammenarbeit von Bob Patrick von General Motors Research
und Owen Mock von der North American Aviation ein Betriebssystem für den IBM
704. Das hatte den Namen GM-NAA I/O System. Es stellte batch-processing zur

4. KI Sprachen und Tools
Erhard Dinhobl Seite 4 von 16
Verfügung und hatte eine bessere Prozessverarbeitung. Das hatte den Vorteil, dass
mehr Jobs in der gleichen Zeit verarbeitet werden konnten als bisher, das aber ohne
Mehrkosten. Dieses Betriebssystem wurde in ungefähr 40 Installationen verwendet.
1956 begann man am MIT (Messecheauseats Institute of Technology) die ersten
Experimente mit Direkt-Eingaben in einen Computer via des Keyboards. Dies ist
vergleichbar mit dem Eingabe-Cursor den wir alle kennen. Doug Ross schrieb im
Februar 1957 das erste Memo das durch eine Tastatur eingegeben wurde. Diese
Experimente erhielten daraufhin von vielen Seiten Unterstützung.
Kurz darauf veröffentlichte Sperry Rand, eine Frau, den kommerziellen Compiler A-0
für den Univac. (Zur Info: Das ist ein Computer von 13 Tonnen und kann 1.905
Rechenoperationen pro Sekunde durchführen, was 2,25 Mhz entspricht). Danach
folgte die Sprache Math-Matic. Die Arbeiten am A-0 und dann dem A-2 Compiler
führten zur Entwicklung von Flow-Matic. Diese war die erste Programmiersprache,
die im kaufmännischen Bereich eingesetzt wurde. Sie hatte Sprachelemente die dem
Englischen ähnlich waren. 1957 wurde auch Fortran entwickelt, welche als erste
höhere Programmiersprache gilt. Diese hatte erstmals das Schleifenkonzept
implementiert. 1959 wurde ERMA, die Electronic Recording Method of Accounting
entwickelt, welche es ermöglichte auf Schecks abgedruckte Kontennummern, welche
mit magnetischer Tinte geschrieben wurden, auszulesen.
Ein Jahr später wurde von einem Team zusammengesetzt aus Spezialisten von
Computererzeugern und dem Pentagon Cobol entwickelt. Basis hierfür waren Math-
Matic und Flow-Matic. Die Common Business Orientated Language wurde speziell für
Anwendungen in der Wirtschaft entwickelt. Sie zeichnet sich durch einfache
Lesbarkeit und große Maschinenunabhängigkeit aus. Ein Mitglied des Teams, Howard
Bromberg, hatte bereits während der Entwicklung dem Projekt einen Grabstein
ausgestellt. Jedoch können wir heute sagen, dass Cobol bis jetzt überlebt hat. 1960
wurde LISP, die erste Programmiersprache für Anwendungen der KI von John
McCarthy entwickelt, welche ich aber noch genauer behandeln werde. 1962, das
Geburtsjahr der Computerspiele. MIT Studenten programmierten SpaceWar. Ein
Display zeigte einfache Grafiken, welche Raumschiffe darstellen sollten. Die beiden
Spieler feuerten auf das gegnerische Schiff. Gesteuert wurde durch einfache
Versionen von heutigen Joysticks.
Kurz darauf wurde der ASCII American Standard Code for Information Interchange
definiert. Dieser sollte den Datenaustausch zwischen Computern von verschiedenen
Herstellern vereinheitlichen. 1964 war das Geburtsjahr von Basic. Es wurde als
einfach zu lernende Programmiersprache für Studenten am Darthmouth College
entwickelt. Danach erfolgte eine sehr rasche Entwicklung von Programmiersprachen.
1965 kamen erste Ansätze für die objektorientierte Programmierung mit Simula auf.
Man konnte damit Daten und Anweisungen in so genannte Objects gruppieren. Jedes
dieser wurde als eigenes System simuliert. 1969 wurde UNIX von Kenneth Thompson
und Dennis Ritchie in den AT&T Laboratories entwickelt. Dieses neue Betriebssystem
enthielt viele Features wie timesharing und file management, welche bereits von
Multics bekannt waren. Multics war ein Betriebssystem der 60er, welches die ersten
Ansätze von Multiuser und Multitasking hatten. UNIX erfuhr schnell einen weiten und
sicheren Status bei Ingenieuren und Wissenschaftern. Ritchie und Thompson
entwickelten Anfang der 70er auch die Programmiersprache B aus ALGOL60 und
BCPP. 1972 erfolgte dann von Ritchie die Fortsetzung zur Sprache C.
In diesem Jahr stellte auch Nolan Bushnell das Videogame Pong und die Firma Atari
video games vor. Auch Prolog, welche ich noch behandeln werde, Smalltalk,
AnsiCobol und Pascal wurden entwickelt.
In den 80ern folgten die Entwicklungen von MS-DOS und Lotus 1-2-3 und somit die
Gründungen von Microsoft und Lotus Development Corp. Weiters wurde ADA83 und
Common Lisp entwickelt und C++ zur vorherrschenden objektorientierten Sprache in

5. KI Sprachen und Tools
Erhard Dinhobl Seite 5 von 16
der Industrie. In den 90ern kamen dann schließlich die Programmiersprachen, die die
meisten kennen werden, wie Java, Visual Basic und die erst vor kurzem erschienenen
C#, J#, alle weiteren .Net Technologien und auch Ruby heraus.
Sprachen Entwicklung wissensbasierter Systeme
Eines der wichtigsten Eigenschaften unseres Geistes ist die Fähigkeit der Abstraktion.
Der Mensch abstrahiert in einem ständig wiederkehrenden Prozess Erfahrungswerte
zu formalen Ausdrücken einer höheren Ebene. Genau diese Fähigkeit erlaubt es uns
Details von komplexen Domänen zu charakterisieren und diese dann als Ganzes zu
verstehen.
Somit kann man sagen, dass man ein intelligentes System entwickeln möchte,
welches maschinell lernt. Das versucht man mit Hilfe von künstlichen Neuronalen
Netzen zu realisieren.
Um diesen natürlichen Sachverhalt wiederum zu formalisieren, hat Allen Newell 1982
die Architektur wissensbasierter bzw. intelligenter Systeme in 2 Ebenen eingeteilt.
Erstens die Symbolebene, welche sich mit der Problemstellung befasst und somit die
Formalismen für die Lösung des Sachverhalts bereitstellt. Als zweites die
Wissensebene, welche das Wissen, also die Daten des Programms und die
Verwendung des Wissens enthält. Und genau diese Trennung zwischen Steuerung
und Wissen ermöglicht es dem Programmierer mehr auf die Effizienz, Einfachheit,
Optimierung und der gleichen, des Programms einzugehen. Weiters wird auch immer
wieder versucht, möglichst kosteneffektiv Informationssysteme zu entwickeln. Das
heißt man versucht zum Beispiel Codes wieder zu verwenden. Deshalb werden so
genannte Expertensystemshells hergestellt, welche Lösungen für ein Problem zur
Verfügung stellen. Im günstigsten Fall muss man dann bei der Entwicklung eines
neuen Systems nur die Wissensbasis neu aufbauen. Da diese Shells nur sehr
unflexibel gegenüber weiteren Anforderungen an das System sind, werden so
genannte Shell-Baukästen erzeugt, welche die Probleme in Teilkomponenten lösen.
Diese sind austauschbar und erweiterbar. Nun zur Praxis. Womit programmiert man
ein intelligentes System?
Wie alles in der Informatik ist auch die KI einer ständigen Weiterentwicklung und
Erweiterung unterzogen. Anfangs waren die am häufigsten verwendeten
Programmiersprachen Prolog und Lisp. Aber aufgrund von Druck auf die
Softwareindustrie durch Entwicklungsstandards und Bedingungen führte dies zur
Entwicklung von Expertensystemen in anderen Sprachen wie Smalltalk, C, C++ oder
Java. Jedoch kann man auch heute Prolog und Lisp vom Programmiersprachenmarkt
der KI nicht wegdenken und sie werden sowohl in der Industrie als auch im
akademischen Bereich eingesetzt. Auch sind praktische Kenntnisse in diesen
Sprachen für KI-Programmierer unerlässlich. Kommen wir zu
Prolog
Diese Sprache gehört zu den deklerativen und ist die Abkürzung für Programing
with logic . Sie wurde um 1972 von Alan Colmerauer und der Groupe d'Intelligence
Artificielle de Luminy entwickelt. Mitte der 70er kam der erste lauffähige Kompiler
für Prolog heraus. Dieser wurde von David Warren entwickelt.
In der KI wird nicht nur versucht, menschliche Intelligenz zu simulieren, sondern
auch menschliche Sprache am Computer zu analysieren, zu verstehen und zu
simulieren. In Zukunft wird, vermute ich, auch die Kommunikation mit dem
Computer auf natürlicher Sprache basieren und somit auch passieren. Prolog eignet
sich dafür sehr gut, mit Hilfe von linguistischen Theorien natürlichsprachliche
Kommunikation in die Praxis umzusetzen. Weitere nennenswerte Anwendungsgebiete
von Prolog sind: Expertensysteme, Wissensverarbeitung, Spiele, symbolische

6. KI Sprachen und Tools
Erhard Dinhobl Seite 6 von 16
Mathematik, Prototyping, Constraint-Programmierung und Deduktive Datenbanken
(Unterschiede zu relationalen DB s sind: sie sind abstrakter, somit muss sich der
Benutzer um Joins, Selektionen und Projektionen keine Gedanken machen, sie sind
mächtiger und Daten die mit Daten berechnet werden, gelten ebenfalls als Daten).
Prolog beruht auf der Prädikatenlogik der Mathematik. (Zur Info: Aussagen lassen
sich in der Prädikatenlogik mithilfe von Junktoren und Quantoren verknüpfen und
definieren). Somit ist eine oft gebräuchliche Technik nicht anwendbar. Nämlich: x =
x + 1, also das Inkrement von Variablen. Denn eine in der Prädikatenlogik
gebundene Variable kann KEIN zweites Mal an einen anderen Wert gebunden
werden.
Gehen wir zum ersten Beispiel, welches KEINE Hello-World -Anwendung ist, wie in
vielen Programmiersprachen. Sondern es wird eine Datenbasis angelegt und danach
Anfragen an den Interpreter gestellt. Dieser versucht eine Antwort yes oder no
mithilfe der gespeicherten Daten abzuleiten. Ist diese positiv kann man die Aussage
als logisch ableitbar aus den vorhandenen Daten betrachten.
Das Beispiel:
auto(polo).
auto(jazz).
auto(civic).
motorrad(valkyrie).
firma(honda).
firma(vw).
hersteller(vw, polo).
hersteller(honda, civic).
hersteller(honda, jazz).
hersteller(honda, valkyrie).
Jetzt stellen wir Anfragen an den Interpreter:
?- auto(polo).
yes
?- auto(golf).
no
Tja Golf ist in den Daten nicht gespeichert, deshalb erhalten wir no . Weiters ist in
Prolog jeder Token der mit einem Grossbuchstaben beginnt eine Variable. z.B.:
X=honda;
In Prolog kann man auch Regeln mithilfe des :- -Regeloperators definieren. Wir
definieren jetzt eine Regel, welche überprüft ob ein Motorrad und ein Auto vom
selben Hersteller ist:
selberhersteller(X,Y) :-
hersteller(H,X),
hersteller(H,Y).
Hier kann man schon einen weiteren Operator erkennen. Nämlich das und welches
in der Prädikatenlogik ^ ist und hier in Prolog ein Beistrich , .. Weitere Operatoren
sind ; für v (Oder) :- für <- (Implikation, der Regeloperator umgedreht,
also wenn, dann) und not für (Nicht). Stellen wir jetzt die Anfrage:

7. KI Sprachen und Tools
Erhard Dinhobl Seite 7 von 16
?- selberhersteller(valkyrie,jazz).
yes
?- selberhersteller(X,civic).
X=civic
X=jazz
X=valkyrie
Während in den prozeduralen Programmiersprachen Rekursionen oft nur eine
Vereinfachung iterativer Problemlösungen bietet und Listen ein Nebenprodukt sind,
ist z.B. ersteres die einzige Möglichkeit in Prolog Schleifen zu implementieren. Somit
ist auch der Verlust des Inkrement einer Zahl x = x +1 schmerzfrei zu ertragen,
denn dies wird ja hauptsächlich in Schleifen verwendet.
Beispiel:
mann(adam).
mann(tobias).
mann(frank).
frau(eva).
frau(daniela).
frau(ulrike).
vater(adam,tobias).
vater(tobias,frank).
vater(tobias,ulrike).
mutter(eva,tobias).
mutter(daniela,frank).
mutter(daniela,ulrike).
elternteil(X,Y) :-
mutter(X,Y);
vater(X,Y).
vorfahr(X,Z) :-
elternteil(X,Z).
vorfahr(X,Z) :-
elternteil(X,Y),
vorfahr(Y,Z).
Listen sind ebenfalls ein Hauptbestandteil von Prolog. Beispiele:
erzeugungen(vw,auto,[polo,golf]).
erzeugungen(suzuki,motorrad,[vanvan,bandit]).
Falls jemand Interesse hat, die Beispiele wurden mit dem Open-Source Prolog-
Interpreter SWI-Prolog erhältlich auf http://www.swi-prolog.org ausprogrammiert.
Kommen wir zu

8. KI Sprachen und Tools
Erhard Dinhobl Seite 8 von 16
Lisp
Wie schon erwähnt, wurde Lisp in den 60ern von John McCarthy entwickelt. Er lebt
noch und ist Dozent an der Uni Stanford.
In den 70ern kamen Lisp-Maschinen auf. Dies waren Computer die Lisp-Programme
direkt in ihrer Hardware ausführen konnten. Sie wurden am MIT im AI Laboratorium
realisiert. Damals mit dabei war Richard Stallman, Gründer des GNU-Projektes. Kurz
darauf wuchsen die Firmen LMI und Symbolics, welche die LISP-Maschinen und
deren Software weiterentwickelten und vermarkteten aus dem Boden. Jedoch
entstand in diesem Duo ein Konkurrenzkampf, in dem Symbolics die Führung
übernahm. Dies war aber nur deshalb möglich, solange die DARPA den Ankauf von
LISP-Maschinen im Rahmen des Star-Wars Projektes unterstützte. Die DARPA, früher
ARPA, Defense Advanced Research Projects Agency, die Entwickler des ARPANET, ist
eine Agentur des Pentagons, welche Hightech-Projekte für das Militär durchführt.
Während dieser Zeit entwickelten Xerox und TI ihre eigenen Maschinen und stellten
diese auf den Markt. Jedoch verdrängten die aufkommenden Unix-basierenden und
dadurch viel billigeren Sun Workstations vergleichbare Modelle von anderen
Herstellern vom Markt.
Während der Weiterentwicklung von LISP entstanden nicht auch aufgrund von
ständiger Standardisierung viele Dialekte. Historisch nennenswerte sind MACLISP,
INTERLISP sowie das Standard LISP von A.C. Hearn. Der heutige Standard heißt
Common Lisp und ist durch Einfluss der Lisp-Maschinen und deren Sprachstandards
entstanden.
Diese Programmiersprache gehört zu den prozeduralen Sprachen, wie C++ oder
Visual Basic. Somit wird ein Algorithmus programmiert. Also nicht wie in deklerativen
Sprachen (vgl. Prolog) wo Aussagen geschrieben werden, welche Zusammenhänge in
einer Aktionsdomäne definieren. Um es aber ganz genau zu sagen ist LISP im
Gegensatz zu den sonst bekannten prozeduralen Sprachen funktional. D.h. Syntax
und Semantik sind aus der mathematischen Theorie rekursiver Funktionen
abgeleitet. Genau diese Art der Programmierung in Kombination mit der reichen
Anzahl an vorhandenen Werkzeugen für die Erstellung von symbolischen
Datenstrukturen macht LISP so beliebt. Die Hauptanwendungsgebiete sind die
Entwicklung von KI-Werkzeugen, die Erstellung und der Test von Prototypen und
deren Systeme und die Implementierung von Suchalgorithmen und Interpretern.
LISP durchläuft heute einen mehr als 40jährigen Entwicklungsprozess. Nun zur
Sprache selbst. Grundlegende syntaktische Einheiten sind die LISP-Atome. Das sind
eine Verkettungen von alphanumerische Symbolen und Sonderzeichen. Beispiele:
14.5782, 1000, ein-bindestrich-wort, *eine-markierung*. Weiters
gibt es Listen, welche eine Folge von Atomen sind: (1 3 5 7), (vw(polo,
golf), honda(civi, jazz)). Wie jede Programmiersprache kann auch LISP
Rechenoperationen durchführen. Nur gehe ich deshalb darauf ein, weil es sich nicht
um die Infixnotation 4 + 5 , also den Operator in der Mitte stehend, die
herkömmliche Schreibweise handelt, sondern es arbeitet mit der Präfixnotation. Zum
Beispiel + 4 5 . (Zur Info: Es gibt noch die Postfixnotation: 4 5 + ).
Um nun jetzt komplexere Ausdrücke zu Formulieren, wie (4 + 5) * (5 + 2) bedarf
es einfach nur ein wenig Umdenken zu (* (+ 4 5) (+ 5 2)) . Lisp verlangt Klammern
am Anfang und am Ende. Stellen wir solche einfachen Ausdrücke dem Interpreter, so
werden wir das Ergebnis bekommen, in unserem Fall 63 . Lisp versucht hier also
den Ausdruck (x y z) als (f x y) zu interpretieren, also als Funktion mit den
Parametern x und y. Somit darf das aber nicht mit den vorhin genannten Listen
verwechselt werden, welche ja von der gleichen Form sind. Was ja eigentlich
durchaus möglich wäre. Um diese Verwechslung zu vermeiden stellt Lisp hierfür die
quote Funktion zur Verfügung, welche man vor eine Liste schreibt, damit diese

9. KI Sprachen und Tools
Erhard Dinhobl Seite 9 von 16
nicht ausgewertet wird. Zum Beispiel: (a b c) und als Ergebnis erhalten wir (a
b c). Würden wir nur (a b c) dem Interpreter vorwerfen, so würden wir
Error: invalid function a erhalten, vorausgesetzt es gibt keine Funktion
a.
Jetzt programmieren wir eine Funktion, die den Absolutwert also den Betrag einer
Zahl x liefert:
(defun absolut-val (x)
(cond ((< x 0) (* x -1))
((>= x 0) x)))
Und dann der Aufruf:
> (absolut-val -2)
2
Unter Lisp gibt es dann noch eine Besonderheit, nämlich: ( ) die leere Liste,
welche sowohl als Liste als auch als Atom angesehen werden. Es trägt dem Namen
nil. Wer Interesse an der LISP-Programmierung hat, findet einen Lisp-Interpreter
unter http://www.ufasoft.com/lisp. Er ist sehr sehr instabil und kostet trotzdem
Geld. Ich verwendete die Demoversion!
Weitere nennenswerte Sprachen der KI sind Haskell, ML (Abk. MetaLanguage) bzw.
deren Dialekte, Gödel, Mercury und SNOBOL auch bekannt unter ICON.
Kommen wir nun zu bereits vorhandener
Software und Projekte
Die am Markt vorhandenen Expertensysteme sind zum größten Teil für Produktion,
Analyse und Warenwirtschaft, Videokameraüberwachung (Computer Aided Security
kurz CAS) und Simulation Neuronaler Netze entwickelt. Als Beispiele:
YVE
Your Variant Engineer ist ein wissensbasiertes System welches Unternehmenswissen,
Berechnungs- und Konstruktionsregeln sowie Konstruktionselemente speichert und
auf die man zugreifen kann und verwenden kann. Dabei werden Erfahrungswerte,
Formeln, Vorschriften und Tabellen erfasst und in Workflows umgesetzt. Die
Workflows sind die Formalisierungen der Prozesse die zu einem Ergebnis führen; wie
fertig konstruiertes Produkt oder ähnliches. Den Preis konnte ich nicht eruieren!
orisabase
ist eine objektorientierte und regelbasierte Entwicklungsumgebung. Ihre Stärke
besteht darin, dass die Verwaltung von objektorientierten Daten und die Daten selbst
sowie die Entwicklung in einer Umgebung vereinheitlicht werden. Es wird bei
Analyse-, Diagnose-, Simulations- und Optimierungsentwicklungen verwendet. Diese
Software gibt es seit 1996, ist rund 200-mal installiert worden und hat einen Preis
von 2500 Euro zzgl. Mwst., Speicherbedarf 50 MB. Diesen objektorientierten Ansatz
der Wissensrepräsentation nennt man Framesystem. Dabei werden Situationen durch
ein Gerüst, ein Frame, beschrieben. Dieses hat die üblichen, möglichen
Eigenschaften der Situation und ist somit eine abstrakte Beschreibung dieser. Durch
zuweisen der Eigenschaften entsteht daraus eine Instanz, also eine spezielle
Situation.

10. KI Sprachen und Tools
Erhard Dinhobl Seite 10 von 16
Brainware
ist ein Tool zur Entwicklung von Software auf Basis von künstlicher Neuronaler
Netze. Es wird für kommerzielle, technische und wissenschaftliche Problemlösungen
herangezogen und kann auch in Ergänzung zur Fuzzy-Logic eingesetzt werden.
Anwendungsgebiete sind Einkauf, Medizin, Sicherheitswesen,
Bilderdatenverarbeitung, Mustererkennung und Steuer- und Regelungstechnik. Diese
Software wurde 7-mal installiert, ist seit 1995 auf dem Markt, hat einen Preis von
3000 Euro zzgl. Mwst. und benötigt 10 MB an Festplattenspeicher.
CAS Computer Aided Security
Diese Software dient zur Auswertung von Videodaten, welche von Videokameras
kommen, die in Sicherheitsrelevanten Bereichen installiert sind. Darunter fallen vor
allem Bankfoyers, Botschaften, Flure, Museen usw. Es bewertet gezielte statische
Veränderungen im Sichtfeld. Es ist also kein Bewegungsmelder, da sich ja Personen
dort bewegen können und auch somit am Sinn vorbei gehen würde. Es sollte sich
daher bei Ereignissen wie Diebstahl, Zurücklassen von Gegenständen, Vandalismus
oder Übernachtungsgästen melden. Es sollte auch bei Sabotage an den Kameras
wie Verdrehen, Abdecken, Blenden oder Defokussieren bellen. Diese Software ist seit
2003 am Markt.
Prolog-Interpreter SWI-Prolog
Ich möchte hier auch den Prolog-Interpreter, mit dem ich gearbeitet habe,
vorstellen.
Hier der Startschirm, wo man dem Interpreter Anfragen geben kann.
Dann eine neue Datei mit File / New angelegt und es öffnet sich der normale
Windowseditor:

11. KI Sprachen und Tools
Erhard Dinhobl Seite 11 von 16
Das Beispielprogramm von vorhin eingetippt und den Editor geschlossen. Über File /
Consult die Datei dem Interpreter zum laden gegeben und dann meine Anfragen
gestellt.
Und der
UfaSoft Lisp
Interpreter. Man sieht den Dialog Terminal , welcher die Eingabemaske für die
Anfragen enthält. Funktion eingetippt

12. KI Sprachen und Tools
Erhard Dinhobl Seite 12 von 16
Und dann kann man die Anfragen an den Interpreter stellen:

13. KI Sprachen und Tools
Erhard Dinhobl Seite 13 von 16
Projekt: Regelbasierte Generierung musikalischer Strukturen in der
KI-Sprache Prolog
An der Universität in Osnabrück, hat die Forschungsstelle für Musik- und
Medientechnologie in Zusammenarbeit mit dem Institut für Computerlinguistik und
Künstliche Intelligenz dieses Projekt ins Leben gerufen. Basis hierfür war das bereits
vorhandene Wissen über die KI-Forschung der Beschreibung und des Verstehens von
gesprochener Sprache. Die dabei aufgestellten Abstraktionen und die Erfahrungen
der Analysen semantischer und syntaktischer Strukturen wurden adaptiert und auf
die Musik angewandt, da hierbei vergleichbare Phänomene anzutreffen sind. Diese
somit entstandene formale Beschreibung der Musik wurde verwendet, um diese zu
generieren. Dazu wurde ein System geschaffen, welches in der Lage war nach
bestimmten Regeln stilistisch und musiktheoretisch akzeptable Kompositionen zu
spielen. Angeregt durch das Großprojekt LILOG, wurden viele verschiedene
Programme geschrieben, welche in ihrem Zusammenspiel in der Lage waren,
musikalisch anhörbare Blues-Improvisationen zu erzeugen und über MIDI
abzuspielen. (Zur Info: LILOG ist ein System welches Tourismustexte ansatzweise
versteht, den Inhalt repräsentieren und Fragen zum Inhalt beantworten kann) Es
gibt auch weitere Regelbasen für andere Musikstile. Zum Beispiel vierstimmige
Choräle, Volkslieder und auch für aleatorische Kompositionen, also zufällige. In
diesem Vorgang der Regelbasenerzeugung wurden musiktheoretische Grundlagen für
Musikstile erfasst und in Regeln umgesetzt und implementiert. Wird ein sinnvolles
Werk erzeugt, können weiters die Regeln als Wissensbasis für die Musikanalyse
verwendet werden.
Ich habe keinen Einblick in den Source-Code, könnte mir aber einen kleinen Ansatz
so vorstellen.
Ein Musikstück besteht aus Rhythmus, also den Notenwerten, und Noten.
Somit definieren wir Rythmusdaten: (bleiben wir beim 2/4-Takt)
rythm(1/2, [1/2]).
rythm(1/2, [1/4, 1/4]]).
rythm(1/4, [1/8, 1/8]).
rythm(1/2, [1/8, 1/8, 1/8, 1/8]).
Und wir definieren Klangdaten, also Noten:
sound(1/2, [p, g0, g0, g0]).
sound(1/2, [dis0]).
sound(1/2, [p, f0, f0, f0]).
sound(1/2, [d0]).
Somit können wir hier folgendes Ableiten:
Wer es kennt: Motiv aus Beethoven s Sinfonie Nr. 5
Hier wäre dann die einfachste Variation dieses Motivs zum Beispiel die halbe Note
durch 2 viertel zu substituieren.
In Hinblick auf die Zukunft wollen die Mitarbeiter des Projekts nicht nur Erfahrungen
sammeln um eine Software zur automatischen Musikanalyse zu entwickeln sondern
auch um Kenntnisse auf die computerlinguistische Forschung anzuwenden.

14. KI Sprachen und Tools
Erhard Dinhobl Seite 14 von 16
PureData eine grafische Programmiersprache zur Erzeugung von
Klang
PureData ist eine grafische Programmiersprache und wurde 1990 von Miller Puckett
entwickelt. Sie wird fast ausschließlich im Bereich der Lehre und Kunst verwendet
und dient zur Erzeugung interaktiver Computermusik. Ein implementiertes
Programm, ein so genannter Patch, besteht aus Objekten, Datenströmen, Messages,
Subpatches und Arrays. Aufgrund von verändernden Werten und mit den Objekten
definierten Regeln wird ein bestimmter, variierender Klang erzeugt. PureData ist
Open-Source. Wer Interesse hat: http://www.puredata.org
Ein Beispielpatch:
Die Musik die dabei entsteht ist ganz bestimmt kein 100%iger Hörgenuss, jedoch
interessant.
Verwandte Arbeiten
In diesem Kapitel möchte ich noch ein paar empfehlenswerte Arbeiten bzw. Bücher
angeben, welche sich ebenfalls mit diesem Thema befassen. Natürlich konnte und
kann ich durch dieses kleine Projekt keine Programmiersprachen vollständig
beschreiben und erklären, jedoch denke ich, bildet sie ein kleines Fundament um mit
der Materie der Implementierung von XPS vertraut zu werden.
Verwandte Arbeiten:
Paradigms of Artificial Intelligence Programming , Peter Norvig, Morgan
Kaufmann Publishers Inc., 2001
Künstliche Intelligenz Strategien zur Lösung komplexer Probleme , George
F. Luger, Addison-Wesley, 2001
Logic Programming with Prolog , Max Bramer, Springer Verlag, 2005

15. KI Sprachen und Tools
Erhard Dinhobl Seite 15 von 16
Prolog Programming for Artifical Intelligence , Ivan Bratko, Addison-Wesley,
2000
Practical Common Lisp , Peter Seibel, Apress, 2005
Zusammenfassung
Als Schlusswort möchte ich die Punkte herausnehmen, welche ich als wichtig
erachte, zu wissen. Die wären: Die erste Programmiersprache der Welt war
Plankalkül, 1941 von Konrad Zuse. 1948 definiert Shannon das Bit. Eine Frau, Sperry
Rand entwickelte 1957 die erste Programmiersprache für die Wirtschaft. Die KI-
Programmierung kam in den 60ern auf und teilt die Anwendungen in 2 Ebenen,
Symbolebene und Wissensebene. Die wichtigsten Sprachen sind Lisp und Prolog.
Wobei letzteres vom programmiertechnischen Aspekt her, sicher interessanter ist.
John McCarthy entwickelte Lisp und Alan Colmerauer Prolog. Letztere eignet sich
sehr gut für Sprachausgabe und Analyse. Die Expertensysteme auf dem Markt sind
für Produktion, Analyse und Warenwirtschaft, CAS und Simulation Neuronaler Netze.
Literatur
Systeme und Sprachen der KI
www.aaai.org/AITopics/html/sys.html
Geschichte der Programmiersprachen
www.computerhistory.org/timeline/timeline.php?timeline_category=sl
Fachgruppe "Deklerative Sprachen" der Gesellschaft für Informatik eV
wdp.first.gmd.de:8080/geske/fg111/
Lisp Dialekte/Geschichte/Code Samples/Lispsysteme/
www.aviduratas.de/lisp/
Prolog Codesamples/Aufbau
www.uni-hildesheim.de/~chlehn/p_ueb/probuch.pdf
www.ifi.unizh.ch/req/courses/logische_programmierung/
ws03/documents/Prolog_Tutorial.pdf
Prolog Historische Entwicklung
www-i2.informatik.rwth-aachen.de/
Teaching/Course/LP/2003/Folien/folien03-3.pdf
http://kti.ms.mff.cuni.cz/~bartak/prolog/contents.html
Türme von Hanoi in Lisp
www.apl.jhu.edu/~hall/lisp/Hanoi.lisp
Programmierparadigmen/deskriptive Programmierung
www.informatik.uni-bonn.de/III/lehre/
vorlesungen/Informatik_I/WS01/Folien/endversion/E.pdf
www.cs.uni-bonn.de/III/lehre/vorlesungen/
DeskriptiveProgrammierung/SS00/Druckvorlagen/pdf/dsp21.pdf
Bücher:
Programmieren Neuronaler Netze eine Turbo Pascal Toolbox , Hilger
Kruse, Roland Mangold, Bernhard Mechler, Oliver Pengler, Addison-Wesley,
1991

16. KI Sprachen und Tools
Erhard Dinhobl Seite 16 von 16
Robotor und common sense , Duelen Gerard, McCarthy John, Heidelberg:
Spektrum d. Wiss., 1986
Brainware
www.softguide.de/prog_z/pz_0232.htm
Software, Open Source Projekte
www.aaai.org/AITopics/html/soft.html
Projekt: Regelbasierte Generierung musikalischer Strukturen in der Sprache Prolog
bird.musik.uni-osnabrueck.de/cgi-
bin/as_web.exe?projects.ask+B+Regelbasierte
Software-marktplatz.de (Liste von Expertensystemen wie Brainware, Con4pro,
Help2Know, Statistica Neural Networks und deren Hersteller)
www.software-marktplatz.de/45000000-software-kuenstliche-intelligenz-
expertensysteme-wissensbasierte-systeme.html
Weitere Software und Interessantes
pd-graz.mur.at (PureData Projekt: Miller Puckette s grafische
Programmiersprache zur Erzeugung von Klang, Grazer Community)
www.ufasoft.com/lisp/ (UfaSoft Common Lisp Interpreter)
pakmed.net (PakNeuro: neurologisches Assessment Tool)

17. This document was created with Win2PDF available at http://www.win2pdf.com.
The unregistered version of Win2PDF is for evaluation or non-commercial use only.