Vektor "schrumpft" wieder zusammen



  • Hi,

    mein Ziel ist es ein neuronales Netzwerk selbst zu programieren. Ich habe mir dazu eine Klasse entworfen.
    feedForwardNet.h:

    #include <vector>
    
    #pragma once
    class feedForwardNet
    {
    public:
    	feedForwardNet(int, std::vector<int>, int);
    	~feedForwardNet(void);
    	int get_nbrOfLayers();
    
    ...
    
    private:
    	std::vector< std::vector < std::vector<double> > > weights; //als Vektor von Matrizen zu interpretieren
    };
    

    feedForwardNet.cpp:

    #include "feedForwardNet.h"
    #include <iostream>
    
    feedForwardNet::feedForwardNet(int input, std::vector<int> hidden, int output)//Prüfen ob Werte größer 0!
    {
    	std::vector< std::vector < std::vector<double> > > weights;
    	weights.resize(1+hidden.size());
    
    	if (hidden.size())
    	{
    		weights.front().resize(hidden.front());
    	}
    	else
    	{
    		weights.front().resize(output);
    	}
    	for (int i=0; i<weights.front().size(); i++)
    	{
    		weights.front()[i].resize(input+1);
    	}
    
    	for (int l=0; l<(static_cast<int>(hidden.size())-1); l++)
    	{
    		weights[l+1].resize(hidden[l+1]);
    		for (int i=0; i<weights[l+1].size(); i++)
    		{
    			weights[l+1][i].resize(hidden[l]+1);
    		}
    	}
    	weights[static_cast<int>(hidden.size())].resize(output);
    	if (hidden.size())
    	{
    		for (int i=0; i<weights.back().size(); i++)
    		{
    			weights.back()[i].resize(hidden.back()+1);
    		}
    	}
    
    	for (int l=0; l<weights.size(); l++)
    	{
    		for (int i=0; i<weights[l].size(); i++)
    		{
    			weights[l][i][0] = -1;
    			for (int j=1; j<weights[l][i].size(); j++)
    			{
    				weights[l][i][j] = l+i+j;
    			}
    		}
    	}
    	std::cout << weights.size() << "\n"; //spuckt entsprechende Anzahl an Matrizen/Schichten aus
    };
    
    feedForwardNet::~feedForwardNet(void)
    {
    }
    
    ...
    
    int feedForwardNet::get_layerInputSize(int nbrOfLayer)
    {
    	return weights[nbrOfLayer][0].size(); //gibt immer nur 0 aus
    }
    
    ...
    

    Wenn ich mir nun eine Instanz erzeuge und innheralb des Konstruktors nach der Länge des "äußeren" Vektors frage, wird mir die richtige größe ausgegeben.
    Wenn ich nun aber nach der Erzeugung wieder nach der Größe des "äußeren" Vektors frage, wird mir nur eine Null ausgegeben.
    Ich hab auch schon mal meine Konstruktion extrem vereinfacht und nur mit

    private:
    std::vector<double> weights;
    ...
    

    gearbeitet und dabei alles überflüssige entfernt. Mit dem gleichen Ergebnis.

    Irgendwie scheint meine Instanz sofort nach ihrer Erzeugung ihre Länge zu vergessen.
    Natürlich kann ich deshalb auch nicht auf die Matrizen im "Inneren" zugreifen, weil die nicht mehr im Vektor gelistet sind.

    Hoffe, mir kann jemand helfen.

    Gruß,
    schmitzlipp



  • Du hast am Anfang des Konstruktors eine lokale Variable "weights" definiert - diese überdeckt die gleichnamige Membervariable und wird am Ende des Konstruktors wieder zerstört.



  • Autsch... ist ja schon spät!
    Vielen Dank, das hätte ich heute nicht mehr selbst gesehen.


Log in to reply