void test_migration()
{
char filename_template[] = "migration_dropping_test.XXXXXX";
char* filename = mktemp(filename_template);
/* create one instance of each class */
CTestClassOld* old_instance=new CTestClassOld();
CTestClassNew* new_instance=new CTestClassNew();
CSerializableAsciiFile* file;
/* serialize int instance, use custom parameter version */
file=new CSerializableAsciiFile(filename, 'w');
old_instance->save_serializable(file, "", 0);
file->close();
SG_UNREF(file);
/* de-serialize float instance, use custom parameter version */
file=new CSerializableAsciiFile(filename, 'r');
new_instance->load_serializable(file, "", 1);
file->close();
SG_UNREF(file);
/* assert that content is equal */
check_equalness(old_instance, new_instance);
SG_UNREF(old_instance);
SG_UNREF(new_instance);
SG_UNREF(file);
unlink(filename);
}
void test_migration()
{
/* create one instance of each class */
CTestClassInt* int_instance=new CTestClassInt();
CTestClassFloat* float_instance=new CTestClassFloat();
CSerializableAsciiFile* file;
/* serialize int instance, use custom parameter version */
file=new CSerializableAsciiFile(filename, 'w');
int_instance->save_serializable(file, "", -1);
file->close();
SG_UNREF(file);
/* now the magic happens, the float instance is derserialized from file.
* Note that the parameter types are different. they will all be mapped.
* See migration methods. Everything is just converted, value is kept.
* The float instance has different initial values for all members, however,
* after de-serializing it from the int_instance file, the values should be
* the same
*
* The parameter mappings are chosen in such way that CTestClassInt could
* be seen as an old version of CTestClassFloat. */
/* de-serialize float instance, use custom parameter version
* Note that a warning will appear, complaining that there is no parameter
* version in file. This is not true, the version is -1, which is used here
* as custom version. Normally numbers >=0 are used. */
file=new CSerializableAsciiFile(filename, 'r');
float_instance->load_serializable(file, "", 1);
file->close();
SG_UNREF(file);
/* assert that content is equal */
check_equalness(int_instance, float_instance);
SG_UNREF(int_instance);
SG_UNREF(float_instance);
SG_UNREF(file);
}
int main(int argc, char** argv)
{
init_shogun_with_defaults();
sg_io->set_loglevel(MSG_DEBUG);
/* create feature data matrix */
SGMatrix<int32_t> data(3, 20);
/* fill matrix with random data */
for (index_t i=0; i<20*3; ++i)
{
if (i%2==0)
data.matrix[i]=0;
else
data.matrix[i]=CMath::random(1, 9);
}
/* create sparse features */
CSparseFeatures<int32_t>* sparse_features=new CSparseFeatures<int32_t>(data);
CSerializableAsciiFile* file;
file=new CSerializableAsciiFile("sparseFeatures.txt", 'w');
sparse_features->save_serializable(file);
file->close();
SG_UNREF(file);
/* this will fail with a warning, same with CSerializableHdf5File and xml serialization*/
CSparseFeatures<int32_t>* sparse_features_loaded = new CSparseFeatures<int32_t>();
file = new CSerializableAsciiFile("sparseFeatures.txt", 'r');
sparse_features_loaded->load_serializable(file);
SG_UNREF(file);
SG_UNREF(sparse_features_loaded);
SG_UNREF(sparse_features);
exit_shogun();
}
void test_load_file_parameter()
{
/* create one instance of each class */
CTestClassInt* int_instance=new CTestClassInt();
CTestClassFloat* float_instance=new CTestClassFloat();
CSerializableAsciiFile* file;
/* serialize int instance */
file=new CSerializableAsciiFile(filename, 'w');
int_instance->save_serializable(file);
file->close();
SG_UNREF(file);
/* reopen file for reading */
file=new CSerializableAsciiFile(filename, 'r');
/* versions that are used in this example */
int32_t file_version=-1;
int32_t current_version=1;
/* load all parameter data, current version is set to 1 here */
DynArray<TParameter*>* params=
float_instance->load_all_file_parameters(file_version,
current_version, file, "");
/* create an array of param infos from float instance parameters */
DynArray<const SGParamInfo*>* param_infos=
new DynArray<const SGParamInfo*>();
for (index_t i=0; i<float_instance->m_parameters->get_num_parameters(); ++i)
{
param_infos->append_element(
new SGParamInfo(float_instance->m_parameters->get_parameter(i),
current_version));
}
/* here the magic mapping happens */
float_instance->map_parameters(params, file_version, param_infos);
/* assert equalness of all parameters
* alphabetical order is "float_features", "matrix", "number", "vector" */
TParameter* current=NULL;
/* "float_features" (no type change here) */
current=params->get_element(0);
SG_SPRINT("checking \"float_features\":\n");
ASSERT(!strcmp(current->m_name, "float_features"));
/* cast to simple features */
CDenseFeatures<int32_t>* features=
*((CDenseFeatures<int32_t>**)current->m_parameter);
SG_SPRINT("checking address (mapped!=original): %p!=%p\n", features,
int_instance->m_features);
ASSERT((void*)features!=(void*)int_instance->m_features);
SG_SPRINT("checking cache size: %d==%d\n", features->get_cache_size(),
int_instance->m_features->get_cache_size());
ASSERT(features->get_cache_size()==
int_instance->m_features->get_cache_size());
SG_SPRINT("checking combined feature weight: %f==%f\n",
features->get_combined_feature_weight(),
int_instance->m_features->get_combined_feature_weight());
ASSERT(features->get_combined_feature_weight()==
int_instance->m_features->get_combined_feature_weight());
SG_SPRINT("checking feature matrix:\n");
SGMatrix<int32_t> int_matrix=int_instance->m_features->get_feature_matrix();
SGMatrix<int32_t> float_matrix=features->get_feature_matrix();
SG_SPRINT("number of rows: %d==%d\n", int_matrix.num_rows,
float_matrix.num_rows);
ASSERT(int_matrix.num_rows==float_matrix.num_rows);
SG_SPRINT("number of cols: %d==%d\n", int_matrix.num_cols,
float_matrix.num_cols);
ASSERT(int_matrix.num_cols==float_matrix.num_cols);
SGMatrix<int32_t>::display_matrix(float_matrix.matrix, float_matrix.num_rows,
float_matrix.num_cols, "mapped");
SGMatrix<int32_t>::display_matrix(int_matrix.matrix, int_matrix.num_rows,
int_matrix.num_cols, "original");
for (index_t i=0; i<int_matrix.num_rows*int_matrix.num_cols; ++i)
ASSERT(int_matrix.matrix[i]==float_matrix.matrix[i]);
/* "matrix" */
current=params->get_element(1);
ASSERT(!strcmp(current->m_name, "matrix"));
SGMatrix<float64_t> matrix(*(float64_t**)current->m_parameter,
*current->m_datatype.m_length_y, *current->m_datatype.m_length_x, false);
SG_SPRINT("checking \"matrix:\n");
SG_SPRINT("number of rows: %d==%d\n", *current->m_datatype.m_length_y,
int_instance->m_matrix_rows);
ASSERT(*current->m_datatype.m_length_y==int_instance->m_matrix_rows);
SGMatrix<float64_t>::display_matrix(matrix.matrix, matrix.num_rows, matrix.num_cols,
"mapped");
SGMatrix<int32_t>::display_matrix(int_instance->m_matrix, int_instance->m_matrix_rows,
int_instance->m_matrix_cols, "original");
for (index_t i=0; i<int_instance->m_matrix_rows*int_instance->m_matrix_cols;
++i)
{
ASSERT(matrix.matrix[i]==int_instance->m_matrix[i]);
}
/* "number" */
current=params->get_element(2);
ASSERT(!strcmp(current->m_name, "number"));
float64_t number=*((float64_t*)current->m_parameter);
SG_SPRINT("checking \"number\": %f == %d\n", number,
int_instance->m_number);
ASSERT(number==int_instance->m_number);
/* "vector" */
current=params->get_element(3);
ASSERT(!strcmp(current->m_name, "vector"));
SGVector<float64_t> vector(*(float64_t**)current->m_parameter,
*current->m_datatype.m_length_y, false);
SG_SPRINT("checking \"vector:\n");
SG_SPRINT("length: %d==%d\n", *current->m_datatype.m_length_y,
int_instance->m_vector_length);
ASSERT(*current->m_datatype.m_length_y==int_instance->m_vector_length);
SGVector<float64_t>::display_vector(vector.vector, vector.vlen, "mapped");
SGVector<int32_t>::display_vector(int_instance->m_vector, int_instance->m_vector_length,
"original");
for (index_t i=0; i<int_instance->m_vector_length; ++i)
ASSERT(vector.vector[i]==int_instance->m_vector[i]);
/* clean up */
for (index_t i=0; i<param_infos->get_num_elements(); ++i)
delete param_infos->get_element(i);
delete param_infos;
for (index_t i=0; i<params->get_num_elements(); ++i)
{
/* delete data of TParameters because they were mapped */
params->get_element(i)->m_delete_data=true;
delete params->get_element(i);
}
delete params;
file->close();
SG_UNREF(file);
SG_UNREF(int_instance);
SG_UNREF(float_instance);
}
void test_load_file_parameter()
{
char filename_tmp[] = "load_all_file_test.XXXXXX";
int fd = mkstemp(filename_tmp);
ASSERT(fd != -1);
int retval = close(fd);
ASSERT(retval != -1);
char* filename = filename_tmp;
/* create one instance of each class */
CTestClassInt* int_instance=new CTestClassInt();
CTestClassFloat* float_instance=new CTestClassFloat();
CSerializableAsciiFile* file;
/* serialize int instance */
file=new CSerializableAsciiFile(filename, 'w');
int_instance->save_serializable(file);
file->close();
SG_UNREF(file);
/* reopen file for reading */
file=new CSerializableAsciiFile(filename, 'r');
int32_t file_version=-1;
/* load all parameter data, current version is set to 1 here */
DynArray<TParameter*>* params=
float_instance->load_all_file_parameters(file_version, 1, file, "");
/* test the result */
for (index_t i=0; i<params->get_num_elements(); ++i)
{
TParameter* current=params->get_element(i);
current->m_delete_data = true; // TODO: This shouldn't be necessary!
/* ensure that data is same as of the instance for all parameters */
if (!strcmp(current->m_name, "number"))
{
int32_t value_number=*((int32_t*)current->m_parameter);
SG_SPRINT("%i\n", value_number);
ASSERT(value_number=int_instance->m_number);
}
else if (!strcmp(current->m_name, "vector"))
{
int32_t* value_vector=*((int32_t**)current->m_parameter);
SGVector<int32_t>::display_vector(value_vector, int_instance->m_vector_length);
for (index_t j=0; j<int_instance->m_vector_length; ++j)
ASSERT(value_vector[j]=int_instance->m_vector[j]);
}
else if (!strcmp(current->m_name, "matrix"))
{
int32_t* value_matrix=*((int32_t**)current->m_parameter);
SGMatrix<int32_t>::display_matrix(value_matrix, int_instance->m_matrix_rows,
int_instance->m_matrix_cols);
for (index_t j=0; j<int_instance->m_matrix_rows*int_instance->m_matrix_cols;
++j)
{
ASSERT(value_matrix[j]==int_instance->m_matrix[j]);
}
}
else if (!strcmp(current->m_name, "int_features"))
{
CDenseFeatures<int32_t>* features=
*((CDenseFeatures<int32_t>**)
current->m_parameter);
SGMatrix<int32_t> feature_matrix_loaded=
features->get_feature_matrix();
SGMatrix<int32_t> feature_matrix_original=
int_instance->m_features->get_feature_matrix();
SGMatrix<int32_t>::display_matrix(feature_matrix_loaded.matrix,
feature_matrix_loaded.num_rows,
feature_matrix_loaded.num_cols,
"features");
for (index_t j=0;
j<int_instance->m_matrix_rows*int_instance->m_matrix_cols;
++j)
{
ASSERT(feature_matrix_original.matrix[j]==
feature_matrix_loaded.matrix[j]);
}
}
}
/* assert that parameter data is sorted */
for (index_t i=1; i<params->get_num_elements(); ++i)
{
/* assert via TParameter < and == operator */
TParameter* t1=params->get_element(i-1);
TParameter* t2=params->get_element(i);
ASSERT((*t1)<(*t2) || (*t1)==(*t2));
/* assert via name (which is used in the operator, but to be sure */
const char* s1=t1->m_name;
const char* s2=t2->m_name;
SG_SPRINT("param \"%s\" <= \"%s\" ? ... ", s1, s2);
ASSERT(strcmp(s1, s2)<=0);
SG_SPRINT("yes\n");
}
/* clean up */
for (index_t i=0; i<params->get_num_elements(); ++i)
delete params->get_element(i);
delete params;
file->close();
SG_UNREF(file);
SG_UNREF(int_instance);
SG_UNREF(float_instance);
unlink(filename);
}