51 set_feature_matrix(matrix);
58 set_feature_matrix(
SGMatrix<ST>(src, num_feat, num_vec));
80 free_feature_matrix();
95 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
99 if (feature_matrix.matrix)
102 return &feature_matrix.matrix[real_num * int64_t(num_features)];
110 feat = feature_cache->lock_entry(real_num);
115 feat = feature_cache->set_entry(real_num);
120 feat = compute_feature_vector(num, len, feat);
122 if (get_num_preprocessors())
124 int32_t tmp_len = len;
125 ST* tmp_feat_before = feat;
126 ST* tmp_feat_after = NULL;
128 for (int32_t i = 0; i < get_num_preprocessors(); i++)
135 tmp_feat_after = applied.
vector;
139 SG_FREE(tmp_feat_before);
140 tmp_feat_before = tmp_feat_after;
146 sg_memcpy(feat, tmp_feat_after,
sizeof(ST) * tmp_len);
147 SG_FREE(tmp_feat_after);
158 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
160 if (num>=get_num_vectors())
162 SG_ERROR(
"Index out of bounds (number of vectors %d, you " 163 "requested %d)\n", get_num_vectors(), num);
166 if (!feature_matrix.matrix)
167 SG_ERROR(
"Requires a in-memory feature matrix\n")
169 if (vector.
vlen != num_features)
171 "Vector not of length %d (has %d)\n", num_features, vector.
vlen);
173 sg_memcpy(&feature_matrix.matrix[real_num * int64_t(num_features)], vector.
vector,
174 int64_t(num_features) *
sizeof(ST));
180 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
182 if (num >= get_num_vectors())
184 SG_ERROR(
"Index out of bounds (number of vectors %d, you " 185 "requested %d)\n", get_num_vectors(), real_num);
190 ST* vector= get_feature_vector(num, vlen, do_free);
197 feature_cache->unlock_entry(m_subset_stack->subset_idx_conversion(num));
205 free_feature_vector(vec.
vector, num,
false);
211 if (m_subset_stack->has_subsets())
212 SG_ERROR(
"A subset is set, cannot call vector_subset\n")
214 ASSERT(feature_matrix.matrix)
215 ASSERT(idx_len<=num_vectors)
217 int32_t num_vec = num_vectors;
218 num_vectors = idx_len;
222 for (int32_t i = 0; i < idx_len; i++)
227 if (ii < 0 || ii >= num_vec)
228 SG_ERROR(
"Index out of range: should be 0<%d<%d\n", ii, num_vec)
233 sg_memcpy(&feature_matrix.matrix[int64_t(num_features) * i],
234 &feature_matrix.matrix[int64_t(num_features) * ii],
235 num_features *
sizeof(ST));
242 if (m_subset_stack->has_subsets())
243 SG_ERROR(
"A subset is set, cannot call feature_subset\n")
245 ASSERT(feature_matrix.matrix)
246 ASSERT(idx_len<=num_features)
247 int32_t num_feat = num_features;
248 num_features = idx_len;
250 for (int32_t i = 0; i < num_vectors; i++)
252 ST* src = &feature_matrix.matrix[int64_t(num_feat) * i];
253 ST* dst = &feature_matrix.matrix[int64_t(num_features) * i];
256 for (int32_t j = 0; j < idx_len; j++)
260 if (jj < 0 || jj >= num_feat)
262 "Index out of range: should be 0<%d<%d\n", jj, num_feat);
273 if (!m_subset_stack->has_subsets())
274 return feature_matrix;
277 copy_feature_matrix(target);
284 REQUIRE(column_offset>=0,
"Column offset (%d) cannot be negative!\n", column_offset);
285 REQUIRE(!target.
equals(feature_matrix),
"Source and target feature matrices cannot be the same\n");
287 index_t num_vecs=get_num_vectors();
288 index_t num_cols=num_vecs+column_offset;
290 REQUIRE(target.
matrix!=
nullptr,
"Provided matrix is not allocated!\n");
292 "Number of rows of given matrix (%d) should be equal to the number of features (%d)!\n",
295 "Number of cols of given matrix (%d) should be at least %d!\n",
298 if (!m_subset_stack->has_subsets())
300 auto src=feature_matrix.matrix;
301 auto dest=target.
matrix+int64_t(num_features)*column_offset;
302 sg_memcpy(dest, src, feature_matrix.size()*
sizeof(ST));
306 for (int32_t i=0; i<num_vecs; ++i)
308 auto real_i=m_subset_stack->subset_idx_conversion(i);
309 auto src=feature_matrix.matrix+real_i*int64_t(num_features);
310 auto dest=target.
matrix+int64_t(num_features)*(column_offset+i);
311 sg_memcpy(dest, src, num_features*
sizeof(ST));
319 m_subset_stack->remove_all_subsets();
321 clean_preprocessors();
322 free_feature_matrix();
323 return st_feature_matrix;
329 free_feature_matrix();
330 feature_matrix = matrix;
337 num_feat = num_features;
338 num_vec = num_vectors;
339 return feature_matrix.matrix;
346 ST* fm = get_transposed(num_feat, num_vec);
353 num_feat = get_num_vectors();
354 num_vec = num_features;
356 int32_t old_num_vec=get_num_vectors();
358 ST* fm = SG_MALLOC(ST, int64_t(num_feat) * num_vec);
360 for (int32_t i=0; i<old_num_vec; i++)
364 for (int32_t j=0; j<vec.
vlen; j++)
365 fm[j*int64_t(old_num_vec)+i]=vec.
vector[j];
367 free_feature_vector(vec, i);
380 ASSERT(num_feat>0 && num_vec>0)
382 free_feature_matrix();
385 for (int32_t i = 0; i < num_vec; i++)
390 for (int32_t j = 0; j < num_feat; j++)
391 feature_matrix.matrix[i * int64_t(num_feat) + j] = (ST) v.
vector[j];
393 num_features = num_feat;
394 num_vectors = num_vec;
399 if (m_subset_stack->has_subsets())
400 SG_ERROR(
"A subset is set, cannot call apply_preproc\n")
402 SG_DEBUG(
"force: %d\n", force_preprocessing)
404 if (feature_matrix.matrix && get_num_preprocessors())
406 for (int32_t i = 0; i < get_num_preprocessors(); i++)
408 if ((!is_preprocessed(i) || force_preprocessing))
429 if (!feature_matrix.matrix)
432 if (!get_num_preprocessors())
433 SG_ERROR(
"no preprocessors available\n")
441 return m_subset_stack->has_subsets() ? m_subset_stack->get_size() : num_vectors;
454 if (m_subset_stack->has_subsets())
455 SG_ERROR(
"A subset is set, cannot call set_num_vectors\n")
463 if (m_subset_stack->has_subsets())
464 SG_ERROR(
"A subset is set, cannot call initialize_cache\n")
466 if (num_features && num_vectors)
469 feature_cache =
new CCache<ST>(get_cache_size(), num_features,
479 if (m_subset_stack->has_subsets())
480 SG_ERROR(
"A subset is set, cannot call reshape\n")
482 if (p_num_features * p_num_vectors
483 == this->num_features * this->num_vectors)
485 num_features = p_num_features;
486 num_vectors = p_num_vectors;
505 ST* vec1 = get_feature_vector(vec_idx1, len1, free1);
506 ST* vec2 = sf->get_feature_vector(vec_idx2, len2, free2);
510 free_feature_vector(vec1, vec_idx1, free1);
511 sf->free_feature_vector(vec2, vec_idx2, free2);
517 float64_t* vec2, int32_t vec2_len,
bool abs_val)
519 ASSERT(vec2_len == num_features)
523 ST* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
525 ASSERT(vlen == num_features)
529 for (int32_t i = 0; i < num_features; i++)
530 vec2[i] += alpha * CMath::abs(vec1[i]);
534 for (int32_t i = 0; i < num_features; i++)
535 vec2[i] += alpha * vec1[i];
538 free_feature_vector(vec1, vec_idx1, vfree);
543 float64_t* vec2, int32_t vec2_len,
bool abs_val)
545 ASSERT(vec2_len == num_features)
549 float64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
551 ASSERT(vlen == num_features)
555 for (int32_t i = 0; i < num_features; i++)
556 vec2[i] += alpha * CMath::abs(vec1[i]);
563 free_feature_vector(vec1, vec_idx1, vfree);
573 if (vector_index>=get_num_vectors())
575 SG_ERROR(
"Index out of bounds (number of vectors %d, you " 576 "requested %d)\n", get_num_vectors(), vector_index);
579 dense_feature_iterator* iterator = SG_MALLOC(dense_feature_iterator, 1);
580 iterator->vec = get_feature_vector(vector_index, iterator->vlen,
582 iterator->vidx = vector_index;
590 dense_feature_iterator* it = (dense_feature_iterator*) iterator;
591 if (!it || it->index >= it->vlen)
605 dense_feature_iterator* it = (dense_feature_iterator*) iterator;
606 free_feature_vector(it->vec, it->vidx, it->vfree);
616 index_t real_idx=m_subset_stack->subset_idx_conversion(indices.
vector[i]);
617 sg_memcpy(&feature_matrix_copy.
matrix[i*num_features],
618 &feature_matrix.matrix[real_idx*num_features],
619 num_features*
sizeof(ST));
635 REQUIRE(max<num_features && min>=0,
636 "Provided dimensions is in the range [%d, %d] but they " 637 "have to be within [0, %d]! But it \n", min, max, num_features);
643 for (
index_t j=0; j<get_num_vectors(); ++j)
645 index_t real_idx=m_subset_stack->subset_idx_conversion(j);
646 feature_matrix_copy(i, j)=feature_matrix(dims[i], real_idx);
662 SG_SDEBUG(
"Using underlying feature matrix with %d dimensions and %d feature vectors!\n", num_features, num_vectors);
665 SG_REF(shallow_copy_features);
666 if (m_subset_stack->has_subsets())
667 shallow_copy_features->
add_subset(m_subset_stack->get_last_subset()->get_subset_idx());
669 return shallow_copy_features;
686 feature_cache = NULL;
693 SG_ADD(&feature_matrix,
"feature_matrix",
697 #define GET_FEATURE_TYPE(f_type, sg_type) \ 698 template<> EFeatureType CDenseFeatures<sg_type>::get_feature_type() const \ 716 #undef GET_FEATURE_TYPE 721 ASSERT(vec2_len == num_features)
725 bool* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
727 ASSERT(vlen == num_features)
730 for (int32_t i = 0; i < num_features; i++)
731 result += vec1[i] ? vec2[i] : 0;
733 free_feature_vector(vec1, vec_idx1, vfree);
741 ASSERT(vec2_len == num_features)
745 char* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
747 ASSERT(vlen == num_features)
750 for (int32_t i = 0; i < num_features; i++)
751 result += vec1[i] * vec2[i];
753 free_feature_vector(vec1, vec_idx1, vfree);
761 ASSERT(vec2_len == num_features)
765 int8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
767 ASSERT(vlen == num_features)
770 for (int32_t i = 0; i < num_features; i++)
771 result += vec1[i] * vec2[i];
773 free_feature_vector(vec1, vec_idx1, vfree);
779 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
781 ASSERT(vec2_len == num_features)
785 uint8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
787 ASSERT(vlen == num_features)
790 for (int32_t i = 0; i < num_features; i++)
791 result += vec1[i] * vec2[i];
793 free_feature_vector(vec1, vec_idx1, vfree);
799 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
801 ASSERT(vec2_len == num_features)
805 int16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
807 ASSERT(vlen == num_features)
810 for (int32_t i = 0; i < num_features; i++)
811 result += vec1[i] * vec2[i];
813 free_feature_vector(vec1, vec_idx1, vfree);
819 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
821 ASSERT(vec2_len == num_features)
825 uint16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
827 ASSERT(vlen == num_features)
830 for (int32_t i = 0; i < num_features; i++)
831 result += vec1[i] * vec2[i];
833 free_feature_vector(vec1, vec_idx1, vfree);
839 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
841 ASSERT(vec2_len == num_features)
845 int32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
847 ASSERT(vlen == num_features)
850 for (int32_t i = 0; i < num_features; i++)
851 result += vec1[i] * vec2[i];
853 free_feature_vector(vec1, vec_idx1, vfree);
859 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
861 ASSERT(vec2_len == num_features)
865 uint32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
867 ASSERT(vlen == num_features)
870 for (int32_t i = 0; i < num_features; i++)
871 result += vec1[i] * vec2[i];
873 free_feature_vector(vec1, vec_idx1, vfree);
879 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
881 ASSERT(vec2_len == num_features)
885 int64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
887 ASSERT(vlen == num_features)
890 for (int32_t i = 0; i < num_features; i++)
891 result += vec1[i] * vec2[i];
893 free_feature_vector(vec1, vec_idx1, vfree);
899 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
901 ASSERT(vec2_len == num_features)
905 uint64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
907 ASSERT(vlen == num_features)
910 for (int32_t i = 0; i < num_features; i++)
911 result += vec1[i] * vec2[i];
913 free_feature_vector(vec1, vec_idx1, vfree);
919 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
921 ASSERT(vec2_len == num_features)
925 float32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
927 ASSERT(vlen == num_features)
930 for (int32_t i = 0; i < num_features; i++)
931 result += vec1[i] * vec2[i];
933 free_feature_vector(vec1, vec_idx1, vfree);
939 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
941 ASSERT(vec2_len == num_features)
945 float64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
947 ASSERT(vlen == num_features)
950 free_feature_vector(vec1, vec_idx1, vfree);
956 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
958 ASSERT(vec2_len == num_features)
962 floatmax_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
964 ASSERT(vlen == num_features)
967 for (int32_t i = 0; i < num_features; i++)
968 result += vec1[i] * vec2[i];
970 free_feature_vector(vec1, vec_idx1, vfree);
982 int32_t v1len, v2len;
983 bool v1free, v2free, stop =
false;
985 for (int32_t i = 0; i < num_vectors; i++)
987 vec1 = get_feature_vector(i, v1len, v1free);
993 for (int32_t j=0; j<v1len; j++)
995 if (vec1[j]!=vec2[j])
999 free_feature_vector(vec1, i, v1free);
1000 free_feature_vector(vec2, i, v2free);
1014 REQUIRE(others!=
nullptr,
"The list of other feature instances is not initialized!\n");
1017 auto total_num_vectors=get_num_vectors();
1020 while (current!=
nullptr)
1024 REQUIRE(casted!=
nullptr,
"Provided object's type (%s) must match own type (%s)!\n",
1025 current->get_name(), get_name());
1026 REQUIRE(num_features==casted->num_features,
1027 "Provided feature object has different dimension (%d) than this one (%d)!\n",
1028 casted->num_features, num_features);
1030 total_num_vectors+=casted->get_num_vectors();
1040 copy_feature_matrix(data, num_copied);
1041 num_copied+=get_num_vectors();
1045 while (current!=
nullptr)
1049 num_copied+=casted->get_num_vectors();
1066 auto list=some<CList>();
1067 list->append_element(other);
1068 return create_merged_copy(list);
1075 matrix.
load(loader);
1076 set_feature_matrix(matrix);
1082 feature_matrix.
save(writer);
1088 "base_features must be of dynamic type CDenseFeatures\n")
virtual const char * get_name() const =0
CSubsetStack * m_subset_stack
CSGObject * get_next_element()
int32_t num_features
number of features in cache
CDenseFeatures(int32_t size=0)
virtual int32_t get_num_vectors() const =0
#define SG_NOTIMPLEMENTED
T dot(const SGVector< T > &a, const SGVector< T > &b)
Features that support dot products among other operations.
EFeatureClass
shogun feature class
ST * get_feature_vector(int32_t num, int32_t &len, bool &dofree)
class to add subset support to another class. A CSubsetStackStack instance should be added and wrappe...
virtual int32_t get_dim_feature_space() const =0
CSGObject * get_first_element()
int32_t num_vectors
number of vectors in cache
Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDen...
SGMatrix< ST > feature_matrix
A File access base class.
virtual EFeatureClass get_feature_class() const =0
The class DenseFeatures implements dense feature matrices.
all of classes and functions are contained in the shogun namespace
The class Features is the base class of all feature objects.
virtual SGMatrix< ST > apply_to_feature_matrix(CFeatures *features)=0
SGVector< float64_t > get_computed_dot_feature_vector(int32_t num)
virtual void save(CFile *saver)
bool equals(const SGMatrix< T > &other) const
T max(const Container< T > &a)
virtual SGVector< ST > apply_to_feature_vector(SGVector< ST > vector)=0
virtual void remove_all_subsets()
virtual void add_subset(SGVector< index_t > subset)
virtual EFeatureType get_feature_type() const =0
Class List implements a doubly connected list for low-level-objects.
void copy_feature_matrix(SGMatrix< ST > target, index_t column_offset=0) const
#define GET_FEATURE_TYPE(f_type, sg_type)