38 :
CDotFeatures(orig), sparse_feature_matrix(orig.sparse_feature_matrix),
39 feature_cache(orig.feature_cache)
66 REQUIRE(index>=0 && index<get_num_features(),
67 "get_feature(num=%d,index=%d): index exceeds [0;%d]\n",
68 num, index, get_num_features()-1);
73 free_sparse_feature_vector(num);
81 free_sparse_feature_vector(num);
89 free_sparse_feature_vector(num);
95 REQUIRE(num>=0 && num<get_num_vectors(),
96 "get_sparse_feature_vector(num=%d): num exceeds [0;%d]\n",
97 num, get_num_vectors()-1);
98 index_t real_num=m_subset_stack->subset_idx_conversion(num);
100 if (sparse_feature_matrix.sparse_matrix)
102 return sparse_feature_matrix[real_num];
109 result.
features=feature_cache->lock_entry(num);
115 result.
features=feature_cache->set_entry(num);
122 result.
features=compute_sparse_feature_vector(num,
126 if (get_num_preprocessors())
132 for (int32_t i=0; i<get_num_preprocessors(); i++)
137 SG_FREE(tmp_feat_before);
138 tmp_feat_before=tmp_feat_after;
143 memcpy(result.
features, tmp_feat_after,
146 SG_FREE(tmp_feat_after);
158 ST result = sv.
dense_dot(alpha,vec,dim,b);
159 free_sparse_feature_vector(num);
165 REQUIRE(vec,
"add_to_dense_vec(num=%d,dim=%d): vec must not be NULL\n",
167 REQUIRE(dim>=get_num_features(),
168 "add_to_dense_vec(num=%d,dim=%d): dim should contain number of features %d\n",
169 num, dim, get_num_features());
193 free_sparse_feature_vector(num);
198 int32_t num,
float64_t* vec, int32_t dim,
bool abs_val)
206 feature_cache->unlock_entry(m_subset_stack->subset_idx_conversion(num));
213 if (m_subset_stack->has_subsets())
214 SG_ERROR(
"Not allowed with subset\n");
216 return sparse_feature_matrix;
221 if (m_subset_stack->has_subsets())
222 SG_ERROR(
"Not allowed with subset\n");
229 if (m_subset_stack->has_subsets())
230 SG_ERROR(
"Not allowed with subset\n");
232 sparse_feature_matrix=sm;
235 for (int32_t j=0; j<get_num_vectors(); j++) {
238 "sparse_matrix[%d] check failed (matrix features %d >= vector dimension %d)\n",
245 SGMatrix<ST> full(get_num_features(), get_num_vectors());
248 SG_INFO(
"converting sparse features to full feature matrix of %d x %d"
249 " entries\n", sparse_feature_matrix.num_vectors, get_num_features())
251 for (int32_t v=0; v<full.
num_cols; v++)
253 int32_t idx=m_subset_stack->subset_idx_conversion(v);
258 int64_t offs=(v*get_num_features())
270 free_sparse_feature_matrix();
281 remove_all_subsets();
282 free_sparse_feature_matrix();
283 sparse_feature_matrix.from_dense(full);
288 SG_INFO(
"force: %d\n", force_preprocessing)
290 if ( sparse_feature_matrix.sparse_matrix && get_num_preprocessors() )
292 for (int32_t i=0; i<get_num_preprocessors(); i++)
294 if ( (!is_preprocessed(i) || force_preprocessing) )
297 SG_INFO(
"preprocessing using preproc %s\n", get_preprocessor(i)->get_name())
307 SG_WARNING(
"no sparse feature matrix available or features already preprocessed - skipping.\n")
316 set_full_feature_matrix(fm);
326 return m_subset_stack->has_subsets() ? m_subset_stack->get_size() : sparse_feature_matrix.num_vectors;
331 return sparse_feature_matrix.num_features;
336 int32_t n=get_num_features();
338 sparse_feature_matrix.num_features=num;
339 return sparse_feature_matrix.num_features;
350 feature_cache->unlock_entry(m_subset_stack->subset_idx_conversion(num));
358 index_t num_vec=get_num_vectors();
359 for (int32_t i=0; i<num_vec; i++)
360 num+=sparse_feature_matrix[m_subset_stack->subset_idx_conversion(i)].num_feat_entries;
369 index_t num_vec=get_num_vectors();
370 for (int32_t i=0; i<num_vec; i++)
378 free_feature_vector(i);
403 float64_t result=sq_lhs[idx_a]+sq_rhs[idx_b];
452 return get_num_features();
467 free_sparse_feature_vector(vec_idx1);
468 sf->free_sparse_feature_vector(vec_idx2);
482 REQUIRE(vec2,
"dense_dot(vec_idx1=%d,vec2_len=%d): vec2 must not be NULL\n",
484 REQUIRE(vec2_len>=get_num_features(),
485 "dense_dot(vec_idx1=%d,vec2_len=%d): vec2_len should contain number of features %d %d\n",
486 vec_idx1, vec2_len, get_num_features());
494 "sparse_matrix[%d] check failed (matrix features %d >= vector dimension %d)\n",
498 "sparse_matrix[%d] check failed (dense vector dimension %d >= vector dimension %d)\n",
505 free_sparse_feature_vector(vec_idx1);
519 if (vector_index>=get_num_vectors())
521 SG_ERROR(
"Index out of bounds (number of vectors %d, you "
522 "requested %d)\n", get_num_vectors(), vector_index);
525 if (!sparse_feature_matrix.sparse_matrix)
526 SG_ERROR(
"Requires a in-memory feature matrix\n")
528 sparse_feature_iterator* it=
new sparse_feature_iterator();
529 it->sv=get_sparse_feature_vector(vector_index);
531 it->vector_index=vector_index;
538 sparse_feature_iterator* it=(sparse_feature_iterator*) iterator;
539 if (!it || it->index>=it->sv.num_feat_entries)
542 int32_t i=it->index++;
544 index=it->sv.features[i].feat_index;
545 value=(
float64_t) it->sv.features[i].entry;
562 delete ((sparse_feature_iterator*) iterator);
574 index_t real_index=m_subset_stack->subset_idx_conversion(index);
580 free_sparse_feature_vector(index);
598 sparse_feature_matrix.sort_features();
605 m_parameters->add_vector(&sparse_feature_matrix.sparse_matrix, &sparse_feature_matrix.num_vectors,
606 "sparse_feature_matrix",
607 "Array of sparse vectors.");
608 m_parameters->add(&sparse_feature_matrix.num_features,
"sparse_feature_matrix.num_features",
609 "Total number of features.");
612 #define GET_FEATURE_TYPE(sg_type, f_type) \
613 template<> EFeatureType CSparseFeatures<sg_type>::get_feature_type() const \
631 #undef GET_FEATURE_TYPE
635 remove_all_subsets();
637 free_sparse_feature_matrix();
638 sparse_feature_matrix.load(loader);
643 remove_all_subsets();
645 free_sparse_feature_matrix();
646 return sparse_feature_matrix.load_with_labels(loader);
651 if (m_subset_stack->has_subsets())
652 SG_ERROR(
"Not allowed with subset\n");
654 sparse_feature_matrix.save(writer);
659 if (m_subset_stack->has_subsets())
660 SG_ERROR(
"Not allowed with subset\n");
662 sparse_feature_matrix.save_with_labels(writer, labels);
T get_feature(int32_t index)
CSubsetStack * m_subset_stack
SGVector< float64_t > load_with_labels(CLibSVMFile *loader)
SGMatrix< ST > get_feature_matrix()
std::complex< float64_t > complex128_t
virtual bool get_next_feature(int32_t &index, float64_t &value, void *iterator)
virtual void set_full_feature_matrix(SGMatrix< ST > full)
virtual CFeatures * duplicate() const
int32_t get_num_dimensions()
virtual EFeatureClass get_feature_class() const
Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSp...
virtual ~CSparseFeatures()
Template class SparseFeatures implements sparse matrices.
virtual float64_t dot(int32_t vec_idx1, CDotFeatures *df, int32_t vec_idx2)
void set_sparse_feature_matrix(SGSparseMatrix< ST > sm)
int64_t get_num_nonzero_entries()
SGSparseVector< T > * sparse_matrix
array of sparse vectors of size num_vectors
#define SG_NOTIMPLEMENTED
#define GET_FEATURE_TYPE(sg_type, f_type)
float64_t compute_squared_norm(CSparseFeatures< float64_t > *lhs, float64_t *sq_lhs, int32_t idx_a, CSparseFeatures< float64_t > *rhs, float64_t *sq_rhs, int32_t idx_b)
T sparse_dot(const SGSparseVector< T > &v)
virtual void free_feature_iterator(void *iterator)
void save_with_labels(CLibSVMFile *writer, SGVector< float64_t > labels)
virtual int32_t get_nnz_features_for_vector(int32_t num)
virtual int32_t get_dim_feature_space() const
ST dense_dot(ST alpha, int32_t num, ST *vec, int32_t dim, ST b)
Features that support dot products among other operations.
EFeatureClass
shogun feature class
void free_sparse_feature_matrix()
SGSparseMatrix< ST > get_sparse_feature_matrix()
virtual int32_t get_num_vectors() const
void free_feature_vector(int32_t num)
void free_sparse_features()
virtual void * get_feature_iterator(int32_t vector_index)
CSparseFeatures< ST > * get_transposed()
virtual SGSparseVectorEntry< ST > * compute_sparse_feature_vector(int32_t num, int32_t &len, SGSparseVectorEntry< ST > *target=NULL)
SGMatrix< ST > get_full_feature_matrix()
A File access base class.
SGVector< T > get_dense(int32_t dimension)
virtual EFeatureClass get_feature_class() const =0
void add_to_dense_vec(float64_t alpha, int32_t num, float64_t *vec, int32_t dim, bool abs_val=false)
int32_t get_num_features() const
virtual bool apply_preprocessor(bool force_preprocessing=false)
The class DenseFeatures implements dense feature matrices.
float64_t * compute_squared(float64_t *sq)
all of classes and functions are contained in the shogun namespace
T dense_dot(T alpha, T *vec, int32_t dim, T b)
read sparse real valued features in svm light format e.g. -1 1:10.0 2:100.2 1000:1.3 with -1 == (optional) label and dim 1 - value 10.0 dim 2 - value 100.2 dim 1000 - value 1.3
The class Features is the base class of all feature objects.
ST get_feature(int32_t num, int32_t index)
int32_t set_num_features(int32_t num)
virtual CFeatures * copy_subset(SGVector< index_t > indices)
void obtain_from_simple(CDenseFeatures< ST > *sf)
SGSparseVector< ST > get_sparse_feature_vector(int32_t num)
SGVector< ST > get_full_feature_vector(int32_t num)
void free_sparse_feature_vector(int32_t num)
CSparseFeatures(int32_t size=0)
virtual EFeatureType get_feature_type() const =0
static T abs(T a)
return the absolute value of a number
SGSparseVectorEntry< T > * features