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 ; } }