Erweiterte Watibar

In Matlab fängt man mit Progressbars eigentlich recht simpel an. Und dann wirds größer und man will Informationen unterbringen, zum Beispiel wieviel Zeit vergangen ist, wieviel noch verbleibt, diverse Zwischenstände. Und wenn erst einmal für eine Funktion eine solche komplexe Waitbar erstellt hat, möchte man sie auch weiterverwenden, austauschen, konfigurieren, etc.

Wie man das recht gut, objekt-orientiert und elegant mit Event-Listeners in Matlab realisieren kann, versuche ich mal im Folgenden an Hand eines simplen Beispiels zu demonstrieren…
Matlab bringt bereits eine recht einfache, aber gute Fortschrittsanzeige mit, die mit waitbar aufgerufen wird, und für jede Iteration aktualisiert werden kann.

Man hätte also in etwa mit folgenden Code eine schnelle, schlanke Lösung

for r=1:obj.rounds
   obj.performance = obj.computePerformance;
   waitbar(r/obj.rounds)
end

Für einfache, wirklich kurze Programme funktioniert das sehr gut. Aber man wird schon relativ häufig feststellen, dass Programme sehr schnell unübersichtlich und groß werden. Und hier wird man schnell einige Nachteile dieses Vorgehens feststellen:

• Man erweitert die Waitbar um weitere Inhalte (z.B. abgelaufene Zeit) und hat recht komplexen Code. Dabei möchte man diese Progress-Bar vielleicht auch für andere Vorgänge nutzen – man möchte aber redundanten Code vermeiden
• Man möchte die Waitbar gegen eine andere austauschen, oder statt einer GUI-basierten Fortschrittsanzeige eine textuelle Ausgabe, wenn man die Funktion per Kommandozeile auruft – Oder beides gleichzeitig, oder komplett deaktivieren…
• Die Funktion, die die Schleife ausführt soll eigentlich nicht GUI-Dinge, Benutzerausgaben abwickeln. Außerdem macht der zusätzliche Code die Funktion unleserlich – Es scheint irgendwie intuitiv nicht richtig so, es sollte gekappselt sein.

Was man hier möchte ist eine seperate Funktion, die benachrichtigt wird bei jedem Schleifendurchlauf, um einen Fortschrittsbalken (welcher Art auch immer) zu aktualisieren. Und die eigentlich Funktion hat nichts weiter mit der Realisierung zu tun, außer ein solches notify zu senden.

Das sind Events und Eventlistener. Und sowas gibts schon in Matlab – sofern man objekt-orientiert entwickelt. Folgendes Beispiel demonstriert die Funktionsweise – der Cycler ist ein Objet, dass eine bestimmte Operation iteriert, und eine Performance berechnet:

classdef cycler < handle
 
    properties (SetAccess = protected)
        rounds = 20;
    end
 
    properties (GetAccess = public)
        performance = 0;
        actualRound;
    end
 
    events
        cycle;
    end
 
    methods
 
        function rounds = getRoundCount(obj)
           rounds = obj.rounds;
        end
 
        function runCycles(obj)
            for r=1:obj.rounds
                obj.performance = obj.computePerformance;
                obj.actualRound = r;
                notify(obj,'cycle');
            end
        end
 
        function perf = computePerformance(obj)
            % some magic calculation
            pause(0.35)
            perf = rand;
        end
    end
end

Zunächst kommt eine Reihe von Properties. Zum Beispiel soll auch die aktuell laufende Runde in einer Variable abgelegt werden, die man zum Beispiel auch für die Progressbar als zusätzliche Information nutzen könnte.
Interessanter sind hier events. In diesem Fall gibt es nur ein Event: cycle. Es soll nach jeder Iteration ein Event cycle gesendet werden. Und das ganze passiert in der Methode runCycles. Diese Schleife sieht genauso aus wie in dem simplen Beispiel oben, aber mit dem Unterschied:

notify(obj,'cycle');

Hier wird einfach nur ein notify auf dem Objekt aufgerufen.
Nur schauen wir uns an, wie man eine solche Waitbar realisieren kann:

