Skip to content
Snippets Groups Projects
Select Git revision
  • bbc8ed70a89194dc46ac2541f15e30ef0afb79ba
  • master default protected
2 results

Agent.py

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    new_method.cpp 5.15 KiB
    #include <sicstus/sicstus.h>
    /* ex_glue.h is generated by splfr from the foreign/[2,3] facts.
       Always include the glue header in your foreign resource code.
    */
    #include "new_method_glue.h"
    #include <mlpack/methods/new_method.hpp>
    #include <mlpack/core.hpp>
    
    // including helper functions for converting between arma structures and arrays
    #include "../../helper_files/helper.hpp"
    
    using namespace arma;
    using namespace mlpack;
    using namespace std;
    using namespace mlpack::regression;
    
    // Global Variable of the BayesianLinearRegression object so it can be accessed from all functions
    BayesianLinearRegression regressor;
    
    
    // input:	const bool , const bool , const size_t , const double
    // output: double
    void initModel(SP_integer centerData, SP_integer scaleData, SP_integer nIterMax, double tol)
    {
    	regressor = new BayesianLinearRegression((centerData == 1), (scaleData == 1), nIterMax, tol);
    }
    
    // input:
    // output: double
    SP_integer alpha()
    {
    	return regressor.Alpha();
    }
    
    // input:
    // output: double
    SP_integer beta()
    {
    	return regressor.Beta();
    }
    
    // input:
    // output: const arma::colvec &
    float * dataOffset(SP_integer *arraySize)
    {
    	// save the DataOffset output in colvec
    	colvec armaDataOffset = regressor.DataOffset();
    
    	*arraySize = armaDataOffset.n_elem;
    
    	return convertArmaToArray(armaDataOffset);
    }
    
    // input:
    // output: const arma::colvec &
    float * dataScale(SP_integer *arraySize)
    {
    	// save the DataScale output in colvec
    	colvec armaDataScale = regressor.DataScale();
    
    	*arraySize = armaDataScale.n_elem;
    
    	return convertArmaToArray(armaDataScale);
    }
    
    // input:
    // output: const arma::colvec &
    float * omega(SP_integer *arraySize)
    {
    	// save the Omega output in colvec
    	colvec armaOmega = regressor.Omega();
    
    	*arraySize = armaOmega.n_elem;
    
    	return convertArmaToArray(armaOmega);
    }
    
    // input: const arma::mat &points, arma::rowvec &predictions
    // output:
    void predict(float *pointsArr, SP_integer pointsSize, SP_integer pointsRowNum, float **predicArr, SP_integer *predicSize)
    {
    	// convert the Prolog arrays to std::vec for easy conversion to arma::mat
    	mat data = convertArrayToMat(pointsArr, pointsSize, pointsRowNum);
    
    	// run the prediction and save the result in arma::rowvec
    	rowvec predictions;
    	regressor.Predict(data, predictions);
    
    
    	// give back the sizes and the converted results as arrays
    	*predicSize = predictions.n_elem;
    
    	*predicArr = convertArmaToArray(predictions);
    }
    
    // input: const arma::mat &points, arma::rowvec &predictions, arma::rowvec &std
    // output:
    void predictWithStd(float *pointsArr, SP_integer pointsSize, SP_integer pointsRowNum, float **predicArr, SP_integer *predicSize, float **stdArr, SP_integer *stdSize)
    {
    	// convert the Prolog arrays to std::vec for easy conversion to arma::mat
    	mat data = convertArrayToMat(pointsArr, pointsSize, pointsRowNum);
    
    	// run the prediction and save the results in arma::rowvecs
    	rowvec predictions;
    	rowvec std;
    	regressor.Predict(data, predictions, std);
    
    	// give back the sizes and the converted results as arrays
    	*predicSize = predictions.n_elem;
    	*stdSize = std.n_elem;
    
    	*predicArr = convertArmaToArray(predictions);
    	*stdArr = convertArmaToArray(std);
    }
    
    
    // input:
    // output: double
    SP_integer responsesOffset()
    {
    	return regressor.ResponsesOffset();
    }
    
    // input: const arma::mat &data, const arma::rowvec &responses
    // output: double
    SP_integer rmse(float *matrix, SP_integer matSize, SP_integer matRowNum, float *arr, SP_integer vecSize)
    {
    	// convert the Prolog arrays to arma::rowvec and arma::mat
    	rowvec responses = convertArrayToRowvec(arr, vecSize);
    	mat data = convertArrayToMat(matrix, matSize, matRowNum);
    
    	// run the model function and return the error
    	return regressor.RMSE(data, responses);
    }
    
    // input: const arma::mat &data, const arma::rowvec &responses
    // output:
    void train(float *matrix, SP_integer matSize, SP_integer matRowNum, float *arr, SP_integer vecSize)
    {
    	if(matSize / matRowNum != vecSize)
    	{
    		cout << "Target dim doesnt fit to the Data dim" << endl;
    		return;
    	}
    	// convert the Prolog arrays to arma::rowvec and arma::mat
    	rowvec responses = convertArrayToRowvec(arr, vecSize);
    	mat data = convertArrayToMat(matrix, matSize, matRowNum);
    
    	// run the model function
    	regressor.Train(data, responses);
    }
    
    // input:
    // output: double
    SP_integer variance()
    {
    	return regressor.Variance();
    }
    
    /*
    void testing()
    {
    	// load the iris data
    	mat dataset;
    	bool loaded = mlpack::data::Load("iris.csv", dataset);
    
    	// split the data into train and test
    	mat trainData = dataset.cols(1, 4);
    	trainData.shed_row(trainData.n_rows - 1);
    	rowvec trainTarget = trainData.row(trainData.n_rows - 1);
    	trainData.shed_row(trainData.n_rows - 1);
    
    	mat testData = dataset.col(dataset.n_cols - 1);
    	testData.shed_row(testData.n_rows - 1);
    	rowvec testTarget = testData.row(testData.n_rows - 1);
    	testData.shed_row(testData.n_rows - 1);
    
    
    	// init the bayesian linear regressor model
    
    
    	// train the model
    	regressor.Train(trainData, trainTarget);
    
    	// predict with the test data
    	rowvec prediction;
    	regressor.Predict(testData, prediction);
    
    
    	// compare test target and prediction
    	cout << "Train Data: " << trainData << endl;
    	cout << "Train Target: " << trainTarget << endl;
    	cout << "Alpha" << alpha() << endl;
    	cout << "Beta" << beta() << endl;
    }
    */