Esempio n. 1
0
vector<ArrayXXb> PyArray_ToArraysXXb(PyObject* array) {
	if(PyArray_DESCR(array)->type != PyArray_DescrFromType(NPY_BOOL)->type)
		throw Exception("Can only handle arrays of bool values.");

	if(PyArray_NDIM(array) == 3) {
		vector<ArrayXXb> channels;

		if(PyArray_FLAGS(array) & NPY_F_CONTIGUOUS)
			for(int m = 0; m < PyArray_DIM(array, 2); ++m)
				channels.push_back(Matrix<bool, Dynamic, Dynamic, ColMajor>(
					PyArray_DIM(array, 0),
					PyArray_DIM(array, 1)));

		else if(PyArray_FLAGS(array) & NPY_C_CONTIGUOUS)
			for(int m = 0; m < PyArray_DIM(array, 2); ++m)
				channels.push_back(Matrix<bool, Dynamic, Dynamic, RowMajor>(
					PyArray_DIM(array, 0),
					PyArray_DIM(array, 1)));

		else
			throw Exception("Data must be stored in contiguous memory.");

		bool* data = reinterpret_cast<bool*>(PyArray_DATA(array));

		for(int m = 0; m < channels.size(); ++m)
			for(int i = 0; i < channels[m].size(); ++i)
				channels[m].data()[i] = data[m * channels[m].size() + i];

		return channels;
	} else {
		throw Exception("Can only handle three-dimensional arrays.");
	}
}
Esempio n. 2
0
bool CallbackInterface::operator()(int iter, const Trainable& cd) {
	CDObject* cdObj = reinterpret_cast<CDObject*>(CD_new(mType, 0, 0));

	// TODO: fix this hack
	cdObj->cd = const_cast<Trainable*>(&cd);
	cdObj->owner = false;

	// call Python object
	PyObject* args = Py_BuildValue("(iO)", iter, cdObj);
	PyObject* result = PyObject_CallObject(mCallback, args);
	Py_DECREF(args);

	// if cont is false, training will be aborted
	bool cont = true;

	if(result) {
		if(PyBool_Check(result))
			cont = (result == Py_True);
		Py_DECREF(result);
		Py_DECREF(cdObj);
	} else {
		Py_DECREF(cdObj);
		throw Exception("Some error occured during call to callback function.");
	}

	return cont;
}
Esempio n. 3
0
PyObject* MixtureComponent_train(MixtureComponentObject* self, PyObject* args, PyObject* kwds) {
	const char* kwlist[] = {"data", "weights", "parameters", 0};

	PyObject* data;
	PyObject* weights = 0;
	PyObject* parameters = 0;

	// read arguments
	if(!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", const_cast<char**>(kwlist),
		&data, &weights, &parameters))
		return 0;

	if(weights == Py_None)
		weights = 0;

	// make sure data is stored in NumPy array
	data = PyArray_FROM_OTF(data, NPY_DOUBLE, NPY_F_CONTIGUOUS | NPY_ALIGNED);

	if(!data) {
		PyErr_SetString(PyExc_TypeError, "Data has to be stored in NumPy array.");
		return 0;
	}

	bool converged;

	try {
		Mixture::Component::Parameters* params = PyObject_ToMixtureComponentParameters(parameters);

		if(weights) {
			MatrixXd weightsMatrix = PyArray_ToMatrixXd(weights);
			MatrixXd dataMatrix = PyArray_ToMatrixXd(data);

			if(weightsMatrix.rows() != 1)
				weightsMatrix = weightsMatrix.transpose();
			if(weightsMatrix.rows() != 1)
				throw Exception("Weights should be stored in a row vector.");

			converged = self->component->train(dataMatrix, weightsMatrix, *params);
		} else {
			converged = self->component->train(PyArray_ToMatrixXd(data), *params);
		}

		delete params;
	} catch(Exception exception) {
		Py_DECREF(data);
		PyErr_SetString(PyExc_RuntimeError, exception.message());
		return 0;
	}

	Py_DECREF(data);

	if(converged) {
		Py_INCREF(Py_True);
		return Py_True;
	} else {
		Py_INCREF(Py_False);
		return Py_False;
	}
}
Esempio n. 4
0
Trainable::Parameters* PyObject_ToMLRParameters(PyObject* parameters) {
	MLR::Parameters* params = dynamic_cast<MLR::Parameters*>(
		PyObject_ToParameters(parameters, new MLR::Parameters));

	// read parameters from dictionary
	if(parameters && parameters != Py_None) {
		PyObject* callback = PyDict_GetItemString(parameters, "callback");
		if(callback)
			if(PyCallable_Check(callback))
				params->callback = new CallbackInterface(&MLR_type, callback);
			else if(callback != Py_None)
				throw Exception("callback should be a function or callable object.");

		PyObject* train_weights = PyDict_GetItemString(parameters, "train_weights");
		if(train_weights)
			if(PyBool_Check(train_weights))
				params->trainWeights = (train_weights == Py_True);
			else
				throw Exception("train_weights should be of type `bool`.");

		PyObject* train_biases = PyDict_GetItemString(parameters, "train_biases");
		if(train_biases)
			if(PyBool_Check(train_biases))
				params->trainBiases = (train_biases == Py_True);
			else
				throw Exception("train_biases should be of type `bool`.");

		PyObject* regularize_weights = PyDict_GetItemString(parameters, "regularize_weights");
		if(regularize_weights)
			params->regularizeWeights = PyObject_ToRegularizer(regularize_weights);

		PyObject* regularize_biases = PyDict_GetItemString(parameters, "regularize_biases");
		if(regularize_biases)
			params->regularizeBiases = PyObject_ToRegularizer(regularize_biases);

	}

	return params;
}
Esempio n. 5
0
MatrixXd PyArray_ToMatrixXd(PyObject* array) {
	if(PyArray_DESCR(array)->type != PyArray_DescrFromType(NPY_DOUBLE)->type)
		throw Exception("Can only handle arrays of double values.");

	if(PyArray_NDIM(array) == 1) {
		if(PyArray_FLAGS(array) & NPY_F_CONTIGUOUS)
			return Map<Matrix<double, Dynamic, Dynamic, ColMajor> >(
				reinterpret_cast<double*>(PyArray_DATA(array)),
				PyArray_DIM(array, 0), 1);

		else if(PyArray_FLAGS(array) & NPY_C_CONTIGUOUS)
			return Map<Matrix<double, Dynamic, Dynamic, RowMajor> >(
				reinterpret_cast<double*>(PyArray_DATA(array)),
				PyArray_DIM(array, 0), 1);

		else
			throw Exception("Data must be stored in contiguous memory.");

	} else if(PyArray_NDIM(array) == 2) {
		if(PyArray_FLAGS(array) & NPY_F_CONTIGUOUS)
			return Map<Matrix<double, Dynamic, Dynamic, ColMajor> >(
				reinterpret_cast<double*>(PyArray_DATA(array)),
				PyArray_DIM(array, 0),
				PyArray_DIM(array, 1));

		else if(PyArray_FLAGS(array) & NPY_C_CONTIGUOUS)
			return Map<Matrix<double, Dynamic, Dynamic, RowMajor> >(
				reinterpret_cast<double*>(PyArray_DATA(array)),
				PyArray_DIM(array, 0),
				PyArray_DIM(array, 1));

		else
			throw Exception("Data must be stored in contiguous memory.");

	} else {
		throw Exception("Can only handle one- and two-dimensional arrays.");
	}
}
Esempio n. 6
0
Tuples PyList_AsTuples(PyObject* list) {
	if(!PyList_Check(list))
		throw Exception("Indices should be given in a list.");

	Tuples tuples;

	// convert list of tuples
	for(int i = 0; i < PyList_Size(list); ++i) {
		PyObject* tuple = PyList_GetItem(list, i);

		if(!PyTuple_Check(tuple) || PyTuple_Size(tuple) != 2)
			throw Exception("Indices should be stored in a list of 2-tuples.");

		int m, n;

		if(!PyArg_ParseTuple(tuple, "ii", &m, &n))
			throw Exception("Indices should be integers.");

		tuples.push_back(make_pair(m, n));
	}

	return tuples;
}
Esempio n. 7
0
Regularizer PyObject_ToRegularizer(PyObject* regularizer) {
	if(PyFloat_Check(regularizer))
		return Regularizer(PyFloat_AsDouble(regularizer));

	if(PyInt_Check(regularizer))
		return Regularizer(static_cast<double>(PyInt_AsLong(regularizer)));

	if(PyDict_Check(regularizer)) {
		PyObject* r_strength = PyDict_GetItemString(regularizer, "strength");
		PyObject* r_transform = PyDict_GetItemString(regularizer, "transform");
		PyObject* r_norm = PyDict_GetItemString(regularizer, "norm");

		if(r_transform == Py_None)
			r_transform = 0;

		Regularizer::Norm norm = Regularizer::L2;

		if(r_norm) {
			if(PyString_Size(r_norm) != 2)
				throw Exception("Regularizer norm should be 'L1' or 'L2'.");

			switch(PyString_AsString(r_norm)[1]) {
				default:
					throw Exception("Regularizer norm should be 'L1' or 'L2'.");

				case '1':
					norm = Regularizer::L1;
					break;

				case '2':
					norm = Regularizer::L2;
					break;
			}
		}

		double strength = r_transform ? 1. : 0.;

		if(r_strength) {
			if(PyInt_Check(r_strength)) {
				strength = static_cast<double>(PyInt_AsLong(r_strength));
			} else {
				if(!PyFloat_Check(r_strength))
					throw Exception("Regularizer strength should be of type `float`.");
				strength = PyFloat_AsDouble(r_strength);
			}
		}

		if(r_transform) {
			PyObject* matrix = PyArray_FROM_OTF(r_transform, NPY_DOUBLE, NPY_IN_ARRAY);

			if(!matrix)
				throw Exception("Regularizer transform should be of type `ndarray`.");

			return Regularizer(PyArray_ToMatrixXd(matrix), norm, strength);
		} else {
			return Regularizer(strength, norm);
		}
	}

	PyObject* matrix = PyArray_FROM_OTF(regularizer, NPY_DOUBLE, NPY_IN_ARRAY);

	if(matrix)
		return Regularizer(PyArray_ToMatrixXd(matrix));

	throw Exception("Regularizer should be of type `dict`, `float` or `ndarray`.");
}
Esempio n. 8
0
Mixture::Component::Parameters* PyObject_ToMixtureComponentParameters(PyObject* parameters) {
	Mixture::Component::Parameters* params = new Mixture::Component::Parameters;

	if(parameters && parameters != Py_None) {
		PyObject* verbosity = PyDict_GetItemString(parameters, "verbosity");
		if(verbosity)
			if(PyInt_Check(verbosity))
				params->verbosity = PyInt_AsLong(verbosity);
			else if(PyFloat_Check(verbosity))
				params->verbosity = static_cast<int>(PyFloat_AsDouble(verbosity));
			else
				throw Exception("verbosity should be of type `int`.");

		PyObject* max_iter = PyDict_GetItemString(parameters, "max_iter");
		if(max_iter)
			if(PyInt_Check(max_iter))
				params->maxIter = PyInt_AsLong(max_iter);
			else if(PyFloat_Check(max_iter))
				params->maxIter = static_cast<int>(PyFloat_AsDouble(max_iter));
			else
				throw Exception("max_iter should be of type `int`.");

		PyObject* threshold = PyDict_GetItemString(parameters, "threshold");
		if(threshold)
			if(PyFloat_Check(threshold))
				params->threshold = PyFloat_AsDouble(threshold);
			else if(PyInt_Check(threshold))
				params->threshold = static_cast<double>(PyFloat_AsDouble(threshold));
			else
				throw Exception("threshold should be of type `float`.");

		PyObject* train_priors = PyDict_GetItemString(parameters, "train_priors");
		if(train_priors)
			if(PyBool_Check(train_priors))
				params->trainPriors = (train_priors == Py_True);
			else
				throw Exception("train_priors should be of type `bool`.");

		PyObject* train_covariance = PyDict_GetItemString(parameters, "train_covariance");
		if(train_covariance)
			if(PyBool_Check(train_covariance))
				params->trainCovariance = (train_covariance == Py_True);
			else
				throw Exception("train_covariance should be of type `bool`.");

		PyObject* train_scales = PyDict_GetItemString(parameters, "train_scales");
		if(train_scales)
			if(PyBool_Check(train_scales))
				params->trainScales = (train_scales == Py_True);
			else
				throw Exception("train_scales should be of type `bool`.");

		PyObject* train_mean = PyDict_GetItemString(parameters, "train_mean");
		if(train_mean)
			if(PyBool_Check(train_mean))
				params->trainMean = (train_mean == Py_True);
			else
				throw Exception("train_mean should be of type `bool`.");

		PyObject* regularize_priors = PyDict_GetItemString(parameters, "regularize_priors");
		if(regularize_priors)
			if(PyFloat_Check(regularize_priors))
				params->regularizePriors = PyFloat_AsDouble(regularize_priors);
			else if(PyInt_Check(regularize_priors))
				params->regularizePriors = static_cast<double>(PyFloat_AsDouble(regularize_priors));
			else
				throw Exception("regularize_priors should be of type `float`.");

		PyObject* regularize_covariance = PyDict_GetItemString(parameters, "regularize_covariance");
		if(regularize_covariance)
			if(PyFloat_Check(regularize_covariance))
				params->regularizeCovariance = PyFloat_AsDouble(regularize_covariance);
			else if(PyInt_Check(regularize_covariance))
				params->regularizeCovariance = static_cast<double>(PyFloat_AsDouble(regularize_covariance));
			else
				throw Exception("regularize_covariance should be of type `float`.");

		PyObject* regularize_scales = PyDict_GetItemString(parameters, "regularize_scales");
		if(regularize_scales)
			if(PyFloat_Check(regularize_scales))
				params->regularizeScales = PyFloat_AsDouble(regularize_scales);
			else if(PyInt_Check(regularize_scales))
				params->regularizeScales = static_cast<double>(PyFloat_AsDouble(regularize_scales));
			else
				throw Exception("regularize_scales should be of type `float`.");

		PyObject* regularize_mean = PyDict_GetItemString(parameters, "regularize_mean");
		if(regularize_mean)
			if(PyFloat_Check(regularize_mean))
				params->regularizeMean = PyFloat_AsDouble(regularize_mean);
			else if(PyInt_Check(regularize_mean))
				params->regularizeMean = static_cast<double>(PyFloat_AsDouble(regularize_mean));
			else
				throw Exception("regularize_mean should be of type `float`.");
	}

	return params;
}
Esempio n. 9
0
Mixture::Parameters* PyObject_ToMixtureParameters(PyObject* parameters) {
	Mixture::Parameters* params = new Mixture::Parameters;

	if(parameters && parameters != Py_None) {
		PyObject* verbosity = PyDict_GetItemString(parameters, "verbosity");
		if(verbosity)
			if(PyInt_Check(verbosity))
				params->verbosity = PyInt_AsLong(verbosity);
			else if(PyFloat_Check(verbosity))
				params->verbosity = static_cast<int>(PyFloat_AsDouble(verbosity));
			else
				throw Exception("verbosity should be of type `int`.");

		PyObject* max_iter = PyDict_GetItemString(parameters, "max_iter");
		if(max_iter)
			if(PyInt_Check(max_iter))
				params->maxIter = PyInt_AsLong(max_iter);
			else if(PyFloat_Check(max_iter))
				params->maxIter = static_cast<int>(PyFloat_AsDouble(max_iter));
			else
				throw Exception("max_iter should be of type `int`.");

		PyObject* threshold = PyDict_GetItemString(parameters, "threshold");
		if(threshold)
			if(PyFloat_Check(threshold))
				params->threshold = PyFloat_AsDouble(threshold);
			else if(PyInt_Check(threshold))
				params->threshold = static_cast<double>(PyFloat_AsDouble(threshold));
			else
				throw Exception("threshold should be of type `float`.");

		PyObject* val_iter = PyDict_GetItemString(parameters, "val_iter");
		if(val_iter)
			if(PyInt_Check(val_iter))
				params->valIter = PyInt_AsLong(val_iter);
			else if(PyFloat_Check(val_iter))
				params->valIter = static_cast<int>(PyFloat_AsDouble(val_iter));
			else
				throw Exception("val_iter should be of type `int`.");

		PyObject* val_look_ahead = PyDict_GetItemString(parameters, "val_look_ahead");
		if(val_look_ahead)
			if(PyInt_Check(val_look_ahead))
				params->valLookAhead = PyInt_AsLong(val_look_ahead);
			else if(PyFloat_Check(val_look_ahead))
				params->valLookAhead = static_cast<int>(PyFloat_AsDouble(val_look_ahead));
			else
				throw Exception("val_look_ahead should be of type `int`.");

		PyObject* initialize = PyDict_GetItemString(parameters, "initialize");
		if(initialize)
			if(PyBool_Check(initialize))
				params->initialize = (initialize == Py_True);
			else
				throw Exception("initialize should be of type `bool`.");

		PyObject* train_priors = PyDict_GetItemString(parameters, "train_priors");
		if(train_priors)
			if(PyBool_Check(train_priors))
				params->trainPriors = (train_priors == Py_True);
			else
				throw Exception("train_priors should be of type `bool`.");

		PyObject* train_components = PyDict_GetItemString(parameters, "train_components");
		if(train_components)
			if(PyBool_Check(train_components))
				params->trainComponents = (train_components == Py_True);
			else
				throw Exception("train_components should be of type `bool`.");

		PyObject* regularize_priors = PyDict_GetItemString(parameters, "regularize_priors");
		if(regularize_priors)
			if(PyFloat_Check(regularize_priors))
				params->regularizePriors = PyFloat_AsDouble(regularize_priors);
			else if(PyInt_Check(regularize_priors))
				params->regularizePriors = static_cast<double>(PyFloat_AsDouble(regularize_priors));
			else
				throw Exception("regularize_priors should be of type `float`.");
	}

	return params;
}
Esempio n. 10
0
Trainable::Parameters* PyObject_ToMCGSMParameters(PyObject* parameters) {
	MCGSM::Parameters* params = dynamic_cast<MCGSM::Parameters*>(
		PyObject_ToParameters(parameters, new MCGSM::Parameters));

	// read parameters from dictionary
	if(parameters && parameters != Py_None) {
		PyObject* callback = PyDict_GetItemString(parameters, "callback");
		if(callback)
			if(PyCallable_Check(callback))
				params->callback = new CallbackInterface(&MCGSM_type, callback);
			else if(callback != Py_None)
				throw Exception("callback should be a function or callable object.");

		PyObject* train_priors = PyDict_GetItemString(parameters, "train_priors");
		if(train_priors)
			if(PyBool_Check(train_priors))
				params->trainPriors = (train_priors == Py_True);
			else
				throw Exception("train_priors should be of type `bool`.");

		PyObject* train_scales = PyDict_GetItemString(parameters, "train_scales");
		if(train_scales)
			if(PyBool_Check(train_scales))
				params->trainScales = (train_scales == Py_True);
			else
				throw Exception("train_scales should be of type `bool`.");

		PyObject* train_weights = PyDict_GetItemString(parameters, "train_weights");
		if(train_weights)
			if(PyBool_Check(train_weights))
				params->trainWeights = (train_weights == Py_True);
			else
				throw Exception("train_weights should be of type `bool`.");

		PyObject* train_features = PyDict_GetItemString(parameters, "train_features");
		if(train_features)
			if(PyBool_Check(train_features))
				params->trainFeatures = (train_features == Py_True);
			else
				throw Exception("train_features should be of type `bool`.");

		PyObject* train_cholesky_factors = PyDict_GetItemString(parameters, "train_cholesky_factors");
		if(train_cholesky_factors)
			if(PyBool_Check(train_cholesky_factors))
				params->trainCholeskyFactors = (train_cholesky_factors == Py_True);
			else
				throw Exception("train_cholesky_factors should be of type `bool`.");

		PyObject* train_predictors = PyDict_GetItemString(parameters, "train_predictors");
		if(train_predictors)
			if(PyBool_Check(train_predictors))
				params->trainPredictors = (train_predictors == Py_True);
			else
				throw Exception("train_predictors should be of type `bool`.");

		PyObject* train_linear_features = PyDict_GetItemString(parameters, "train_linear_features");
		if(train_linear_features)
			if(PyBool_Check(train_linear_features))
				params->trainLinearFeatures = (train_linear_features == Py_True);
			else
				throw Exception("train_linear_features should be of type `bool`.");

		PyObject* train_means = PyDict_GetItemString(parameters, "train_means");
		if(train_means)
			if(PyBool_Check(train_means))
				params->trainMeans = (train_means == Py_True);
			else
				throw Exception("train_means should be of type `bool`.");

		PyObject* regularize_features = PyDict_GetItemString(parameters, "regularize_features");
		if(regularize_features)
			params->regularizeFeatures = PyObject_ToRegularizer(regularize_features);

		PyObject* regularize_predictors = PyDict_GetItemString(parameters, "regularize_predictors");
		if(regularize_predictors)
			params->regularizePredictors = PyObject_ToRegularizer(regularize_predictors);

		PyObject* regularize_weights = PyDict_GetItemString(parameters, "regularize_weights");
		if(regularize_weights)
			params->regularizeWeights = PyObject_ToRegularizer(regularize_weights);

		PyObject* regularize_linear_features = PyDict_GetItemString(parameters, "regularize_linear_features");
		if(regularize_linear_features)
			params->regularizeLinearFeatures = PyObject_ToRegularizer(regularize_linear_features);

		PyObject* regularize_means = PyDict_GetItemString(parameters, "regularize_means");
		if(regularize_means)
			params->regularizeMeans = PyObject_ToRegularizer(regularize_means);
	}

	return params;
}