classdef CyclerProgressBar < handle
 
    properties (SetAccess = protected)
        Start;
        h;
    end
 
   methods
      function obj = CyclerProgressBar(cycler_obj)
         obj.h = waitbar(0, 'Please Wait', 'Name', 'Running Cycles');
         posi = get(obj.h,'Position');
         posi(4) = posi(4) + 100;
         set(obj.h,'Position',posi);
         addlistener(cycler_obj, 'cycle',@(src,evtdata)handleEvnt(obj,src,evtdata));
         obj.Start = tic;
      end
 
      function delete(obj)
         delete(obj.h);
      end
 
      function handleEvnt(obj,src,evtdata)
           timer = toc(obj.Start);
           obj.h = waitbar(src.actualRound/src.getRoundCount, obj.h, ...
           sprintf('Validation Round %d (%d)\n\n Performance:\nThis iteration: %3.1f  %%\n\nTime: \nRemaining: %4.0f sec. - Elapsed: %4.0f sec.\n\n',...
           src.actualRound, src.getRoundCount, ...
           src.performance*100,...
           (timer/src.actualRound)*(src.getRoundCount-src.actualRound), timer));
      end
   end
end

Der Konstruktor erstellt direkt die in Matlab gewohnte Waitbar (man könnte dies evlt. auch später machen oder über eine seperate Funktion). Um nun in der Waitbar mehrere Zeilen Text unterbringen zu können, vergrößert man diese mittels GUI-Properties:

         posi = get(obj.h,'Position');
         posi(4) = posi(4) + 100;
         set(obj.h,'Position',posi);

Der Konstruktor bekommt direkt das Objekt mit übergeben, auf das er horchen soll. Ein bißchen tricky war in diesem die Funktion addListener zu modifizieren, damit die Progressbar sich aus dem Objekt, auf das es horcht, weitere Informationen (wie z.B. Performance) ziehen kann und diese mit ausgibt. Wenn man einen Blick in die Beispiele der Matlab-Doku wirft, findet man meist so etwas hier:

addlistener(toggle_button_obj,'ToggledState',@RespondToToggle.handleEvnt);

Was ich eigentlich wollte, ist das Objekt (oder etwas anderes) mit übergeben. Hierfür macht man sich die Funktionaltität anonymer Funktionen zu nutze:

addlistener(cycler_obj, 'cycle',@(src,evtdata)handleEvnt(obj,src,evtdata));

Nun kann die Funktion handleEvent das Objekt, dass das notify ausführt, mit übergeben bekommen.
in Timer mit wird mittels tic zum einen Timer gestartet und die Startzeit abgelegt, damit wäre der Konstruktor fertig.
Bei jedem notify wird nun handleEvent aufgerufen. Dabei checkt man mit toc die abelaufene Zeit. Und nun kann ich mit Hilfe von sprintf und weil ich das Waitbar-Fenster vergrößert habe, jede Menge Informationen ausgeben, wie Uhrzeit und Performance.
Der EventListener muss nun nur noch registiert werden:

demoCycler = cycler;
demoBar = CyclerProgressBar(demoCycler);
demoCycler.runCycles;
delete(demoBar);

Denkbar wären, wie bereits zuvor erwähnt, nun auch weitere Progressbars, die anderen Text enthalten, oder eine zusätzliche textuelle Ausgabe (was ich mal aus Faulheit hier jetzt nicht mehr gecodet habe ).

Sicherlich sind Eventlistener in Matlab nicht so flexibel wie in Java, doch sie funktionieren wie in diesem Beispiel für einfach Dinge recht gut.

Das Beispiel zum Download:
AdvancedWaitbarSample (69)

string = '<html>Nicht nur Zeilenumbrüche<br>sondern zum Beispiel auch <b>fett</b> ist möglich</html>';

Aber das ist noch nicht alles, das ganze funktioniert nicht nur mit Tooltips, sondern auch mit den meisten andern GUI-Objekten, wie z.B. listbox oder Buttons. Nur mit StaticText, also simplen Labels, geht es wohl nicht. Dabei ist es unerheblich, ob man die GUI im Editor schreibt oder mit GUIDE die Werte setzt.

Und kurz nachgedacht, wenn das ganze html ist, ja, dann kann man auch Bilder und jede Menge anderen Unfug damit einbinden, z.B. einen Button mit einem Bild versehen.

So musste ich leider feststellen, dass es zwar die Möglichkeit gibt, Balkendiagramme in Matlab zu erstellen, aber eine Annotierung der x- und y-Achsenwerte beschränkt sich auf Zahlen, und ist nicht – wie ich es gern hätte – auf Strings erweiterbar ist. Das ganze läßt sich mit einem kleinen dirty fix umgehen, in dem man einfach “leere” Boxplots zusätzlich verwendet, die eine solche Art von Beschriftung unterstützen. Hier ein Matlab-Beispiel für ein horizontales Balkendiagramm:

