verbesserungsvorschläge für endlich fertig gestellte klasse

Turing

@exigoner:
Mit neuronalen Netzen kenne ich mich leider überhaupt nicht aus. Werden die nicht auch in der Mustererkennung eingesetzt? Schreib doch einfach auf, was Du mit der Matrix konkret machen willst.

Zu Kommentaren:
Ich finde Kommentare schon sehr wichtig, aber auch hier gilt eindeutig die Devise, dass weniger auch mehr sein kann.

keine sorge, ich kenne mich ddarin auch nicht aus, dann hab ich aber ne klasse für ein netz gefunden und wollt ein eigenes machen, nachdem ich das verstanden habe, was bei sowenig infos im netz recht schwierig ist. aber ich hab ja zeit.

nachdem ich die klassen oben um einen standartkonstruktor bereichert habe, und noch ne set-member (für die größe) hinzugefügt habe, wollte ich damit die ein-und-ausgabe daten der neuronen speichern sollen.
frag mich nicht wie, aber meine klasse matrix (2d array) soll die gewichte, die später justiert werden speichern.
die arrays darunter speichern nur aus und eingabe daten.

achtung die is von mir ein wenig modifiziert:

class simpleNet
{
private:
	matrix<float> ihWeights, hoWeights; //ursprünglich float** ihWeights
	matrix<float> ihWDelta, hoWDelta;

	array<float> in_inp, in_hid, in_outp;  //ursprünglich float* in_inp,...
	array<float> out_inp, out_hid, out_outp;  
	array<float> errH, errO, prefO, diffO;

	int amount_inp, amount_hid, amount_outp;
	float errTol, learnRate, absorp;

public:
    anne(int neur_input, int neur_hidden, int neur_output);
    anne(int neur_input, int neur_hidden, int neur_output, float **ihW, float **hoW);
    ~anne();

    float *getOutput();
    float *getODiff();

    void setErrTolerance(float tol);
    void setLearnRate(float rate);
    void setAbsorp(float abs);

    float *run(float *input);
    bool train(float *input, float *pOutput);

    void setZero();
};

der programmmierer hat diese arrays zum speichern und die 2d-arrays anscheinend noch zum berechnen benutzt:

float *simpleNet::run(float *input){            //complete run through the net
    setZero();                                  //set needed matrices to zero
    for(int i=0; i<amountI; i++)                //save input-vector
        inI[i]=input[i];
    for(int i=0; i<amountI; i++)                //special case here: inI=outI
        outI[i]=inI[i];
    outI[amountI]=1;                            //shift neuron = 1                        
    for(int i=0; i<amountH; i++)                //get input of hidden layer
        for(int j=0; j<=amountI; j++)
                inH[i]+=ihWeights[j][i]*outI[j];
    for(int i=0; i<amountH; i++)                //get output of hidden layer (sigmoide function)
        outH[i]=1/(1+exp(-inH[i]));
    outH[amountH]=1;                             //shift neuron = 1
    for(int i=0; i<amountO; i++)                //get input of output layer
        for(int j=0; j<=amountH; j++)
                inO[i]+=hoWeights[j][i]*outH[j];
    for(int i=0; i<amountO; i++)                 //get output of output layer (sigmoide function)    
        outO[i]=1/(1+exp(-inO[i]));
    return outO;
}    

bool simpleNet::train(float *input, float *pOutput){
    bool converge=true;
    for(int i=0; i<=amountI; i++)               //set delta matrices to 0 (start value)
        for(int j=0; j<amountH; j++)
                ihWDelta[i][j]=0;
    for(int i=0; i<=amountH; i++)
        for(int j=0; j<amountO; j++)
                hoWDelta[i][j]=0;
    run(input);                                 //run forward
    for(int i=0; i<amountO; i++)                //save preferred output
        prefO[i]=pOutput[i];
    for(int i=0; i<amountO; i++){               //compute output difference vector
        diffO[i]=prefO[i]-outO[i];
        if(fabs(diffO[i])>errTol) converge=false;//difference within limit?
    }
    for(int i=0; i<amountO; i++)                //compute error vector of output layer
        errO[i]=diffO[i]*outO[i]*(1-outO[i]);
    for(int i=0; i<=amountH; i++){               //compute error vector of hidden layer
        for(int j=0; j<amountO; j++)
                errH[i]+=errO[j]*hoWeights[i][j];
        errH[i]*=outH[i]*(1-outH[i]);
    }
    for(int i=0; i<=amountI; i++)                //update input-hidden weight matrix
        for(int j=0; j<amountH; j++){
                ihWDelta[i][j]=learnRate*errH[j]*outI[i]+ihWDelta[i][j]*absorp;
                ihWeights[i][j]=ihWeights[i][j]+ihWDelta[i][j];
        }    
    for(int i=0; i<=amountH; i++)                //update hidden-output weight matrix
        for(int j=0; j<amountO; j++){
                hoWDelta[i][j]=learnRate*errO[j]*outH[i]+hoWDelta[i][j]*absorp;
                hoWeights[i][j]=hoWeights[i][j]+hoWDelta[i][j];
        }
    return converge;
}

