“成员的无效使用……你忘了&吗？”访问另一个类对象中的类对象

Question

我正在尝试编写自己的 NeuralNetwork，并使用自己的 Matrix2D 类进行操作。我正在尝试写出神经网络第一个权重矩阵的值，但出现如下错误： 161|error: invalid use of member 'Matrix2D NeuralNewtork::first_hidden_​​weights()' （你忘记了 '&' 吗？） |

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

float RandomNumber()
{
    return ((((double) rand() / (RAND_MAX))*2)-1);
}

class Matrix2D{
    public:
        int rows;
        int columns;
        float **matrix;
        Matrix2D(int x, int y){
            rows = x;
            columns = y;
            matrix = new float*[rows];
            for (int i = 0; i < rows; i++) {
                matrix[i] = new float[columns];
            }
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    matrix[i][j] = 0;
                }
            }
        }
        Matrix2D randomizeMatrix(){
            Matrix2D result(rows, columns);
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    matrix[i][j] = RandomNumber();
                }
            }
            return result;
        }
        static Matrix2D scalarMultiply(Matrix2D x, float y){
            Matrix2D result(x.rows, x.columns);
            for (int i = 0; i < x.rows; i++) {
                for (int j = 0; j < x.columns; j++) {
                    result.matrix[i][j] = x.matrix[i][j] * y;
                }
            }
            return result;
        }
        static Matrix2D scalarAddition(Matrix2D x, float y){
            Matrix2D result(x.rows, x.columns);
            for (int i = 0; i < x.rows; i++) {
                for (int j = 0; j < x.columns; j++) {
                    result.matrix[i][j] = x.matrix[i][j] + y;
                }
            }
            return result;
        }
        static Matrix2D scalarSubstraction(Matrix2D x, float y){
            Matrix2D result(x.rows, x.columns);
            for (int i = 0; i < x.rows; i++) {
                for (int j = 0; j < x.columns; j++) {
                    result.matrix[i][j] = x.matrix[i][j] - y;
                }
            }
            return result;
        }
        static Matrix2D matrixAddition(Matrix2D x, Matrix2D y){
            Matrix2D result(x.rows, x.columns);
            for (int i = 0; i < x.rows; i++) {
                for (int j = 0; j < x.columns; j++) {
                    result.matrix[i][j] = x.matrix[i][j] + y.matrix[i][j];
                }
            }
            return result;
        }
        static Matrix2D matrixTranspose(Matrix2D x){
            Matrix2D result(x.columns, x.rows);
            for (int i = 0; i < x.rows; i++) {
                for (int j = 0; j < x.columns; j++) {
                    result.matrix[j][i] = x.matrix[i][j];
                }
            }
            return result;
        }
        static Matrix2D matrixMultiplication(Matrix2D x, Matrix2D y){
            Matrix2D result(x.rows, y.columns);
            for (int i = 0; i < result.rows; i++) {
                for (int j = 0; j < result.columns; j++) {
                    float sum = 0;
                    for (int k = 0; k < x.columns; i++) {
                        sum += x.matrix[i][k] * y.matrix[k][j];
                    }
                    result.matrix[i][j] = sum;
                }
            }
            return result;
        }
        void printMatrix(){
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                cout << matrix[i][j] << " ";
                }
            cout << endl;
            }
            cout << endl;
        }
};

class NeuralNewtork{
    public:
        int numberof_input_nodes;
        int numberof_hidden_layers;
        int numberof_hidden_nodes;
        int numberof_output_nodes;
        Matrix2D first_hidden_weights();
        Matrix2D* hidden_weigths();
        Matrix2D output_weights();
        Matrix2D* hidden_biases();
        Matrix2D output_biases();

        NeuralNewtork(int input_nodes, int hidden_layers, int hidden_nodes, int output_nodes){
            numberof_input_nodes = input_nodes;
            numberof_hidden_layers = hidden_layers;
            numberof_hidden_nodes = hidden_nodes;
            numberof_output_nodes = output_nodes;

            Matrix2D first_hidden_weights(hidden_nodes, input_nodes);
            first_hidden_weights.randomizeMatrix();

            Matrix2D* hidden_weigths[numberof_hidden_layers-1];
                for (int i=0; i<numberof_hidden_layers-1; i++){
                    hidden_weigths[i] = new Matrix2D(numberof_hidden_nodes, numberof_hidden_nodes);
                    hidden_weigths[i]->randomizeMatrix();
                }

            Matrix2D output_weights(numberof_output_nodes, numberof_hidden_nodes);
            output_weights.randomizeMatrix();

            Matrix2D* hidden_biases[numberof_hidden_layers];
                for (int i=0; i<numberof_hidden_layers; i++){
                    hidden_biases[i] = new Matrix2D(numberof_hidden_nodes, 1);
                    hidden_biases[i]->randomizeMatrix();
                }

            Matrix2D output_biases(numberof_output_nodes, 1);
            output_biases.randomizeMatrix();
        }
        Matrix2D feedForward(Matrix2D input){

        }

};

int main()
{
    srand (time(0));
    //Matrix2D myMatrix(3,7);
    //myMatrix.randomizeMatrix();
    //myMatrix.printMatrix();

    NeuralNewtork nn(4, 3, 5, 1);
    nn.first_hidden_weights.printMatrix();     //<=This line gives the error:

    return 0;
}

我正在尝试打印 first_hidden_​​weight Matrix2D 对象矩阵组件，以查看我的代码是否按预期方式工作，但当我尝试访问该变量时出现错误。

Answer 1

第一个问题是您将所有权重定义为返回 Matrix2D 而非成员变量的零参数函数。删除()。

其次，您的构造函数创建并初始化 影子变量，这些变量与您的成员变量完全解耦。 使用= 运算符显式初始化它们：

first_hidden_weights = Matrix2D(hidden_nodes, input_nodes);

对于hidden_weights 和hidden_biases 成员，我建议您使用std::vector<Matrix2D>。这使内存管理自动化，并为您提供了许多方便的方法。你可以像这样初始化hidden_weights：

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)); // or use emplace_back
    hidden_weights.back().randomizeMatrix();
}

最后，由于您似乎在构造后经常调用randomizeMatrix，因此请考虑创建一个自动随机化的显式构造函数：

enum class Randomize { Randomize };

class Matrix2D {
...
  Matrix2D(int x, int y, Randomize)
  : Matrix2D(x, y) { // delegate to the simple constructor
    randomizeMatrix();
  }
...
};

然后您可以简单地编写类似Matrix2D(x, y, Randomize) 的内容。