| 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl DecisionTreeNode, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : DecisionTreeNode in class org.apache.ignite.ml.tree.DecisionTree | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public MeanAbsValueConvergenceChecker(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(ignite Ignite, cache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public Builder(preprocessor Preprocessor<K,V>, countOfComponents int) in class org.apache.ignite.ml.clustering.gmm.GmmPartitionData.Builder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor Preprocessor<K,V>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(datasetBuilder DatasetBuilder<K,V>, envBuilder LearningEnvironmentBuilder, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : KMeansModel in class org.apache.ignite.ml.clustering.kmeans.KMeansTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected abstract learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : Vector to row : LabeledVector in method private calculateFrequencies(row LabeledVector, valuesByFreq Map<Double,Integer>[]) : Map<Double,Integer>[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionLSQRTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBBinaryClassifierTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl BaggedModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, ignite Ignite, cache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl GaussianNaiveBayesModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : GaussianNaiveBayesModel in class org.apache.ignite.ml.naivebayes.gaussian.GaussianNaiveBayesTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public LabeledDatasetPartitionDataBuilderOnHeap(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.structures.partition.LabeledDatasetPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl GmmModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : GmmModel in class org.apache.ignite.ml.clustering.gmm.GmmTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl LogisticRegressionModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LogisticRegressionModel in class org.apache.ignite.ml.regressions.logistic.LogisticRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl IgniteModel<Vector,Double>, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : IgniteModel<Vector,Double> in class org.apache.ignite.ml.composition.bagging.BaggingTest.CountTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public BinarizationPreprocessor(threshold double, basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.binarization.BinarizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public ImputerPreprocessor(imputingValues Vector, basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.simple.ConvergenceCheckerStubFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	func : IgniteFunction<LabeledVector<L>,LabeledVector<L1>> to func : IgniteFunction<LabeledVector<L1>,LabeledVector<L2>> in method public map(func IgniteFunction<LabeledVector<L1>,LabeledVector<L2>>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.Preprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : MultiClassModel<M> in class org.apache.ignite.ml.multiclass.OneVsRestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : DecisionTreeNode in class org.apache.ignite.ml.tree.DecisionTree | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl LinearRegressionModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : AdaptableDatasetModel<I,O,IW,OW,M> in class org.apache.ignite.ml.trainers.AdaptableDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public NormalizationPreprocessor(p int, basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl StackedModel<IS,IA,O,AM>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method private computeSum(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : StandardScalerData in class org.apache.ignite.ml.preprocessing.standardscaling.StandardScalerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : GmmModel in class org.apache.ignite.ml.clustering.gmm.GmmTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBRegressionTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,T> to basePreprocessor : Preprocessor<K,V> in method public fit(ignite Ignite, cache IgniteCache<K,V>, basePreprocessor Preprocessor<K,V>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.PreprocessingTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, upstreamMap Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LogisticRegressionModel in class org.apache.ignite.ml.regressions.logistic.LogisticRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsComposition, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : Vector to row : LabeledVector in method private calculateTheSums(row LabeledVector, sums double[]) : double[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl BaggedModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(ignite Ignite, envBuilder LearningEnvironmentBuilder, upstreamCache IgniteCache<K,V>, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : SVMLinearClassificationModel in class org.apache.ignite.ml.svm.SVMLinearClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.median.MedianOfMedianConvergenceCheckerFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to preprocessor : Preprocessor<K,V> in method public SimpleDatasetDataBuilder(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : MinMaxScalerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl SVMLinearClassificationModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : SVMLinearClassificationModel in class org.apache.ignite.ml.svm.SVMLinearClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	pipeline : Pipeline<K,V,Vector> to pipeline : Pipeline<K,V,Integer,Double> in method private scorePipeline(pipeline Pipeline<K,V,Integer,Double>, datasetBuilderSupplier Function<IgniteBiPredicate<K,V>,DatasetBuilder<K,V>>, testDataIterSupplier BiFunction<IgniteBiPredicate<K,V>,M,LabelPairCursor<L>>, scoreCalculator Metric<L>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public StandardScalerPreprocessor(means double[], sigmas double[], basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.standardscaling.StandardScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(newMdl MultiClassModel<M>, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : MultiClassModel<M> in class org.apache.ignite.ml.multiclass.OneVsRestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public LabelPartitionDataBuilderOnHeap(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.structures.partition.LabelPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : Object[] to row : LabeledVector in method private calculateFrequencies(row LabeledVector, categoryFrequencies Map<String,Integer>[]) : Map<String,Integer>[] in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, featureExtractor Preprocessor<K,V>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : ImputerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : DiscreteNaiveBayesModel in class org.apache.ignite.ml.naivebayes.discrete.DiscreteNaiveBayesTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public MedianOfMedianConvergenceChecker(sampleSize long, lblMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.median.MedianOfMedianConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to vectorizer : Preprocessor<K,V> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, vectorizer Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.tree.boosting.GDBOnTreesLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, data Map<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public ConvergenceChecker(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.ConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public updateModel(mdl KNNRegressionModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : KNNRegressionModel in class org.apache.ignite.ml.knn.regression.KNNRegressionTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,T> to basePreprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.PreprocessingTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : KNNClassificationModel in class org.apache.ignite.ml.knn.classification.KNNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,T> to basePreprocessor : Preprocessor<K,V> in method public fit(data Map<K,V>, parts int, basePreprocessor Preprocessor<K,V>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.PreprocessingTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl LinearRegressionModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionLSQRTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public BootstrappedDatasetBuilder(preprocessor Preprocessor<K,V>, samplesCnt int, subsampleSize double) in class org.apache.ignite.ml.dataset.impl.bootstrapping.BootstrappedDatasetBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(upstreamMap Map<K,V>, partitions int, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method private extractClassLabels(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<Double> in class org.apache.ignite.ml.multiclass.OneVsRestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to vectorizer : Preprocessor<K,V> in method public abstract create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, vectorizer Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.ConvergenceCheckerFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(ignite Ignite, cache IgniteCache<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl StackedModel<IS,IA,O,AM>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to extractor : Preprocessor<K,V> in method protected updateModel(mdl AdaptableDatasetModel<I,O,IW,OW,M>, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : AdaptableDatasetModel<I,O,IW,OW,M> in class org.apache.ignite.ml.trainers.AdaptableDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : KNNRegressionModel in class org.apache.ignite.ml.knn.regression.KNNRegressionTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : GaussianNaiveBayesModel in class org.apache.ignite.ml.naivebayes.gaussian.GaussianNaiveBayesTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceCheckerFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public MinMaxScalerPreprocessor(min double[], max double[], basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Object[]> to basePreprocessor : Preprocessor<K,V> in method public OneHotEncoderPreprocessor(encodingValues Map<String,Integer>[], basePreprocessor Preprocessor<K,V>, handledIndices Set<Integer>) in class org.apache.ignite.ml.preprocessing.encoding.onehotencoder.OneHotEncoderPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : BinarizationPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(data Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(upstreamMap Map<K,V>, envBuilder LearningEnvironmentBuilder, partitions int, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected computeInitialValue(envBuilder LearningEnvironmentBuilder, builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteBiTuple<Double,Long> in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache Map<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public SimpleLabeledDatasetDataBuilder(vectorizer Preprocessor<K,V>) in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleLabeledDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl KNNClassificationModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : KNNClassificationModel in class org.apache.ignite.ml.knn.classification.KNNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl IgniteModel<I,List<O>>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : Vector to row : LabeledVector in method private calculateTheCounts(row LabeledVector, counts int[]) : int[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(upstreamMap Map<K,V>, partitions int, envBuilder LearningEnvironmentBuilder, featureExtractor Preprocessor<K,V>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache Map<K,V>, filter IgniteBiPredicate<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,T> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, ignite Ignite, cache IgniteCache<K,V>, basePreprocessor Preprocessor<K,V>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.PreprocessingTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(upstreamMap Map<K,V>, partitions int, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor Preprocessor<K,V>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : NormalizationPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, envBuilder LearningEnvironmentBuilder, featureExtractor Preprocessor<K,V>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(datasetBuilder DatasetBuilder<K,V>, envBuilder LearningEnvironmentBuilder, featureExtractor Preprocessor<K,V>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,double[]> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : MultilayerPerceptron in class org.apache.ignite.ml.nn.MLPTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsComposition, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.tree.randomforest.RandomForestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Object[]> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : EncoderPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public learnModels(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl IgniteModel<I,List<O>>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	pipeline : Pipeline<K,V,Vector> to pipeline : Pipeline<K,V,Integer,Double> in method public score(pipeline Pipeline<K,V,Integer,Double>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, amountOfFolds int, paramGrid ParamGrid) : CrossValidationResult in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl ModelsSequentialComposition<I,O1,O2>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,double[]> to extractor : Preprocessor<K,V> in method protected updateModel(lastLearnedMdl MultilayerPerceptron, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : MultilayerPerceptron in class org.apache.ignite.ml.nn.MLPTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : StandardScalerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.standardscaling.StandardScalerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,double[]> to vectorizer : Preprocessor<K,V> in method public createSimpleLabeledDataset(datasetBuilder DatasetBuilder<K,V>, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, vectorizer Preprocessor<K,V>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public DecisionTreeDataBuilder(preprocessor Preprocessor<K,V>, buildIdx boolean) in class org.apache.ignite.ml.tree.data.DecisionTreeDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to vectorizer : Preprocessor<K,V> in method public buildDataset(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, vectorizer Preprocessor<K,V>) : Dataset<EmptyContext,LabeledVectorSet<Double,LabeledVector>> in class org.apache.ignite.ml.knn.KNNUtils | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, datasetBuilder DatasetBuilder<K,V>, basePreprocessor Preprocessor<K,V>) : MaxAbsScalerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.maxabsscaling.MaxAbsScalerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsSequentialComposition<I,O1,O2>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Object[]> to basePreprocessor : Preprocessor<K,V> in method public StringEncoderPreprocessor(encodingValues Map<String,Integer>[], basePreprocessor Preprocessor<K,V>, handledIndices Set<Integer>) in class org.apache.ignite.ml.preprocessing.encoding.stringencoder.StringEncoderPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache IgniteCache<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : ANNClassificationModel in class org.apache.ignite.ml.knn.ann.ANNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Object[]> to basePreprocessor : Preprocessor<K,V> in method public EncoderPreprocessor(encodingValues Map<String,Integer>[], basePreprocessor Preprocessor<K,V>, handledIndices Set<Integer>) in class org.apache.ignite.ml.preprocessing.encoding.EncoderPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, ignite Ignite, cache IgniteCache<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl KMeansModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : KMeansModel in class org.apache.ignite.ml.clustering.kmeans.KMeansTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.tree.randomforest.RandomForestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, data Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,Vector> to basePreprocessor : Preprocessor<K,V> in method public MaxAbsScalerPreprocessor(maxAbs double[], basePreprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.preprocessing.maxabsscaling.MaxAbsScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : IgniteModel<Vector,Double> in class org.apache.ignite.ml.composition.bagging.BaggingTest.CountTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : Object[] to row : LabeledVector in method private initializeCategoryFrequencies(row LabeledVector) : Map<String,Integer>[] in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to vectorizer : Preprocessor<K,V> in method private getCentroids(vectorizer Preprocessor<K,V>, datasetBuilder DatasetBuilder<K,V>) : List<Vector> in class org.apache.ignite.ml.knn.ann.ANNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to vectorizer : Preprocessor<K,V> in method private getCentroidStat(datasetBuilder DatasetBuilder<K,V>, vectorizer Preprocessor<K,V>, centers List<Vector>) : CentroidStat in class org.apache.ignite.ml.knn.ann.ANNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl ANNClassificationModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : ANNClassificationModel in class org.apache.ignite.ml.knn.ann.ANNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,T> to basePreprocessor : Preprocessor<K,V> in method public fit(envBuilder LearningEnvironmentBuilder, data Map<K,V>, parts int, basePreprocessor Preprocessor<K,V>) : Preprocessor<K,V> in class org.apache.ignite.ml.preprocessing.PreprocessingTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public FeatureMatrixWithLabelsOnHeapDataBuilder(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.dataset.primitive.FeatureMatrixWithLabelsOnHeapDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : Vectorizer<K,V,CO,?> to featureExtractor : Preprocessor<K,V> in method public createSimpleDataset(datasetBuilder DatasetBuilder<K,V>, envBuilder LearningEnvironmentBuilder, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor Preprocessor<K,V>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,Double> to extractor : Preprocessor<K,V> in method protected updateModel(mdl DiscreteNaiveBayesModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : DiscreteNaiveBayesModel in class org.apache.ignite.ml.naivebayes.discrete.DiscreteNaiveBayesTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public ConvergenceCheckerStub(sampleSize long, externalLbToInternalMapping IgniteFunction, loss Loss, datasetBuilder DatasetBuilder, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.simple.ConvergenceCheckerStub | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(data Map<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O,O> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition.SameTrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                            
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Double> to data : Map<Integer,double[]> in method public testScoreWithBadDataset() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	tmp : Object[] to tmp : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.encoding.stringencoder.StringEncoderPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testFitDefault() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testSolveLeastSquares() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	extractor : Vectorizer<K,V,C,Double> to extractor : Vectorizer<K,V,Serializable,Double> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Integer> to data : Map<Integer,double[]> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.LocalLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,Object[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.KMeansFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.dataset.AlgorithmSpecificDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	binarizationTrainer : BinarizationTrainer<Integer,double[]> to binarizationTrainer : BinarizationTrainer<Integer,Vector> in method public testFitDefault() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	split : TrainTestSplit<Integer,Object[]> to split : TrainTestSplit<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cursor : LabelPairCursor<Integer> to cursor : LabelPairCursor<Double> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.StandardScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	tmp : Object[] to tmp : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.encoding.onehotencoder.OneHotEncoderPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	lsqr : LSQROnHeap<Integer,double[]> to lsqr : LSQROnHeap<Integer,Vector> in method public testSolveLeastSquares() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,String[]> to data : Map<Integer,Vector> in method public testFitOnStringCategorialFeaturesWithReversedOrder() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	split : TrainTestSplit<Integer,Object[]> to split : TrainTestSplit<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics_and_pipeline | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.MaxAbsScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.StandardScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_2_Imputing | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.binarization.BinarizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderTrainer : EncoderTrainer<Integer,String[]> to strEncoderTrainer : EncoderTrainer<Integer,Vector> in method public testFitOnStringCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	extractor : Vectorizer<K,V,C,L> to extractor : Preprocessor<K,V> in method public unsafeCoerce(trainer DatasetTrainer<? extends M,L>) : DatasetTrainer<IgniteModel<I,O>,L> in class org.apache.ignite.ml.composition.CompositionUtils | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	checker : ConvergenceChecker<Integer,LabeledVector<Double>,Integer> to checker : ConvergenceChecker<Integer,LabeledVector<Double>> in method public testConvergenceChecking() : void in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceCheckerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	convCheck : ConvergenceChecker<K,V,C> to convCheck : ConvergenceChecker<K,V> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : IgniteCache<Integer,Integer> to data : IgniteCache<Integer,double[]> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	lsqr : LSQROnHeap<Integer,double[]> to lsqr : LSQROnHeap<Integer,Vector> in method public testSolveLinearSystemWithX0() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : EncoderPreprocessor<Integer,Object[]> to preprocessor : EncoderPreprocessor<Integer,Vector> in method public testFitWithUnknownStringValueInTheGivenData() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,Object[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.LinearRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_1_Read_and_Learn | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial_with_One_Hot_Encoder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.RandomForestRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_2_Imputing | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : MinMaxScalerPreprocessor<Integer,Vector> to preprocessor : MinMaxScalerPreprocessor<Integer,double[]> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Double> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,double[]> in method public testScoreWithBadDataset() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.SVMFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.LinearRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,Object[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.RandomForestRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Double> to data : Map<Integer,double[]> in method public testScoreWithGoodDataset() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : NormalizationPreprocessor<Integer,Vector> to preprocessor : NormalizationPreprocessor<Integer,double[]> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Object[]> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics_and_pipeline | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	builder : SimpleLabeledDatasetDataBuilder<Integer,Person,AlgorithmSpecificPartitionContext,? extends Serializable> to builder : SimpleLabeledDatasetDataBuilder<Integer,Vector,AlgorithmSpecificPartitionContext> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.dataset.AlgorithmSpecificDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testSolveLinearSystemWithX0() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,String[]> to data : Map<Integer,Vector> in method public testFitOnStringCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.dataset.AlgorithmSpecificDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Object[]> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private getCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.tutorial.TitanicUtils | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	checker : ConvergenceChecker<Integer,LabeledVector<Double>,Integer> to checker : ConvergenceChecker<Integer,LabeledVector<Double>> in method public testConvergenceChecking() : void in class org.apache.ignite.ml.composition.boosting.convergence.median.MedianOfMedianConvergenceCheckerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.DecisionTreeRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	e : LabelPair<Integer> to e : LabelPair<Double> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.GBTRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,Object[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.DecisionTreeRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.StandardScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,String[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFitOnStringCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.RandomForestRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,Object[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFitWithUnknownStringValueInTheGivenData() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Object[]> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.KMeansFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	extractor : Vectorizer<K,V,C,L1> to extractor : Preprocessor<K,V> in method public withConvertedLabels(new2Old IgniteFunction<L1,L>) : DatasetTrainer<M,L1> in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testSolveLinearSystem() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.dataset.CacheBasedDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.RandomForestFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cache : IgniteCache<Integer,Object[]> to cache : IgniteCache<Integer,Vector> in method public readPassengers(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.tutorial.TitanicUtils | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.KMeansFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Object[]> to data : Map<Integer,Vector> in method public testFitOnIntegerCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Object[]> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,Object[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFitOnIntegerCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.DecisionTreeRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Double> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,double[]> in method public testScoreWithGoodDataset() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : MaxAbsScalerPreprocessor<Integer,Vector> to preprocessor : MaxAbsScalerPreprocessor<Integer,double[]> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.maxabsscaling.MaxAbsScalerPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MaxAbsScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.dataset.CacheBasedDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.GBTRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : StringEncoderPreprocessor<Integer,String[]> to preprocessor : StringEncoderPreprocessor<Integer,Vector> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.encoding.StringEncoderPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Vector,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MaxAbsScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : EncoderPreprocessor<Integer,String[]> to preprocessor : EncoderPreprocessor<Integer,Vector> in method public testFitOnStringCategorialFeaturesWithReversedOrder() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to normalizationPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Double> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,double[]> in method public testScoreWithGoodDatasetAndBinaryMetrics() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.LogRegFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.maxabsscaling.MaxAbsScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Object[]> to scoreCalculator : CrossValidation<DecisionTreeNode,Double,Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.DecisionTreeFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderTrainer : EncoderTrainer<Integer,String[]> to strEncoderTrainer : EncoderTrainer<Integer,Vector> in method public testFitOnStringCategorialFeaturesWithReversedOrder() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.dataset.AlgorithmSpecificDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,Object[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.LinearRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	split : TrainTestSplit<Integer,Object[]> to split : TrainTestSplit<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testSolveLinearSystem() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	feature : Double to feature : Serializable in method public apply(key K, value V) : LabeledVector<L> in class org.apache.ignite.ml.dataset.feature.extractor.Vectorizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : NormalizationPreprocessor<Integer,double[]> to preprocessor : NormalizationPreprocessor<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.GBTFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : OneHotEncoderPreprocessor<Integer,String[]> to preprocessor : OneHotEncoderPreprocessor<Integer,Vector> in method public testOneCategorialFeature() : void in class org.apache.ignite.ml.preprocessing.encoding.OneHotEncoderPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,Object[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.RandomForestRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Object[]> to data : Map<Integer,Vector> in method public testFitWithUnknownStringValueInTheGivenData() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	binarizationTrainer : BinarizationTrainer<Integer,double[]> to binarizationTrainer : BinarizationTrainer<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : EncoderPreprocessor<Integer,Object[]> to preprocessor : EncoderPreprocessor<Integer,Vector> in method public testFitOnIntegerCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : OneHotEncoderPreprocessor<Integer,String[]> to preprocessor : OneHotEncoderPreprocessor<Integer,Vector> in method public testApplyWithUnknownGategorialValues() : void in class org.apache.ignite.ml.preprocessing.encoding.OneHotEncoderPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	checker : ConvergenceChecker<Integer,LabeledVector<Double>,Integer> to checker : ConvergenceChecker<Integer,LabeledVector<Double>> in method public testConvergenceCheckingWithAnomaliesInData() : void in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceCheckerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheMock : Map<Integer,Double[]> to cacheMock : Map<Integer,Vector> in method public testTrainWithTheLinearlySeparableCase() : void in class org.apache.ignite.ml.pipeline.PipelineTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.standardscaling.StandardScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	vectorizer : Vectorizer<K,V,C,double[]> to patchedPreprocessor : PatchedPreprocessor<K,V,Double,double[]> in method protected updateModel(mdl LogisticRegressionModel, datasetBuilder DatasetBuilder<K,V>, extractor Preprocessor<K,V>) : LogisticRegressionModel in class org.apache.ignite.ml.regressions.logistic.LogisticRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	lsqr : LSQROnHeap<Integer,double[]> to lsqr : LSQROnHeap<Integer,Vector> in method public testSolveLinearSystem() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	split : TrainTestSplit<Integer,Object[]> to split : TrainTestSplit<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : ImputerPreprocessor<Integer,Vector> to preprocessor : ImputerPreprocessor<Integer,double[]> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : EncoderPreprocessor<Integer,String[]> to preprocessor : EncoderPreprocessor<Integer,Vector> in method public testFitOnStringCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : Vector to res : LabeledVector in method public apply(k K, v V) : LabeledVector in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,Object[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.DecisionTreeRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationTrainer : NormalizationTrainer<Integer,double[]> to normalizationTrainer : NormalizationTrainer<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cursor : LabelPairCursor<Integer> to cursor : LabelPairCursor<Double> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.LocalLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	split : TrainTestSplit<Integer,Object[]> to split : TrainTestSplit<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_2_Imputing | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.StandardScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,Object[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.GBTRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	convCheck : ConvergenceChecker<K,V,C> to convCheck : ConvergenceChecker<K,V> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, vectorizer Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.tree.boosting.GDBOnTreesLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	sample : Map<double[],Double> to sample : Map<Double,LabeledVector<Double>> in method public testUpdate() : void in class org.apache.ignite.ml.tree.randomforest.RandomForestRegressionTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheMock : Map<Integer,Double[]> to cacheMock : Map<Integer,Vector> in method public testTrainWithMissedFinalStage() : void in class org.apache.ignite.ml.pipeline.PipelineTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,double[],Vector> to preprocessor : BinarizationPreprocessor<Integer,Vector> in method public testFitDefault() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	sample : Map<Double,double[]> to sample : Map<Double,LabeledVector<Double>> in method public testFit() : void in class org.apache.ignite.ml.tree.randomforest.RandomForestRegressionTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,Object[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.GBTRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataPoints : Map<Integer,DataPoint> to dataPoints : Map<Integer,Vector> in method public basicTest() : void in class org.apache.ignite.ml.dataset.primitive.SimpleDatasetTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Person,Vector> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MaxAbsScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.MaxAbsScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,Double> to data : Map<Integer,double[]> in method public testScoreWithGoodDatasetAndBinaryMetrics() : void in class org.apache.ignite.ml.selection.cv.CrossValidationTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : OneHotEncoderPreprocessor<Integer,Object[]> to preprocessor : OneHotEncoderPreprocessor<Integer,Vector> in method public testTwoCategorialFeatureAndTwoDoubleFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.OneHotEncoderPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : OneHotEncoderPreprocessor<Integer,String[]> to preprocessor : OneHotEncoderPreprocessor<Integer,Vector> in method public testApplyWithStringValues() : void in class org.apache.ignite.ml.preprocessing.encoding.OneHotEncoderPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to minMaxScalerPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testSolveLeastSquares() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	e : LabelPair<Integer> to e : LabelPair<Double> in method public testIterate() : void in class org.apache.ignite.ml.selection.scoring.cursor.LocalLabelPairCursorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	oneHotEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to oneHotEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial_with_One_Hot_Encoder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial_with_One_Hot_Encoder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : BinarizationPreprocessor<Integer,double[]> to preprocessor : BinarizationPreprocessor<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,Vector> to preprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to strEncoderPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Scaling_With_Stacking | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	patchedVectorizer : Vectorizer<K,V,C,Double> to patchedPreprocessor : PatchedPreprocessor<K,V,Double,Double> in method protected updateModel(mdl SVMLinearClassificationModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : SVMLinearClassificationModel in class org.apache.ignite.ml.svm.SVMLinearClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataPoints : Map<Integer,DataPoint> to dataPoints : Map<Integer,Vector> in method public basicTest() : void in class org.apache.ignite.ml.dataset.primitive.SimpleLabeledDatasetTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderTrainer : EncoderTrainer<Integer,Object[]> to strEncoderTrainer : EncoderTrainer<Integer,Vector> in method public testFitOnIntegerCategorialFeatures() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics_and_pipeline | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to data : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.StandardScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testSolveLinearSystemWithX0() : void in class org.apache.ignite.ml.math.isolve.lsqr.LSQROnHeapTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,Object[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.KMeansFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling_with_Pipeline | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,String[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFitOnStringCategorialFeaturesWithReversedOrder() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> to imputingPreprocessor : Preprocessor<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV_with_Param_Grid_and_metrics | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	persons : IgniteCache<Integer,Person> to persons : IgniteCache<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.dataset.CacheBasedDatasetExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,Object[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.inference.spark.modelparser.LinearRegressionFromSparkExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,Person> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private createCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureExtractor : IgniteBiFunction<Integer,Object[],Object[]> to vectorizer : Vectorizer<Integer,Vector,Integer,Double> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial_with_One_Hot_Encoder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	vectorizer : ArraysVectorizer<Integer> to vectorizer : DoubleArrayVectorizer<Integer> in method public vectorizerShouldReturnAllFeaturesByDefault() : void in class org.apache.ignite.ml.dataset.feature.extractor.VectorizerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderTrainer : EncoderTrainer<Integer,Object[]> to strEncoderTrainer : EncoderTrainer<Integer,Vector> in method public testFitWithUnknownStringValueInTheGivenData() : void in class org.apache.ignite.ml.preprocessing.encoding.EncoderTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                            
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl SVMLinearClassificationModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : SVMLinearClassificationModel in class org.apache.ignite.ml.svm.SVMLinearClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.simple.ConvergenceCheckerStubFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected abstract learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public LabelPartitionDataBuilderOnHeap(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.structures.partition.LabelPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl StackedModel<IS,IA,O,AM>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : Vectorizer<K,V,CO,?> to preprocessor : Preprocessor<K,V> in method public SimpleDatasetDataBuilder(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public learnModels(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public FeatureMatrixWithLabelsOnHeapDataBuilder(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.dataset.primitive.FeatureMatrixWithLabelsOnHeapDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public MedianOfMedianConvergenceChecker(sampleSize long, lblMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.median.MedianOfMedianConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, data Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(data Map<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceCheckerFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl DecisionTreeNode, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : DecisionTreeNode in class org.apache.ignite.ml.tree.DecisionTree | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public create(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ConvergenceChecker<K,V> in class org.apache.ignite.ml.composition.boosting.convergence.median.MedianOfMedianConvergenceCheckerFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public DecisionTreeDataBuilder(preprocessor Preprocessor<K,V>, buildIdx boolean) in class org.apache.ignite.ml.tree.data.DecisionTreeDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,CO,Double> to preprocessor : Preprocessor<K,V> in method public LabeledDatasetPartitionDataBuilderOnHeap(preprocessor Preprocessor<K,V>) in class org.apache.ignite.ml.structures.partition.LabeledDatasetPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : KMeansModel in class org.apache.ignite.ml.clustering.kmeans.KMeansTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl IgniteModel<I,List<O>>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : SVMLinearClassificationModel in class org.apache.ignite.ml.svm.SVMLinearClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public Builder(preprocessor Preprocessor<K,V>, countOfComponents int) in class org.apache.ignite.ml.clustering.gmm.GmmPartitionData.Builder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public BootstrappedDatasetBuilder(preprocessor Preprocessor<K,V>, samplesCnt int, subsampleSize double) in class org.apache.ignite.ml.dataset.impl.bootstrapping.BootstrappedDatasetBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, ignite Ignite, cache IgniteCache<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	model : LinearRegressionModel to mdl : LinearRegressionModel in method private toString(mdl LinearRegressionModel) : String in class org.apache.ignite.examples.ml.regression.linear.BostonHousePricesPredictionExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected computeInitialValue(envBuilder LearningEnvironmentBuilder, builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteBiTuple<Double,Long> in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache Map<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public update(mdlToUpdate GDBTrainer.GDBModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<IgniteModel<Vector,Double>> in class org.apache.ignite.ml.composition.boosting.GDBLearningStrategy | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache Map<K,V>, filter IgniteBiPredicate<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public ConvergenceChecker(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.ConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBBinaryClassifierTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl BaggedModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected learnLabels(builder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : boolean in class org.apache.ignite.ml.composition.boosting.GDBRegressionTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl ModelsSequentialComposition<I,O1,O2>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl IgniteModel<I,List<O>>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl KMeansModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : KMeansModel in class org.apache.ignite.ml.clustering.kmeans.KMeansTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method private extractClassLabels(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : List<Double> in class org.apache.ignite.ml.multiclass.OneVsRestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.tree.randomforest.RandomForestTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, ignite Ignite, cache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : IgniteModel<I,List<O>> in class org.apache.ignite.ml.composition.combinators.parallel.TrainersParallelComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsSequentialComposition<I,O1,O2>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O1,O2> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public MeanAbsValueConvergenceChecker(sampleSize long, externalLbToInternalMapping IgniteFunction<Double,Double>, loss Loss, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.mean.MeanAbsValueConvergenceChecker | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(ignite Ignite, cache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsComposition, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl StackedModel<IS,IA,O,AM>, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : StackedModel<IS,IA,O,AM> in class org.apache.ignite.ml.composition.stacking.StackedDatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsSequentialComposition<I,O,O> in class org.apache.ignite.ml.composition.combinators.sequential.TrainersSequentialComposition.SameTrainersSequentialComposition | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public update(mdl M, data Map<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public evaluate(dataCache IgniteCache<K,V>, mdl IgniteModel<Vector,Double>, preprocessor Preprocessor<K,V>) : BinaryClassificationMetricValues in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(data Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public fit(datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : DecisionTreeNode in class org.apache.ignite.ml.tree.DecisionTree | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method public ConvergenceCheckerStub(sampleSize long, externalLbToInternalMapping IgniteFunction, loss Loss, datasetBuilder DatasetBuilder, preprocessor Preprocessor<K,V>, precision double) in class org.apache.ignite.ml.composition.boosting.convergence.simple.ConvergenceCheckerStub | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl BaggedModel, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : BaggedModel in class org.apache.ignite.ml.composition.bagging.BaggedTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	featureExtractor : IgniteBiFunction<K,V,Vector> to preprocessor : Preprocessor<K,V> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, upstreamMap Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, preprocessor Preprocessor<K,V>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	vectorizer : Vectorizer<K,V,C,L> to preprocessor : Preprocessor<K,V> in method public fit(ignite Ignite, cache IgniteCache<K,V>, preprocessor Preprocessor<K,V>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Parameter	extractor : Vectorizer<K,V,C,Double> to preprocessor : Preprocessor<K,V> in method protected updateModel(mdl ModelsComposition, datasetBuilder DatasetBuilder<K,V>, preprocessor Preprocessor<K,V>) : ModelsComposition in class org.apache.ignite.ml.tree.randomforest.RandomForestTrainer | 
                                From | 
                                To |