void sse_test_mul()
{
SIMD_MATRIX2F(mat2x2) = { 1,2,3,4 };
SIMD_MATRIX2F(mat2x2_2) = { 5,6,7,8 };
SIMD_MATRIX3F(mat3x3) = { 1, 2, 3,
4, 1, 1,
1, 8, 9 };
SIMD_MATRIX3F(mat3x3_2) = { 1, 2, 3,
4, 16, 11,
1, 8, 9 };
SIMD_MATRIX4F(mat4x4) = { 1, 2, 3, 10,
1, 5, 1, 20,
7, 8, 2, 30,
4, 1, 5, 100 };
SIMD_MATRIX4F(mat4x4_2) = { 9, 10, 11, 22,
1, 5, 1, 20,
7, 8, 2, 30,
4, 1, 5, 100 };
SIMD_MATRIX2F(mat2x2_tag);
SIMD_MATRIX3F(mat3x3_tag);
SIMD_MATRIX4F(mat4x4_tag);
PECKER_LOG_STR("STD MUL\n");
PECKER_LOG_STR("MAT2X2\n");
matrix_dot_unsafe_std_t::mul(mat2x2_tag, mat2x2, mat2x2_2);
printf_mat(&mat2x2_tag);
PECKER_LOG_STR("MAT3X3\n");
matrix_dot_unsafe_std_t::mul(mat3x3_tag, mat3x3, mat3x3_2);
printf_mat(&mat3x3_tag);
PECKER_LOG_STR("MAT4X4\n");
matrix_dot_unsafe_std_t::mul(mat4x4_tag, mat4x4, mat4x4_2);
printf_mat(&mat4x4_tag);
PECKER_LOG_STR("SSE MUL\n");
PECKER_LOG_STR("MAT2X2\n");
matrix_dot_unsafe_sse_t::mul(mat2x2_tag, mat2x2, mat2x2_2);
printf_mat(&mat2x2_tag);
PECKER_LOG_STR("MAT3X3\n");
matrix_dot_unsafe_sse_t::mul(mat3x3_tag, mat3x3, mat3x3_2);
printf_mat(&mat3x3_tag);
PECKER_LOG_STR("MAT4X4\n");
matrix_dot_unsafe_sse_t::mul(mat4x4_tag, mat4x4, mat4x4_2);
printf_mat(&mat4x4_tag);
}
double MedSTC::sparse_coding(char* model_dir, Corpus* pC, Params *param)
{
char model_root[512];
sprintf(model_root, "%s/final", model_dir);
load_model(model_root);
init_param( pC );
// remove unseen words
Document* doc = NULL;
if ( pC->num_terms > m_nNumTerms ) {
for ( int i=0; i<pC->num_docs; i ++ ) {
doc = &(pC->docs[i]);
for ( int k=0; k<doc->length; k++ )
if ( doc->words[k] >= m_nNumTerms )
doc->words[k] = m_nNumTerms - 1;
}
}
// allocate memory
int max_length = pC->max_corpus_length();
double **phi = (double**)malloc(sizeof(double*)*max_length);
for (int n=0; n<max_length; n++) {
phi[n] = (double*)malloc(sizeof(double) * m_nK);
}
double **theta = (double**)malloc(sizeof(double*)*(pC->num_docs));
for (int d=0; d<pC->num_docs; d++) {
theta[d] = (double*)malloc(sizeof(double)*m_nK);
}
double **avgTheta = (double**)malloc(sizeof(double*)*m_nLabelNum);
for ( int k=0; k<m_nLabelNum; k++ ) {
avgTheta[k] = (double*)malloc(sizeof(double)*m_nK);
memset(avgTheta[k], 0, sizeof(double)*m_nK);
}
vector<vector<double> > avgWrdCode(m_nNumTerms);
vector<int> wrdCount(m_nNumTerms, 0);
for ( int i=0; i<m_nNumTerms; i++ ) {
avgWrdCode[i].resize( m_nK, 0 );
}
vector<int> perClassDataNum(m_nLabelNum, 0);
char filename[100];
sprintf(filename, "%s/evl-slda-obj.dat", model_dir);
FILE* fileptr = fopen(filename, "w");
double dEntropy = 0, dobj = 0, dNonZeroWrdCode = 0, dNonZeroDocCode = 0;
int nTotalWrd = 0;
for (int d=0; d<pC->num_docs; d++) {
doc = &(pC->docs[d]);
// initialize phi.
for (int n=0; n<doc->length; n++) {
double *phiPtr = phi[n];
for ( int k=0; k<m_nK; k++ ) {
phiPtr[k] = 1.0 / m_nK;
}
}
dobj = sparse_coding( doc, d, param, theta[d], phi );
// do prediction
doc->predlabel = predict(theta[d]);
doc->scores = (double*) malloc(sizeof(double)*m_nLabelNum);;
predict_scores(doc->scores,theta[d]);
doc->lhood = dobj;
fprintf(fileptr, "%5.5f\n", dobj);
//dEntropy += safe_entropy( exp[d], m_nK );
int gndLabel = doc->gndlabel;
perClassDataNum[gndLabel] ++;
for ( int k=0; k<m_nK; k++ ) {
for ( int n=0; n<doc->length; n++ ) {
//fprintf( wrdfptr, "%.10f ", phi[n][k] );
if ( phi[n][k] > 0/*1e-10*/ ) dNonZeroWrdCode ++;
}
//fprintf( wrdfptr, "\n" );
avgTheta[gndLabel][k] += theta[d][k];
if ( theta[d][k] > 0 ) dNonZeroDocCode ++;
}
nTotalWrd += doc->length;
//fprintf( wrdfptr, "\n" );
//fflush( wrdfptr );
dEntropy += safe_entropy( theta[d], m_nK );
//// the average distribution of each word on the topics.
//for ( int n=0; n<doc->length; n++ ) {
// int wrd = doc->words[n];
// wrdCount[wrd] ++;
// for ( int k=0; k<m_nK; k++ ) {
// avgWrdCode[wrd][k] += phi[n][k];
// }
//}
}
fclose( fileptr );
/* save theta & average theta. */
sprintf(filename, "%s/evl-theta.dat", model_dir);
save_theta(filename, theta, pC->num_docs, m_nK);
sprintf(filename, "%s/evl-avgTheta.dat", model_dir);
for ( int m=0; m<m_nLabelNum; m++ ) {
int dataNum = perClassDataNum[m];
for ( int k=0; k<m_nK; k++ ) {
avgTheta[m][k] /= dataNum;
}
}
printf_mat(filename, avgTheta, m_nLabelNum, m_nK);
/* save the average topic distribution for each word. */
sprintf(filename, "%s/evl-avgWrdCode.dat", model_dir);
fileptr = fopen( filename, "w" );
for ( int i=0; i<m_nNumTerms; i++ ) {
double dNorm = wrdCount[i];
for ( int k=0; k<m_nK; k++ ) {
double dval = avgWrdCode[i][k];
if ( dNorm > 0 ) dval /= dNorm;
fprintf( fileptr, "%.10f ", dval );
}
fprintf( fileptr, "\n" );
}
fclose( fileptr );
//printf_mat( filename, avgWrdCode, m_nNumTerms, m_nK );
/* save the low dimension representation. */
get_test_filename(filename, model_dir, param);
outputLowDimData(filename, pC, theta);
/* save the prediction performance. */
sprintf(filename, "%s/evl-performance.dat", model_dir);
double dAcc = save_prediction(filename, pC);
// free memory
for (int i=0; i<pC->num_docs; i++ ) {
free( theta[i] );
}
for ( int n=0; n<max_length; n++ ) {
free( phi[n] );
}
for ( int k=0; k<m_nLabelNum; k++ ) {
free( avgTheta[k] );
}
free( theta );
free( phi );
free( avgTheta );
return dAcc;
}
void sse_test_inv()
{
SIMD_MATRIX2F(mat2x2) = { 4, 4,
3, 1 };
SIMD_MATRIX3F(mat3x3) = { 5, 2, 3,
4, 9, 1,
1, 8, 9 };
SIMD_MATRIX4F(mat4x4) = { 1, 2, 3, 10,
1, 5, 1, 20,
7, 8, 2, 30,
4, 1, 5, 100 };
SIMD_MATRIX2F(mat2x2_tag);
SIMD_MATRIX3F(mat3x3_tag);
SIMD_MATRIX4F(mat4x4_tag);
SIMD_MATRIX2F(mat2x2_test);
SIMD_MATRIX3F(mat3x3_test);
SIMD_MATRIX4F(mat4x4_test);
PECKER_LOG_STR("STD INV\n");
PECKER_LOG_STR("MAT2X2\n");
if (matrix_inv_unsafe_std_t::inverse2x2(mat2x2_tag, mat2x2))
{
printf_mat(&mat2x2_tag);
matrix_dot_unsafe_std_t::mul(mat2x2_test, mat2x2, mat2x2_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat2x2_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
PECKER_LOG_STR("MAT3X3\n");
if (matrix_inv_unsafe_std_t::inverse3x3(mat3x3_tag, mat3x3))
{
printf_mat(&mat3x3_tag);
matrix_dot_unsafe_std_t::mul(mat3x3_test, mat3x3, mat3x3_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat3x3_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
PECKER_LOG_STR("MAT4X4\n");
if (matrix_inv_unsafe_std_t::inverse4x4(mat4x4_tag, mat4x4))
{
printf_mat(&mat4x4_tag);
matrix_dot_unsafe_std_t::mul(mat4x4_test, mat4x4, mat4x4_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat4x4_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
PECKER_LOG_STR("SSE INV\n");
PECKER_LOG_STR("MAT2X2\n");
if (matrix_inv_unsafe_sse_t::inverse2x2(mat2x2_tag, mat2x2))
{
printf_mat(&mat2x2_tag);
matrix_dot_unsafe_sse_t::mul(mat2x2_test, mat2x2, mat2x2_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat2x2_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
PECKER_LOG_STR("MAT3X3\n");
if (matrix_inv_unsafe_sse_t::inverse3x3(mat3x3_tag, mat3x3))
{
printf_mat(&mat3x3_tag);
matrix_dot_unsafe_sse_t::mul(mat3x3_test, mat3x3, mat3x3_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat3x3_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
PECKER_LOG_STR("MAT4X4\n");
if (matrix_inv_unsafe_sse_t::inverse4x4(mat4x4_tag, mat4x4))
{
printf_mat(&mat4x4_tag);
matrix_dot_unsafe_sse_t::mul(mat4x4_test, mat4x4, mat4x4_tag);
PECKER_LOG_STR("TEST MAT INV\n");
printf_mat(&mat4x4_test);
}
else
{
PECKER_LOG_STR("can't inverse!\n");
}
}
void printf_mat(const MATRIX2F_t* mat_ptr, bool brow_major = true)
{
return printf_mat((const float_t*)mat_ptr, 2, 2, brow_major);
}
