m_fSigmaT = m_DistFunction->decay(m_fSigma0, m_iCycle, m_fLambda);

Nun frage ich mich, ob es möglich ist, dieses problem irgendwie mit hilfe von openMP zu umgehen.
Oder ist dieses Beispiel eines der Probleme, die man nicht parallelisieren kann, ohne Genauigkeit einzubüßen?

#pragma omp for
	for(int i = 0; i < static_cast<int>(m_iCycles); i++) {
		m_iCycle = i;
		std::cout<<"Cycle: "<<m_iCycle<<std::endl;

	    // The input vectors are presented to the network at random
		iChoice = RandInt(iMin, iMax);
	    SetInput( GetTrainingSet()->GetInput(iChoice) );

		// Present the input vector to each node and determine the BMU
		FindBMNeuron();

		// Calculate the width of the neighborhood for this time step
		m_fSigmaT = m_DistFunction->decay(m_fSigma0, m_iCycle, m_fLambda);

		// Adjust the weight vector of the BMU and its neighbors
		PropagateBW();
	}

void SOMNet::Training(const unsigned int &iCycles) {
	m_iCycles = iCycles;
	int iChoice = 0;
	int iMin 	= 0;
	int iMax 	= GetTrainingSet()->GetNrElements()-1;

	// find sigma0
	assert(iCycles > 0);
	assert(m_fSigma0 > 0.f);
	m_fLambda = m_iCycles / log(m_fSigma0);

	for(int i = 0; i < static_cast<int>(m_iCycles); i++) {
		m_iCycle = i;
		std::cout<<"Cycle: "<<m_iCycle<<std::endl;

	    // The input vectors are presented to the network at random
		iChoice = RandInt(iMin, iMax);
	    SetInput( GetTrainingSet()->GetInput(iChoice) );

		// Present the input vector to each node and determine the BMU
		FindBMNeuron();

		// Calculate the width of the neighborhood for this time step
		m_fSigmaT = m_DistFunction->decay(m_fSigma0, m_iCycle, m_fLambda);

		// Adjust the weight vector of the BMU and its neighbors
		PropagateBW();
	}
}

Dann habe ich eine Unterfunktion bei der der Hauptrechenaufwand liegt:

//#pragma omp parallel for
	for(int i = 0; i < static_cast<int>(m_pOPLayer->GetNeurons().size() ); i++) {
		pNeuron = (SOMNeuron*)m_pOPLayer->GetNeuron(i);
		fDist = pNeuron->GetDistance2Neur(*m_pBMNeuron);

		if(fDist < m_fSigmaT) {
			//calculate by how much weights get adjusted ..
			fInfluence = m_DistFunction->distance(fDist, m_fSigmaT);
			pNeuron->SetInfluence(fInfluence);

			// .. and adjust them
			pNeuron->AdaptEdges();
		}

	    //reduce the learning rate
		fLearningRate = m_DistFunction->decay(m_fLearningRate, m_iCycle, m_iCycles);
		pNeuron->SetLearningRate(fLearningRate);
	}

void SOMNeuron::AdaptEdges() {
	Edge 	*pEdge 	= NULL;
	float 	fInput 	= 0.f;
	float 	fWeight = 0.f;

    for(unsigned int i = 0; i < GetConsI().size(); i++) {
    	pEdge 	= GetConI(i);
    	fWeight = *pEdge;
    	fInput 	= *pEdge->GetDestination(this);

    	pEdge->SetValue(fWeight + (m_fInfluence*m_fLearningRate*(fInput-fWeight) ) );
    }
}

Wenn ich das Netz regulär auf ein paar Farben trainiere, dann sieht das Ergebnis richtig aus, da alle Farben bestimmten und abgegrenzten Bereichen zugeordnet werden:
http://s14.directupload.net/images/120308/8r92wjkw.png
Wenn ich jetzt OpenMP benutze, dann sieht das ganze fast immer so aus:
http://s1.directupload.net/images/120308/gtuomo4j.png
Ehrlich gesagt bin ich mir jetzt auch nicht mehr sicher woran es liegt.
Wenn ich die Lernrate konstant setze, bekomme ich die gleichen Resultate in beiden Fällen,
sodass es an etwas anderen liegen muss. Ich weis jetzt auch nicht wo das Problem liegt, aber die Ausgabebilder demonstrieren, dass es eins gibt, wenn ich OpenMP benutze.

P.S.: Und tut die ungarische Notation Not? Das ist in C++ ziemlich unsinnig, da man es sowieso nicht konsequent durchhalten kann ohne verrückt zu werden und macht alles bloß total unleserlich.