übrigens ich will wirklich nichts kopieren, ich wollte nur verstehen wie die netze funktionieren.
nun weiß ich nicht ob sich listen, da besser machen, zumal ich noch nie welche gemacht oder benutzt habe.

@turing
jo die werden u.a. zur mustererkennung genutzt!
meine matrix wird also oft verändert, es laufen wahrscheinlich sehr viele berechnungen ab...
bringt das aber wirklich was listen zu nehmen?

Walli

exigoner schrieb:

bringt das aber wirklich was listen zu nehmen?

Das kommt drauf an, wie die Matrix besetzt ist und welche Operationen primär darauf ausgeführt werden sollen. Listen bringen z.B. nur Probleme, wenn du viele Indexzugriffe hast. Und die Erklärung, warum der Gauß und die Multiplikationen mit Listen einfacher sein sollen ist Turing auch noch schuldig geblieben.

hat, jemand noch einen tipp zur performanceverbesserung?

Turing

Zu den schuldig gebliebenen Begründungen:

Matrixmultiplikation: C = A * B;

Ich will das jetzt nicht explizit coden, das wird sowieso falsch aber so "on the fly" hab ich mir das wie folgt vorgestellt:
Ich durchlaufe Matrix A immer wieder zeilenweise und B spaltenweise bilde dann über Zeilen/Spalten die Summen und gut.

Dir schwebt irgendwie sowas vor, oder:

for (int i=0; i < BREITE; i++)
for (int j=0; j < HOEHE; j++)
for (int k=0; k < BREITE; k++)
    c[i][j] += a[i][k] * b[k][j];

Ok was Einfachheit angeht ist der 2. Versuch wohl kaum zu übertreffen. Da hast Du recht, Matrixmultiplikation geht mit einem Feld leichter zu implementieren.
Wahrscheinlich wird der 2. Versuch aber ein wenig langsamer laufen, da sehr viele Adressen immer wieder berechnet werden müssen. Das ist bei meinem Vorschlag nicht nötig, da sich das nächste Paar, was multipliziert wird immer in der direkten Nachbarschaft befindet.

Und was Gauss angeht, verhält es sich meiner Meinung nach ähnlich:
Beim Feld müssen ständig Adressen berechnet werden, in der Liste nicht.

Gruss

turing

also würdest du eine liste bevorzugen. nun bin ich mir nicht sicher ob sich der aufwand nun lohnt. und ehrlich gesagt weiß ich im moment auch gar nicht wie ich soo eine liste machen muss.
wie würde den grob eine liste für ein array aussehen, die das nötigst kann, also größe festlegen, etwas reinpacken, etwas löschen und indexzugriffe.
wenn die bitte nicht zu dreist ist

volkard

Turing schrieb:

Beim Feld müssen ständig Adressen berechnet werden, in der Liste nicht.

ok. aber zeigernachguckungen (inderektionen) kosten auch.
natürlich VIEL weniger als plutimikationen. punkt für dich.

anderster wird es, wenn wir feststellen, daß das programm felder mit bestimmten zur compilzeit bekannten größen braucht. wenn ich recht sehe, ist das der fall. selbst wenn man die größen manchmal ändern mag, wenn das programm ne stunde lang läuft, aber ein compilerlauf mit geänderter größe nur 10 sekunden und damit das prog 10% schneller wird, sind compilezeitkonstante größen eine überlegung wert.

denen wir also mal kurz über

