asertion failed : eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());

[CORONADO123]

Dear, I have a query, I know that this is due to an error in the dimensions of the matrices, but when compiling it does not present any error, I attach the complete code and the instructions that generate the error.

          //IMPLEMENTACION DE UN ALGORITMO DE  APRENDIZAJE SOM-RNA KOHONEN EN C++

//El proceso de aprendizaje de SOM es estocástico, fuera de línea y no supervisado.
//clase VectorXd representa un vector de tamaño dinámico en Eigen.
//En este caso, el vector se inicializa con valores aleatorios usando la función Random.

//El código dentro de la macro eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols())
//comprueba si el número de filas y columnas de ambas matrices es el mismo.
//Si estas dimensiones no son iguales, se generará un error en tiempo de compilación.
#include
#include <Eigen/Dense>//Eigen es una biblioteca de C++ para álgebra lineal que proporciona tipos de datos y operaciones eficientes para trabajar con matrices y vectores.
#include
#include
using namespace Eigen;
using namespace std;

class KohonenNetwork{
public:
MatrixXd weights;//MatrixXd: Este es un tipo de datos proporcionado por la biblioteca Eigen
//que representa una matriz de valores de tipo double.
int inputSize;
int outputSize;

KohonenNetwork(int inputSize, int outputSize)
    : inputSize(inputSize), outputSize(outputSize) {
    // Inicialización aleatoria de pesos
    std::srand(std::time(0));//srand(): Es una función en C que inicializa la semilla del generador de números aleatorios utilizado por la función rand().

    weights = MatrixXd::Random(outputSize, inputSize);//VARIABLE PESOS

    // ::Random(outputSize, inputSize) : Este es un método que se llama en el tipo de datos MatrixXd
    //para inicializar la matriz con valores aleatorios.outputSize y inputSize son los tamaños de la matriz resultante, donde outputSize es el número de filas y inputSize es el número de columnas.
}

int findWinner(const VectorXd& input) const {//FUNCION PARA DETERMINAR NEURONA GANADORA
    int winner = 0;
    double minDistance = (weights.row(0) - input).squaredNorm();

    for (int i = 1; i < outputSize; ++i) {
        double distance = (weights.row(i) - input).squaredNorm();
        if (distance < minDistance) {
            minDistance = distance;
            winner = i;//neurona ganadora
        }
    }

    return winner;    }

/* int encontrarGanadora(const VectorXd& entrada) const {
// Encontrar la neurona ganadora (neurona con el peso más cercano a la entrada)
double mejorDistancia = std::numeric_limits::max();
int neuronaGanadora = 0;

    for (int i = 0; i < numNeuronas; ++i) {
        double distancia = (pesos.row(i) - entrada).norm();

        if (distancia < mejorDistancia) {
            mejorDistancia = distancia;
            neuronaGanadora = i;//NEURONA GANADORA
        }
    }

    return neuronaGanadora;
}

*/

void updateWeights(int winner, const VectorXd& input, double learningRate) {
    weights.row(winner) += learningRate * (input - weights.row(winner));
}

MatrixXd getWeights() const {
    return weights;
}

};

int main() {
// Configuración de la red
const int inputSize = 2;
const int outputSize = 4;
const int numTrainingSamples = 1000;
const double learningRate = 0.1;
int winner;
const int numSensores = 4;
// VectorXd input;

// Inicialización de la semilla para números aleatorios
srand(static_cast<unsigned int>(time(nullptr)));



/*entrada << -1, 0,
           -1, 1,
           -1, -1,
            0, -1,
            0, 1,
            0, 0,
            1, 1,
            1, -1,
            1, 0;
std::cout <<entrada;*/

            
/* ([[-1, 0], // sin obstaculos
    [-1, 1], //sin obstaculos
    [-1, -1], // sin obstaculos
    [0, -1], // obstaculo detectado a derecha
    [0, 1], // obstaculo a izq
    [0, 0], //obstaculo centro
    [1, 1],// demasiado cerca a derecha
    [1, -1], //demasiado cerca a izq
    [1, 0]    // demasiado cerca centro
] ); */
// Crear datos de entrenamiento (simulados)
MatrixXf trainingData(inputSize, numTrainingSamples);
trainingData = MatrixXf::Random(inputSize, numTrainingSamples);

        // Crear y entrenar la red
     KohonenNetwork kohonen(inputSize, outputSize);

     // Entrada de ejemplo desde los sensores (valores digitales aleatorios)
   
     VectorXf entrada = VectorXf::Random(numSensores);//En este código, VectorXd es un tipo de datos proporcionado por la biblioteca Eigen
   
     
     //Eigen::MatrixXd m(2, 2);  // Entrada de ejemplo desde los sensores (valores digitales aleatorios)
  //   m(0, 0) = 3;
  //   m(1, 0) = 2.5;
  //   m(0, 1) = -1;
   //  m(1, 1) = 2;
     //para representar vectores dinámicos de tamaño variable. 
     //La función Random genera valores aleatorios en el rango [-1, 1] y los asigna al vector entrada. Este vector ahora contiene numEntradas valores digitales aleatorios.
    
for (int epoch = 0; epoch < 1000; ++epoch) {
    // Realizar un pase hacia adelante y hacia atrás por cada ejemplo de entrenamiento
    for (int i = 0; i < numTrainingSamples; ++i) {
        VectorXf input = trainingData.col(i);

        // Pase hacia adelante y hacia atrás
     winner = kohonen.findWinner(input);//genera error
      int neuronaGanadora =kohonen.findWinner(entrada);//GENERARA ERROR
     kohonen.updateWeights(winner, input, learningRate);//genera error
    }
}
// Obtener los pesos finales
MatrixXd finalWeights = kohonen.getWeights();
// Mostrar resultados

// std::cout << "datos de entrenamiento: \n" << trainingData.transpose() << "\n";
std::cout << "Pesos finales de la red de Kohonen:\n" << finalWeights << "\n";
std::cout << "datos de entrada de la red de Kohonen:\n" << entrada << "\n";
std::cout << "datos de entrenamiento:\n " <<trainingData << "\n";
std::cout << "neurona de salida:\n" << outputSize << "\n";
std::cout << "neurona de salida:\n" << inputSize << "\n";
// std::cout << "mostramos el vector de entrada m:\n" << m << std::endl;

}

The institutions that generate this error are the following:

// Pase hacia adelante y hacia atrás
winner = kohonen.findWinner(input);//genera error
int neuronaGanadora =kohonen.findWinner(entrada);//GENERARA ERROR
kohonen.updateWeights(winner, input, learningRate);//genera error

Thank you for any suggestions to solve the problem during the compilation of the code developed in C++