C++ VectorXd::cwiseProduct方法代碼示例

        /** Function for computing the potentials of the nodes and the edges in
         * the graph.
         */
        void computePotentials()
        {
            // Method steps:
            //  1. Compute node potentials
            //  2. Compute edge potentials

            //
            //  1. Node potentials
            //

            std::vector<CNodePtr>::iterator it;

            //cout << "NODE POTENTIALS" << endl;

            for ( it = m_nodes.begin(); it != m_nodes.end(); it++ )
            {
                CNodePtr nodePtr = *it;

                if ( !nodePtr->finalPotentials() )
                {
                    // Get the node type
                    //size_t type = nodePtr->getType()->getID();

                    // Compute the node potentials according to the node type and its
                    // extracted features

                    Eigen::VectorXd potentials = nodePtr->getType()->computePotentials( nodePtr->getFeatures() );

                    // Apply the node class multipliers
                    potentials = potentials.cwiseProduct( nodePtr->getClassMultipliers() );

                    /*Eigen::VectorXd fixed = nodePtr->getFixed();

                    potentials = potentials.cwiseProduct( fixed );*/

                    nodePtr->setPotentials( potentials );
                }

            }

            //
            //  2. Edge potentials
            //

            std::vector<CEdgePtr>::iterator it2;

            //cout << "EDGE POTENTIALS" << endl;

            for ( it2 = m_edges.begin(); it2 != m_edges.end(); it2++ )
            {
                CEdgePtr edgePtr = *it2;

                Eigen::MatrixXd potentials
                        = edgePtr->getType()->computePotentials( edgePtr->getFeatures() );

                edgePtr->setPotentials ( potentials );
            }

        }

double compareT(Eigen::Isometry3d a, Eigen::Isometry3d b,
		Eigen::VectorXd weight)
{
	Eigen::Quaterniond qa(a.rotation());
	Eigen::Quaterniond qb(b.rotation());
	Eigen::Vector3d pa = a.translation();
	Eigen::Vector3d pb = b.translation();
	Eigen::VectorXd va(7), vb(7), verr(7), vScaled(7);
	va << pa, qa.x(), qa.y(), qa.z(), qa.w();
	vb << pb, qb.x(), qb.y(), qb.z(), qb.w();
	verr = vb - va;
	vScaled = weight.cwiseProduct(verr);
	return vScaled.squaredNorm();
}

void UPGMpp::applyMaskToPotentials(CGraph &graph, map<size_t,vector<size_t> > &mask )
{
    vector<CNodePtr> &nodes = graph.getNodes();

    for ( size_t node_index = 0; node_index < nodes.size(); node_index++ )
    {
        CNodePtr nodePtr    = nodes[node_index];
        size_t nodeID       = nodePtr->getID();

        if ( mask.count(nodeID) )
        {
            Eigen::VectorXd nodePot = nodePtr->getPotentials();
            Eigen::VectorXd potMask( nodePot.rows() );
            potMask.fill(0);

            for ( size_t mask_index = 0; mask_index < mask[nodeID].size(); mask_index++ )
                potMask(mask[nodeID][mask_index]) = 1;

            nodePot = nodePot.cwiseProduct(potMask);

            nodePtr->setPotentials( nodePot );
        }
    }
}

/**
* It multiply the result of the wheight Function with the Bias value
*
* @return it returns the result of the multiplication
**/
Eigen::VectorXd Product(Eigen::VectorXd weighedVector, Eigen::VectorXd biasVector){
 return weighedVector.cwiseProduct(biasVector);
}

