63 m_subset_stack->remove_all_subsets();
64 free_feature_matrix();
70 m_subset_stack->remove_all_subsets();
79 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
83 if (feature_matrix.matrix)
86 return &feature_matrix.matrix[real_num * int64_t(num_features)];
94 feat = feature_cache->lock_entry(real_num);
99 feat = feature_cache->set_entry(real_num);
104 feat = compute_feature_vector(num, len, feat);
106 if (get_num_preprocessors())
108 int32_t tmp_len = len;
109 ST* tmp_feat_before = feat;
110 ST* tmp_feat_after = NULL;
112 for (int32_t i = 0; i < get_num_preprocessors(); i++)
119 tmp_feat_after = applied.
vector;
124 tmp_feat_before = tmp_feat_after;
127 memcpy(feat, tmp_feat_after,
sizeof(ST) * tmp_len);
138 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
140 if (num>=get_num_vectors())
142 SG_ERROR(
"Index out of bounds (number of vectors %d, you "
143 "requested %d)\n", get_num_vectors(), num);
146 if (!feature_matrix.matrix)
147 SG_ERROR(
"Requires a in-memory feature matrix\n");
149 if (vector.
vlen != num_features)
151 "Vector not of length %d (has %d)\n", num_features, vector.
vlen);
153 memcpy(&feature_matrix.matrix[real_num * int64_t(num_features)], vector.
vector,
154 int64_t(num_features) *
sizeof(ST));
160 int32_t real_num=m_subset_stack->subset_idx_conversion(num);
162 if (num >= get_num_vectors())
164 SG_ERROR(
"Index out of bounds (number of vectors %d, you "
165 "requested %d)\n", get_num_vectors(), real_num);
170 ST* vector= get_feature_vector(num, vlen, do_free);
177 feature_cache->unlock_entry(m_subset_stack->subset_idx_conversion(num));
185 free_feature_vector(vec.
vector, num,
false);
191 if (m_subset_stack->has_subsets())
192 SG_ERROR(
"A subset is set, cannot call vector_subset\n");
194 ASSERT(feature_matrix.matrix);
195 ASSERT(idx_len<=num_vectors);
197 int32_t num_vec = num_vectors;
198 num_vectors = idx_len;
202 for (int32_t i = 0; i < idx_len; i++)
207 if (ii < 0 || ii >= num_vec)
208 SG_ERROR(
"Index out of range: should be 0<%d<%d\n", ii, num_vec);
213 memcpy(&feature_matrix.matrix[int64_t(num_features) * i],
214 &feature_matrix.matrix[int64_t(num_features) * ii],
215 num_features *
sizeof(ST));
222 if (m_subset_stack->has_subsets())
223 SG_ERROR(
"A subset is set, cannot call feature_subset\n");
225 ASSERT(feature_matrix.matrix);
226 ASSERT(idx_len<=num_features);
227 int32_t num_feat = num_features;
228 num_features = idx_len;
230 for (int32_t i = 0; i < num_vectors; i++)
232 ST* src = &feature_matrix.matrix[int64_t(num_feat) * i];
233 ST* dst = &feature_matrix.matrix[int64_t(num_features) * i];
236 for (int32_t j = 0; j < idx_len; j++)
240 if (jj < 0 || jj >= num_feat)
242 "Index out of range: should be 0<%d<%d\n", jj, num_feat);
252 if (!m_subset_stack->has_subsets())
253 return feature_matrix;
255 SGMatrix<ST> submatrix(num_features, get_num_vectors());
258 for (int32_t i=0; i<submatrix.
num_cols; ++i)
260 int32_t real_i = m_subset_stack->subset_idx_conversion(i);
261 memcpy(&submatrix.
matrix[i*int64_t(num_features)],
262 &feature_matrix.matrix[real_i * int64_t(num_features)],
263 num_features *
sizeof(ST));
272 m_subset_stack->remove_all_subsets();
274 clean_preprocessors();
275 free_feature_matrix();
276 return st_feature_matrix;
281 m_subset_stack->remove_all_subsets();
282 free_feature_matrix();
283 feature_matrix = matrix;
290 num_feat = num_features;
291 num_vec = num_vectors;
292 return feature_matrix.
matrix;
299 ST* fm = get_transposed(num_feat, num_vec);
306 num_feat = get_num_vectors();
307 num_vec = num_features;
309 int32_t old_num_vec=get_num_vectors();
311 ST* fm =
SG_MALLOC(ST, int64_t(num_feat) * num_vec);
313 for (int32_t i=0; i<old_num_vec; i++)
317 for (int32_t j=0; j<vec.
vlen; j++)
318 fm[j*int64_t(old_num_vec)+i]=vec.
vector[j];
320 free_feature_vector(vec, i);
328 if (m_subset_stack->has_subsets())
329 SG_ERROR(
"A subset is set, cannot call copy_feature_matrix\n");
331 free_feature_matrix();
332 feature_matrix = src.
clone();
340 m_subset_stack->remove_all_subsets();
345 ASSERT(num_feat>0 && num_vec>0);
347 free_feature_matrix();
350 for (int32_t i = 0; i < num_vec; i++)
355 for (int32_t j = 0; j < num_feat; j++)
356 feature_matrix.matrix[i * int64_t(num_feat) + j] = (ST) v.
vector[j];
358 num_features = num_feat;
359 num_vectors = num_vec;
364 if (m_subset_stack->has_subsets())
365 SG_ERROR(
"A subset is set, cannot call apply_preproc\n");
367 SG_DEBUG(
"force: %d\n", force_preprocessing);
369 if (feature_matrix.matrix && get_num_preprocessors())
371 for (int32_t i = 0; i < get_num_preprocessors(); i++)
373 if ((!is_preprocessed(i) || force_preprocessing))
394 if (!feature_matrix.matrix)
397 if (!get_num_preprocessors())
398 SG_ERROR(
"no preprocessors available\n");
408 return m_subset_stack->has_subsets() ? m_subset_stack->get_size() : num_vectors;
421 if (m_subset_stack->has_subsets())
422 SG_ERROR(
"A subset is set, cannot call set_num_vectors\n");
430 if (m_subset_stack->has_subsets())
431 SG_ERROR(
"A subset is set, cannot call initialize_cache\n");
433 if (num_features && num_vectors)
436 feature_cache =
new CCache<ST>(get_cache_size(), num_features,
446 if (m_subset_stack->has_subsets())
447 SG_ERROR(
"A subset is set, cannot call reshape\n");
449 if (p_num_features * p_num_vectors
450 == this->num_features * this->num_vectors)
452 num_features = p_num_features;
453 num_vectors = p_num_vectors;
472 ST* vec1 = get_feature_vector(vec_idx1, len1, free1);
473 ST* vec2 = sf->get_feature_vector(vec_idx2, len2, free2);
477 free_feature_vector(vec1, vec_idx1, free1);
478 sf->free_feature_vector(vec2, vec_idx2, free2);
484 float64_t* vec2, int32_t vec2_len,
bool abs_val)
486 ASSERT(vec2_len == num_features);
490 ST* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
492 ASSERT(vlen == num_features);
496 for (int32_t i = 0; i < num_features; i++)
501 for (int32_t i = 0; i < num_features; i++)
502 vec2[i] += alpha * vec1[i];
505 free_feature_vector(vec1, vec_idx1, vfree);
515 if (vector_index>=get_num_vectors())
517 SG_ERROR(
"Index out of bounds (number of vectors %d, you "
518 "requested %d)\n", get_num_vectors(), vector_index);
521 dense_feature_iterator* iterator =
SG_MALLOC(dense_feature_iterator, 1);
522 iterator->vec = get_feature_vector(vector_index, iterator->vlen,
524 iterator->vidx = vector_index;
532 dense_feature_iterator* it = (dense_feature_iterator*) iterator;
533 if (!it || it->index >= it->vlen)
547 dense_feature_iterator* it = (dense_feature_iterator*) iterator;
548 free_feature_vector(it->vec, it->vidx, it->vfree);
558 index_t real_idx=m_subset_stack->subset_idx_conversion(indices.
vector[i]);
559 memcpy(&feature_matrix_copy.
matrix[i*num_features],
560 &feature_matrix.matrix[real_idx*num_features],
561 num_features*
sizeof(ST));
583 feature_cache = NULL;
590 SG_ADD(&feature_matrix,
"feature_matrix",
594 #define GET_FEATURE_TYPE(f_type, sg_type) \
595 template<> EFeatureType CDenseFeatures<sg_type>::get_feature_type() const \
613 #undef GET_FEATURE_TYPE
618 ASSERT(vec2_len == num_features);
622 bool* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
624 ASSERT(vlen == num_features);
627 for (int32_t i = 0; i < num_features; i++)
628 result += vec1[i] ? vec2[i] : 0;
630 free_feature_vector(vec1, vec_idx1, vfree);
638 ASSERT(vec2_len == num_features);
642 char* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
644 ASSERT(vlen == num_features);
647 for (int32_t i = 0; i < num_features; i++)
648 result += vec1[i] * vec2[i];
650 free_feature_vector(vec1, vec_idx1, vfree);
658 ASSERT(vec2_len == num_features);
662 int8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
664 ASSERT(vlen == num_features);
667 for (int32_t i = 0; i < num_features; i++)
668 result += vec1[i] * vec2[i];
670 free_feature_vector(vec1, vec_idx1, vfree);
676 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
678 ASSERT(vec2_len == num_features);
682 uint8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
684 ASSERT(vlen == num_features);
687 for (int32_t i = 0; i < num_features; i++)
688 result += vec1[i] * vec2[i];
690 free_feature_vector(vec1, vec_idx1, vfree);
696 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
698 ASSERT(vec2_len == num_features);
702 int16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
704 ASSERT(vlen == num_features);
707 for (int32_t i = 0; i < num_features; i++)
708 result += vec1[i] * vec2[i];
710 free_feature_vector(vec1, vec_idx1, vfree);
716 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
718 ASSERT(vec2_len == num_features);
722 uint16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
724 ASSERT(vlen == num_features);
727 for (int32_t i = 0; i < num_features; i++)
728 result += vec1[i] * vec2[i];
730 free_feature_vector(vec1, vec_idx1, vfree);
736 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
738 ASSERT(vec2_len == num_features);
742 int32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
744 ASSERT(vlen == num_features);
747 for (int32_t i = 0; i < num_features; i++)
748 result += vec1[i] * vec2[i];
750 free_feature_vector(vec1, vec_idx1, vfree);
756 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
758 ASSERT(vec2_len == num_features);
762 uint32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
764 ASSERT(vlen == num_features);
767 for (int32_t i = 0; i < num_features; i++)
768 result += vec1[i] * vec2[i];
770 free_feature_vector(vec1, vec_idx1, vfree);
776 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
778 ASSERT(vec2_len == num_features);
782 int64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
784 ASSERT(vlen == num_features);
787 for (int32_t i = 0; i < num_features; i++)
788 result += vec1[i] * vec2[i];
790 free_feature_vector(vec1, vec_idx1, vfree);
796 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
798 ASSERT(vec2_len == num_features);
802 uint64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
804 ASSERT(vlen == num_features);
807 for (int32_t i = 0; i < num_features; i++)
808 result += vec1[i] * vec2[i];
810 free_feature_vector(vec1, vec_idx1, vfree);
816 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
818 ASSERT(vec2_len == num_features);
822 float32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
824 ASSERT(vlen == num_features);
827 for (int32_t i = 0; i < num_features; i++)
828 result += vec1[i] * vec2[i];
830 free_feature_vector(vec1, vec_idx1, vfree);
836 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
838 ASSERT(vec2_len == num_features);
842 float64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
844 ASSERT(vlen == num_features);
847 free_feature_vector(vec1, vec_idx1, vfree);
853 int32_t vec_idx1,
const float64_t* vec2, int32_t vec2_len)
855 ASSERT(vec2_len == num_features);
859 floatmax_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
861 ASSERT(vlen == num_features);
864 for (int32_t i = 0; i < num_features; i++)
865 result += vec1[i] * vec2[i];
867 free_feature_vector(vec1, vec_idx1, vfree);
879 int32_t v1len, v2len;
880 bool v1free, v2free, stop =
false;
882 for (int32_t i = 0; i < num_vectors; i++)
884 vec1 = get_feature_vector(i, v1len, v1free);
890 for (int32_t j=0; j<v1len; j++)
892 if (vec1[j]!=vec2[j])
896 free_feature_vector(vec1, i, v1free);
897 free_feature_vector(vec2, i, v2free);
909 SG_DEBUG(
"entering %s::create_merged_copy()\n", get_name());
912 strcmp(get_name(), other->
get_name()))
914 SG_ERROR(
"%s::create_merged_copy(): Features are of different type!\n",
922 SG_ERROR(
"%s::create_merged_copy(): Could not cast object of %s to "
923 "same type as %s\n",get_name(), other->
get_name(), get_name());
928 SG_ERROR(
"%s::create_merged_copy(): Provided feature object has "
929 "different dimension than this one\n");
936 SG_DEBUG(
"copying matrix of this instance\n");
937 memcpy(data.matrix, feature_matrix.matrix,
938 num_features*num_vectors*
sizeof(ST));
941 SG_DEBUG(
"copying matrix of provided instance\n");
942 memcpy(&data.matrix[num_vectors*num_features],
949 SG_DEBUG(
"leaving %s::create_merged_copy()\n", get_name());
953 #define LOAD(f_load, sg_type) \
954 template<> void CDenseFeatures<sg_type>::load(CFile* loader) \
961 loader->f_load(matrix, num_feat, num_vec); \
962 set_feature_matrix(SGMatrix<sg_type>(matrix, num_feat, num_vec)); \
966 LOAD(get_matrix,
bool)
967 LOAD(get_matrix,
char)
968 LOAD(get_int8_matrix, int8_t)
969 LOAD(get_matrix, uint8_t)
970 LOAD(get_matrix, int16_t)
971 LOAD(get_matrix, uint16_t)
972 LOAD(get_matrix, int32_t)
973 LOAD(get_uint_matrix, uint32_t)
974 LOAD(get_long_matrix, int64_t)
975 LOAD(get_ulong_matrix, uint64_t)
981 #define SAVE(f_write, sg_type) \
982 template<> void CDenseFeatures<sg_type>::save(CFile* writer) \
986 writer->f_write(feature_matrix.matrix, feature_matrix.num_rows, \
987 feature_matrix.num_cols); \
991 SAVE(set_matrix,
bool)
992 SAVE(set_matrix,
char)
993 SAVE(set_int8_matrix, int8_t)
994 SAVE(set_matrix, uint8_t)
995 SAVE(set_matrix, int16_t)
996 SAVE(set_matrix, uint16_t)
997 SAVE(set_matrix, int32_t)
998 SAVE(set_uint_matrix, uint32_t)
999 SAVE(set_long_matrix, int64_t)
1000 SAVE(set_ulong_matrix, uint64_t)
1006 template class CDenseFeatures<bool>;
1007 template class CDenseFeatures<char>;
1008 template class CDenseFeatures<int8_t>;
1009 template class CDenseFeatures<uint8_t>;
1010 template class CDenseFeatures<int16_t>;
1011 template class CDenseFeatures<uint16_t>;
1012 template class CDenseFeatures<int32_t>;
1013 template class CDenseFeatures<uint32_t>;
1014 template class CDenseFeatures<int64_t>;
1015 template class CDenseFeatures<uint64_t>;
1016 template class CDenseFeatures<float32_t>;
1017 template class CDenseFeatures<float64_t>;
1018 template class CDenseFeatures<floatmax_t>;