template<typename T,int sizey,int sizex>
class Matrix{
   T data[sizex*sizey];
   public:
   T& at(int y,int x){
      assert(0<=y && y<=sizey);
      assert(0<=x && x<=sizex);
      return data[y*sizex+x];
   }
};

nach.

abgesehen von der brutalen vereinfachung des codes (und dafür bin ich immer zu haben :D) könnte das auch lecker schnell sein. schaue wir den flaschenhals an. das ist die plutimikation bei y*sizex+x. legen wir doch einfach mal fest, daß sizex eine zweierpotenz sein soll.

template<typename T,int sizey,int sizex>
class Matrix{
   static const int fastsizex=nextPowerOfTwo<sizex>::value;
   T data[fastsizex*sizey];
   public:
   T& at(int y,int x){
      assert(0<=y && y<=sizey);
      assert(0<=x && x<=sizex);
      return data[y*fastsizex+x];
   }
};

und voila, es fühlt sich eigentlich recht schnell an und maximal 50% speicherverschwendung.

und dann würde ich mit dem trick mit dem proxy noch den op[][] anbieten und fest daran glauben, daß es so ausreichend in ordnung ist, um mich wieder dem hauptprogramm zuzuwenden.

IHR verwirrt mich

Turing

@volkard
Das ist tricky mit den 2er-Potenzen zu multiplizieren. Ich verteile die Daten einfach so, dass sie Multiplikation nix kostet, gute Idee.

@volkard
wie is eigentlich sonn info-studium, ich überleg vielleicht nach meinem abi 2006 auch in die richtung zu gehen, vielleicht mach aber auch eher was in richtung biologie.
wie macht sich das eigenlich auch so - geldtechnisch mit jobangeboten wenn man fertig ist?

volkard

exigoner schrieb:

@volkard
wie is eigentlich sonn info-studium, ich überleg vielleicht nach meinem abi 2006 auch in die richtung zu gehen, vielleicht mach aber auch eher was in richtung biologie.
wie macht sich das eigenlich auch so - geldtechnisch mit jobangeboten wenn man fertig ist?

MACH BIO!
info kannst offensichtlich. wenn du fertig bist, biste nachgewiesener BIO und info kannste auch, zur not mit zusatzscheinen oder durch diplomarbeit mit info oder wasweisich nachweisbar.

ich hab den fehler gemacht, info zu studieren. ich mache schon ein paar maschbauer einfach platt, weil ich noch weiß, was ein kniehebel ist, weil evonlventenverzahnung für mich nix mit mathe zu tun hat, sondern schlicht naheliegend ist usw.
aber mich einstellen als maschbauer+info kann sich keiner wagen. it auch richtig. mein maschbaue-wissen ist kläglich. die ansätze sind gut. mit ein paar jahren training wäre ich sehr gut. mist.

ich hätte was anderes studieren müssen, vielleicht mathe, physik, e-technik- maschbau, irgenwas, wozu ich wenig lernen muss. dann hätte ich jetzt zwei fächer mit heimspiel. so habe ich nur das, was mir eh zugeflogen ist und im studium auch erschreckend wenig gelernt.

Konrad Rudolph

volkard schrieb:

exigoner schrieb:

@volkard
wie is eigentlich sonn info-studium, ich überleg vielleicht nach meinem abi 2006 auch in die richtung zu gehen, vielleicht mach aber auch eher was in richtung biologie.
wie macht sich das eigenlich auch so - geldtechnisch mit jobangeboten wenn man fertig ist?

MACH BIO!

Es gäbe da ja auch noch Bioinformatik ... http://bioinformatik-berlin.de/

Das Studium ist recht spannend, auch wenn ich noch nicht recht herausbekommen habe, was das mit Informatik zu tun hat. Die manchmal verwendete englische Bezeichnung "Computational biology" trifft es IMO besser aber das kommt wohl auch sehr auf die jeweilige Uni, an der man es studiert an.

volkard

Konrad Rudolph schrieb:

Es gäbe da ja auch noch Bioinformatik ... http://bioinformatik-berlin.de/

naja, das klingt für mich ehrlich nach halbwissen auf beiden bereichen.

Konrad Rudolph

volkard schrieb:

Konrad Rudolph schrieb:

Es gäbe da ja auch noch Bioinformatik ... http://bioinformatik-berlin.de/