int main(int argc, char **argv) {
/*    NeuralNetwork nn(Eigen::Vector4d(3,3,3,1), 0.2, 0.1);

    typedef Eigen::Matrix<double,1,1> Vector1d;
    Vector1d rtrue;
    rtrue << 1;
    Vector1d rfalse;
    rfalse << 0;

    int NUM_ITERS = 100000;


    std::cout << "Beginning learning phase...\niteration 0";
    
    
    
    std::vector<std::pair<Eigen::VectorXd, Eigen::VectorXd>> training_data;
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(1,1,1), rtrue));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(1,0,0), rtrue));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(0,1,0), rtrue));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(0,0,1), rtrue));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(1,1,0), rfalse));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(0,1,1), rfalse));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(1,0,1), rfalse));
    training_data.push_back(std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(Eigen::Vector3d(0,0,0), rfalse));
    
    nn.TrainBatch(training_data, 100000, 0.000001);
    
    std::cout <<"Learning done."<< std::endl;
    std::cout <<"Beginning testing phase...\n";

    std::cout << nn.Evaluate(Eigen::Vector3d(1,1,1)) << " vs " << 1 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(1,1,0)) << " vs " << 0 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(1,0,0)) << " vs " << 1 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(1,0,1)) << " vs " << 0 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(0,1,1)) << " vs " << 0 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(0,1,0)) << " vs " << 1 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(0,0,1)) << " vs " << 1 << std::endl;
    std::cout << nn.Evaluate(Eigen::Vector3d(0,0,0)) << " vs " << 0 << std::endl;
*/

    Reader reader;
    Eigen::VectorXd layers(4);
    layers << 10, 10, 5,1;
    NeuralNetwork nn(layers, 0.2, 0.1);
    
    std::cout << "Reading training data..." << std::flush;
    std::vector<std::pair<Eigen::VectorXd, Eigen::VectorXd>> training_data;
    std::cout << reader.ReadTrainingData("training_sample.csv",10,1,training_data) << " lines read." << std::endl;
    
    std::cout << "Beginning learning phase..." << std::endl;
    nn.TrainBatch(training_data, 50000, 0.001);
    std::cout << "End training phase..." << std::endl;
    nn.PrintWeights();
    std::cout << "Reading evaluation data..." << std::flush;
    std::vector<Eigen::VectorXd> evaluation_input_data;
    std::vector<Eigen::VectorXd> evaluation_output_data;
    
    int evaluation_rowcount = 0;
    std::cout << (evaluation_rowcount = reader.ReadEvaluationData("training_normalized.csv",10,1,evaluation_input_data, evaluation_output_data)) << " lines read." << std::endl;
    std::cout << "Beginning testing phase..." << std::endl;
    double cumulative_mse = 0;
    int success_count = 0;
    double success_square_error_threshold = 0.16;
    for(int i = 0; i < evaluation_rowcount; ++i) {
      Eigen::VectorXd output = nn.Evaluate(evaluation_input_data[i]);
      Eigen::VectorXd error = evaluation_output_data[i] - output;
      double square_error = error.cwiseProduct(error).sum() / error.size();
      cumulative_mse += square_error;
      if(square_error < success_square_error_threshold) {
	++success_count;
      }
      
      //std::cout << nn.Evaluate(evaluation_input_data[i]) << " vs. " << evaluation_output_data[i] << std::endl;
    }
    
    nn.PrintWeights();
    nn.PrintStates();
    
    
    std::cout << "End testing phase. Mean square error " << cumulative_mse/evaluation_rowcount << "\n";
    std::cout << success_count << " / " << evaluation_rowcount << " rows classified correctly (mse < " << success_square_error_threshold << ")\n";

    //std::cout << nn.Evaluate(evaluation_input_data[0]) << " vs. " << evaluation_output_data[0] << std::endl;
    //nn.PrintStates();
    //std::cout << nn.Evaluate(evaluation_input_data[1]) << " vs. " << evaluation_output_data[1] << std::endl;
    //nn.PrintStates();
    //std::cout << nn.Evaluate(evaluation_input_data[4]) << " vs. " << evaluation_output_data[4] << std::endl;
    //nn.PrintStates();
    
    return 0;
}

/// <summary>
/// use a kernel matrix and solve the svm problem
/// </summary>
/// <param name="Kernel">precomputed kernel</param>
DualSolution libSVMWrapper::Solve(const Eigen::MatrixXd &Kernel)
{
	// unfortunately libsvm needs "svm_nodes", so we have to copy everything
	// workaround pointer to matrix entries (eigen3 does not allow it?)
	// copy entries (code from libSVM)
	int j = 0, sc = NumberOfData + 1;

	// TODO
	// libSVM_x_space[j+k].value = *(Kernel.data() + (k-1)*NumberOfData + i);  // by reference or pointer
	#pragma omp parallel for
	for (int i = 0; i < libSVM_Problem.l; i++)
	{
		j = (sc+1)*i ;
		for (int k = 0; k < sc; k++)
		{
			libSVM_x_space[j].index = k + 1;
			if (k == 0)
			{
				libSVM_x_space[j].value = i + 1;
			}
			else
			{
				libSVM_x_space[j+k].value = Kernel(i, k - 1);
			}

		}
		j = ((sc+1)*i+sc) ;
		libSVM_x_space[j+1].index = -1;
	}


	#ifdef DEBUG
	for (int i = 0; i < libSVM_Problem.l; i++)
	{
		if ((int) libSVM_Problem.x[i][0].value <= 0 || (int) libSVM_Problem.x[i][0].value > sc)
		{
			printf("Wrong input format: sample_serial_number out of range\n");
			exit(0);
		}
	}


	const char *error_msg;
	error_msg = svm_check_parameter(&libSVM_Problem, &libSVM_Parameter);
	if (error_msg)
	{
		fprintf(stderr, "ERROR: %s\n", error_msg);
		exit(1);
	}
	#endif

	// train the model
	if (libSVM_Model != NULL)
	{
		svm_free_model_content(libSVM_Model);
		libSVM_Model = NULL;
	}
	libSVM_Model = svm_train(&libSVM_Problem, &libSVM_Parameter);
	// extract results

	// bias is easy
	double Bias = -1 * libSVM_Model->rho[0];

	// alpha should be dense now
	Eigen::VectorXd Alpha = Eigen::MatrixXd::Zero(NumberOfData, 1);
	for (int i = 0; i < libSVM_Model->l; i++)
	{
		Alpha(libSVM_Model->sv_indices[i] - 1) = (libSVM_Model->sv_coef[0][i] < 0) ? -1 * libSVM_Model->sv_coef[0][i] : libSVM_Model->sv_coef[0][i];
	}

	DualSolution DS;
	DS.Bias = Bias;
	DS.Alpha = Alpha;

	Eigen::VectorXd tt = Alpha.cwiseProduct(Y);

	// objective value of dual solution
	DS.Value = Alpha.sum()    - 0.5* (double)(tt.transpose() * (Kernel*tt));


	return DS;

}