[−][src]Trait opencv::ml::prelude::TrainData

pub trait TrainData {
    pub fn as_raw_TrainData(&self) -> *const c_void;

    pub fn as_raw_mut_TrainData(&mut self) -> *mut c_void;

    pub fn get_layout(&self) -> Result<i32> { ... }

    pub fn get_n_train_samples(&self) -> Result<i32> { ... }

    pub fn get_n_test_samples(&self) -> Result<i32> { ... }

    pub fn get_n_samples(&self) -> Result<i32> { ... }

    pub fn get_n_vars(&self) -> Result<i32> { ... }

    pub fn get_n_all_vars(&self) -> Result<i32> { ... }

    pub fn get_sample(
        &self, 
        var_idx: &dyn ToInputArray, 
        sidx: i32, 
        buf: &mut f32
    ) -> Result<()> { ... }

    pub fn get_samples(&self) -> Result<Mat> { ... }

    pub fn get_missing(&self) -> Result<Mat> { ... }

    pub fn get_train_samples(
        &self, 
        layout: i32, 
        compress_samples: bool, 
        compress_vars: bool
    ) -> Result<Mat> { ... }

    pub fn get_train_responses(&self) -> Result<Mat> { ... }

    pub fn get_train_norm_cat_responses(&self) -> Result<Mat> { ... }

    pub fn get_test_responses(&self) -> Result<Mat> { ... }

    pub fn get_test_norm_cat_responses(&self) -> Result<Mat> { ... }

    pub fn get_responses(&self) -> Result<Mat> { ... }

    pub fn get_norm_cat_responses(&self) -> Result<Mat> { ... }

    pub fn get_sample_weights(&self) -> Result<Mat> { ... }

    pub fn get_train_sample_weights(&self) -> Result<Mat> { ... }

    pub fn get_test_sample_weights(&self) -> Result<Mat> { ... }

    pub fn get_var_idx(&self) -> Result<Mat> { ... }

    pub fn get_var_type(&self) -> Result<Mat> { ... }

    pub fn get_var_symbol_flags(&self) -> Result<Mat> { ... }

    pub fn get_response_type(&self) -> Result<i32> { ... }

    pub fn get_train_sample_idx(&self) -> Result<Mat> { ... }

    pub fn get_test_sample_idx(&self) -> Result<Mat> { ... }

    pub fn get_values(
        &self, 
        vi: i32, 
        sidx: &dyn ToInputArray, 
        values: &mut f32
    ) -> Result<()> { ... }

    pub fn get_norm_cat_values(
        &self, 
        vi: i32, 
        sidx: &dyn ToInputArray, 
        values: &mut i32
    ) -> Result<()> { ... }

    pub fn get_default_subst_values(&self) -> Result<Mat> { ... }

    pub fn get_cat_count(&self, vi: i32) -> Result<i32> { ... }

    pub fn get_class_labels(&self) -> Result<Mat> { ... }

    pub fn get_cat_ofs(&self) -> Result<Mat> { ... }

    pub fn get_cat_map(&self) -> Result<Mat> { ... }

    pub fn set_train_test_split(
        &mut self, 
        count: i32, 
        shuffle: bool
    ) -> Result<()> { ... }

    pub fn set_train_test_split_ratio(
        &mut self, 
        ratio: f64, 
        shuffle: bool
    ) -> Result<()> { ... }

    pub fn shuffle_train_test(&mut self) -> Result<()> { ... }

    pub fn get_test_samples(&self) -> Result<Mat> { ... }

    pub fn get_names(&self, names: &mut Vector<String>) -> Result<()> { ... }
}

Class encapsulating training data.

Please note that the class only specifies the interface of training data, but not implementation. All the statistical model classes in ml module accepts Ptr<TrainData> as parameter. In other words, you can create your own class derived from TrainData and pass smart pointer to the instance of this class into StatModel::train.

See also

@ref ml_intro_data

Required methods

pub fn as_raw_TrainData(&self) -> *const c_void[src]

pub fn as_raw_mut_TrainData(&mut self) -> *mut c_void[src]

Loading content...

Provided methods

pub fn get_layout(&self) -> Result<i32>[src]

pub fn get_n_train_samples(&self) -> Result<i32>[src]

