Künstliche Intelligenz - Sprachen und Tools

KI Sprachen und Tools

Autor: Erhard Dinhobl


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



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



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



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



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:



?- 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

http://www.swi-prolog.org



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



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.

http://www.ufasoft.com/lisp



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:



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



Und dann kann man die Anfragen an den Interpreter stellen:



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.



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

http://www.puredata.org



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

http://www.aaai.org/AITopics/html/sys.html

http://www.computerhistory.org/timeline/timeline.php?timeline_category=sl

http://www.aviduratas.de/lisp/

http://www.uni-hildesheim.de/~chlehn/p_ueb/probuch.pdf

http://www.ifi.unizh.ch/req/courses/logische_programmierung/

http://kti.ms.mff.cuni.cz/~bartak/prolog/contents.html

http://www.apl.jhu.edu/~hall/lisp/Hanoi.lisp

http://www.informatik.uni-bonn.de/III/lehre/

http://www.cs.uni-bonn.de/III/lehre/vorlesungen/



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)

http://www.softguide.de/prog_z/pz_0232.htm

http://www.aaai.org/AITopics/html/soft.html

http://www.software-marktplatz.de/45000000-software-kuenstliche-intelligenz-

expertensysteme-wissensbasierte-systeme.html

http://www.ufasoft.com/lisp/

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.

http://www.win2pdf.com

Künstliche Intelligenz - Sprachen und Tools

Documents

Transcript of Künstliche Intelligenz - Sprachen und Tools