void CMultitaskLogisticRegression::initialize_parameters()
{
set_z(0.0);
set_q(2.0);
set_termination(0);
set_regularization(0);
set_tolerance(1e-3);
set_max_iter(1000);
}
CSLEPMachine::CSLEPMachine(
float64_t z, CDotFeatures* train_features,
CLabels* train_labels) :
CLinearMachine(), m_z(1.0)
{
set_z(z);
set_features(train_features);
set_labels(train_labels);
set_termination(slep_options::get_default_termination());
set_regularization(slep_options::get_default_regularization());
set_tolerance(slep_options::get_default_tolerance());
set_max_iter(slep_options::get_default_max_iter());
}
void SimulatedAnnealingOrder::from_XML(const tinyxml2::XMLDocument& document)
{
const tinyxml2::XMLElement* root_element = document.FirstChildElement("SimulatedAnnealingOrder");
if(!root_element)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: IncrementalOrder class.\n"
<< "void from_XML(const tinyxml2::XMLDocument&) method.\n"
<< "SimulatedAnnealingOrder element is NULL.\n";
throw std::logic_error(buffer.str());
}
// Minimum order
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("MinimumOrder");
if(element)
{
const size_t new_minimum_order = atoi(element->GetText());
try
{
minimum_order = new_minimum_order;
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Maximum order
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("MaximumOrder");
if(element)
{
const size_t new_maximum_order = atoi(element->GetText());
try
{
maximum_order = new_maximum_order;
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Parameters assays number
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("TrialsNumber");
if(element)
{
const size_t new_trials_number = atoi(element->GetText());
try
{
set_trials_number(new_trials_number);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Performance calculation method
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("PerformanceCalculationMethod");
if(element)
{
const std::string new_performance_calculation_method = element->GetText();
try
{
set_performance_calculation_method(new_performance_calculation_method);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Cooling rate
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("CoolingRate");
if(element)
{
const double new_cooling_rate = atof(element->GetText());
try
{
set_cooling_rate(new_cooling_rate);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Reserve parameters data
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("ReserveParametersData");
if(element)
{
const std::string new_reserve_parameters_data = element->GetText();
try
{
set_reserve_parameters_data(new_reserve_parameters_data != "0");
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Reserve performance data
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("ReservePerformanceHistory");
if(element)
{
const std::string new_reserve_performance_data = element->GetText();
try
{
set_reserve_performance_data(new_reserve_performance_data != "0");
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Reserve selection performance data
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("ReserveSelectionPerformanceHistory");
if(element)
{
const std::string new_reserve_selection_performance_data = element->GetText();
try
{
set_reserve_selection_performance_data(new_reserve_selection_performance_data != "0");
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Reserve minimal parameters
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("ReserveMinimalParameters");
if(element)
{
const std::string new_reserve_minimal_parameters = element->GetText();
try
{
set_reserve_minimal_parameters(new_reserve_minimal_parameters != "0");
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Display
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("Display");
if(element)
{
const std::string new_display = element->GetText();
try
{
set_display(new_display != "0");
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Selection performance goal
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("SelectionPerformanceGoal");
if(element)
{
const double new_selection_performance_goal = atof(element->GetText());
try
{
set_selection_performance_goal(new_selection_performance_goal);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Maximum iterations number
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("MaximumIterationsNumber");
if(element)
{
const size_t new_maximum_iterations_number = atoi(element->GetText());
try
{
set_maximum_iterations_number(new_maximum_iterations_number);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Maximum time
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("MaximumTime");
if(element)
{
const double new_maximum_time = atoi(element->GetText());
try
{
set_maximum_time(new_maximum_time);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Tolerance
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("Tolerance");
if(element)
{
const double new_tolerance = atof(element->GetText());
try
{
set_tolerance(new_tolerance);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
// Minimum temperature
{
const tinyxml2::XMLElement* element = root_element->FirstChildElement("MinimumTemperature");
if(element)
{
const double new_minimum_temperature = atof(element->GetText());
try
{
set_minimum_temperature(new_minimum_temperature);
}
catch(const std::logic_error& e)
{
std::cout << e.what() << std::endl;
}
}
}
}
static int real_run_check (int round, PRN *prn)
{
int coeff_acc = 0, sderr_acc = 0, err = 0;
char line[512];
MODEL *pmod = NULL;
pmod = gretl_model_new();
if (pmod == NULL) {
fputs("Out of memory\n", stderr);
return 1;
}
set_tolerance();
catch_arctan();
if (!err) {
err = generate_params(line, round, prn);
}
if (!err) {
catch_log_depvar();
err = nl_parse_line(NLS, tester.model_spec, (const double **) Z,
datainfo, prn);
if (verbose) {
printf("%s\n", tester.model_spec);
}
if (err) {
fprintf(stderr, "%s: ERROR: in nl_parse_line\n '%s'\n",
tester.datname, tester.model_spec);
errmsg(err, prn);
return err;
}
}
if (!err) {
if (use_derivs) {
err = print_derivs(line, prn);
} else {
err = print_params(line, prn);
}
}
if (!err) {
*pmod = nl_model(&Z, datainfo, OPT_NONE, prn);
if (pmod->errcode) {
err = pmod->errcode;
fprintf(stderr, "%s: ERROR: model error %d\n", tester.datname, err);
errmsg(err, prn);
} else {
if (verbose) {
pmod->ID = 0;
printmodel(pmod, datainfo, OPT_NONE, prn);
}
print_tol = gretl_model_get_double(pmod, "tol");
total_iters += gretl_model_get_int(pmod, "iters");
get_accuracy(pmod, &coeff_acc, &sderr_acc);
if (coeff_acc < worst_coeff_acc) {
worst_coeff_acc = coeff_acc;
strcpy(worst_coeff_name, tester.datname);
}
/* Lanczos1 is weird */
if (strcmp(tester.datname, "Lanczos1") &&
sderr_acc < worst_sderr_acc) {
worst_sderr_acc = sderr_acc;
strcpy(worst_sderr_name, tester.datname);
}
}
gretl_model_free(pmod);
pmod = NULL;
}
if (err && !verbose) {
printf(" Estimation failed\n");
}
if (err) {
n_fail++;
} else {
avg_coeff_min += coeff_acc;
avg_sd_min += sderr_acc;
n_ok++;
}
if (!err) {
if (verbose) printf("\n ***\n");
if (coeff_acc >= 6) {
printf(" coefficient accuracy >= %d digits\n", coeff_acc);
} else if (coeff_acc >= MIN_DIGITS) {
printf(" coefficient accuracy >= %d digits\n", coeff_acc);
} else {
printf(" min. coefficient accuracy < %d digits\n", MIN_DIGITS);
}
if (sderr_acc >= 6) {
printf(" stderr accuracy >= %d digits\n", sderr_acc);
} else if (sderr_acc >= MIN_DIGITS) {
printf(" stderr accuracy >= %d digits\n", sderr_acc);
} else {
printf(" min. stderr accuracy < %d digits\n", MIN_DIGITS);
}
}
if (verbose)
printf("Round %d, error code = %d\n", round, err);
return err;
}