pub fn get_n_test_samples(&self) -> Result<i32>[src]

pub fn get_n_samples(&self) -> Result<i32>[src]

pub fn get_n_vars(&self) -> Result<i32>[src]

pub fn get_n_all_vars(&self) -> Result<i32>[src]

pub fn get_sample(
    &self,
    var_idx: &dyn ToInputArray,
    sidx: i32,
    buf: &mut f32
) -> Result<()>[src]

pub fn get_samples(&self) -> Result<Mat>[src]

pub fn get_missing(&self) -> Result<Mat>[src]

pub fn get_train_samples(
    &self,
    layout: i32,
    compress_samples: bool,
    compress_vars: bool
) -> Result<Mat>[src]

Returns matrix of train samples

Parameters

  • layout: The requested layout. If it's different from the initial one, the matrix is transposed. See ml::SampleTypes.
  • compressSamples: if true, the function returns only the training samples (specified by sampleIdx)
  • compressVars: if true, the function returns the shorter training samples, containing only the active variables.

In current implementation the function tries to avoid physical data copying and returns the matrix stored inside TrainData (unless the transposition or compression is needed).

C++ default parameters

  • layout: ROW_SAMPLE
  • compress_samples: true
  • compress_vars: true

pub fn get_train_responses(&self) -> Result<Mat>[src]

Returns the vector of responses

The function returns ordered or the original categorical responses. Usually it's used in regression algorithms.

pub fn get_train_norm_cat_responses(&self) -> Result<Mat>[src]

Returns the vector of normalized categorical responses

The function returns vector of responses. Each response is integer from 0 to <number of classes>-1. The actual label value can be retrieved then from the class label vector, see TrainData::getClassLabels.

pub fn get_test_responses(&self) -> Result<Mat>[src]

pub fn get_test_norm_cat_responses(&self) -> Result<Mat>[src]

pub fn get_responses(&self) -> Result<Mat>[src]

pub fn get_norm_cat_responses(&self) -> Result<Mat>[src]

pub fn get_sample_weights(&self) -> Result<Mat>[src]

pub fn get_train_sample_weights(&self) -> Result<Mat>[src]

pub fn get_test_sample_weights(&self) -> Result<Mat>[src]

pub fn get_var_idx(&self) -> Result<Mat>[src]

pub fn get_var_type(&self) -> Result<Mat>[src]

pub fn get_var_symbol_flags(&self) -> Result<Mat>[src]

pub fn get_response_type(&self) -> Result<i32>[src]

pub fn get_train_sample_idx(&self) -> Result<Mat>[src]

pub fn get_test_sample_idx(&self) -> Result<Mat>[src]

pub fn get_values(
    &self,
    vi: i32,
    sidx: &dyn ToInputArray,
    values: &mut f32
) -> Result<()>[src]

pub fn get_norm_cat_values(
    &self,
    vi: i32,
    sidx: &dyn ToInputArray,
    values: &mut i32
) -> Result<()>[src]

pub fn get_default_subst_values(&self) -> Result<Mat>[src]

pub fn get_cat_count(&self, vi: i32) -> Result<i32>[src]

pub fn get_class_labels(&self) -> Result<Mat>[src]

Returns the vector of class labels

The function returns vector of unique labels occurred in the responses.

pub fn get_cat_ofs(&self) -> Result<Mat>[src]

pub fn get_cat_map(&self) -> Result<Mat>[src]

pub fn set_train_test_split(&mut self, count: i32, shuffle: bool) -> Result<()>[src]

Splits the training data into the training and test parts

See also

TrainData::setTrainTestSplitRatio

C++ default parameters

  • shuffle: true

pub fn set_train_test_split_ratio(
    &mut self,
    ratio: f64,
    shuffle: bool
) -> Result<()>[src]

Splits the training data into the training and test parts

The function selects a subset of specified relative size and then returns it as the training set. If the function is not called, all the data is used for training. Please, note that for each of TrainData::getTrain* there is corresponding TrainData::getTest*, so that the test subset can be retrieved and processed as well.

See also

TrainData::setTrainTestSplit

C++ default parameters

  • shuffle: true

pub fn shuffle_train_test(&mut self) -> Result<()>[src]

pub fn get_test_samples(&self) -> Result<Mat>[src]