naja, das klingt für mich ehrlich nach halbwissen auf beiden bereichen.

Hmm, das wäre dann für jedes "Hybrid"-Studium der Fall. Fakt ist aber, dass Bioinformatiker (zur Zeit noch) hoch im Kurs stehen. Das sieht man auch am Forschungstrend ... es vergeht z.B. kaum eine Ausgabe der Technology Review, in der nicht mindestens ein großer Artikel zu einem Thema der Bioinformatik erscheint.

volkard

[quote="Konrad Rudolph"]Hmm, das wäre dann für jedes "Hybrid"-Studium der Fall.[quote]
exakt.

Fakt ist aber, dass Bioinformatiker (zur Zeit noch) hoch im Kurs stehen. Das sieht man auch am Forschungstrend ... es vergeht z.B. kaum eine Ausgabe der Technology Review, in der nicht mindestens ein großer Artikel zu einem Thema der Bioinformatik erscheint.

und diese spitzenforscher sind niemals mit abschluss "BioInformatik" gesegnet, das mußt du auch bedenken. ich fürchte, wir haben es hier mit einem fregesteller zu tun, der in sachen informatik die richtigen fragen stellt (meine bewertung) und der es in bio zu was bringen kann (kombinationsbewrtung aus seinem interesse und der informatikbewertung). er *kann* also in beiden bereichen echt gut werden, und ich nehme an, info wird ihm zufliegen. dann soll er bio möglichst tief gelernt kriegen.

aber ich kenne ihn nicht. kann auch sein, daß er anders entscheiden sollte.

dann werde ich wohl eher in richtung biologie gehen. ich habe mir in informatik(cpp/os,etc) bisher alles selbst beigebracht(gut mein buch hat nat. auch was dazu beigetragen ), aber das hat mich dann auch verunsichert. ich war mir nicht sicher ob sich das dannn noch lohnt zu studieren, da ich voraussichtlich ja so oder so weiter programmieren übe, etc.
aber wenn du schon sagst, dass du im studium eh nicht so viel gerlernt hast und eher in die bio(an meiner stelle) gehen würdest, dann bestärkt das meinen gedanken.

mfg

exigoner lass dich lieber nicht von volkard auf den falschen Weg bringen.

was hast du denn gemacht?

Pdug

Ist das hier nen C++ Kurs ?
Wenn ich mal meinen Senf dazugeben darf (ohne den Thread ganz lesen zu müssen):
Solltest du - immer noch unregistrierter - exigoner zwischen Informatik- + Bio- Studium schwanken, dann geh an eine Campus-Uni (alle Fakulltäten in einem Bau) und mach Bio.

Gründe:

in Biologie lernst du imho wissenschaftliches Arbeiten besser als in Informatik
Informatik als Nebenfach oder Freizeitgestaltung ist kein Problem, da in selber Uni nebenan
in passenden Lehrstühlen der Biologie (Genetik, Kybernetik, Ökosysteme, Neuro, ...) wird viel programmiert/modelliert/simuliert

(Sieht anders aus, wenn du Info besser findest, oder spezielle Ziele hast wie z.B. Compilerbau, CAD, HCI )

Weiterhin:

Wer in einem Studium (Informatik oder nicht) nichts lernt ist selber Schuld
Programmieren Lernen ist i.A. nicht Teil eines Informatikstudiums (an einer FH vielleicht)
Gerade die Grundvorlesungen Informatik halte ich für sehr, sehr nützlich (EBNF, Schleifeninvarianten, Turingmaschinen, Automaten, O(n), von Neumann etc pp).
(Was nicht darüber hinwegtäuscht, daß der Nutzen einem Studenten schwerlich klar ist und es oft weit dahergeholt scheint)

Informier dich vor dem Studium, welche Arbeitsgruppen/Lehrstühle an der Fakultät gibt und wo der jeweilige Forschungsschwerpunkt liegt und gleich das ab mit deinen Interessen.
Kümmere dich recht früh (4.-6. Semester) um einen Hiwi-Job - Denn das ist der Ort, wo du am besten lernst (und sogar Geld nebenbei verdienst).
Ist ja klar, daß es für Biologen außerhalb von Uni/Pharmaindustrie wenig nicht-fachfremde Arbeitsplätze gibt...