I'm bulding my own Neural Network with my own Matrix class.

I'm trying to use the swishMatrix() function on a Matrix2D class object, before adding it to a vector<Matrix2D> variable. But I get this error and I have no idea why. -> no matching function for call to 'std::vector<Matrix2D>::push_back(int)'|

When I use the swishMatrix() on a normal Matrix2D object it works fine.

Here's the Matrix2D class

class Matrix2D{
    public:
        int rows;
        int columns;
        vector<vector<float> > matrix;
        Matrix2D() = default;
        Matrix2D(int x, int y){
            rows = x;
            columns = y;
            for (int i = 0; i < rows; i  ) {
                vector<float> v1;
                for (int j = 0; j < columns; j  ) {
                    v1.push_back(0);
                }
                matrix.push_back(v1);
            }
        }
        swishMatrix(){            
            for (int i = 0; i < rows; i  ) {
                for (int j = 0; j < columns; j  ) {
                    matrix[i][j] = matrix[i][j] * sigmoid(matrix[i][j]);
                }
            }            
        }        
        //Here there's a lot of static functions for matrix operations
};

Here's the Neural Network class

class NeuralNewtork{
    public:
       
        //A lot more declaration here but not important
        Matrix2D first_hidden_weights;

        Matrix2D input_nodes;

        vector<Matrix2D> hidden_weights;      

        vector<Matrix2D> hidden_biases; 

        vector<Matrix2D> activated_hidden_nodes;       

        NeuralNewtork(int input_nodes, int hidden_layers, int hidden_nodes, int action_nodes){
            first_hidden_weights = Matrix2D(numberof_hidden_nodes, numberof_input_nodes);
            first_hidden_weights.randomizeMatrix();            

            hidden_weights.reserve(numberof_hidden_layers-1);
            for (int i=0; i<numberof_hidden_layers-1; i  ){
                hidden_weights.push_back(Matrix2D(numberof_hidden_nodes, numberof_hidden_nodes));
                hidden_weights.back().randomizeMatrix();
            }           

            hidden_biases.reserve(numberof_hidden_layers);
            for (int i=0; i<numberof_hidden_layers; i  ){
                hidden_biases.push_back(Matrix2D(numberof_hidden_nodes, 1));
                hidden_biases.back().randomizeMatrix();
            }     
            //There are more declerations here but they aren't important for this problem   
        }

        feedForward(Matrix2D input){
            input_nodes = input;

        
            for(int i = 0; i < numberof_hidden_layers 1; i  ){
                if(i==0){                    
                    activated_hidden_nodes.push_back(Matrix2D::matrixAddition(Matrix2D::matrixMultiplication(first_hidden_weights, input_nodes), hidden_biases[0]).swishMatrix());
                    //This is the line where I get the error
                    //no matching function for call to 'std::vector<Matrix2D>::push_back(int)'|
                    
                }
                if(i!=0 && i!=numberof_hidden_layers){
                    activated_hidden_nodes.push_back(Matrix2D::matrixAddition(Matrix2D::matrixMultiplication(hidden_weights[i-1], activated_hidden_nodes[i-1]), hidden_biases[i]).swishMatrix());  
                    //This is also a line where I get the error
                    //no matching function for call to 'std::vector<Matrix2D>::push_back(int)'|
                }
                if(i==numberof_hidden_layers){
                    //Not important
                }
            }
        }

I might have missed some part of the code, it was hard to keep short, but all the needed variables are correctly assigned.

CodePudding user response：

The trivial fix is to make swishMatrix return the matrix object again:

Matrix2D& swishMatrix(){            
    for (int i = 0; i < rows; i  ) {
         for (int j = 0; j < columns; j  ) {
              matrix[i][j] = matrix[i][j] * sigmoid(matrix[i][j]);
         }
    }     
    return *this;       
}  

Never ever write code again without explicit return types on your methods.