Returns matrix of test samples

pub fn get_names(&self, names: &mut Vector<String>) -> Result<()>[src]

Returns vector of symbolic names captured in loadFromCSV()

Loading content...

Implementations

impl<'_> dyn TrainData + '_[src]

pub fn missing_value() -> Result<f32>[src]

pub fn get_sub_vector(vec: &Mat, idx: &Mat) -> Result<Mat>[src]

Extract from 1D vector elements specified by passed indexes.

Parameters

  • vec: input vector (supported types: CV_32S, CV_32F, CV_64F)
  • idx: 1D index vector

pub fn get_sub_matrix(matrix: &Mat, idx: &Mat, layout: i32) -> Result<Mat>[src]

Extract from matrix rows/cols specified by passed indexes.

Parameters

  • matrix: input matrix (supported types: CV_32S, CV_32F, CV_64F)
  • idx: 1D index vector
  • layout: specifies to extract rows (cv::ml::ROW_SAMPLES) or to extract columns (cv::ml::COL_SAMPLES)

pub fn load_from_csv(
    filename: &str,
    header_line_count: i32,
    response_start_idx: i32,
    response_end_idx: i32,
    var_type_spec: &str,
    delimiter: i8,
    missch: i8
) -> Result<Ptr<dyn TrainData>>[src]

Reads the dataset from a .csv file and returns the ready-to-use training data.

Parameters

  • filename: The input file name
  • headerLineCount: The number of lines in the beginning to skip; besides the header, the function also skips empty lines and lines staring with #
  • responseStartIdx: Index of the first output variable. If -1, the function considers the last variable as the response
  • responseEndIdx: Index of the last output variable + 1. If -1, then there is single response variable at responseStartIdx.
  • varTypeSpec: The optional text string that specifies the variables' types. It has the format ord[n1-n2,n3,n4-n5,...]cat[n6,n7-n8,...]. That is, variables from n1 to n2 (inclusive range), n3, n4 to n5 ... are considered ordered and n6, n7 to n8 ... are considered as categorical. The range [n1..n2] + [n3] + [n4..n5] + ... + [n6] + [n7..n8] should cover all the variables. If varTypeSpec is not specified, then algorithm uses the following rules:
    • all input variables are considered ordered by default. If some column contains has non- numerical values, e.g. 'apple', 'pear', 'apple', 'apple', 'mango', the corresponding variable is considered categorical.
    • if there are several output variables, they are all considered as ordered. Error is reported when non-numerical values are used.
    • if there is a single output variable, then if its values are non-numerical or are all integers, then it's considered categorical. Otherwise, it's considered ordered.
  • delimiter: The character used to separate values in each line.
  • missch: The character used to specify missing measurements. It should not be a digit. Although it's a non-numerical value, it surely does not affect the decision of whether the variable ordered or categorical.

Note: If the dataset only contains input variables and no responses, use responseStartIdx = -2 and responseEndIdx = 0. The output variables vector will just contain zeros.

C++ default parameters

  • response_start_idx: -1
  • response_end_idx: -1
  • var_type_spec: String()
  • delimiter: ','
  • missch: '?'

pub fn create(
    samples: &dyn ToInputArray,
    layout: i32,
    responses: &dyn ToInputArray,
    var_idx: &dyn ToInputArray,
    sample_idx: &dyn ToInputArray,
    sample_weights: &dyn ToInputArray,
    var_type: &dyn ToInputArray
) -> Result<Ptr<dyn TrainData>>[src]

Creates training data from in-memory arrays.

Parameters

  • samples: matrix of samples. It should have CV_32F type.
  • layout: see ml::SampleTypes.
  • responses: matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical)
  • varIdx: vector specifying which variables to use for training. It can be an integer vector (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables.
  • sampleIdx: vector specifying which samples to use for training. It can be an integer vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples.
  • sampleWeights: optional vector with weights for each sample. It should have CV_32F type.
  • varType: optional vector of type CV_8U and size <number_of_variables_in_samples> + <number_of_variables_in_responses>, containing types of each input and output variable. See ml::VariableTypes.

C++ default parameters

  • var_idx: noArray()
  • sample_idx: noArray()
  • sample_weights: noArray()
  • var_type: noArray()

Implementors

Loading content...