g_ = clf;
figure(g_);
% ABCdescription enthält Strings: Beschreibungen für Gruppen von Werten A B C (A B C müssen gleich groß sein)
% zeros - 1 sorgt dafür, dass alle Werte -1 für die Boxplots.
boxplot(zeros(size(A)) - 1, ABCdescription, 'orientation', 'horizontal');
% Balkendiagramm horizontal mit barh
barh([A, B, C ,'group');
% Anpassen der x-Achse, z.B. nur Werte von 0 bis 1 -> die Boxplots bei -1 sind nicht mehr sichtbar.
set(gca,'xlim',[0 1]);
legend('A','B','C');
leginfo_ = {'Orientation', 'vertical', 'Location', 'NorthWest'};
legend(leginfo_{:});  % create legend
% nach Bedarf abspeichern und schließen
saveas(g_, 'myABC', 'png');
close(g_);

Man braucht zunächst eine Matrix mit Trainingsmustern. Ein einzelnes Muster besteht aus einem Vektor, die Vektoren zusammen ergeben dann die Muster-Matrix. Zu jedem Muster gehört zusätzlich eine Klassifizierung, bei binären Problemen (“Ist vom Muster vom A oder B?”) ist dies im Allgemeinen 1 oder 0. Somit hat man als Zielmatrix einen transponierten Vektor, für jedes Muster ein Klassifizierungswert 1 oder 0. Eine neue Instanz eine neuronalen Netzes erhält man durch:

net = newff(MusterMatrix,ZielMatrix, [10 2], {'logsig','logsig'},'trainrp','learngdm','mse');

Die ersten beiden Parameter geben somit die Muster und ihre Klassifizierung an. Man kann hierfür auch zusätzlich die Testdaten nehmen, die Muster werden in diesem Schritt nur benötigt, um die Größe der Eingabeschicht zu ermitteln, Werte zu normalisieren und eventuell die Koordinate, für die Werte in jedem Muster gleich ist, zu ignorieren (in diesem Fall wird keine Verbindung zur verdeckten Schicht erstellt).
Der dritte Paramter ist ein Zeilenvektor, in diesem Beispiel (10 2). dieser spezifiziert die Anzahl der verdeckten Schichten. Eingabeschicht und Ausgabeschicht werden wie bereits erwähnt automatisch anhand der Muster und der Sollklassifizierung ermittelt. Mit (10, 2) würde man zum Beispiel 2 verdeckte Schichten mit 10 bzw. 2 Neuronen erstellen.
Der nächste Parmater ist ein Cellarray und spezifiziert die zu nutzende Aktivierungsfunktion für jedes Netz. Die logistische Funktion (logsig) ist meist die Regel bei neuroanlen Netzen.
Dann folgenden noch 3 Strings, die Trainingsfunktion, die Lernfunktion und die Fehlerfunktion, am gebräuchlichsten ist wohl der mittlere quadratische Fehler (mse). Als Trainingsfunktion bevorzuge ich persönliche Resilient Backpropagation (trainrp), sie bezieht die Historie des Fehlergradienten mit ein und ist in der Regel performanter als Standard-Backpropagation. Standardmäßig ist die Trainingsfunktion in der Toolbox jedoch Levenberg-Marquardt Backpropagation (trainlm).
Damit hat man ein Netz erstellt, dass nun trainiert werden soll, dazu benutzt man ganz einfach train:

net = train(net,MusterMatrix,ZielMatrix);

Dabei sollte man natürlich nur Trainingsdaten nehmen. Es öffnet sich ein Fenster, dass Fortschritt und Performanz in jeder Iteration anzeigt. Anschließend kann man das Netz testen, oder für einzelne Muster auswerten:

out = sim(net, TestDaten);

out enthält anschließend vorhergesagte Werte.
Vor dem Training kann man auch noch einige Anpassungen vornehmen, z.B.

net.trainParam.showWindow = 0; % Gui nicht anzeigen, hilfreich bei automatischen tests
net.trainParam.lr = 0.1;              % Lernarte ändern
net.trainParam.epochs = 100;      % Anzahl der Trainigsdurchläufe
net.trainParam.goal = 1e-3;         % Abbruchbedingung bezüglich Fehler

Auch für das Netz kann man zahlreiche Änderungen vornehmen, wenn man zum Beispiel nicht will, dass gleiche Werte in den Mustern ignoriert werden und trotzdem Verbindungen zur verdeckten Schicht erstellt werden, kann mal folgendes machen:

ipf = {};
tpf = {};
ddf = 'dividerand';
net = newff(MusterMatrix,ZielMatrix, [10 2], {'logsig','logsig'},'trainrp','learngdm','mse',ipf,tpf,ddf);

Zur Bestimmung der Qualität erstellter Netze gibt es noch einige weitere Tools, Stichwort rocplot.
Kleiner Wehrmutstropfen ist, dass die Neural Network Toolbox manchmal sehr knapp dokumentiert ist, vor allem wenn es um kleine Parameter geht. Auch google hilft einem nicht immer weiter. Oft hilft nur probieren und mal in den Quellcode schauen.
Nichts desto trotz ist es eine mächtige Toolbox, man kann viele Netzarten und -architekturen realisieren, wie z.B. Input-Time-Deay-Netze, Elman-Netze, rekurrente Netze. Und dabei kann man vieles selber nach eigenen Bedürfnissen anpassen, ohne dass man eine komplett neue Software schreiben muss.

Nun ist es an der Zeit, auf der neuen ntfs-Partition ganz normal das zweite Windows XP zu installieren. Dadurch wird natürlich die alte Windows-Partition erstmal nicht mehr bootbar. Nachdem man da alles soweit installiert und eventuell upgedated hat, bootet man erneut mit einer Live-CD, der nächste Schritt ist die Installation von grub.

Die folgenden Aktionen sind als root-user bzw. mit sudo durchzuführen. Zunächst wird die ca. 100 MB große ext3-Partition (in diesem Beispiel sda4) gemountet:

mkdir /mnt/tempgrub
mount /dev/sda4 /mnt/tempgrub

und anschließend grub installiert:

grub-install --root-directory=/mnt/tempgrub/ /dev/sda4

Nun muss noch eine menu.lst angelegt werden in /mnt/tempgrub/boot/grub/ – mit Einträgen in etwa so:

timeout 60
default 0
 
title Windows XP - I
unhide (hd0,0)
hide (hd0,1)
rootnoverify (hd0,0)
makeactive
chainloader +1
 
title Windows XP - II
unhide (hd0,1)
hide (hd0,0)
rootnoverify (hd0,1)
makeactive
chainloader +1

Wobei (hd0,x) jeweils für x-te Partition steht (bei sda muss man immer eins dazuzählen). hide und unhide verstecken die jeweilige andere Windows-Partition, die grad nicht genutzt wird. Besonders acht sollte man auf Leerzeichen zwsichen hide und (hda..) geben, sonst gibts Fehler in der Form:

Grub Error 13: "Invalid or unsupported executable format"

Zur Sicherheit noch einmal wiederholen, damit auch grub up to date ist:

grub-install --root-directory=/mnt/tempgrub/ /dev/sda4

Und beim nächsten Reboot sollte man dann in der Lage sein, zwischen den beiden Windows XP Partitionen zu wählen. Das ganze sollte auch mit Windows Vista funktionieren – wobei Vista -afaik- nen eigenen bootloader hat, damit sollte es natürlich auch schon so gehen.

Der Code sieht dann bei mir etwa so aus:

set size 1.0,1.0
set key box linestyle 1
set auto y
set auto x
set terminal png
set output "myBoxPlot.png"
set title "sample-boxplot"
set xlabel "evolution"
set ylabel "sequence relationen"
set boxwidth 0.4
plot 'tmp.plot' using 1:3:2:6:5 with candlesticks fs solid 0.7 title "upper / under quartil", \
'' using 1:4:4:4:4 with candlestick lt -1 fs solid 1.0 title "median"

Wobei in den eingelesenen Daten der erste Eintrag den entsprechenden boxplot spezifiziert, gefolgt von unteres Quartil und Minimum, dann Maximum und oberes Quartil im 5. und 6. Eintrag. Der Median wird dann im nächsten Plot aus dem 4. Eintrag genommen und einfach als flacher Candlestick dargestellt. Damit lassen sich Boxplot dann auch schön automatisiert aus csv-Dateien mit gegebenen Quartil- und Median-Werten mit gnuplot zeichnen.

Beispiel Boxplot mit gnuplot