template< class ST > void CMatrixFeatures< ST >::get_feature_vector_col(
SGVector< ST > out,
int32_t num,
int32_t col) const
{
if ( num < 0 || num >= get_num_vectors() )
{
SG_ERROR("The index of the feature vector to get must be between "
"0 and %d (get_num_vectors()-1)\n", get_num_vectors()-1);
}
// Shorthands for the dimensions of the feature vector to get
int32_t num_cols = m_features[num].num_cols;
int32_t num_rows = m_features[num].num_rows;
if ( col < 0 || col >= num_cols )
{
SG_ERROR("The index of the column to get must be between "
"0 and %d (#columns of the feature vector)\n", num_cols);
}
if ( out.vlen < get_num_features() )
{
SG_ERROR("The vector out must have space to hold at least "
"%d (get_num_features()) elements\n", get_num_features());
}
int32_t start = col*num_rows;
for ( int32_t i = 0 ; i < get_num_features(); ++i )
{
out[i] = m_features[num][start + i];
}
}
template< class ST > SGMatrix< ST > CMatrixFeatures< ST >::get_feature_vector(
int32_t num) const
{
if ( num < 0 || num >= get_num_vectors() )
{
SG_ERROR("The index of the feature vector to get must be between "
"0 and %d (get_num_vectors()-1)\n", get_num_vectors()-1);
}
return m_features[num];
}
template<class ST> void* CDenseFeatures<ST>::get_feature_iterator(int32_t vector_index)
{
if (vector_index>=get_num_vectors())
{
SG_ERROR("Index out of bounds (number of vectors %d, you "
"requested %d)\n", get_num_vectors(), vector_index);
}
dense_feature_iterator* iterator = SG_MALLOC(dense_feature_iterator, 1);
iterator->vec = get_feature_vector(vector_index, iterator->vlen,
iterator->vfree);
iterator->vidx = vector_index;
iterator->index = 0;
return iterator;
}
template<class ST> SGVector<ST> CDenseFeatures<ST>::get_feature_vector(int32_t num)
{
/* index conversion for subset, only for array access */
int32_t real_num=m_subset_stack->subset_idx_conversion(num);
if (num >= get_num_vectors())
{
SG_ERROR("Index out of bounds (number of vectors %d, you "
"requested %d)\n", get_num_vectors(), real_num);
}
int32_t vlen;
bool do_free;
ST* vector= get_feature_vector(num, vlen, do_free);
return SGVector<ST>(vector, vlen, do_free);
}
template< class ST > void CMatrixFeatures< ST >::set_feature_vector(
SGMatrix< ST > const vec,
int32_t num)
{
if ( num < 0 || num >= get_num_vectors() )
{
SG_ERROR("The index of the feature vector to set must be between "
"0 and %d (get_num_vectors()-1)\n", get_num_vectors()-1);
}
if ( get_num_features() != 0 && vec.num_rows != get_num_features() )
{
SG_ERROR("The feature vector to set must have the same features "
"as the rest of the MatrixFeatures, %d "
"(get_num_features())\n", get_num_features());
}
m_features.set_matrix(num, vec);
}
template<class ST> ST* CDenseFeatures<ST>::get_transposed(int32_t &num_feat, int32_t &num_vec)
{
num_feat = get_num_vectors();
num_vec = num_features;
int32_t old_num_vec=get_num_vectors();
ST* fm = SG_MALLOC(ST, int64_t(num_feat) * num_vec);
for (int32_t i=0; i<old_num_vec; i++)
{
SGVector<ST> vec=get_feature_vector(i);
for (int32_t j=0; j<vec.vlen; j++)
fm[j*int64_t(old_num_vec)+i]=vec.vector[j];
free_feature_vector(vec, i);
}
return fm;
}
template<class ST> void CDenseFeatures<ST>::set_feature_vector(SGVector<ST> vector, int32_t num)
{
/* index conversion for subset, only for array access */
int32_t real_num=m_subset_stack->subset_idx_conversion(num);
if (num>=get_num_vectors())
{
SG_ERROR("Index out of bounds (number of vectors %d, you "
"requested %d)\n", get_num_vectors(), num);
}
if (!feature_matrix.matrix)
SG_ERROR("Requires a in-memory feature matrix\n")
if (vector.vlen != num_features)
SG_ERROR(
"Vector not of length %d (has %d)\n", num_features, vector.vlen);
memcpy(&feature_matrix.matrix[real_num * int64_t(num_features)], vector.vector,
int64_t(num_features) * sizeof(ST));
}
template<class ST> void CSparseFeatures<ST>::set_sparse_feature_matrix(SGSparseMatrix<ST> sm)
{
if (m_subset_stack->has_subsets())
SG_ERROR("Not allowed with subset\n");
sparse_feature_matrix=sm;
// TODO: check should be implemented in sparse matrix class
for (int32_t j=0; j<get_num_vectors(); j++) {
SGSparseVector<ST> sv=get_sparse_feature_vector(j);
REQUIRE(get_num_features() >= sv.get_num_dimensions(),
"sparse_matrix[%d] check failed (matrix features %d >= vector dimension %d)\n",
j, get_num_features(), sv.get_num_dimensions());
}
}
template<class ST> SGMatrix<ST> CDenseFeatures<ST>::get_feature_matrix()
{
if (!m_subset_stack->has_subsets())
return feature_matrix;
SGMatrix<ST> submatrix(num_features, get_num_vectors());
/* copy a subset vector wise */
for (int32_t i=0; i<submatrix.num_cols; ++i)
{
int32_t real_i = m_subset_stack->subset_idx_conversion(i);
memcpy(&submatrix.matrix[i*int64_t(num_features)],
&feature_matrix.matrix[real_i * int64_t(num_features)],
num_features * sizeof(ST));
}
return submatrix;
}
template<class ST> SGMatrix<ST> CSparseFeatures<ST>::get_full_feature_matrix()
{
SGMatrix<ST> full(get_num_features(), get_num_vectors());
full.zero();
SG_INFO("converting sparse features to full feature matrix of %d x %d"
" entries\n", sparse_feature_matrix.num_vectors, get_num_features())
for (int32_t v=0; v<full.num_cols; v++)
{
int32_t idx=m_subset_stack->subset_idx_conversion(v);
SGSparseVector<ST> current=sparse_feature_matrix[idx];
for (int32_t f=0; f<current.num_feat_entries; f++)
{
int64_t offs=(v*get_num_features())
+current.features[f].feat_index;
full.matrix[offs]=current.features[f].entry;
}
}
return full;
}
template<class ST> SGSparseVector<ST> CSparseFeatures<ST>::get_sparse_feature_vector(int32_t num)
{
REQUIRE(num>=0 && num<get_num_vectors(),
"get_sparse_feature_vector(num=%d): num exceeds [0;%d]\n",
num, get_num_vectors()-1);
index_t real_num=m_subset_stack->subset_idx_conversion(num);
if (sparse_feature_matrix.sparse_matrix)
{
return sparse_feature_matrix[real_num];
}
else
{
SGSparseVector<ST> result;
if (feature_cache)
{
result.features=feature_cache->lock_entry(num);
if (result.features)
return result;
else
{
result.features=feature_cache->set_entry(num);
}
}
//if (!result.features)
// result.do_free=true;
result.features=compute_sparse_feature_vector(num,
result.num_feat_entries, result.features);
if (get_num_preprocessors())
{
int32_t tmp_len=result.num_feat_entries;
SGSparseVectorEntry<ST>* tmp_feat_before=result.features;
SGSparseVectorEntry<ST>* tmp_feat_after = NULL;
for (int32_t i=0; i<get_num_preprocessors(); i++)
{
//tmp_feat_after=((CSparsePreprocessor<ST>*) get_preproc(i))->apply_to_feature_vector(tmp_feat_before, tmp_len);
if (i!=0) // delete feature vector, except for the the first one, i.e., feat
SG_FREE(tmp_feat_before);
tmp_feat_before=tmp_feat_after;
}
if (tmp_feat_after)
{
memcpy(result.features, tmp_feat_after,
sizeof(SGSparseVectorEntry<ST>)*tmp_len);
SG_FREE(tmp_feat_after);
result.num_feat_entries=tmp_len;
}
SG_DEBUG("len: %d len2: %d\n", result.num_feat_entries, get_num_features())
}
return result ;
}
}
